mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-09 13:48:55 +00:00
1009 lines
31 KiB
C
1009 lines
31 KiB
C
/*
|
|
* Copyright (C) 2012, Collabora Ltd.
|
|
* Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>
|
|
* Copyright (C) 2013, Fluendo S.A.
|
|
* Author: Andoni Morales <amorales@fluendo.com>
|
|
* Copyright (C) 2014, Sebastian Dröge <sebastian@centricular.com>
|
|
* Copyright (C) 2014, Collabora Ltd.
|
|
* Author: Matthieu Bouron <matthieu.bouron@collabora.com>
|
|
* Copyright (C) 2015, Sebastian Dröge <sebastian@centricular.com>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation
|
|
* version 2.1 of the License.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <gst/gst.h>
|
|
#include <pthread.h>
|
|
#include <gmodule.h>
|
|
|
|
#include "gstjniutils.h"
|
|
|
|
static GModule *java_module;
|
|
static jint (*get_created_java_vms) (JavaVM ** vmBuf, jsize bufLen,
|
|
jsize * nVMs);
|
|
static jint (*create_java_vm) (JavaVM ** p_vm, JNIEnv ** p_env, void *vm_args);
|
|
static JavaVM *java_vm;
|
|
static gboolean started_java_vm = FALSE;
|
|
static pthread_key_t current_jni_env;
|
|
static jobject (*get_class_loader) (void);
|
|
|
|
gint
|
|
gst_amc_jni_get_android_level ()
|
|
{
|
|
JNIEnv *env;
|
|
gint ret = __ANDROID_API__;
|
|
jfieldID sdkIntFieldID = NULL;
|
|
|
|
env = gst_amc_jni_get_env ();
|
|
|
|
jclass versionClass = (*env)->FindClass (env, "android/os/Build$VERSION");
|
|
if (versionClass == NULL)
|
|
goto done;
|
|
|
|
sdkIntFieldID = (*env)->GetStaticFieldID (env, versionClass, "SDK_INT", "I");
|
|
if (sdkIntFieldID == NULL)
|
|
goto done;
|
|
|
|
ret = (*env)->GetStaticIntField (env, versionClass, sdkIntFieldID);
|
|
done:
|
|
return ret;
|
|
}
|
|
|
|
jclass
|
|
gst_amc_jni_get_class (JNIEnv * env, GError ** err, const gchar * name)
|
|
{
|
|
jclass tmp, ret = NULL;
|
|
|
|
GST_DEBUG ("Retrieving Java class %s", name);
|
|
|
|
tmp = (*env)->FindClass (env, name);
|
|
if ((*env)->ExceptionCheck (env) || !tmp) {
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
|
|
GST_LIBRARY_ERROR_FAILED, "Failed to find class %s", name);
|
|
goto done;
|
|
}
|
|
|
|
ret = (*env)->NewGlobalRef (env, tmp);
|
|
if (!ret) {
|
|
GST_ERROR ("Failed to get %s class global reference", name);
|
|
}
|
|
|
|
done:
|
|
if (tmp)
|
|
(*env)->DeleteLocalRef (env, tmp);
|
|
tmp = NULL;
|
|
|
|
return ret;
|
|
}
|
|
|
|
jmethodID
|
|
gst_amc_jni_get_method_id (JNIEnv * env, GError ** err, jclass klass,
|
|
const gchar * name, const gchar * signature)
|
|
{
|
|
jmethodID ret;
|
|
|
|
ret = (*env)->GetMethodID (env, klass, name, signature);
|
|
if ((*env)->ExceptionCheck (env) || !ret) {
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
|
|
GST_LIBRARY_ERROR_FAILED, "Failed to get method ID %s (%s)", name,
|
|
signature);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
jmethodID
|
|
gst_amc_jni_get_static_method_id (JNIEnv * env, GError ** err, jclass klass,
|
|
const gchar * name, const gchar * signature)
|
|
{
|
|
jmethodID ret;
|
|
|
|
ret = (*env)->GetStaticMethodID (env, klass, name, signature);
|
|
if ((*env)->ExceptionCheck (env) || !ret) {
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
|
|
GST_LIBRARY_ERROR_FAILED, "Failed to get static method ID %s (%s)",
|
|
name, signature);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
jfieldID
|
|
gst_amc_jni_get_field_id (JNIEnv * env, GError ** err, jclass klass,
|
|
const gchar * name, const gchar * type)
|
|
{
|
|
jfieldID ret;
|
|
|
|
ret = (*env)->GetFieldID (env, klass, name, type);
|
|
if ((*env)->ExceptionCheck (env) || !ret) {
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
|
|
GST_LIBRARY_ERROR_FAILED, "Failed to get field ID %s (%s)", name, type);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
jfieldID
|
|
gst_amc_jni_get_static_field_id (JNIEnv * env, GError ** err, jclass klass,
|
|
const gchar * name, const gchar * type)
|
|
{
|
|
jfieldID ret;
|
|
|
|
ret = (*env)->GetStaticFieldID (env, klass, name, type);
|
|
if ((*env)->ExceptionCheck (env) || !ret) {
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
|
|
GST_LIBRARY_ERROR_FAILED, "Failed to get static field ID %s (%s)", name,
|
|
type);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
jobject
|
|
gst_amc_jni_new_object (JNIEnv * env, GError ** err, gboolean global,
|
|
jclass klass, jmethodID constructor, ...)
|
|
{
|
|
jobject tmp;
|
|
va_list args;
|
|
|
|
va_start (args, constructor);
|
|
tmp = (*env)->NewObjectV (env, klass, constructor, args);
|
|
va_end (args);
|
|
|
|
if ((*env)->ExceptionCheck (env) || !tmp) {
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
|
|
GST_LIBRARY_ERROR_FAILED, "Failed to create object");
|
|
return NULL;
|
|
}
|
|
|
|
if (global)
|
|
return gst_amc_jni_object_make_global (env, tmp);
|
|
else
|
|
return tmp;
|
|
}
|
|
|
|
jobject
|
|
gst_amc_jni_new_object_from_static (JNIEnv * env, GError ** err,
|
|
gboolean global, jclass klass, jmethodID method, ...)
|
|
{
|
|
jobject tmp;
|
|
va_list args;
|
|
|
|
va_start (args, method);
|
|
tmp = (*env)->CallStaticObjectMethodV (env, klass, method, args);
|
|
va_end (args);
|
|
|
|
if ((*env)->ExceptionCheck (env) || !tmp) {
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
|
|
GST_LIBRARY_ERROR_FAILED, "Failed to create object");
|
|
return NULL;
|
|
}
|
|
|
|
if (global)
|
|
return gst_amc_jni_object_make_global (env, tmp);
|
|
else
|
|
return tmp;
|
|
}
|
|
|
|
jobject
|
|
gst_amc_jni_object_make_global (JNIEnv * env, jobject object)
|
|
{
|
|
jobject ret;
|
|
|
|
ret = (*env)->NewGlobalRef (env, object);
|
|
if (!ret) {
|
|
GST_ERROR ("Failed to create global reference");
|
|
}
|
|
gst_amc_jni_object_local_unref (env, object);
|
|
|
|
return ret;
|
|
}
|
|
|
|
jobject
|
|
gst_amc_jni_object_ref (JNIEnv * env, jobject object)
|
|
{
|
|
jobject ret;
|
|
|
|
ret = (*env)->NewGlobalRef (env, object);
|
|
if (!ret) {
|
|
GST_ERROR ("Failed to create global reference");
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void
|
|
gst_amc_jni_object_unref (JNIEnv * env, jobject object)
|
|
{
|
|
g_return_if_fail (object != NULL);
|
|
|
|
(*env)->DeleteGlobalRef (env, object);
|
|
}
|
|
|
|
void
|
|
gst_amc_jni_object_local_unref (JNIEnv * env, jobject object)
|
|
{
|
|
g_return_if_fail (object != NULL);
|
|
|
|
(*env)->DeleteLocalRef (env, object);
|
|
}
|
|
|
|
jstring
|
|
gst_amc_jni_string_from_gchar (JNIEnv * env, GError ** err,
|
|
gboolean global, const gchar * string)
|
|
{
|
|
jstring tmp;
|
|
|
|
tmp = (*env)->NewStringUTF (env, string);
|
|
if ((*env)->ExceptionCheck (env)) {
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
|
|
GST_LIBRARY_ERROR_FAILED, "Failed to call Java method");
|
|
tmp = NULL;
|
|
}
|
|
|
|
if (global)
|
|
return gst_amc_jni_object_make_global (env, tmp);
|
|
else
|
|
return tmp;
|
|
}
|
|
|
|
gchar *
|
|
gst_amc_jni_string_to_gchar (JNIEnv * env, jstring string, gboolean release)
|
|
{
|
|
const gchar *s = NULL;
|
|
gchar *ret = NULL;
|
|
|
|
s = (*env)->GetStringUTFChars (env, string, NULL);
|
|
if (!s) {
|
|
GST_ERROR ("Failed to convert string to UTF8");
|
|
goto done;
|
|
}
|
|
|
|
ret = g_strdup (s);
|
|
(*env)->ReleaseStringUTFChars (env, string, s);
|
|
|
|
done:
|
|
if (release) {
|
|
(*env)->DeleteLocalRef (env, string);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* getExceptionSummary() and getStackTrace() taken from Android's
|
|
* platform/libnativehelper/JNIHelp.cpp
|
|
* Modified to work with normal C strings and without C++.
|
|
*
|
|
* Copyright (C) 2006 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/*
|
|
* Returns a human-readable summary of an exception object. The buffer will
|
|
* be populated with the "binary" class name and, if present, the
|
|
* exception message.
|
|
*/
|
|
static gchar *
|
|
getExceptionSummary (JNIEnv * env, jthrowable exception)
|
|
{
|
|
GString *gs = g_string_new ("");
|
|
jclass exceptionClass = NULL, classClass = NULL;
|
|
jmethodID classGetNameMethod, getMessage;
|
|
jstring classNameStr = NULL, messageStr = NULL;
|
|
const char *classNameChars, *messageChars;
|
|
|
|
/* get the name of the exception's class */
|
|
exceptionClass = (*env)->GetObjectClass (env, exception);
|
|
classClass = (*env)->GetObjectClass (env, exceptionClass);
|
|
classGetNameMethod =
|
|
(*env)->GetMethodID (env, classClass, "getName", "()Ljava/lang/String;");
|
|
|
|
classNameStr =
|
|
(jstring) (*env)->CallObjectMethod (env, exceptionClass,
|
|
classGetNameMethod);
|
|
|
|
if (classNameStr == NULL) {
|
|
if ((*env)->ExceptionCheck (env))
|
|
(*env)->ExceptionClear (env);
|
|
g_string_append (gs, "<error getting class name>");
|
|
goto done;
|
|
}
|
|
|
|
classNameChars = (*env)->GetStringUTFChars (env, classNameStr, NULL);
|
|
if (classNameChars == NULL) {
|
|
if ((*env)->ExceptionCheck (env))
|
|
(*env)->ExceptionClear (env);
|
|
g_string_append (gs, "<error getting class name UTF-8>");
|
|
goto done;
|
|
}
|
|
|
|
g_string_append (gs, classNameChars);
|
|
|
|
(*env)->ReleaseStringUTFChars (env, classNameStr, classNameChars);
|
|
|
|
/* if the exception has a detail message, get that */
|
|
getMessage =
|
|
(*env)->GetMethodID (env, exceptionClass, "getMessage",
|
|
"()Ljava/lang/String;");
|
|
messageStr = (jstring) (*env)->CallObjectMethod (env, exception, getMessage);
|
|
if (messageStr == NULL) {
|
|
if ((*env)->ExceptionCheck (env))
|
|
(*env)->ExceptionClear (env);
|
|
goto done;
|
|
}
|
|
g_string_append (gs, ": ");
|
|
|
|
messageChars = (*env)->GetStringUTFChars (env, messageStr, NULL);
|
|
if (messageChars != NULL) {
|
|
g_string_append (gs, messageChars);
|
|
(*env)->ReleaseStringUTFChars (env, messageStr, messageChars);
|
|
} else {
|
|
if ((*env)->ExceptionCheck (env))
|
|
(*env)->ExceptionClear (env);
|
|
g_string_append (gs, "<error getting message>");
|
|
}
|
|
|
|
done:
|
|
if (exceptionClass)
|
|
(*env)->DeleteLocalRef (env, exceptionClass);
|
|
if (classClass)
|
|
(*env)->DeleteLocalRef (env, classClass);
|
|
if (classNameStr)
|
|
(*env)->DeleteLocalRef (env, classNameStr);
|
|
if (messageStr)
|
|
(*env)->DeleteLocalRef (env, messageStr);
|
|
|
|
return g_string_free (gs, FALSE);
|
|
}
|
|
|
|
/*
|
|
* Returns an exception (with stack trace) as a string.
|
|
*/
|
|
static gchar *
|
|
getStackTrace (JNIEnv * env, jthrowable exception)
|
|
{
|
|
GString *gs = g_string_new ("");
|
|
jclass stringWriterClass = NULL, printWriterClass = NULL;
|
|
jclass exceptionClass = NULL;
|
|
jmethodID stringWriterCtor, stringWriterToStringMethod;
|
|
jmethodID printWriterCtor, printStackTraceMethod;
|
|
jobject stringWriter = NULL, printWriter = NULL;
|
|
jstring messageStr = NULL;
|
|
const char *utfChars;
|
|
|
|
stringWriterClass = (*env)->FindClass (env, "java/io/StringWriter");
|
|
|
|
if (stringWriterClass == NULL) {
|
|
g_string_append (gs, "<error getting java.io.StringWriter class>");
|
|
goto done;
|
|
}
|
|
|
|
stringWriterCtor =
|
|
(*env)->GetMethodID (env, stringWriterClass, "<init>", "()V");
|
|
stringWriterToStringMethod =
|
|
(*env)->GetMethodID (env, stringWriterClass, "toString",
|
|
"()Ljava/lang/String;");
|
|
|
|
printWriterClass = (*env)->FindClass (env, "java/io/PrintWriter");
|
|
if (printWriterClass == NULL) {
|
|
g_string_append (gs, "<error getting java.io.PrintWriter class>");
|
|
goto done;
|
|
}
|
|
|
|
printWriterCtor =
|
|
(*env)->GetMethodID (env, printWriterClass, "<init>",
|
|
"(Ljava/io/Writer;)V");
|
|
stringWriter = (*env)->NewObject (env, stringWriterClass, stringWriterCtor);
|
|
if (stringWriter == NULL) {
|
|
if ((*env)->ExceptionCheck (env))
|
|
(*env)->ExceptionClear (env);
|
|
g_string_append (gs, "<error creating new StringWriter instance>");
|
|
goto done;
|
|
}
|
|
|
|
printWriter =
|
|
(*env)->NewObject (env, printWriterClass, printWriterCtor, stringWriter);
|
|
if (printWriter == NULL) {
|
|
if ((*env)->ExceptionCheck (env))
|
|
(*env)->ExceptionClear (env);
|
|
g_string_append (gs, "<error creating new PrintWriter instance>");
|
|
goto done;
|
|
}
|
|
|
|
exceptionClass = (*env)->GetObjectClass (env, exception);
|
|
printStackTraceMethod =
|
|
(*env)->GetMethodID (env, exceptionClass, "printStackTrace",
|
|
"(Ljava/io/PrintWriter;)V");
|
|
(*env)->CallVoidMethod (env, exception, printStackTraceMethod, printWriter);
|
|
if ((*env)->ExceptionCheck (env)) {
|
|
(*env)->ExceptionClear (env);
|
|
g_string_append (gs, "<exception while printing stack trace>");
|
|
goto done;
|
|
}
|
|
|
|
messageStr = (jstring) (*env)->CallObjectMethod (env, stringWriter,
|
|
stringWriterToStringMethod);
|
|
if (messageStr == NULL) {
|
|
if ((*env)->ExceptionCheck (env))
|
|
(*env)->ExceptionClear (env);
|
|
g_string_append (gs, "<failed to call StringWriter.toString()>");
|
|
goto done;
|
|
}
|
|
|
|
utfChars = (*env)->GetStringUTFChars (env, messageStr, NULL);
|
|
if (utfChars == NULL) {
|
|
if ((*env)->ExceptionCheck (env))
|
|
(*env)->ExceptionClear (env);
|
|
g_string_append (gs, "<failed to get UTF chars for message>");
|
|
goto done;
|
|
}
|
|
|
|
g_string_append (gs, utfChars);
|
|
|
|
(*env)->ReleaseStringUTFChars (env, messageStr, utfChars);
|
|
|
|
done:
|
|
if (stringWriterClass)
|
|
(*env)->DeleteLocalRef (env, stringWriterClass);
|
|
if (printWriterClass)
|
|
(*env)->DeleteLocalRef (env, printWriterClass);
|
|
if (exceptionClass)
|
|
(*env)->DeleteLocalRef (env, exceptionClass);
|
|
if (stringWriter)
|
|
(*env)->DeleteLocalRef (env, stringWriter);
|
|
if (printWriter)
|
|
(*env)->DeleteLocalRef (env, printWriter);
|
|
if (messageStr)
|
|
(*env)->DeleteLocalRef (env, messageStr);
|
|
|
|
return g_string_free (gs, FALSE);
|
|
}
|
|
|
|
static JNIEnv *
|
|
gst_amc_jni_attach_current_thread (void)
|
|
{
|
|
JNIEnv *env;
|
|
JavaVMAttachArgs args;
|
|
gint ret;
|
|
|
|
GST_DEBUG ("Attaching thread %p", g_thread_self ());
|
|
args.version = JNI_VERSION_1_6;
|
|
args.name = NULL;
|
|
args.group = NULL;
|
|
|
|
if ((ret = (*java_vm)->AttachCurrentThread (java_vm, &env, &args)) != JNI_OK) {
|
|
GST_ERROR ("Failed to attach current thread: %d", ret);
|
|
return NULL;
|
|
}
|
|
|
|
return env;
|
|
}
|
|
|
|
static void
|
|
gst_amc_jni_detach_current_thread (void *env)
|
|
{
|
|
gint ret;
|
|
|
|
GST_DEBUG ("Detaching thread %p", g_thread_self ());
|
|
if ((ret = (*java_vm)->DetachCurrentThread (java_vm)) != JNI_OK) {
|
|
GST_DEBUG ("Failed to detach current thread: %d", ret);
|
|
}
|
|
}
|
|
|
|
static JavaVM *
|
|
get_application_java_vm (void)
|
|
{
|
|
GModule *module = NULL;
|
|
JavaVM *(*get_java_vm) (void);
|
|
JavaVM *vm = NULL;
|
|
|
|
module = g_module_open (NULL, G_MODULE_BIND_LOCAL);
|
|
|
|
if (!module) {
|
|
return NULL;
|
|
}
|
|
|
|
if (g_module_symbol (module, "gst_android_get_java_vm",
|
|
(gpointer *) & get_java_vm) && get_java_vm) {
|
|
vm = get_java_vm ();
|
|
}
|
|
|
|
g_module_close (module);
|
|
|
|
return vm;
|
|
}
|
|
|
|
static gboolean
|
|
check_nativehelper (void)
|
|
{
|
|
GModule *module;
|
|
void **jni_invocation = NULL;
|
|
gboolean ret = FALSE;
|
|
|
|
module = g_module_open (NULL, G_MODULE_BIND_LOCAL);
|
|
if (!module)
|
|
return ret;
|
|
|
|
/* Check if libnativehelper is loaded in the process and if
|
|
* it has these awful wrappers for JNI_CreateJavaVM and
|
|
* JNI_GetCreatedJavaVMs that crash the app if you don't
|
|
* create a JniInvocation instance first. If it isn't we
|
|
* just fail here and don't initialize anything.
|
|
* See this code for reference:
|
|
* https://android.googlesource.com/platform/libnativehelper/+/master/JniInvocation.cpp
|
|
*/
|
|
if (!g_module_symbol (module, "_ZN13JniInvocation15jni_invocation_E",
|
|
(gpointer *) & jni_invocation)) {
|
|
ret = TRUE;
|
|
} else {
|
|
ret = (jni_invocation != NULL && *jni_invocation != NULL);
|
|
}
|
|
|
|
g_module_close (module);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
load_java_module (const gchar * name)
|
|
{
|
|
java_module = g_module_open (name, G_MODULE_BIND_LOCAL);
|
|
if (!java_module)
|
|
goto load_failed;
|
|
|
|
if (!g_module_symbol (java_module, "JNI_CreateJavaVM",
|
|
(gpointer *) & create_java_vm)) {
|
|
GST_ERROR ("Could not find 'JNI_CreateJavaVM' in '%s': %s",
|
|
GST_STR_NULL (name), g_module_error ());
|
|
create_java_vm = NULL;
|
|
}
|
|
|
|
if (!g_module_symbol (java_module, "JNI_GetCreatedJavaVMs",
|
|
(gpointer *) & get_created_java_vms))
|
|
goto symbol_error;
|
|
|
|
return TRUE;
|
|
|
|
load_failed:
|
|
{
|
|
GST_ERROR ("Failed to load Java module '%s': %s", GST_STR_NULL (name),
|
|
g_module_error ());
|
|
return FALSE;
|
|
}
|
|
symbol_error:
|
|
{
|
|
GST_ERROR ("Failed to locate required JNI symbols in '%s': %s",
|
|
GST_STR_NULL (name), g_module_error ());
|
|
g_module_close (java_module);
|
|
java_module = NULL;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
check_application_class_loader (void)
|
|
{
|
|
gboolean ret = TRUE;
|
|
GModule *module = NULL;
|
|
|
|
module = g_module_open (NULL, G_MODULE_BIND_LOCAL);
|
|
if (!module) {
|
|
return FALSE;
|
|
}
|
|
if (!g_module_symbol (module, "gst_android_get_application_class_loader",
|
|
(gpointer *) & get_class_loader)) {
|
|
ret = FALSE;
|
|
}
|
|
|
|
g_module_close (module);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
initialize_classes (void)
|
|
{
|
|
if (!check_application_class_loader ()) {
|
|
GST_ERROR ("Could not find application class loader provider");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_amc_jni_initialize_java_vm (void)
|
|
{
|
|
jsize n_vms;
|
|
gint ret;
|
|
|
|
if (java_vm) {
|
|
GST_DEBUG ("Java VM already provided by the application");
|
|
return initialize_classes ();
|
|
}
|
|
|
|
java_vm = get_application_java_vm ();
|
|
if (java_vm) {
|
|
GST_DEBUG ("Java VM successfully requested from the application");
|
|
return initialize_classes ();
|
|
}
|
|
|
|
/* Returns TRUE if we can safely
|
|
* a) get the current VMs and
|
|
* b) start a VM if none is started yet
|
|
*
|
|
* FIXME: On Android >= 4.4 we won't be able to safely start a
|
|
* VM on our own without using private C++ API!
|
|
*/
|
|
if (!check_nativehelper ()) {
|
|
GST_ERROR ("Can't safely check for VMs or start a VM");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!load_java_module (NULL)) {
|
|
if (!load_java_module ("libdvm"))
|
|
return FALSE;
|
|
}
|
|
|
|
n_vms = 0;
|
|
if ((ret = get_created_java_vms (&java_vm, 1, &n_vms)) != JNI_OK)
|
|
goto get_created_failed;
|
|
|
|
if (n_vms > 0) {
|
|
GST_DEBUG ("Successfully got existing Java VM %p", java_vm);
|
|
} else if (create_java_vm) {
|
|
JNIEnv *env;
|
|
JavaVMInitArgs vm_args;
|
|
JavaVMOption options[4];
|
|
|
|
GST_DEBUG ("Found no existing Java VM, trying to start one");
|
|
|
|
options[0].optionString = "-verbose:jni";
|
|
options[1].optionString = "-verbose:gc";
|
|
options[2].optionString = "-Xcheck:jni";
|
|
options[3].optionString = "-Xdebug";
|
|
|
|
vm_args.version = JNI_VERSION_1_4;
|
|
vm_args.options = options;
|
|
vm_args.nOptions = 4;
|
|
vm_args.ignoreUnrecognized = JNI_TRUE;
|
|
if ((ret = create_java_vm (&java_vm, &env, &vm_args)) != JNI_OK)
|
|
goto create_failed;
|
|
GST_DEBUG ("Successfully created Java VM %p", java_vm);
|
|
|
|
started_java_vm = TRUE;
|
|
} else {
|
|
GST_ERROR ("JNI_CreateJavaVM not available");
|
|
java_vm = NULL;
|
|
}
|
|
|
|
if (java_vm == NULL)
|
|
return FALSE;
|
|
|
|
return initialize_classes ();
|
|
|
|
get_created_failed:
|
|
{
|
|
GST_ERROR ("Failed to get already created VMs: %d", ret);
|
|
g_module_close (java_module);
|
|
java_module = NULL;
|
|
return FALSE;
|
|
}
|
|
create_failed:
|
|
{
|
|
GST_ERROR ("Failed to create a Java VM: %d", ret);
|
|
g_module_close (java_module);
|
|
java_module = NULL;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_amc_jni_set_error_string (JNIEnv * env, GError ** err, GQuark domain,
|
|
gint code, const gchar * message)
|
|
{
|
|
jthrowable exception;
|
|
|
|
if (!err) {
|
|
if ((*env)->ExceptionCheck (env))
|
|
(*env)->ExceptionClear (env);
|
|
return;
|
|
}
|
|
|
|
if ((*env)->ExceptionCheck (env)) {
|
|
if ((exception = (*env)->ExceptionOccurred (env))) {
|
|
gchar *exception_description, *exception_stacktrace;
|
|
|
|
/* Clear exception so that we can call Java methods again */
|
|
(*env)->ExceptionClear (env);
|
|
|
|
exception_description = getExceptionSummary (env, exception);
|
|
exception_stacktrace = getStackTrace (env, exception);
|
|
g_set_error (err, domain, code, "%s: %s\n%s", message,
|
|
exception_description, exception_stacktrace);
|
|
g_free (exception_description);
|
|
g_free (exception_stacktrace);
|
|
|
|
(*env)->DeleteLocalRef (env, exception);
|
|
} else {
|
|
(*env)->ExceptionClear (env);
|
|
g_set_error (err, domain, code, "%s", message);
|
|
}
|
|
} else {
|
|
g_set_error (err, domain, code, "%s", message);
|
|
}
|
|
}
|
|
|
|
G_GNUC_PRINTF (5, 6)
|
|
void gst_amc_jni_set_error (JNIEnv * env, GError ** err, GQuark domain,
|
|
gint code, const gchar * format, ...)
|
|
{
|
|
gchar *message;
|
|
va_list var_args;
|
|
|
|
va_start (var_args, format);
|
|
message = g_strdup_vprintf (format, var_args);
|
|
va_end (var_args);
|
|
|
|
gst_amc_jni_set_error_string (env, err, domain, code, message);
|
|
|
|
g_free (message);
|
|
}
|
|
|
|
static gpointer
|
|
gst_amc_jni_initialize_internal (gpointer data)
|
|
{
|
|
pthread_key_create (¤t_jni_env, gst_amc_jni_detach_current_thread);
|
|
return gst_amc_jni_initialize_java_vm ()? GINT_TO_POINTER (1) : NULL;
|
|
}
|
|
|
|
/* Allow the application to set the Java VM */
|
|
void
|
|
gst_amc_jni_set_java_vm (JavaVM * vm)
|
|
{
|
|
GST_DEBUG ("Application provides Java VM %p", vm);
|
|
java_vm = vm;
|
|
}
|
|
|
|
gboolean
|
|
gst_amc_jni_initialize (void)
|
|
{
|
|
GOnce once = G_ONCE_INIT;
|
|
|
|
g_once (&once, gst_amc_jni_initialize_internal, NULL);
|
|
return once.retval != NULL;
|
|
}
|
|
|
|
JNIEnv *
|
|
gst_amc_jni_get_env (void)
|
|
{
|
|
JNIEnv *env;
|
|
|
|
if ((env = pthread_getspecific (current_jni_env)) == NULL) {
|
|
env = gst_amc_jni_attach_current_thread ();
|
|
pthread_setspecific (current_jni_env, env);
|
|
}
|
|
|
|
return env;
|
|
}
|
|
|
|
gboolean
|
|
gst_amc_jni_is_vm_started (void)
|
|
{
|
|
return started_java_vm;
|
|
}
|
|
|
|
jclass
|
|
gst_amc_jni_get_application_class (JNIEnv * env, const gchar * name,
|
|
GError ** err)
|
|
{
|
|
jclass tmp = NULL;
|
|
jclass class = NULL;
|
|
jstring name_jstr = NULL;
|
|
|
|
jobject class_loader = NULL;
|
|
jclass class_loader_cls = NULL;
|
|
jmethodID load_class_id = 0;
|
|
|
|
GST_LOG ("attempting to retrieve class %s", name);
|
|
|
|
if (!get_class_loader) {
|
|
g_set_error (err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED,
|
|
"Could not retrieve application class loader function");
|
|
goto done;
|
|
}
|
|
|
|
class_loader = get_class_loader ();
|
|
if (!class_loader) {
|
|
g_set_error (err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED,
|
|
"Could not retrieve application class loader");
|
|
goto done;
|
|
}
|
|
|
|
class_loader_cls = (*env)->GetObjectClass (env, class_loader);
|
|
if (!class_loader_cls) {
|
|
g_set_error (err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED,
|
|
"Could not retrieve application class loader java class");
|
|
goto done;
|
|
}
|
|
|
|
load_class_id =
|
|
gst_amc_jni_get_method_id (env, err, class_loader_cls, "loadClass",
|
|
"(Ljava/lang/String;)Ljava/lang/Class;");
|
|
if (!load_class_id) {
|
|
goto done;
|
|
}
|
|
|
|
name_jstr = gst_amc_jni_string_from_gchar (env, err, FALSE, name);
|
|
if (!name_jstr) {
|
|
goto done;
|
|
}
|
|
|
|
if (gst_amc_jni_call_object_method (env, err, class_loader,
|
|
load_class_id, &tmp, name_jstr)) {
|
|
class = gst_amc_jni_object_make_global (env, tmp);
|
|
}
|
|
|
|
done:
|
|
gst_amc_jni_object_local_unref (env, name_jstr);
|
|
gst_amc_jni_object_local_unref (env, class_loader_cls);
|
|
|
|
return class;
|
|
}
|
|
|
|
#define CALL_STATIC_TYPE_METHOD(_type, _name, _jname) \
|
|
gboolean gst_amc_jni_call_static_##_name##_method (JNIEnv *env, GError ** err, jclass klass, jmethodID methodID, _type * value, ...) \
|
|
{ \
|
|
gboolean ret = TRUE; \
|
|
va_list args; \
|
|
va_start(args, value); \
|
|
*value = (*env)->CallStatic##_jname##MethodV(env, klass, methodID, args); \
|
|
if ((*env)->ExceptionCheck (env)) { \
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, \
|
|
"Failed to call static Java method"); \
|
|
ret = FALSE; \
|
|
} \
|
|
va_end(args); \
|
|
return ret; \
|
|
}
|
|
|
|
CALL_STATIC_TYPE_METHOD (gboolean, boolean, Boolean);
|
|
CALL_STATIC_TYPE_METHOD (gint8, byte, Byte);
|
|
CALL_STATIC_TYPE_METHOD (gshort, short, Short);
|
|
CALL_STATIC_TYPE_METHOD (gint, int, Int);
|
|
CALL_STATIC_TYPE_METHOD (gchar, char, Char);
|
|
CALL_STATIC_TYPE_METHOD (gint64, long, Long);
|
|
CALL_STATIC_TYPE_METHOD (gfloat, float, Float);
|
|
CALL_STATIC_TYPE_METHOD (gdouble, double, Double);
|
|
CALL_STATIC_TYPE_METHOD (jobject, object, Object);
|
|
|
|
gboolean
|
|
gst_amc_jni_call_static_void_method (JNIEnv * env, GError ** err, jclass klass,
|
|
jmethodID methodID, ...)
|
|
{
|
|
gboolean ret = TRUE;
|
|
va_list args;
|
|
va_start (args, methodID);
|
|
|
|
(*env)->CallStaticVoidMethodV (env, klass, methodID, args);
|
|
if ((*env)->ExceptionCheck (env)) {
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
|
|
GST_LIBRARY_ERROR_FAILED, "Failed to call static Java method");
|
|
ret = FALSE;
|
|
}
|
|
va_end (args);
|
|
return ret;
|
|
}
|
|
|
|
#define CALL_TYPE_METHOD(_type, _name, _jname) \
|
|
gboolean gst_amc_jni_call_##_name##_method (JNIEnv *env, GError ** err, jobject obj, jmethodID methodID, _type *value, ...) \
|
|
{ \
|
|
gboolean ret = TRUE; \
|
|
va_list args; \
|
|
va_start(args, value); \
|
|
*value = (*env)->Call##_jname##MethodV(env, obj, methodID, args); \
|
|
if ((*env)->ExceptionCheck (env)) { \
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, \
|
|
"Failed to call Java method"); \
|
|
ret = FALSE; \
|
|
} \
|
|
va_end(args); \
|
|
return ret; \
|
|
}
|
|
|
|
CALL_TYPE_METHOD (gboolean, boolean, Boolean);
|
|
CALL_TYPE_METHOD (gint8, byte, Byte);
|
|
CALL_TYPE_METHOD (gshort, short, Short);
|
|
CALL_TYPE_METHOD (gint, int, Int);
|
|
CALL_TYPE_METHOD (gchar, char, Char);
|
|
CALL_TYPE_METHOD (gint64, long, Long);
|
|
CALL_TYPE_METHOD (gfloat, float, Float);
|
|
CALL_TYPE_METHOD (gdouble, double, Double);
|
|
CALL_TYPE_METHOD (jobject, object, Object);
|
|
|
|
gboolean
|
|
gst_amc_jni_call_void_method (JNIEnv * env, GError ** err, jobject obj,
|
|
jmethodID methodID, ...)
|
|
{
|
|
gboolean ret = TRUE;
|
|
va_list args;
|
|
va_start (args, methodID);
|
|
|
|
(*env)->CallVoidMethodV (env, obj, methodID, args);
|
|
if ((*env)->ExceptionCheck (env)) {
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
|
|
GST_LIBRARY_ERROR_FAILED, "Failed to call Java method");
|
|
ret = FALSE;
|
|
}
|
|
va_end (args);
|
|
return ret;
|
|
}
|
|
|
|
#define GET_TYPE_FIELD(_type, _name, _jname) \
|
|
gboolean gst_amc_jni_get_##_name##_field (JNIEnv *env, GError ** err, jobject obj, jfieldID fieldID, _type *value) \
|
|
{ \
|
|
gboolean ret = TRUE; \
|
|
\
|
|
*value = (*env)->Get##_jname##Field(env, obj, fieldID); \
|
|
if ((*env)->ExceptionCheck (env)) { \
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, \
|
|
"Failed to get Java field"); \
|
|
ret = FALSE; \
|
|
} \
|
|
return ret; \
|
|
}
|
|
|
|
GET_TYPE_FIELD (gboolean, boolean, Boolean);
|
|
GET_TYPE_FIELD (gint8, byte, Byte);
|
|
GET_TYPE_FIELD (gshort, short, Short);
|
|
GET_TYPE_FIELD (gint, int, Int);
|
|
GET_TYPE_FIELD (gchar, char, Char);
|
|
GET_TYPE_FIELD (gint64, long, Long);
|
|
GET_TYPE_FIELD (gfloat, float, Float);
|
|
GET_TYPE_FIELD (gdouble, double, Double);
|
|
GET_TYPE_FIELD (jobject, object, Object);
|
|
|
|
#define GET_STATIC_TYPE_FIELD(_type, _name, _jname) \
|
|
gboolean gst_amc_jni_get_static_##_name##_field (JNIEnv *env, GError ** err, jclass klass, jfieldID fieldID, _type *value) \
|
|
{ \
|
|
gboolean ret = TRUE; \
|
|
\
|
|
*value = (*env)->GetStatic##_jname##Field(env, klass, fieldID); \
|
|
if ((*env)->ExceptionCheck (env)) { \
|
|
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, \
|
|
"Failed to get static Java field"); \
|
|
ret = FALSE; \
|
|
} \
|
|
return ret; \
|
|
}
|
|
|
|
GET_STATIC_TYPE_FIELD (gboolean, boolean, Boolean);
|
|
GET_STATIC_TYPE_FIELD (gint8, byte, Byte);
|
|
GET_STATIC_TYPE_FIELD (gshort, short, Short);
|
|
GET_STATIC_TYPE_FIELD (gint, int, Int);
|
|
GET_STATIC_TYPE_FIELD (gchar, char, Char);
|
|
GET_STATIC_TYPE_FIELD (gint64, long, Long);
|
|
GET_STATIC_TYPE_FIELD (gfloat, float, Float);
|
|
GET_STATIC_TYPE_FIELD (gdouble, double, Double);
|
|
GET_STATIC_TYPE_FIELD (jobject, object, Object);
|