Adding support for OpenSL ES output in native WebRTC
BUG=4573,2982,2175,3590
TEST=modules_unittests --gtest_filter=AudioDevice*, AppRTCDemo and WebRTCDemo
Summary:
- Removes dependency of the 'enable_android_opensl' compiler flag.
Instead, OpenSL ES is always supported, and will enabled for devices that
supports low-latency output.
- WebRTC no longer supports OpenSL ES for the input/recording side.
- Removes old code and demos using OpenSL ES for audio input.
- Improves accuracy of total delay estimates (better AEC performance).
- Reduces roundtrip audio latency; especially when OpenSL can be used.
Performance verified on: Nexus 5, 6, 7 and 9. Samsung Galaxy S4 and S6.
Android One device.
R=magjed@webrtc.org, phoglund@webrtc.org, tommi@webrtc.org
Review URL: https://webrtc-codereview.appspot.com/51759004
Cr-Commit-Position: refs/heads/master@{#9208}
diff --git a/webrtc/modules/utility/source/jvm_android.cc b/webrtc/modules/utility/source/jvm_android.cc
new file mode 100644
index 0000000..2655195
--- /dev/null
+++ b/webrtc/modules/utility/source/jvm_android.cc
@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <android/log.h>
+
+#include "webrtc/modules/utility/interface/jvm_android.h"
+
+#include "webrtc/base/checks.h"
+
+#define TAG "JVM"
+#define ALOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)
+#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
+
+namespace webrtc {
+
+JVM* g_jvm;
+
+// TODO(henrika): add more clases here if needed.
+struct {
+ const char* name;
+ jclass clazz;
+} loaded_classes[] = {
+ {"org/webrtc/voiceengine/WebRtcAudioManager", nullptr},
+ {"org/webrtc/voiceengine/BuildInfo", nullptr},
+};
+
+// Android's FindClass() is trickier than usual because the app-specific
+// ClassLoader is not consulted when there is no app-specific frame on the
+// stack. Consequently, we only look up all classes once in native WebRTC.
+// http://developer.android.com/training/articles/perf-jni.html#faq_FindClass
+void LoadClasses(JNIEnv* jni) {
+ for (auto& c : loaded_classes) {
+ jclass localRef = FindClass(jni, c.name);
+ CHECK_EXCEPTION(jni) << "Error during FindClass: " << c.name;
+ CHECK(localRef) << c.name;
+ jclass globalRef = reinterpret_cast<jclass>(jni->NewGlobalRef(localRef));
+ CHECK_EXCEPTION(jni) << "Error during NewGlobalRef: " << c.name;
+ CHECK(globalRef) << c.name;
+ c.clazz = globalRef;
+ }
+}
+
+void FreeClassReferences(JNIEnv* jni) {
+ for (auto& c : loaded_classes) {
+ jni->DeleteGlobalRef(c.clazz);
+ c.clazz = nullptr;
+ }
+}
+
+jclass LookUpClass(const char* name) {
+ for (auto& c : loaded_classes) {
+ if (c.name == name)
+ return c.clazz;
+ }
+ CHECK(false) << "Unable to find class in lookup table";
+ return 0;
+}
+
+// AttachCurrentThreadIfNeeded implementation.
+AttachCurrentThreadIfNeeded::AttachCurrentThreadIfNeeded()
+ : attached_(false) {
+ ALOGD("AttachCurrentThreadIfNeeded::ctor%s", GetThreadInfo().c_str());
+ JavaVM* jvm = JVM::GetInstance()->jvm();
+ CHECK(jvm);
+ JNIEnv* jni = GetEnv(jvm);
+ if (!jni) {
+ ALOGD("Attaching thread to JVM");
+ JNIEnv* env = nullptr;
+ jint ret = jvm->AttachCurrentThread(&env, nullptr);
+ attached_ = (ret == JNI_OK);
+ }
+}
+
+AttachCurrentThreadIfNeeded::~AttachCurrentThreadIfNeeded() {
+ ALOGD("AttachCurrentThreadIfNeeded::dtor%s", GetThreadInfo().c_str());
+ DCHECK(thread_checker_.CalledOnValidThread());
+ if (attached_) {
+ ALOGD("Detaching thread from JVM");
+ jint res = JVM::GetInstance()->jvm()->DetachCurrentThread();
+ CHECK(res == JNI_OK) << "DetachCurrentThread failed: " << res;
+ }
+}
+
+// GlobalRef implementation.
+GlobalRef::GlobalRef(JNIEnv* jni, jobject object)
+ : jni_(jni), j_object_(NewGlobalRef(jni, object)) {
+ ALOGD("GlobalRef::ctor%s", GetThreadInfo().c_str());
+}
+
+GlobalRef::~GlobalRef() {
+ ALOGD("GlobalRef::dtor%s", GetThreadInfo().c_str());
+ DeleteGlobalRef(jni_, j_object_);
+}
+
+jboolean GlobalRef::CallBooleanMethod(jmethodID methodID, ...) {
+ va_list args;
+ va_start(args, methodID);
+ jboolean res = jni_->CallBooleanMethod(j_object_, methodID, args);
+ CHECK_EXCEPTION(jni_) << "Error during CallBooleanMethod";
+ return res;
+}
+
+void GlobalRef::CallVoidMethod(jmethodID methodID, ...) {
+ va_list args;
+ va_start(args, methodID);
+ jni_->CallVoidMethod(j_object_, methodID, args);
+ CHECK_EXCEPTION(jni_) << "Error during CallVoidMethod";
+}
+
+// NativeRegistration implementation.
+NativeRegistration::NativeRegistration(JNIEnv* jni, jclass clazz)
+ : JavaClass(jni, clazz), jni_(jni) {
+ ALOGD("NativeRegistration::ctor%s", GetThreadInfo().c_str());
+}
+
+NativeRegistration::~NativeRegistration() {
+ ALOGD("NativeRegistration::dtor%s", GetThreadInfo().c_str());
+ jni_->UnregisterNatives(j_class_);
+ CHECK_EXCEPTION(jni_) << "Error during UnregisterNatives";
+}
+
+rtc::scoped_ptr<GlobalRef> NativeRegistration::NewObject(
+ const char* name, const char* signature, ...) {
+ ALOGD("NativeRegistration::NewObject%s", GetThreadInfo().c_str());
+ va_list args;
+ va_start(args, signature);
+ jobject obj = jni_->NewObjectV(j_class_,
+ GetMethodID(jni_, j_class_, name, signature),
+ args);
+ CHECK_EXCEPTION(jni_) << "Error during NewObjectV";
+ va_end(args);
+ return rtc::scoped_ptr<GlobalRef>(new GlobalRef(jni_, obj));
+}
+
+// JavaClass implementation.
+jmethodID JavaClass::GetMethodId(
+ const char* name, const char* signature) {
+ return GetMethodID(jni_, j_class_, name, signature);
+}
+
+jmethodID JavaClass::GetStaticMethodId(
+ const char* name, const char* signature) {
+ return GetStaticMethodID(jni_, j_class_, name, signature);
+}
+
+jobject JavaClass::CallStaticObjectMethod(jmethodID methodID, ...) {
+ va_list args;
+ va_start(args, methodID);
+ jobject res = jni_->CallStaticObjectMethod(j_class_, methodID, args);
+ CHECK_EXCEPTION(jni_) << "Error during CallStaticObjectMethod";
+ return res;
+}
+
+// JNIEnvironment implementation.
+JNIEnvironment::JNIEnvironment(JNIEnv* jni) : jni_(jni) {
+ ALOGD("JNIEnvironment::ctor%s", GetThreadInfo().c_str());
+}
+
+JNIEnvironment::~JNIEnvironment() {
+ ALOGD("JNIEnvironment::dtor%s", GetThreadInfo().c_str());
+ DCHECK(thread_checker_.CalledOnValidThread());
+}
+
+rtc::scoped_ptr<NativeRegistration> JNIEnvironment::RegisterNatives(
+ const char* name, const JNINativeMethod *methods, int num_methods) {
+ ALOGD("JNIEnvironment::RegisterNatives(%s)", name);
+ DCHECK(thread_checker_.CalledOnValidThread());
+ jclass clazz = LookUpClass(name);
+ jni_->RegisterNatives(clazz, methods, num_methods);
+ CHECK_EXCEPTION(jni_) << "Error during RegisterNatives";
+ return rtc::scoped_ptr<NativeRegistration>(
+ new NativeRegistration(jni_, clazz));
+}
+
+std::string JNIEnvironment::JavaToStdString(const jstring& j_string) {
+ DCHECK(thread_checker_.CalledOnValidThread());
+ const char* jchars = jni_->GetStringUTFChars(j_string, nullptr);
+ CHECK_EXCEPTION(jni_);
+ const int size = jni_->GetStringUTFLength(j_string);
+ CHECK_EXCEPTION(jni_);
+ std::string ret(jchars, size);
+ jni_->ReleaseStringUTFChars(j_string, jchars);
+ CHECK_EXCEPTION(jni_);
+ return ret;
+}
+
+// static
+void JVM::Initialize(JavaVM* jvm, jobject context) {
+ ALOGD("JVM::Initialize%s", GetThreadInfo().c_str());
+ CHECK(!g_jvm);
+ g_jvm = new JVM(jvm, context);
+}
+
+// static
+void JVM::Uninitialize() {
+ ALOGD("JVM::Uninitialize%s", GetThreadInfo().c_str());
+ DCHECK(g_jvm);
+ delete g_jvm;
+ g_jvm = nullptr;
+}
+
+// static
+JVM* JVM::GetInstance() {
+ DCHECK(g_jvm);
+ return g_jvm;
+}
+
+JVM::JVM(JavaVM* jvm, jobject context)
+ : jvm_(jvm) {
+ ALOGD("JVM::JVM%s", GetThreadInfo().c_str());
+ CHECK(jni()) << "AttachCurrentThread() must be called on this thread.";
+ context_ = NewGlobalRef(jni(), context);
+ LoadClasses(jni());
+}
+
+JVM::~JVM() {
+ ALOGD("JVM::~JVM%s", GetThreadInfo().c_str());
+ DCHECK(thread_checker_.CalledOnValidThread());
+ FreeClassReferences(jni());
+ DeleteGlobalRef(jni(), context_);
+}
+
+rtc::scoped_ptr<JNIEnvironment> JVM::environment() {
+ ALOGD("JVM::environment%s", GetThreadInfo().c_str());
+ // The JNIEnv is used for thread-local storage. For this reason, we cannot
+ // share a JNIEnv between threads. If a piece of code has no other way to get
+ // its JNIEnv, we should share the JavaVM, and use GetEnv to discover the
+ // thread's JNIEnv. (Assuming it has one, if not, use AttachCurrentThread).
+ // See // http://developer.android.com/training/articles/perf-jni.html.
+ JNIEnv* jni = GetEnv(jvm_);
+ if (!jni) {
+ ALOGE("AttachCurrentThread() has not been called on this thread.");
+ return rtc::scoped_ptr<JNIEnvironment>();
+ }
+ return rtc::scoped_ptr<JNIEnvironment>(new JNIEnvironment(jni));
+}
+
+JavaClass JVM::GetClass(const char* name) {
+ ALOGD("JVM::GetClass(%s)%s", name, GetThreadInfo().c_str());
+ DCHECK(thread_checker_.CalledOnValidThread());
+ return JavaClass(jni(), LookUpClass(name));
+}
+
+} // namespace webrtc