| /* |
| ** Copyright 2012, 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. |
| */ |
| |
| // This source file is automatically generated |
| |
| #pragma GCC diagnostic ignored "-Wunused-variable" |
| #pragma GCC diagnostic ignored "-Wunused-function" |
| |
| #include "jni.h" |
| #include <nativehelper/JNIHelp.h> |
| #include <android_runtime/AndroidRuntime.h> |
| #include <android_runtime/android_view_Surface.h> |
| #include <android_runtime/android_graphics_SurfaceTexture.h> |
| #include <utils/misc.h> |
| |
| #include <assert.h> |
| #include <EGL/egl.h> |
| |
| #include <gui/Surface.h> |
| #include <gui/GLConsumer.h> |
| #include <gui/Surface.h> |
| |
| #include <ui/ANativeObjectBase.h> |
| |
| static jclass egldisplayClass; |
| static jclass eglcontextClass; |
| static jclass eglsurfaceClass; |
| static jclass eglconfigClass; |
| |
| static jmethodID egldisplayGetHandleID; |
| static jmethodID eglcontextGetHandleID; |
| static jmethodID eglsurfaceGetHandleID; |
| static jmethodID eglconfigGetHandleID; |
| |
| static jmethodID egldisplayConstructor; |
| static jmethodID eglcontextConstructor; |
| static jmethodID eglsurfaceConstructor; |
| static jmethodID eglconfigConstructor; |
| |
| static jobject eglNoContextObject; |
| static jobject eglNoDisplayObject; |
| static jobject eglNoSurfaceObject; |
| |
| |
| |
| /* Cache method IDs each time the class is loaded. */ |
| |
| static void |
| nativeClassInit(JNIEnv *_env, jclass glImplClass) |
| { |
| jclass egldisplayClassLocal = _env->FindClass("android/opengl/EGLDisplay"); |
| egldisplayClass = (jclass) _env->NewGlobalRef(egldisplayClassLocal); |
| jclass eglcontextClassLocal = _env->FindClass("android/opengl/EGLContext"); |
| eglcontextClass = (jclass) _env->NewGlobalRef(eglcontextClassLocal); |
| jclass eglsurfaceClassLocal = _env->FindClass("android/opengl/EGLSurface"); |
| eglsurfaceClass = (jclass) _env->NewGlobalRef(eglsurfaceClassLocal); |
| jclass eglconfigClassLocal = _env->FindClass("android/opengl/EGLConfig"); |
| eglconfigClass = (jclass) _env->NewGlobalRef(eglconfigClassLocal); |
| |
| egldisplayGetHandleID = _env->GetMethodID(egldisplayClass, "getNativeHandle", "()J"); |
| eglcontextGetHandleID = _env->GetMethodID(eglcontextClass, "getNativeHandle", "()J"); |
| eglsurfaceGetHandleID = _env->GetMethodID(eglsurfaceClass, "getNativeHandle", "()J"); |
| eglconfigGetHandleID = _env->GetMethodID(eglconfigClass, "getNativeHandle", "()J"); |
| |
| |
| egldisplayConstructor = _env->GetMethodID(egldisplayClass, "<init>", "(J)V"); |
| eglcontextConstructor = _env->GetMethodID(eglcontextClass, "<init>", "(J)V"); |
| eglsurfaceConstructor = _env->GetMethodID(eglsurfaceClass, "<init>", "(J)V"); |
| eglconfigConstructor = _env->GetMethodID(eglconfigClass, "<init>", "(J)V"); |
| |
| jobject localeglNoContextObject = _env->NewObject(eglcontextClass, eglcontextConstructor, reinterpret_cast<jlong>(EGL_NO_CONTEXT)); |
| eglNoContextObject = _env->NewGlobalRef(localeglNoContextObject); |
| jobject localeglNoDisplayObject = _env->NewObject(egldisplayClass, egldisplayConstructor, reinterpret_cast<jlong>(EGL_NO_DISPLAY)); |
| eglNoDisplayObject = _env->NewGlobalRef(localeglNoDisplayObject); |
| jobject localeglNoSurfaceObject = _env->NewObject(eglsurfaceClass, eglsurfaceConstructor, reinterpret_cast<jlong>(EGL_NO_SURFACE)); |
| eglNoSurfaceObject = _env->NewGlobalRef(localeglNoSurfaceObject); |
| |
| |
| jclass eglClass = _env->FindClass("android/opengl/EGL14"); |
| jfieldID noContextFieldID = _env->GetStaticFieldID(eglClass, "EGL_NO_CONTEXT", "Landroid/opengl/EGLContext;"); |
| _env->SetStaticObjectField(eglClass, noContextFieldID, eglNoContextObject); |
| |
| jfieldID noDisplayFieldID = _env->GetStaticFieldID(eglClass, "EGL_NO_DISPLAY", "Landroid/opengl/EGLDisplay;"); |
| _env->SetStaticObjectField(eglClass, noDisplayFieldID, eglNoDisplayObject); |
| |
| jfieldID noSurfaceFieldID = _env->GetStaticFieldID(eglClass, "EGL_NO_SURFACE", "Landroid/opengl/EGLSurface;"); |
| _env->SetStaticObjectField(eglClass, noSurfaceFieldID, eglNoSurfaceObject); |
| } |
| |
| static void * |
| fromEGLHandle(JNIEnv *_env, jmethodID mid, jobject obj) { |
| if (obj == NULL){ |
| jniThrowException(_env, "java/lang/IllegalArgumentException", |
| "Object is set to null."); |
| return nullptr; |
| } |
| |
| jlong handle = _env->CallLongMethod(obj, mid); |
| return reinterpret_cast<void*>(handle); |
| } |
| |
| static jobject |
| toEGLHandle(JNIEnv *_env, jclass cls, jmethodID con, void * handle) { |
| if (cls == eglcontextClass && |
| (EGLContext)handle == EGL_NO_CONTEXT) { |
| return eglNoContextObject; |
| } |
| |
| if (cls == egldisplayClass && |
| (EGLDisplay)handle == EGL_NO_DISPLAY) { |
| return eglNoDisplayObject; |
| } |
| |
| if (cls == eglsurfaceClass && |
| (EGLSurface)handle == EGL_NO_SURFACE) { |
| return eglNoSurfaceObject; |
| } |
| |
| return _env->NewObject(cls, con, reinterpret_cast<jlong>(handle)); |
| } |
| |
| // -------------------------------------------------------------------------- |
| /* EGLint eglGetError ( void ) */ |
| static jint |
| android_eglGetError |
| (JNIEnv *_env, jobject _this) { |
| EGLint _returnValue = (EGLint) 0; |
| _returnValue = eglGetError(); |
| return (jint)_returnValue; |
| } |
| |
| /* EGLDisplay eglGetDisplay ( EGLNativeDisplayType display_id ) */ |
| static jobject |
| android_eglGetDisplay |
| (JNIEnv *_env, jobject _this, jlong display_id) { |
| EGLDisplay _returnValue = (EGLDisplay) 0; |
| _returnValue = eglGetDisplay( |
| reinterpret_cast<EGLNativeDisplayType>(display_id) |
| ); |
| return toEGLHandle(_env, egldisplayClass, egldisplayConstructor, _returnValue); |
| } |
| |
| /* EGLDisplay eglGetDisplay ( EGLNativeDisplayType display_id ) */ |
| static jobject |
| android_eglGetDisplayInt |
| (JNIEnv *_env, jobject _this, jint display_id) { |
| |
| if (static_cast<uintptr_t>(display_id) != |
| reinterpret_cast<uintptr_t>(EGL_DEFAULT_DISPLAY)) { |
| jniThrowException(_env, "java/lang/UnsupportedOperationException", "eglGetDisplay"); |
| return 0; |
| } |
| return android_eglGetDisplay(_env, _this, display_id); |
| } |
| |
| /* EGLBoolean eglInitialize ( EGLDisplay dpy, EGLint *major, EGLint *minor ) */ |
| static jboolean |
| android_eglInitialize |
| (JNIEnv *_env, jobject _this, jobject dpy, jintArray major_ref, jint majorOffset, jintArray minor_ref, jint minorOffset) { |
| jint _exception = 0; |
| const char * _exceptionType = NULL; |
| const char * _exceptionMessage = NULL; |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLint *major_base = (EGLint *) 0; |
| jint _majorRemaining; |
| EGLint *major = (EGLint *) 0; |
| EGLint *minor_base = (EGLint *) 0; |
| jint _minorRemaining; |
| EGLint *minor = (EGLint *) 0; |
| |
| if (major_ref) { |
| if (majorOffset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "majorOffset < 0"; |
| goto exit; |
| } |
| _majorRemaining = _env->GetArrayLength(major_ref) - majorOffset; |
| if (_majorRemaining < 1) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "length - majorOffset < 1 < needed"; |
| goto exit; |
| } |
| major_base = (EGLint *) |
| _env->GetIntArrayElements(major_ref, (jboolean *)0); |
| major = major_base + majorOffset; |
| } |
| |
| if (minor_ref) { |
| if (minorOffset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "minorOffset < 0"; |
| goto exit; |
| } |
| _minorRemaining = _env->GetArrayLength(minor_ref) - minorOffset; |
| if (_minorRemaining < 1) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "length - minorOffset < 1 < needed"; |
| goto exit; |
| } |
| minor_base = (EGLint *) |
| _env->GetIntArrayElements(minor_ref, (jboolean *)0); |
| minor = minor_base + minorOffset; |
| } |
| |
| _returnValue = eglInitialize( |
| (EGLDisplay)dpy_native, |
| (EGLint *)major, |
| (EGLint *)minor |
| ); |
| |
| exit: |
| if (minor_base) { |
| _env->ReleaseIntArrayElements(minor_ref, (jint*)minor_base, |
| _exception ? JNI_ABORT: 0); |
| } |
| if (major_base) { |
| _env->ReleaseIntArrayElements(major_ref, (jint*)major_base, |
| _exception ? JNI_ABORT: 0); |
| } |
| if (_exception) { |
| jniThrowException(_env, _exceptionType, _exceptionMessage); |
| return JNI_FALSE; |
| } |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglTerminate ( EGLDisplay dpy ) */ |
| static jboolean |
| android_eglTerminate |
| (JNIEnv *_env, jobject _this, jobject dpy) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| |
| _returnValue = eglTerminate( |
| (EGLDisplay)dpy_native |
| ); |
| return (jboolean)_returnValue; |
| } |
| |
| /* const char * eglQueryString ( EGLDisplay dpy, EGLint name ) */ |
| static jstring |
| android_eglQueryString__Landroind_opengl_EGLDisplay_2I |
| (JNIEnv *_env, jobject _this, jobject dpy, jint name) { |
| const char* chars = (const char*) eglQueryString( |
| (EGLDisplay)fromEGLHandle(_env, egldisplayGetHandleID, dpy), |
| (EGLint)name |
| ); |
| return _env->NewStringUTF(chars); |
| } |
| /* EGLBoolean eglGetConfigs ( EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config ) */ |
| static jboolean |
| android_eglGetConfigs |
| (JNIEnv *_env, jobject _this, jobject dpy, jobjectArray configs_ref, jint configsOffset, jint config_size, jintArray num_config_ref, jint num_configOffset) { |
| jint _exception = 0; |
| const char * _exceptionType = NULL; |
| const char * _exceptionMessage = NULL; |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| jint _configsRemaining; |
| EGLConfig *configs = (EGLConfig *) 0; |
| EGLint *num_config_base = (EGLint *) 0; |
| jint _num_configRemaining; |
| EGLint *num_config = (EGLint *) 0; |
| |
| if (configs_ref) { |
| if (configsOffset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "configsOffset < 0"; |
| goto exit; |
| } |
| _configsRemaining = _env->GetArrayLength(configs_ref) - configsOffset; |
| if (_configsRemaining < config_size) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "length - configsOffset < config_size < needed"; |
| goto exit; |
| } |
| configs = new EGLConfig[_configsRemaining]; |
| } |
| |
| if (!num_config_ref) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "num_config == null"; |
| goto exit; |
| } |
| if (num_configOffset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "num_configOffset < 0"; |
| goto exit; |
| } |
| _num_configRemaining = _env->GetArrayLength(num_config_ref) - num_configOffset; |
| num_config_base = (EGLint *) |
| _env->GetIntArrayElements(num_config_ref, (jboolean *)0); |
| num_config = num_config_base + num_configOffset; |
| |
| _returnValue = eglGetConfigs( |
| (EGLDisplay)dpy_native, |
| (EGLConfig *)configs, |
| (EGLint)config_size, |
| (EGLint *)num_config |
| ); |
| |
| exit: |
| if (num_config_base) { |
| _env->ReleaseIntArrayElements(num_config_ref, (jint*)num_config_base, |
| _exception ? JNI_ABORT: 0); |
| } |
| if (configs) { |
| for (int i = 0; i < _configsRemaining; i++) { |
| jobject configs_new = toEGLHandle(_env, eglconfigClass, eglconfigConstructor, configs[i]); |
| _env->SetObjectArrayElement(configs_ref, i + configsOffset, configs_new); |
| } |
| delete[] configs; |
| } |
| if (_exception) { |
| jniThrowException(_env, _exceptionType, _exceptionMessage); |
| return JNI_FALSE; |
| } |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglChooseConfig ( EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config ) */ |
| static jboolean |
| android_eglChooseConfig |
| (JNIEnv *_env, jobject _this, jobject dpy, jintArray attrib_list_ref, jint attrib_listOffset, jobjectArray configs_ref, jint configsOffset, jint config_size, jintArray num_config_ref, jint num_configOffset) { |
| jint _exception = 0; |
| const char * _exceptionType = NULL; |
| const char * _exceptionMessage = NULL; |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| bool attrib_list_sentinel = false; |
| EGLint *attrib_list_base = (EGLint *) 0; |
| jint _attrib_listRemaining; |
| EGLint *attrib_list = (EGLint *) 0; |
| jint _configsRemaining; |
| EGLConfig *configs = (EGLConfig *) 0; |
| EGLint *num_config_base = (EGLint *) 0; |
| jint _num_configRemaining; |
| EGLint *num_config = (EGLint *) 0; |
| |
| if (!attrib_list_ref) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "attrib_list == null"; |
| goto exit; |
| } |
| if (attrib_listOffset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "attrib_listOffset < 0"; |
| goto exit; |
| } |
| _attrib_listRemaining = _env->GetArrayLength(attrib_list_ref) - attrib_listOffset; |
| attrib_list_base = (EGLint *) |
| _env->GetIntArrayElements(attrib_list_ref, (jboolean *)0); |
| attrib_list = attrib_list_base + attrib_listOffset; |
| attrib_list_sentinel = false; |
| for (int i = _attrib_listRemaining - 1; i >= 0; i--) { |
| if (attrib_list[i] == EGL_NONE){ |
| attrib_list_sentinel = true; |
| break; |
| } |
| } |
| if (attrib_list_sentinel == false) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "attrib_list must contain EGL_NONE!"; |
| goto exit; |
| } |
| |
| if (configs_ref) { |
| if (configsOffset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "configsOffset < 0"; |
| goto exit; |
| } |
| _configsRemaining = _env->GetArrayLength(configs_ref) - configsOffset; |
| if (_configsRemaining < config_size) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "length - configsOffset < config_size < needed"; |
| goto exit; |
| } |
| configs = new EGLConfig[_configsRemaining]; |
| } |
| |
| if (!num_config_ref) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "num_config == null"; |
| goto exit; |
| } |
| if (num_configOffset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "num_configOffset < 0"; |
| goto exit; |
| } |
| _num_configRemaining = _env->GetArrayLength(num_config_ref) - num_configOffset; |
| if (_num_configRemaining < 1) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "length - num_configOffset < 1 < needed"; |
| goto exit; |
| } |
| num_config_base = (EGLint *) |
| _env->GetIntArrayElements(num_config_ref, (jboolean *)0); |
| num_config = num_config_base + num_configOffset; |
| |
| _returnValue = eglChooseConfig( |
| (EGLDisplay)dpy_native, |
| (EGLint *)attrib_list, |
| (EGLConfig *)configs, |
| (EGLint)config_size, |
| (EGLint *)num_config |
| ); |
| |
| exit: |
| if (num_config_base) { |
| _env->ReleaseIntArrayElements(num_config_ref, (jint*)num_config_base, |
| _exception ? JNI_ABORT: 0); |
| } |
| if (attrib_list_base) { |
| _env->ReleaseIntArrayElements(attrib_list_ref, (jint*)attrib_list_base, |
| JNI_ABORT); |
| } |
| if (configs) { |
| for (int i = 0; i < _configsRemaining; i++) { |
| jobject configs_new = toEGLHandle(_env, eglconfigClass, eglconfigConstructor, configs[i]); |
| _env->SetObjectArrayElement(configs_ref, i + configsOffset, configs_new); |
| } |
| delete[] configs; |
| } |
| if (_exception) { |
| jniThrowException(_env, _exceptionType, _exceptionMessage); |
| return JNI_FALSE; |
| } |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglGetConfigAttrib ( EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value ) */ |
| static jboolean |
| android_eglGetConfigAttrib |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jint attribute, jintArray value_ref, jint offset) { |
| jint _exception = 0; |
| const char * _exceptionType = NULL; |
| const char * _exceptionMessage = NULL; |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config); |
| EGLint *value_base = (EGLint *) 0; |
| jint _remaining; |
| EGLint *value = (EGLint *) 0; |
| |
| if (!value_ref) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "value == null"; |
| goto exit; |
| } |
| if (offset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "offset < 0"; |
| goto exit; |
| } |
| _remaining = _env->GetArrayLength(value_ref) - offset; |
| if (_remaining < 1) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "length - offset < 1 < needed"; |
| goto exit; |
| } |
| value_base = (EGLint *) |
| _env->GetIntArrayElements(value_ref, (jboolean *)0); |
| value = value_base + offset; |
| |
| _returnValue = eglGetConfigAttrib( |
| (EGLDisplay)dpy_native, |
| (EGLConfig)config_native, |
| (EGLint)attribute, |
| (EGLint *)value |
| ); |
| |
| exit: |
| if (value_base) { |
| _env->ReleaseIntArrayElements(value_ref, (jint*)value_base, |
| _exception ? JNI_ABORT: 0); |
| } |
| if (_exception) { |
| jniThrowException(_env, _exceptionType, _exceptionMessage); |
| return JNI_FALSE; |
| } |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLSurface eglCreateWindowSurface ( EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list ) */ |
| static jobject |
| android_eglCreateWindowSurface |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jobject win, jintArray attrib_list_ref, jint offset) { |
| jint _exception = 0; |
| const char * _exceptionType = ""; |
| const char * _exceptionMessage = ""; |
| EGLSurface _returnValue = (EGLSurface) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config); |
| int attrib_list_sentinel = 0; |
| EGLint *attrib_list_base = (EGLint *) 0; |
| jint _remaining; |
| EGLint *attrib_list = (EGLint *) 0; |
| android::sp<ANativeWindow> window; |
| |
| if (attrib_list_ref) { |
| if (offset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "offset < 0"; |
| goto exit; |
| } |
| _remaining = _env->GetArrayLength(attrib_list_ref) - offset; |
| attrib_list_base = (EGLint *) |
| _env->GetIntArrayElements(attrib_list_ref, (jboolean *)0); |
| attrib_list = attrib_list_base + offset; |
| attrib_list_sentinel = 0; |
| for (int i = _remaining - 1; i >= 0; i--) { |
| if (*((EGLint*)(attrib_list + i)) == EGL_NONE){ |
| attrib_list_sentinel = 1; |
| break; |
| } |
| } |
| if (attrib_list_sentinel == 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "attrib_list must contain EGL_NONE!"; |
| goto exit; |
| } |
| } |
| |
| if (win == NULL) { |
| not_valid_surface: |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "Make sure the SurfaceView or associated SurfaceHolder has a valid Surface"; |
| goto exit; |
| } |
| |
| window = android::android_view_Surface_getNativeWindow(_env, win); |
| |
| if (window == NULL) |
| goto not_valid_surface; |
| |
| _returnValue = eglCreateWindowSurface( |
| (EGLDisplay)dpy_native, |
| (EGLConfig)config_native, |
| (EGLNativeWindowType)window.get(), |
| (EGLint *)attrib_list |
| ); |
| |
| exit: |
| if (attrib_list_base) { |
| _env->ReleaseIntArrayElements(attrib_list_ref, attrib_list_base, |
| JNI_ABORT); |
| } |
| if (_exception) { |
| jniThrowException(_env, _exceptionType, _exceptionMessage); |
| return nullptr; |
| } |
| return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue); |
| } |
| |
| /* EGLSurface eglCreateWindowSurface ( EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list ) */ |
| static jobject |
| android_eglCreateWindowSurfaceTexture |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jobject win, jintArray attrib_list_ref, jint offset) { |
| jint _exception = 0; |
| const char * _exceptionType = ""; |
| const char * _exceptionMessage = ""; |
| EGLSurface _returnValue = (EGLSurface) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config); |
| int attrib_list_sentinel = 0; |
| EGLint *attrib_list_base = (EGLint *) 0; |
| jint _remaining; |
| EGLint *attrib_list = (EGLint *) 0; |
| android::sp<ANativeWindow> window; |
| android::sp<android::IGraphicBufferProducer> producer; |
| |
| if (!attrib_list_ref) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "attrib_list == null"; |
| goto exit; |
| } |
| if (offset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "offset < 0"; |
| goto exit; |
| } |
| if (win == NULL) { |
| not_valid_surface: |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "Make sure the SurfaceView or associated SurfaceHolder has a valid Surface"; |
| goto exit; |
| } |
| producer = android::SurfaceTexture_getProducer(_env, win); |
| |
| if (producer == NULL) |
| goto not_valid_surface; |
| |
| window = new android::Surface(producer, true); |
| |
| if (window == NULL) |
| goto not_valid_surface; |
| |
| _remaining = _env->GetArrayLength(attrib_list_ref) - offset; |
| attrib_list_base = (EGLint *) |
| _env->GetIntArrayElements(attrib_list_ref, (jboolean *)0); |
| attrib_list = attrib_list_base + offset; |
| attrib_list_sentinel = 0; |
| for (int i = _remaining - 1; i >= 0; i--) { |
| if (*((EGLint*)(attrib_list + i)) == EGL_NONE){ |
| attrib_list_sentinel = 1; |
| break; |
| } |
| } |
| if (attrib_list_sentinel == 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "attrib_list must contain EGL_NONE!"; |
| goto exit; |
| } |
| |
| _returnValue = eglCreateWindowSurface( |
| (EGLDisplay)dpy_native, |
| (EGLConfig)config_native, |
| (EGLNativeWindowType)window.get(), |
| (EGLint *)attrib_list |
| ); |
| |
| exit: |
| if (attrib_list_base) { |
| _env->ReleaseIntArrayElements(attrib_list_ref, attrib_list_base, |
| JNI_ABORT); |
| } |
| if (_exception) { |
| jniThrowException(_env, _exceptionType, _exceptionMessage); |
| return nullptr; |
| } |
| return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue); |
| } |
| /* EGLSurface eglCreatePbufferSurface ( EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list ) */ |
| static jobject |
| android_eglCreatePbufferSurface |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jintArray attrib_list_ref, jint offset) { |
| jint _exception = 0; |
| const char * _exceptionType = NULL; |
| const char * _exceptionMessage = NULL; |
| EGLSurface _returnValue = (EGLSurface) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config); |
| bool attrib_list_sentinel = false; |
| EGLint *attrib_list_base = (EGLint *) 0; |
| jint _remaining; |
| EGLint *attrib_list = (EGLint *) 0; |
| |
| if (attrib_list_ref) { |
| if (offset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "offset < 0"; |
| goto exit; |
| } |
| _remaining = _env->GetArrayLength(attrib_list_ref) - offset; |
| attrib_list_base = (EGLint *) |
| _env->GetIntArrayElements(attrib_list_ref, (jboolean *)0); |
| attrib_list = attrib_list_base + offset; |
| attrib_list_sentinel = false; |
| for (int i = _remaining - 1; i >= 0; i--) { |
| if (attrib_list[i] == EGL_NONE){ |
| attrib_list_sentinel = true; |
| break; |
| } |
| } |
| if (attrib_list_sentinel == false) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "attrib_list must contain EGL_NONE!"; |
| goto exit; |
| } |
| } |
| |
| _returnValue = eglCreatePbufferSurface( |
| (EGLDisplay)dpy_native, |
| (EGLConfig)config_native, |
| (EGLint *)attrib_list |
| ); |
| |
| exit: |
| if (attrib_list_base) { |
| _env->ReleaseIntArrayElements(attrib_list_ref, (jint*)attrib_list_base, |
| JNI_ABORT); |
| } |
| if (_exception) { |
| jniThrowException(_env, _exceptionType, _exceptionMessage); |
| return nullptr; |
| } |
| return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue); |
| } |
| |
| /* EGLSurface eglCreatePixmapSurface ( EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list ) */ |
| static jobject |
| android_eglCreatePixmapSurface |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jint pixmap, jintArray attrib_list_ref, jint offset) { |
| jniThrowException(_env, "java/lang/UnsupportedOperationException", |
| "eglCreatePixmapSurface"); |
| return nullptr; |
| } |
| |
| /* EGLBoolean eglDestroySurface ( EGLDisplay dpy, EGLSurface surface ) */ |
| static jboolean |
| android_eglDestroySurface |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject surface) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLSurface surface_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, surface); |
| |
| _returnValue = eglDestroySurface( |
| (EGLDisplay)dpy_native, |
| (EGLSurface)surface_native |
| ); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglQuerySurface ( EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value ) */ |
| static jboolean |
| android_eglQuerySurface |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject surface, jint attribute, jintArray value_ref, jint offset) { |
| jint _exception = 0; |
| const char * _exceptionType = NULL; |
| const char * _exceptionMessage = NULL; |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLSurface surface_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, surface); |
| EGLint *value_base = (EGLint *) 0; |
| jint _remaining; |
| EGLint *value = (EGLint *) 0; |
| |
| if (!value_ref) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "value == null"; |
| goto exit; |
| } |
| if (offset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "offset < 0"; |
| goto exit; |
| } |
| _remaining = _env->GetArrayLength(value_ref) - offset; |
| if (_remaining < 1) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "length - offset < 1 < needed"; |
| goto exit; |
| } |
| value_base = (EGLint *) |
| _env->GetIntArrayElements(value_ref, (jboolean *)0); |
| value = value_base + offset; |
| |
| _returnValue = eglQuerySurface( |
| (EGLDisplay)dpy_native, |
| (EGLSurface)surface_native, |
| (EGLint)attribute, |
| (EGLint *)value |
| ); |
| |
| exit: |
| if (value_base) { |
| _env->ReleaseIntArrayElements(value_ref, (jint*)value_base, |
| _exception ? JNI_ABORT: 0); |
| } |
| if (_exception) { |
| jniThrowException(_env, _exceptionType, _exceptionMessage); |
| return JNI_FALSE; |
| } |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglBindAPI ( EGLenum api ) */ |
| static jboolean |
| android_eglBindAPI |
| (JNIEnv *_env, jobject _this, jint api) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| _returnValue = eglBindAPI( |
| (EGLenum)api |
| ); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLenum eglQueryAPI ( void ) */ |
| static jint |
| android_eglQueryAPI |
| (JNIEnv *_env, jobject _this) { |
| EGLenum _returnValue = (EGLenum) 0; |
| _returnValue = eglQueryAPI(); |
| return (jint)_returnValue; |
| } |
| |
| /* EGLBoolean eglWaitClient ( void ) */ |
| static jboolean |
| android_eglWaitClient |
| (JNIEnv *_env, jobject _this) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| _returnValue = eglWaitClient(); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglReleaseThread ( void ) */ |
| static jboolean |
| android_eglReleaseThread |
| (JNIEnv *_env, jobject _this) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| _returnValue = eglReleaseThread(); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLSurface eglCreatePbufferFromClientBuffer ( EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list ) */ |
| static jobject |
| android_eglCreatePbufferFromClientBuffer |
| (JNIEnv *_env, jobject _this, jobject dpy, jint buftype, jlong buffer, jobject config, jintArray attrib_list_ref, jint offset) { |
| jint _exception = 0; |
| const char * _exceptionType = NULL; |
| const char * _exceptionMessage = NULL; |
| EGLSurface _returnValue = (EGLSurface) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config); |
| bool attrib_list_sentinel = false; |
| EGLint *attrib_list_base = (EGLint *) 0; |
| jint _remaining; |
| EGLint *attrib_list = (EGLint *) 0; |
| |
| if (attrib_list_ref) { |
| if (offset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "offset < 0"; |
| goto exit; |
| } |
| _remaining = _env->GetArrayLength(attrib_list_ref) - offset; |
| attrib_list_base = (EGLint *) |
| _env->GetIntArrayElements(attrib_list_ref, (jboolean *)0); |
| attrib_list = attrib_list_base + offset; |
| attrib_list_sentinel = false; |
| for (int i = _remaining - 1; i >= 0; i--) { |
| if (attrib_list[i] == EGL_NONE){ |
| attrib_list_sentinel = true; |
| break; |
| } |
| } |
| if (attrib_list_sentinel == false) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "attrib_list must contain EGL_NONE!"; |
| goto exit; |
| } |
| } |
| |
| _returnValue = eglCreatePbufferFromClientBuffer( |
| (EGLDisplay)dpy_native, |
| (EGLenum)buftype, |
| reinterpret_cast<EGLClientBuffer>(buffer), |
| (EGLConfig)config_native, |
| (EGLint *)attrib_list |
| ); |
| |
| exit: |
| if (attrib_list_base) { |
| _env->ReleaseIntArrayElements(attrib_list_ref, attrib_list_base, |
| JNI_ABORT); |
| } |
| if (_exception) { |
| jniThrowException(_env, _exceptionType, _exceptionMessage); |
| return nullptr; |
| } |
| return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue); |
| } |
| |
| static jobject |
| android_eglCreatePbufferFromClientBufferInt |
| (JNIEnv *_env, jobject _this, jobject dpy, jint buftype, jint buffer, jobject config, jintArray attrib_list_ref, jint offset) { |
| if(sizeof(void*) != sizeof(uint32_t)) { |
| jniThrowException(_env, "java/lang/UnsupportedOperationException", "eglCreatePbufferFromClientBuffer"); |
| return 0; |
| } |
| return android_eglCreatePbufferFromClientBuffer(_env, _this, dpy, buftype, buffer, config, attrib_list_ref, offset); |
| } |
| /* EGLBoolean eglSurfaceAttrib ( EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value ) */ |
| static jboolean |
| android_eglSurfaceAttrib |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject surface, jint attribute, jint value) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLSurface surface_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, surface); |
| |
| _returnValue = eglSurfaceAttrib( |
| (EGLDisplay)dpy_native, |
| (EGLSurface)surface_native, |
| (EGLint)attribute, |
| (EGLint)value |
| ); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglBindTexImage ( EGLDisplay dpy, EGLSurface surface, EGLint buffer ) */ |
| static jboolean |
| android_eglBindTexImage |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject surface, jint buffer) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLSurface surface_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, surface); |
| |
| _returnValue = eglBindTexImage( |
| (EGLDisplay)dpy_native, |
| (EGLSurface)surface_native, |
| (EGLint)buffer |
| ); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglReleaseTexImage ( EGLDisplay dpy, EGLSurface surface, EGLint buffer ) */ |
| static jboolean |
| android_eglReleaseTexImage |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject surface, jint buffer) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLSurface surface_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, surface); |
| |
| _returnValue = eglReleaseTexImage( |
| (EGLDisplay)dpy_native, |
| (EGLSurface)surface_native, |
| (EGLint)buffer |
| ); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglSwapInterval ( EGLDisplay dpy, EGLint interval ) */ |
| static jboolean |
| android_eglSwapInterval |
| (JNIEnv *_env, jobject _this, jobject dpy, jint interval) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| |
| _returnValue = eglSwapInterval( |
| (EGLDisplay)dpy_native, |
| (EGLint)interval |
| ); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLContext eglCreateContext ( EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list ) */ |
| static jobject |
| android_eglCreateContext |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jobject share_context, jintArray attrib_list_ref, jint offset) { |
| jint _exception = 0; |
| const char * _exceptionType = NULL; |
| const char * _exceptionMessage = NULL; |
| EGLContext _returnValue = (EGLContext) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config); |
| EGLContext share_context_native = (EGLContext) fromEGLHandle(_env, eglcontextGetHandleID, share_context); |
| bool attrib_list_sentinel = false; |
| EGLint *attrib_list_base = (EGLint *) 0; |
| jint _remaining; |
| EGLint *attrib_list = (EGLint *) 0; |
| |
| if (!attrib_list_ref) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "attrib_list == null"; |
| goto exit; |
| } |
| if (offset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "offset < 0"; |
| goto exit; |
| } |
| _remaining = _env->GetArrayLength(attrib_list_ref) - offset; |
| attrib_list_base = (EGLint *) |
| _env->GetIntArrayElements(attrib_list_ref, (jboolean *)0); |
| attrib_list = attrib_list_base + offset; |
| attrib_list_sentinel = false; |
| for (int i = _remaining - 1; i >= 0; i--) { |
| if (attrib_list[i] == EGL_NONE){ |
| attrib_list_sentinel = true; |
| break; |
| } |
| } |
| if (attrib_list_sentinel == false) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "attrib_list must contain EGL_NONE!"; |
| goto exit; |
| } |
| |
| _returnValue = eglCreateContext( |
| (EGLDisplay)dpy_native, |
| (EGLConfig)config_native, |
| (EGLContext)share_context_native, |
| (EGLint *)attrib_list |
| ); |
| |
| exit: |
| if (attrib_list_base) { |
| _env->ReleaseIntArrayElements(attrib_list_ref, (jint*)attrib_list_base, |
| JNI_ABORT); |
| } |
| if (_exception) { |
| jniThrowException(_env, _exceptionType, _exceptionMessage); |
| return nullptr; |
| } |
| return toEGLHandle(_env, eglcontextClass, eglcontextConstructor, _returnValue); |
| } |
| |
| /* EGLBoolean eglDestroyContext ( EGLDisplay dpy, EGLContext ctx ) */ |
| static jboolean |
| android_eglDestroyContext |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject ctx) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLContext ctx_native = (EGLContext) fromEGLHandle(_env, eglcontextGetHandleID, ctx); |
| |
| _returnValue = eglDestroyContext( |
| (EGLDisplay)dpy_native, |
| (EGLContext)ctx_native |
| ); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglMakeCurrent ( EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx ) */ |
| static jboolean |
| android_eglMakeCurrent |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject draw, jobject read, jobject ctx) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLSurface draw_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, draw); |
| EGLSurface read_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, read); |
| EGLContext ctx_native = (EGLContext) fromEGLHandle(_env, eglcontextGetHandleID, ctx); |
| |
| _returnValue = eglMakeCurrent( |
| (EGLDisplay)dpy_native, |
| (EGLSurface)draw_native, |
| (EGLSurface)read_native, |
| (EGLContext)ctx_native |
| ); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLContext eglGetCurrentContext ( void ) */ |
| static jobject |
| android_eglGetCurrentContext |
| (JNIEnv *_env, jobject _this) { |
| EGLContext _returnValue = (EGLContext) 0; |
| _returnValue = eglGetCurrentContext(); |
| return toEGLHandle(_env, eglcontextClass, eglcontextConstructor, _returnValue); |
| } |
| |
| /* EGLSurface eglGetCurrentSurface ( EGLint readdraw ) */ |
| static jobject |
| android_eglGetCurrentSurface |
| (JNIEnv *_env, jobject _this, jint readdraw) { |
| EGLSurface _returnValue = (EGLSurface) 0; |
| _returnValue = eglGetCurrentSurface( |
| (EGLint)readdraw |
| ); |
| return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue); |
| } |
| |
| /* EGLDisplay eglGetCurrentDisplay ( void ) */ |
| static jobject |
| android_eglGetCurrentDisplay |
| (JNIEnv *_env, jobject _this) { |
| EGLDisplay _returnValue = (EGLDisplay) 0; |
| _returnValue = eglGetCurrentDisplay(); |
| return toEGLHandle(_env, egldisplayClass, egldisplayConstructor, _returnValue); |
| } |
| |
| /* EGLBoolean eglQueryContext ( EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value ) */ |
| static jboolean |
| android_eglQueryContext |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject ctx, jint attribute, jintArray value_ref, jint offset) { |
| jint _exception = 0; |
| const char * _exceptionType = NULL; |
| const char * _exceptionMessage = NULL; |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLContext ctx_native = (EGLContext) fromEGLHandle(_env, eglcontextGetHandleID, ctx); |
| EGLint *value_base = (EGLint *) 0; |
| jint _remaining; |
| EGLint *value = (EGLint *) 0; |
| |
| if (!value_ref) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "value == null"; |
| goto exit; |
| } |
| if (offset < 0) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "offset < 0"; |
| goto exit; |
| } |
| _remaining = _env->GetArrayLength(value_ref) - offset; |
| if (_remaining < 1) { |
| _exception = 1; |
| _exceptionType = "java/lang/IllegalArgumentException"; |
| _exceptionMessage = "length - offset < 1 < needed"; |
| goto exit; |
| } |
| value_base = (EGLint *) |
| _env->GetIntArrayElements(value_ref, (jboolean *)0); |
| value = value_base + offset; |
| |
| _returnValue = eglQueryContext( |
| (EGLDisplay)dpy_native, |
| (EGLContext)ctx_native, |
| (EGLint)attribute, |
| (EGLint *)value |
| ); |
| |
| exit: |
| if (value_base) { |
| _env->ReleaseIntArrayElements(value_ref, (jint*)value_base, |
| _exception ? JNI_ABORT: 0); |
| } |
| if (_exception) { |
| jniThrowException(_env, _exceptionType, _exceptionMessage); |
| return JNI_FALSE; |
| } |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglWaitGL ( void ) */ |
| static jboolean |
| android_eglWaitGL |
| (JNIEnv *_env, jobject _this) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| _returnValue = eglWaitGL(); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglWaitNative ( EGLint engine ) */ |
| static jboolean |
| android_eglWaitNative |
| (JNIEnv *_env, jobject _this, jint engine) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| _returnValue = eglWaitNative( |
| (EGLint)engine |
| ); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglSwapBuffers ( EGLDisplay dpy, EGLSurface surface ) */ |
| static jboolean |
| android_eglSwapBuffers |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject surface) { |
| EGLBoolean _returnValue = (EGLBoolean) 0; |
| EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); |
| EGLSurface surface_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, surface); |
| |
| _returnValue = eglSwapBuffers( |
| (EGLDisplay)dpy_native, |
| (EGLSurface)surface_native |
| ); |
| return (jboolean)_returnValue; |
| } |
| |
| /* EGLBoolean eglCopyBuffers ( EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target ) */ |
| static jboolean |
| android_eglCopyBuffers |
| (JNIEnv *_env, jobject _this, jobject dpy, jobject surface, jint target) { |
| jniThrowException(_env, "java/lang/UnsupportedOperationException", |
| "eglCopyBuffers"); |
| return JNI_FALSE; |
| } |
| |
| static const char *classPathName = "android/opengl/EGL14"; |
| |
| static const JNINativeMethod methods[] = { |
| {"_nativeClassInit", "()V", (void*)nativeClassInit }, |
| {"eglGetError", "()I", (void *) android_eglGetError }, |
| {"eglGetDisplay", "(I)Landroid/opengl/EGLDisplay;", (void *) android_eglGetDisplayInt }, |
| {"eglGetDisplay", "(J)Landroid/opengl/EGLDisplay;", (void *) android_eglGetDisplay }, |
| {"eglInitialize", "(Landroid/opengl/EGLDisplay;[II[II)Z", (void *) android_eglInitialize }, |
| {"eglTerminate", "(Landroid/opengl/EGLDisplay;)Z", (void *) android_eglTerminate }, |
| {"eglQueryString", "(Landroid/opengl/EGLDisplay;I)Ljava/lang/String;", (void *) android_eglQueryString__Landroind_opengl_EGLDisplay_2I }, |
| {"eglGetConfigs", "(Landroid/opengl/EGLDisplay;[Landroid/opengl/EGLConfig;II[II)Z", (void *) android_eglGetConfigs }, |
| {"eglChooseConfig", "(Landroid/opengl/EGLDisplay;[II[Landroid/opengl/EGLConfig;II[II)Z", (void *) android_eglChooseConfig }, |
| {"eglGetConfigAttrib", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;I[II)Z", (void *) android_eglGetConfigAttrib }, |
| {"_eglCreateWindowSurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;Ljava/lang/Object;[II)Landroid/opengl/EGLSurface;", (void *) android_eglCreateWindowSurface }, |
| {"_eglCreateWindowSurfaceTexture", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;Ljava/lang/Object;[II)Landroid/opengl/EGLSurface;", (void *) android_eglCreateWindowSurfaceTexture }, |
| {"eglCreatePbufferSurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;[II)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePbufferSurface }, |
| {"eglCreatePixmapSurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;I[II)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePixmapSurface }, |
| {"eglDestroySurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;)Z", (void *) android_eglDestroySurface }, |
| {"eglQuerySurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;I[II)Z", (void *) android_eglQuerySurface }, |
| {"eglBindAPI", "(I)Z", (void *) android_eglBindAPI }, |
| {"eglQueryAPI", "()I", (void *) android_eglQueryAPI }, |
| {"eglWaitClient", "()Z", (void *) android_eglWaitClient }, |
| {"eglReleaseThread", "()Z", (void *) android_eglReleaseThread }, |
| {"eglCreatePbufferFromClientBuffer", "(Landroid/opengl/EGLDisplay;IILandroid/opengl/EGLConfig;[II)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePbufferFromClientBufferInt }, |
| {"eglCreatePbufferFromClientBuffer", "(Landroid/opengl/EGLDisplay;IJLandroid/opengl/EGLConfig;[II)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePbufferFromClientBuffer }, |
| {"eglSurfaceAttrib", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;II)Z", (void *) android_eglSurfaceAttrib }, |
| {"eglBindTexImage", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;I)Z", (void *) android_eglBindTexImage }, |
| {"eglReleaseTexImage", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;I)Z", (void *) android_eglReleaseTexImage }, |
| {"eglSwapInterval", "(Landroid/opengl/EGLDisplay;I)Z", (void *) android_eglSwapInterval }, |
| {"eglCreateContext", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;Landroid/opengl/EGLContext;[II)Landroid/opengl/EGLContext;", (void *) android_eglCreateContext }, |
| {"eglDestroyContext", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLContext;)Z", (void *) android_eglDestroyContext }, |
| {"eglMakeCurrent", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;Landroid/opengl/EGLSurface;Landroid/opengl/EGLContext;)Z", (void *) android_eglMakeCurrent }, |
| {"eglGetCurrentContext", "()Landroid/opengl/EGLContext;", (void *) android_eglGetCurrentContext }, |
| {"eglGetCurrentSurface", "(I)Landroid/opengl/EGLSurface;", (void *) android_eglGetCurrentSurface }, |
| {"eglGetCurrentDisplay", "()Landroid/opengl/EGLDisplay;", (void *) android_eglGetCurrentDisplay }, |
| {"eglQueryContext", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLContext;I[II)Z", (void *) android_eglQueryContext }, |
| {"eglWaitGL", "()Z", (void *) android_eglWaitGL }, |
| {"eglWaitNative", "(I)Z", (void *) android_eglWaitNative }, |
| {"eglSwapBuffers", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;)Z", (void *) android_eglSwapBuffers }, |
| {"eglCopyBuffers", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;I)Z", (void *) android_eglCopyBuffers }, |
| }; |
| |
| int register_android_opengl_jni_EGL14(JNIEnv *_env) |
| { |
| int err; |
| err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods)); |
| return err; |
| } |