vp9: add 16x16 idct avx2 (8-bit).
[ffmpeg.git] / libavcodec / ffjni.c
1 /*
2  * JNI utility functions
3  *
4  * Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 #include <jni.h>
24 #include <pthread.h>
25 #include <stdlib.h>
26
27 #include "libavutil/bprint.h"
28 #include "libavutil/log.h"
29
30 #include "config.h"
31 #include "jni.h"
32 #include "ffjni.h"
33
34 static JavaVM *java_vm = NULL;
35 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
36
37 JNIEnv *ff_jni_attach_env(int *attached, void *log_ctx)
38 {
39     int ret = 0;
40     JNIEnv *env = NULL;
41
42     *attached = 0;
43
44     pthread_mutex_lock(&lock);
45     if (java_vm == NULL) {
46         java_vm = av_jni_get_java_vm(log_ctx);
47     }
48     pthread_mutex_unlock(&lock);
49
50     if (!java_vm) {
51         av_log(log_ctx, AV_LOG_ERROR, "No Java virtual machine has been registered\n");
52         return NULL;
53     }
54
55     ret = (*java_vm)->GetEnv(java_vm, (void **)&env, JNI_VERSION_1_6);
56     switch(ret) {
57     case JNI_EDETACHED:
58         if ((*java_vm)->AttachCurrentThread(java_vm, &env, NULL) != 0) {
59             av_log(log_ctx, AV_LOG_ERROR, "Failed to attach the JNI environment to the current thread\n");
60             env = NULL;
61         } else {
62             *attached = 1;
63         }
64         break;
65     case JNI_OK:
66         break;
67     case JNI_EVERSION:
68         av_log(log_ctx, AV_LOG_ERROR, "The specified JNI version is not supported\n");
69         break;
70     default:
71         av_log(log_ctx, AV_LOG_ERROR, "Failed to get the JNI environment attached to this thread");
72         break;
73     }
74
75     return env;
76 }
77
78 int ff_jni_detach_env(void *log_ctx)
79 {
80     if (java_vm == NULL) {
81         av_log(log_ctx, AV_LOG_ERROR, "No Java virtual machine has been registered\n");
82         return AVERROR(EINVAL);
83     }
84
85     return (*java_vm)->DetachCurrentThread(java_vm);
86 }
87
88 char *ff_jni_jstring_to_utf_chars(JNIEnv *env, jstring string, void *log_ctx)
89 {
90     char *ret = NULL;
91     const char *utf_chars = NULL;
92
93     jboolean copy = 0;
94
95     if (!string) {
96         return NULL;
97     }
98
99     utf_chars = (*env)->GetStringUTFChars(env, string, &copy);
100     if ((*env)->ExceptionCheck(env)) {
101         (*env)->ExceptionClear(env);
102         av_log(log_ctx, AV_LOG_ERROR, "String.getStringUTFChars() threw an exception\n");
103         return NULL;
104     }
105
106     ret = av_strdup(utf_chars);
107
108     (*env)->ReleaseStringUTFChars(env, string, utf_chars);
109     if ((*env)->ExceptionCheck(env)) {
110         (*env)->ExceptionClear(env);
111         av_log(log_ctx, AV_LOG_ERROR, "String.releaseStringUTFChars() threw an exception\n");
112         return NULL;
113     }
114
115     return ret;
116 }
117
118 jstring ff_jni_utf_chars_to_jstring(JNIEnv *env, const char *utf_chars, void *log_ctx)
119 {
120     jstring ret;
121
122     ret = (*env)->NewStringUTF(env, utf_chars);
123     if ((*env)->ExceptionCheck(env)) {
124         (*env)->ExceptionClear(env);
125         av_log(log_ctx, AV_LOG_ERROR, "NewStringUTF() threw an exception\n");
126         return NULL;
127     }
128
129     return ret;
130 }
131
132 int ff_jni_exception_get_summary(JNIEnv *env, jthrowable exception, char **error, void *log_ctx)
133 {
134     int ret = 0;
135
136     AVBPrint bp;
137
138     char *name = NULL;
139     char *message = NULL;
140
141     jclass class_class = NULL;
142     jmethodID get_name_id = NULL;
143
144     jclass exception_class = NULL;
145     jmethodID get_message_id = NULL;
146
147     jstring string = NULL;
148
149     av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
150
151     exception_class = (*env)->GetObjectClass(env, exception);
152     if ((*env)->ExceptionCheck(env)) {
153         (*env)->ExceptionClear(env);
154         av_log(log_ctx, AV_LOG_ERROR, "Could not find Throwable class\n");
155         ret = AVERROR_EXTERNAL;
156         goto done;
157     }
158
159     class_class = (*env)->GetObjectClass(env, exception_class);
160     if ((*env)->ExceptionCheck(env)) {
161         (*env)->ExceptionClear(env);
162         av_log(log_ctx, AV_LOG_ERROR, "Could not find Throwable class's class\n");
163         ret = AVERROR_EXTERNAL;
164         goto done;
165     }
166
167     get_name_id = (*env)->GetMethodID(env, class_class, "getName", "()Ljava/lang/String;");
168     if ((*env)->ExceptionCheck(env)) {
169         (*env)->ExceptionClear(env);
170         av_log(log_ctx, AV_LOG_ERROR, "Could not find method Class.getName()\n");
171         ret = AVERROR_EXTERNAL;
172         goto done;
173     }
174
175     string = (*env)->CallObjectMethod(env, exception_class, get_name_id);
176     if ((*env)->ExceptionCheck(env)) {
177         (*env)->ExceptionClear(env);
178         av_log(log_ctx, AV_LOG_ERROR, "Class.getName() threw an exception\n");
179         ret = AVERROR_EXTERNAL;
180         goto done;
181     }
182
183     if (string) {
184         name = ff_jni_jstring_to_utf_chars(env, string, log_ctx);
185         (*env)->DeleteLocalRef(env, string);
186         string = NULL;
187     }
188
189     get_message_id = (*env)->GetMethodID(env, exception_class, "getMessage", "()Ljava/lang/String;");
190     if ((*env)->ExceptionCheck(env)) {
191         (*env)->ExceptionClear(env);
192         av_log(log_ctx, AV_LOG_ERROR, "Could not find method java/lang/Throwable.getMessage()\n");
193         ret = AVERROR_EXTERNAL;
194         goto done;
195     }
196
197     string = (*env)->CallObjectMethod(env, exception, get_message_id);
198     if ((*env)->ExceptionCheck(env)) {
199         (*env)->ExceptionClear(env);
200         av_log(log_ctx, AV_LOG_ERROR, "Throwable.getMessage() threw an exception\n");
201         ret = AVERROR_EXTERNAL;
202         goto done;
203     }
204
205     if (string) {
206         message = ff_jni_jstring_to_utf_chars(env, string, log_ctx);
207         (*env)->DeleteLocalRef(env, string);
208         string = NULL;
209     }
210
211     if (name && message) {
212         av_bprintf(&bp, "%s: %s", name, message);
213     } else if (name && !message) {
214         av_bprintf(&bp, "%s occurred", name);
215     } else if (!name && message) {
216         av_bprintf(&bp, "Exception: %s", message);
217     } else {
218         av_log(log_ctx, AV_LOG_WARNING, "Could not retreive exception name and message\n");
219         av_bprintf(&bp, "Exception occurred");
220     }
221
222     ret = av_bprint_finalize(&bp, error);
223 done:
224
225     av_free(name);
226     av_free(message);
227
228     if (class_class) {
229         (*env)->DeleteLocalRef(env, class_class);
230     }
231
232     if (exception_class) {
233         (*env)->DeleteLocalRef(env, exception_class);
234     }
235
236     if (string) {
237         (*env)->DeleteLocalRef(env, string);
238     }
239
240     return ret;
241 }
242
243 int ff_jni_exception_check(JNIEnv *env, int log, void *log_ctx)
244 {
245     int ret;
246
247     jthrowable exception;
248
249     char *message = NULL;
250
251     if (!(*(env))->ExceptionCheck((env))) {
252         return 0;
253     }
254
255     if (!log) {
256         (*(env))->ExceptionClear((env));
257         return -1;
258     }
259
260     exception = (*env)->ExceptionOccurred(env);
261     (*(env))->ExceptionClear((env));
262
263     if ((ret = ff_jni_exception_get_summary(env, exception, &message, log_ctx)) < 0) {
264         (*env)->DeleteLocalRef(env, exception);
265         return ret;
266     }
267
268     (*env)->DeleteLocalRef(env, exception);
269
270     av_log(log_ctx, AV_LOG_ERROR, "%s\n", message);
271     av_free(message);
272
273     return -1;
274 }
275
276 int ff_jni_init_jfields(JNIEnv *env, void *jfields, const struct FFJniField *jfields_mapping, int global, void *log_ctx)
277 {
278     int i, ret = 0;
279     jclass last_clazz = NULL;
280
281     for (i = 0; jfields_mapping[i].name; i++) {
282         int mandatory = jfields_mapping[i].mandatory;
283         enum FFJniFieldType type = jfields_mapping[i].type;
284
285         if (type == FF_JNI_CLASS) {
286             jclass clazz;
287
288             last_clazz = NULL;
289
290             clazz = (*env)->FindClass(env, jfields_mapping[i].name);
291             if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
292                 goto done;
293             }
294
295             last_clazz = *(jclass*)((uint8_t*)jfields + jfields_mapping[i].offset) =
296                     global ? (*env)->NewGlobalRef(env, clazz) : clazz;
297         } else {
298
299             if (!last_clazz) {
300                 ret = AVERROR_EXTERNAL;
301                 break;
302             }
303
304             switch(type) {
305             case FF_JNI_FIELD: {
306                 jfieldID field_id = (*env)->GetFieldID(env, last_clazz, jfields_mapping[i].method, jfields_mapping[i].signature);
307                 if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
308                     goto done;
309                 }
310
311                 *(jfieldID*)((uint8_t*)jfields + jfields_mapping[i].offset) = field_id;
312                 break;
313             }
314             case FF_JNI_STATIC_FIELD: {
315                 jfieldID field_id = (*env)->GetStaticFieldID(env, last_clazz, jfields_mapping[i].method, jfields_mapping[i].signature);
316                 if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
317                     goto done;
318                 }
319
320                 *(jfieldID*)((uint8_t*)jfields + jfields_mapping[i].offset) = field_id;
321                 break;
322             }
323             case FF_JNI_METHOD: {
324                 jmethodID method_id = (*env)->GetMethodID(env, last_clazz, jfields_mapping[i].method, jfields_mapping[i].signature);
325                 if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
326                     goto done;
327                 }
328
329                 *(jmethodID*)((uint8_t*)jfields + jfields_mapping[i].offset) = method_id;
330                 break;
331             }
332             case FF_JNI_STATIC_METHOD: {
333                 jmethodID method_id = (*env)->GetStaticMethodID(env, last_clazz, jfields_mapping[i].method, jfields_mapping[i].signature);
334                 if ((ret = ff_jni_exception_check(env, mandatory, log_ctx)) < 0 && mandatory) {
335                     goto done;
336                 }
337
338                 *(jmethodID*)((uint8_t*)jfields + jfields_mapping[i].offset) = method_id;
339                 break;
340             }
341             default:
342                 av_log(log_ctx, AV_LOG_ERROR, "Unknown JNI field type\n");
343                 ret = AVERROR(EINVAL);
344                 goto done;
345             }
346         }
347     }
348
349 done:
350     if (ret < 0) {
351         /* reset jfields in case of failure so it does not leak references */
352         ff_jni_reset_jfields(env, jfields, jfields_mapping, global, log_ctx);
353     }
354
355     return ret;
356 }
357
358 int ff_jni_reset_jfields(JNIEnv *env, void *jfields, const struct FFJniField *jfields_mapping, int global, void *log_ctx)
359 {
360     int i;
361
362     for (i = 0; jfields_mapping[i].name; i++) {
363         enum FFJniFieldType type = jfields_mapping[i].type;
364
365         switch(type) {
366         case FF_JNI_CLASS: {
367             jclass clazz = *(jclass*)((uint8_t*)jfields + jfields_mapping[i].offset);
368             if (!clazz)
369                 continue;
370
371             if (global) {
372                 (*env)->DeleteGlobalRef(env, clazz);
373             } else {
374                 (*env)->DeleteLocalRef(env, clazz);
375             }
376
377             *(jclass*)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
378             break;
379         }
380         case FF_JNI_FIELD: {
381             *(jfieldID*)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
382             break;
383         }
384         case FF_JNI_STATIC_FIELD: {
385             *(jfieldID*)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
386             break;
387         }
388         case FF_JNI_METHOD: {
389             *(jmethodID*)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
390             break;
391         }
392         case FF_JNI_STATIC_METHOD: {
393             *(jmethodID*)((uint8_t*)jfields + jfields_mapping[i].offset) = NULL;
394             break;
395         }
396         default:
397             av_log(log_ctx, AV_LOG_ERROR, "Unknown JNI field type\n");
398         }
399     }
400
401     return 0;
402 }