libavcodec/ffjni.c - chromium/third_party/ffmpeg - Git at Google

 /*
  * JNI utility functions
  *
  * Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg 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; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * FFmpeg 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 FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */

 #include <jni.h>
 #include <pthread.h>
 #include <stdlib.h>

 #include "libavutil/bprint.h"
 #include "libavutil/log.h"

 #include "config.h"
 #include "jni.h"
 #include "ffjni.h"

 static JavaVM *java_vm;
 static pthread_key_t current_env;
 static pthread_once_t once = PTHREAD_ONCE_INIT;
 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

 static void jni_detach_env(void *data)
 {
     if (java_vm) {
         (*java_vm)->DetachCurrentThread(java_vm);
     }
 }

 static void jni_create_pthread_key(void)
 {
     pthread_key_create(&current_env, jni_detach_env);
 }

 JNIEnv *ff_jni_get_env(void *log_ctx)
 {
     int ret = 0;
     JNIEnv *env = NULL;

     pthread_mutex_lock(&lock);
     if (java_vm == NULL) {
         java_vm = av_jni_get_java_vm(log_ctx);
     }

     if (!java_vm) {
         av_log(log_ctx, AV_LOG_ERROR, "No Java virtual machine has been registered\n");
         goto done;
     }

     pthread_once(&once, jni_create_pthread_key);

     if ((env = pthread_getspecific(current_env)) != NULL) {
         goto done;
     }

     ret = (*java_vm)->GetEnv(java_vm, (void **)&env, JNI_VERSION_1_6);
     switch(ret) {
     case JNI_EDETACHED:
         if ((*java_vm)->AttachCurrentThread(java_vm, &env, NULL) != 0) {
             av_log(log_ctx, AV_LOG_ERROR, "Failed to attach the JNI environment to the current thread\n");
             env = NULL;
         } else {
             pthread_setspecific(current_env, env);
         }
         break;
     case JNI_OK:
         break;
     case JNI_EVERSION:
         av_log(log_ctx, AV_LOG_ERROR, "The specified JNI version is not supported\n");
         break;
     default:
         av_log(log_ctx, AV_LOG_ERROR, "Failed to get the JNI environment attached to this thread");
         break;
     }

 done:
     pthread_mutex_unlock(&lock);
     return env;
 }

 char *ff_jni_jstring_to_utf_chars(JNIEnv *env, jstring string, void *log_ctx)
 {
     char *ret = NULL;
     const char *utf_chars = NULL;

     jboolean copy = 0;

     if (!string) {
         return NULL;
     }

     utf_chars = (*env)->GetStringUTFChars(env, string, &copy);
     if ((*env)->ExceptionCheck(env)) {
         (*env)->ExceptionClear(env);
         av_log(log_ctx, AV_LOG_ERROR, "String.getStringUTFChars() threw an exception\n");
         return NULL;
     }

     ret = av_strdup(utf_chars);

     (*env)->ReleaseStringUTFChars(env, string, utf_chars);
     if ((*env)->ExceptionCheck(env)) {
         (*env)->ExceptionClear(env);
         av_log(log_ctx, AV_LOG_ERROR, "String.releaseStringUTFChars() threw an exception\n");
         return NULL;
     }

     return ret;
 }

 jstring ff_jni_utf_chars_to_jstring(JNIEnv *env, const char *utf_chars, void *log_ctx)
 {
     jstring ret;

     ret = (*env)->NewStringUTF(env, utf_chars);
     if ((*env)->ExceptionCheck(env)) {
         (*env)->ExceptionClear(env);
         av_log(log_ctx, AV_LOG_ERROR, "NewStringUTF() threw an exception\n");
         return NULL;
     }

     return ret;
 }

 int ff_jni_exception_get_summary(JNIEnv *env, jthrowable exception, char **error, void *log_ctx)
 {
     int ret = 0;

     AVBPrint bp;

     char *name = NULL;
     char *message = NULL;

     jclass class_class = NULL;
     jmethodID get_name_id = NULL;

     jclass exception_class = NULL;
     jmethodID get_message_id = NULL;

     jstring string = NULL;

     av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);

     exception_class = (*env)->GetObjectClass(env, exception);
     if ((*env)->ExceptionCheck(env)) {
         (*env)->ExceptionClear(env);
         av_log(log_ctx, AV_LOG_ERROR, "Could not find Throwable class\n");
         ret = AVERROR_EXTERNAL;
         goto done;
     }

     class_class = (*env)->GetObjectClass(env, exception_class);
     if ((*env)->ExceptionCheck(env)) {
         (*env)->ExceptionClear(env);
         av_log(log_ctx, AV_LOG_ERROR, "Could not find Throwable class's class\n");
         ret = AVERROR_EXTERNAL;
         goto done;
     }

     get_name_id = (*env)->GetMethodID(env, class_class, "getName", "()Ljava/lang/String;");
     if ((*env)->ExceptionCheck(env)) {
         (*env)->ExceptionClear(env);
         av_log(log_ctx, AV_LOG_ERROR, "Could not find method Class.getName()\n");
         ret = AVERROR_EXTERNAL;
         goto done;
     }

     string = (*env)->CallObjectMethod(env, exception_class, get_name_id);
     if ((*env)->ExceptionCheck(env)) {
         (*env)->ExceptionClear(env);
         av_log(log_ctx, AV_LOG_ERROR, "Class.getName() threw an exception\n");
         ret = AVERROR_EXTERNAL;
         goto done;
     }

     if (string) {
         name = ff_jni_jstring_to_utf_chars(env, string, log_ctx);
         (*env)->DeleteLocalRef(env, string);
         string = NULL;
     }

     get_message_id = (*env)->GetMethodID(env, exception_class, "getMessage", "()Ljava/lang/String;");
     if ((*env)->ExceptionCheck(env)) {
         (*env)->ExceptionClear(env);
         av_log(log_ctx, AV_LOG_ERROR, "Could not find method java/lang/Throwable.getMessage()\n");
         ret = AVERROR_EXTERNAL;
         goto done;
     }

     string = (*env)->CallObjectMethod(env, exception, get_message_id);
     if ((*env)->ExceptionCheck(env)) {
         (*env)->ExceptionClear(env);
         av_log(log_ctx, AV_LOG_ERROR, "Throwable.getMessage() threw an exception\n");
         ret = AVERROR_EXTERNAL;
         goto done;
     }

     if (string) {
         message = ff_jni_jstring_to_utf_chars(env, string, log_ctx);
         (*env)->DeleteLocalRef(env, string);
         string = NULL;
     }

     if (name && message) {
         av_bprintf(&bp, "%s: %s", name, message);
     } else if (name && !message) {
         av_bprintf(&bp, "%s occurred", name);
     } else if (!name && message) {
         av_bprintf(&bp, "Exception: %s", message);
     } else {
         av_log(log_ctx, AV_LOG_WARNING, "Could not retrieve exception name and message\n");
         av_bprintf(&bp, "Exception occurred");
     }

     ret = av_bprint_finalize(&bp, error);
 done:

     av_free(name);
     av_free(message);

     if (class_class) {
         (*env)->DeleteLocalRef(env, class_class);
     }

     if (exception_class) {
         (*env)->DeleteLocalRef(env, exception_class);
     }

     if (string) {
         (*env)->DeleteLocalRef(env, string);
     }

     return ret;
 }

 int ff_jni_exception_check(JNIEnv *env, int log, void *log_ctx)
 {
     int ret;

     jthrowable exception;

     char *message = NULL;

     if (!(*(env))->ExceptionCheck((env))) {
         return 0;
     }

     if (!log) {
         (*(env))->ExceptionClear((env));
         return -1;
     }

     exception = (*env)->ExceptionOccurred(env);
     (*(env))->ExceptionClear((env));

     if ((ret = ff_jni_exception_get_summary(env, exception, &message, log_ctx)) < 0) {
         (*env)->DeleteLocalRef(env, exception);
         return ret;
     }

     (*env)->DeleteLocalRef(env, exception);

     av_log(log_ctx, AV_LOG_ERROR, "%s\n", message);
     av_free(message);

     return -1;
 }

 int ff_jni_init_jfields(JNIEnv *env, void *jfields, const struct FFJniField *jfields_mapping, int global, void *log_ctx)
 {
     int i, ret = 0;
     jclass last_clazz = NULL;

     for (i = 0; jfields_mapping[i].name; i++) {
         int mandatory = jfields_mapping[i].mandatory;
         enum FFJniFieldType type = jfields_mapping[i].type;

         if (type == FF_JNI_CLASS) {
             jclass clazz;

             last_clazz = NULL;

             clazz = (*env)->FindClass(env, jfields_mapping[i].name);
             if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
                 goto done;
             }

             last_clazz = *(jclass*)((uint8_t*)jfields + jfields_mapping[i].offset) =
                     global ? (*env)->NewGlobalRef(env, clazz) : clazz;
         } else {

             if (!last_clazz) {
                 ret = AVERROR_EXTERNAL;
                 break;
             }

             switch(type) {
             case FF_JNI_FIELD: {
                 jfieldID field_id = (*env)->GetFieldID(env, last_clazz, jfields_mapping[i].method, jfields_mapping[i].signature);
                 if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
                     goto done;
                 }

                 *(jfieldID*)((uint8_t*)jfields + jfields_mapping[i].offset) = field_id;
                 break;
             }
             case FF_JNI_STATIC_FIELD: {
                 jfieldID field_id = (*env)->GetStaticFieldID(env, last_clazz, jfields_mapping[i].method, jfields_mapping[i].signature);
                 if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
                     goto done;
                 }

                 *(jfieldID*)((uint8_t*)jfields + jfields_mapping[i].offset) = field_id;
                 break;
             }
             case FF_JNI_METHOD: {
                 jmethodID method_id = (*env)->GetMethodID(env, last_clazz, jfields_mapping[i].method, jfields_mapping[i].signature);
                 if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
                     goto done;
                 }

                 *(jmethodID*)((uint8_t*)jfields + jfields_mapping[i].offset) = method_id;
                 break;
             }
             case FF_JNI_STATIC_METHOD: {
                 jmethodID method_id = (*env)->GetStaticMethodID(env, last_clazz, jfields_mapping[i].method, jfields_mapping[i].signature);
                 if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
                     goto done;
                 }

                 *(jmethodID*)((uint8_t*)jfields + jfields_mapping[i].offset) = method_id;
                 break;
             }
             default:
                 av_log(log_ctx, AV_LOG_ERROR, "Unknown JNI field type\n");
                 ret = AVERROR(EINVAL);
                 goto done;
             }

             ret = 0;
         }
     }

 done:
     if (ret < 0) {
         /* reset jfields in case of failure so it does not leak references */
         ff_jni_reset_jfields(env, jfields, jfields_mapping, global, log_ctx);
     }

     return ret;
 }

 int ff_jni_reset_jfields(JNIEnv *env, void *jfields, const struct FFJniField *jfields_mapping, int global, void *log_ctx)
 {
     int i;

     for (i = 0; jfields_mapping[i].name; i++) {
         enum FFJniFieldType type = jfields_mapping[i].type;

         switch(type) {
         case FF_JNI_CLASS: {
             jclass clazz = *(jclass*)((uint8_t*)jfields + jfields_mapping[i].offset);
             if (!clazz)
                 continue;

             if (global) {
                 (*env)->DeleteGlobalRef(env, clazz);
             } else {
                 (*env)->DeleteLocalRef(env, clazz);
             }

             *(jclass*)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
             break;
         }
         case FF_JNI_FIELD: {
             *(jfieldID*)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
             break;
         }
         case FF_JNI_STATIC_FIELD: {
             *(jfieldID*)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
             break;
         }
         case FF_JNI_METHOD: {
             *(jmethodID*)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
             break;
         }
         case FF_JNI_STATIC_METHOD: {
             *(jmethodID*)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
             break;
         }
         default:
             av_log(log_ctx, AV_LOG_ERROR, "Unknown JNI field type\n");
         }
     }

     return 0;
 }
	/*
	* JNI utility functions
	*
	* Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
	*
	* This file is part of FFmpeg.
	*
	* FFmpeg 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; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* FFmpeg 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 FFmpeg; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include <jni.h>
	#include <pthread.h>
	#include <stdlib.h>

	#include "libavutil/bprint.h"
	#include "libavutil/log.h"

	#include "config.h"
	#include "jni.h"
	#include "ffjni.h"

	static JavaVM *java_vm;
	static pthread_key_t current_env;
	static pthread_once_t once = PTHREAD_ONCE_INIT;
	static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

	static void jni_detach_env(void *data)
	{
	if (java_vm) {
	(*java_vm)->DetachCurrentThread(java_vm);
	}
	}

	static void jni_create_pthread_key(void)
	{
	pthread_key_create(&current_env, jni_detach_env);
	}

	JNIEnv ff_jni_get_env(void log_ctx)
	{
	int ret = 0;
	JNIEnv *env = NULL;

	pthread_mutex_lock(&lock);
	if (java_vm == NULL) {
	java_vm = av_jni_get_java_vm(log_ctx);
	}

	if (!java_vm) {
	av_log(log_ctx, AV_LOG_ERROR, "No Java virtual machine has been registered\n");
	goto done;
	}

	pthread_once(&once, jni_create_pthread_key);

	if ((env = pthread_getspecific(current_env)) != NULL) {
	goto done;
	}

	ret = (java_vm)->GetEnv(java_vm, (void *)&env, JNI_VERSION_1_6);
	switch(ret) {
	case JNI_EDETACHED:
	if ((*java_vm)->AttachCurrentThread(java_vm, &env, NULL) != 0) {
	av_log(log_ctx, AV_LOG_ERROR, "Failed to attach the JNI environment to the current thread\n");
	env = NULL;
	} else {
	pthread_setspecific(current_env, env);
	}
	break;
	case JNI_OK:
	break;
	case JNI_EVERSION:
	av_log(log_ctx, AV_LOG_ERROR, "The specified JNI version is not supported\n");
	break;
	default:
	av_log(log_ctx, AV_LOG_ERROR, "Failed to get the JNI environment attached to this thread");
	break;
	}

	done:
	pthread_mutex_unlock(&lock);
	return env;
	}

	char ff_jni_jstring_to_utf_chars(JNIEnv env, jstring string, void *log_ctx)
	{
	char *ret = NULL;
	const char *utf_chars = NULL;

	jboolean copy = 0;

	if (!string) {
	return NULL;
	}

	utf_chars = (*env)->GetStringUTFChars(env, string, &copy);
	if ((*env)->ExceptionCheck(env)) {
	(*env)->ExceptionClear(env);
	av_log(log_ctx, AV_LOG_ERROR, "String.getStringUTFChars() threw an exception\n");
	return NULL;
	}

	ret = av_strdup(utf_chars);

	(*env)->ReleaseStringUTFChars(env, string, utf_chars);
	if ((*env)->ExceptionCheck(env)) {
	(*env)->ExceptionClear(env);
	av_log(log_ctx, AV_LOG_ERROR, "String.releaseStringUTFChars() threw an exception\n");
	return NULL;
	}

	return ret;
	}

	jstring ff_jni_utf_chars_to_jstring(JNIEnv env, const char utf_chars, void *log_ctx)
	{
	jstring ret;

	ret = (*env)->NewStringUTF(env, utf_chars);
	if ((*env)->ExceptionCheck(env)) {
	(*env)->ExceptionClear(env);
	av_log(log_ctx, AV_LOG_ERROR, "NewStringUTF() threw an exception\n");
	return NULL;
	}

	return ret;
	}

	int ff_jni_exception_get_summary(JNIEnv env, jthrowable exception, char error, void log_ctx)
	{
	int ret = 0;

	AVBPrint bp;

	char *name = NULL;
	char *message = NULL;

	jclass class_class = NULL;
	jmethodID get_name_id = NULL;

	jclass exception_class = NULL;
	jmethodID get_message_id = NULL;

	jstring string = NULL;

	av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);

	exception_class = (*env)->GetObjectClass(env, exception);
	if ((*env)->ExceptionCheck(env)) {
	(*env)->ExceptionClear(env);
	av_log(log_ctx, AV_LOG_ERROR, "Could not find Throwable class\n");
	ret = AVERROR_EXTERNAL;
	goto done;
	}

	class_class = (*env)->GetObjectClass(env, exception_class);
	if ((*env)->ExceptionCheck(env)) {
	(*env)->ExceptionClear(env);
	av_log(log_ctx, AV_LOG_ERROR, "Could not find Throwable class's class\n");
	ret = AVERROR_EXTERNAL;
	goto done;
	}

	get_name_id = (*env)->GetMethodID(env, class_class, "getName", "()Ljava/lang/String;");
	if ((*env)->ExceptionCheck(env)) {
	(*env)->ExceptionClear(env);
	av_log(log_ctx, AV_LOG_ERROR, "Could not find method Class.getName()\n");
	ret = AVERROR_EXTERNAL;
	goto done;
	}

	string = (*env)->CallObjectMethod(env, exception_class, get_name_id);
	if ((*env)->ExceptionCheck(env)) {
	(*env)->ExceptionClear(env);
	av_log(log_ctx, AV_LOG_ERROR, "Class.getName() threw an exception\n");
	ret = AVERROR_EXTERNAL;
	goto done;
	}

	if (string) {
	name = ff_jni_jstring_to_utf_chars(env, string, log_ctx);
	(*env)->DeleteLocalRef(env, string);
	string = NULL;
	}

	get_message_id = (*env)->GetMethodID(env, exception_class, "getMessage", "()Ljava/lang/String;");
	if ((*env)->ExceptionCheck(env)) {
	(*env)->ExceptionClear(env);
	av_log(log_ctx, AV_LOG_ERROR, "Could not find method java/lang/Throwable.getMessage()\n");
	ret = AVERROR_EXTERNAL;
	goto done;
	}

	string = (*env)->CallObjectMethod(env, exception, get_message_id);
	if ((*env)->ExceptionCheck(env)) {
	(*env)->ExceptionClear(env);
	av_log(log_ctx, AV_LOG_ERROR, "Throwable.getMessage() threw an exception\n");
	ret = AVERROR_EXTERNAL;
	goto done;
	}

	if (string) {
	message = ff_jni_jstring_to_utf_chars(env, string, log_ctx);
	(*env)->DeleteLocalRef(env, string);
	string = NULL;
	}

	if (name && message) {
	av_bprintf(&bp, "%s: %s", name, message);
	} else if (name && !message) {
	av_bprintf(&bp, "%s occurred", name);
	} else if (!name && message) {
	av_bprintf(&bp, "Exception: %s", message);
	} else {
	av_log(log_ctx, AV_LOG_WARNING, "Could not retrieve exception name and message\n");
	av_bprintf(&bp, "Exception occurred");
	}

	ret = av_bprint_finalize(&bp, error);
	done:

	av_free(name);
	av_free(message);

	if (class_class) {
	(*env)->DeleteLocalRef(env, class_class);
	}

	if (exception_class) {
	(*env)->DeleteLocalRef(env, exception_class);
	}

	if (string) {
	(*env)->DeleteLocalRef(env, string);
	}

	return ret;
	}

	int ff_jni_exception_check(JNIEnv env, int log, void log_ctx)
	{
	int ret;

	jthrowable exception;

	char *message = NULL;

	if (!(*(env))->ExceptionCheck((env))) {
	return 0;
	}

	if (!log) {
	(*(env))->ExceptionClear((env));
	return -1;
	}

	exception = (*env)->ExceptionOccurred(env);
	(*(env))->ExceptionClear((env));

	if ((ret = ff_jni_exception_get_summary(env, exception, &message, log_ctx)) < 0) {
	(*env)->DeleteLocalRef(env, exception);
	return ret;
	}

	(*env)->DeleteLocalRef(env, exception);

	av_log(log_ctx, AV_LOG_ERROR, "%s\n", message);
	av_free(message);

	return -1;
	}

	int ff_jni_init_jfields(JNIEnv env, void jfields, const struct FFJniField jfields_mapping, int global, void log_ctx)
	{
	int i, ret = 0;
	jclass last_clazz = NULL;

	for (i = 0; jfields_mapping[i].name; i++) {
	int mandatory = jfields_mapping[i].mandatory;
	enum FFJniFieldType type = jfields_mapping[i].type;

	if (type == FF_JNI_CLASS) {
	jclass clazz;

	last_clazz = NULL;

	clazz = (*env)->FindClass(env, jfields_mapping[i].name);
	if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
	goto done;
	}

	last_clazz = (jclass)((uint8_t*)jfields + jfields_mapping[i].offset) =
	global ? (*env)->NewGlobalRef(env, clazz) : clazz;
	} else {

	if (!last_clazz) {
	ret = AVERROR_EXTERNAL;
	break;
	}

	switch(type) {
	case FF_JNI_FIELD: {
	jfieldID field_id = (*env)->GetFieldID(env, last_clazz, jfields_mapping[i].method, jfields_mapping[i].signature);
	if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
	goto done;
	}

	(jfieldID)((uint8_t*)jfields + jfields_mapping[i].offset) = field_id;
	break;
	}
	case FF_JNI_STATIC_FIELD: {
	jfieldID field_id = (*env)->GetStaticFieldID(env, last_clazz, jfields_mapping[i].method, jfields_mapping[i].signature);
	if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
	goto done;
	}

	(jfieldID)((uint8_t*)jfields + jfields_mapping[i].offset) = field_id;
	break;
	}
	case FF_JNI_METHOD: {
	jmethodID method_id = (*env)->GetMethodID(env, last_clazz, jfields_mapping[i].method, jfields_mapping[i].signature);
	if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
	goto done;
	}

	(jmethodID)((uint8_t*)jfields + jfields_mapping[i].offset) = method_id;
	break;
	}
	case FF_JNI_STATIC_METHOD: {
	jmethodID method_id = (*env)->GetStaticMethodID(env, last_clazz, jfields_mapping[i].method, jfields_mapping[i].signature);
	if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
	goto done;
	}

	(jmethodID)((uint8_t*)jfields + jfields_mapping[i].offset) = method_id;
	break;
	}
	default:
	av_log(log_ctx, AV_LOG_ERROR, "Unknown JNI field type\n");
	ret = AVERROR(EINVAL);
	goto done;
	}

	ret = 0;
	}
	}

	done:
	if (ret < 0) {
	/* reset jfields in case of failure so it does not leak references */
	ff_jni_reset_jfields(env, jfields, jfields_mapping, global, log_ctx);
	}

	return ret;
	}

	int ff_jni_reset_jfields(JNIEnv env, void jfields, const struct FFJniField jfields_mapping, int global, void log_ctx)
	{
	int i;

	for (i = 0; jfields_mapping[i].name; i++) {
	enum FFJniFieldType type = jfields_mapping[i].type;

	switch(type) {
	case FF_JNI_CLASS: {
	jclass clazz = (jclass)((uint8_t*)jfields + jfields_mapping[i].offset);
	if (!clazz)
	continue;

	if (global) {
	(*env)->DeleteGlobalRef(env, clazz);
	} else {
	(*env)->DeleteLocalRef(env, clazz);
	}

	(jclass)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
	break;
	}
	case FF_JNI_FIELD: {
	(jfieldID)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
	break;
	}
	case FF_JNI_STATIC_FIELD: {
	(jfieldID)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
	break;
	}
	case FF_JNI_METHOD: {
	(jmethodID)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
	break;
	}
	case FF_JNI_STATIC_METHOD: {
	(jmethodID)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
	break;
	}
	default:
	av_log(log_ctx, AV_LOG_ERROR, "Unknown JNI field type\n");
	}
	}

	return 0;
	}