Home | History | Annotate | Download | only in jni
      1 /*
      2 ** Copyright 2012, The Android Open Source Project
      3 **
      4 ** Licensed under the Apache License, Version 2.0 (the "License");
      5 ** you may not use this file except in compliance with the License.
      6 ** You may obtain a copy of the License at
      7 **
      8 **     http://www.apache.org/licenses/LICENSE-2.0
      9 **
     10 ** Unless required by applicable law or agreed to in writing, software
     11 ** distributed under the License is distributed on an "AS IS" BASIS,
     12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 ** See the License for the specific language governing permissions and
     14 ** limitations under the License.
     15 */
     16 
     17 // This source file is automatically generated
     18 
     19 #pragma GCC diagnostic ignored "-Wunused-variable"
     20 #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
     21 #pragma GCC diagnostic ignored "-Wunused-function"
     22 
     23 #include "jni.h"
     24 #include "JNIHelp.h"
     25 #include <android_runtime/AndroidRuntime.h>
     26 #include <android_runtime/android_view_Surface.h>
     27 #include <android_runtime/android_graphics_SurfaceTexture.h>
     28 #include <utils/misc.h>
     29 
     30 #include <assert.h>
     31 #include <EGL/egl.h>
     32 
     33 #include <gui/Surface.h>
     34 #include <gui/GLConsumer.h>
     35 #include <gui/Surface.h>
     36 
     37 #include <ui/ANativeObjectBase.h>
     38 
     39 static int initialized = 0;
     40 
     41 static jclass egldisplayClass;
     42 static jclass eglcontextClass;
     43 static jclass eglsurfaceClass;
     44 static jclass eglconfigClass;
     45 
     46 static jmethodID egldisplayGetHandleID;
     47 static jmethodID eglcontextGetHandleID;
     48 static jmethodID eglsurfaceGetHandleID;
     49 static jmethodID eglconfigGetHandleID;
     50 
     51 static jmethodID egldisplayConstructor;
     52 static jmethodID eglcontextConstructor;
     53 static jmethodID eglsurfaceConstructor;
     54 static jmethodID eglconfigConstructor;
     55 
     56 static jobject eglNoContextObject;
     57 static jobject eglNoDisplayObject;
     58 static jobject eglNoSurfaceObject;
     59 
     60 
     61 
     62 /* Cache method IDs each time the class is loaded. */
     63 
     64 static void
     65 nativeClassInit(JNIEnv *_env, jclass glImplClass)
     66 {
     67     jclass egldisplayClassLocal = _env->FindClass("android/opengl/EGLDisplay");
     68     egldisplayClass = (jclass) _env->NewGlobalRef(egldisplayClassLocal);
     69     jclass eglcontextClassLocal = _env->FindClass("android/opengl/EGLContext");
     70     eglcontextClass = (jclass) _env->NewGlobalRef(eglcontextClassLocal);
     71     jclass eglsurfaceClassLocal = _env->FindClass("android/opengl/EGLSurface");
     72     eglsurfaceClass = (jclass) _env->NewGlobalRef(eglsurfaceClassLocal);
     73     jclass eglconfigClassLocal = _env->FindClass("android/opengl/EGLConfig");
     74     eglconfigClass = (jclass) _env->NewGlobalRef(eglconfigClassLocal);
     75 
     76     egldisplayGetHandleID = _env->GetMethodID(egldisplayClass, "getNativeHandle", "()J");
     77     eglcontextGetHandleID = _env->GetMethodID(eglcontextClass, "getNativeHandle", "()J");
     78     eglsurfaceGetHandleID = _env->GetMethodID(eglsurfaceClass, "getNativeHandle", "()J");
     79     eglconfigGetHandleID = _env->GetMethodID(eglconfigClass, "getNativeHandle", "()J");
     80 
     81 
     82     egldisplayConstructor = _env->GetMethodID(egldisplayClass, "<init>", "(J)V");
     83     eglcontextConstructor = _env->GetMethodID(eglcontextClass, "<init>", "(J)V");
     84     eglsurfaceConstructor = _env->GetMethodID(eglsurfaceClass, "<init>", "(J)V");
     85     eglconfigConstructor = _env->GetMethodID(eglconfigClass, "<init>", "(J)V");
     86 
     87     jobject localeglNoContextObject = _env->NewObject(eglcontextClass, eglcontextConstructor, reinterpret_cast<jlong>(EGL_NO_CONTEXT));
     88     eglNoContextObject = _env->NewGlobalRef(localeglNoContextObject);
     89     jobject localeglNoDisplayObject = _env->NewObject(egldisplayClass, egldisplayConstructor, reinterpret_cast<jlong>(EGL_NO_DISPLAY));
     90     eglNoDisplayObject = _env->NewGlobalRef(localeglNoDisplayObject);
     91     jobject localeglNoSurfaceObject = _env->NewObject(eglsurfaceClass, eglsurfaceConstructor, reinterpret_cast<jlong>(EGL_NO_SURFACE));
     92     eglNoSurfaceObject = _env->NewGlobalRef(localeglNoSurfaceObject);
     93 
     94 
     95     jclass eglClass = _env->FindClass("android/opengl/EGL14");
     96     jfieldID noContextFieldID = _env->GetStaticFieldID(eglClass, "EGL_NO_CONTEXT", "Landroid/opengl/EGLContext;");
     97     _env->SetStaticObjectField(eglClass, noContextFieldID, eglNoContextObject);
     98 
     99     jfieldID noDisplayFieldID = _env->GetStaticFieldID(eglClass, "EGL_NO_DISPLAY", "Landroid/opengl/EGLDisplay;");
    100     _env->SetStaticObjectField(eglClass, noDisplayFieldID, eglNoDisplayObject);
    101 
    102     jfieldID noSurfaceFieldID = _env->GetStaticFieldID(eglClass, "EGL_NO_SURFACE", "Landroid/opengl/EGLSurface;");
    103     _env->SetStaticObjectField(eglClass, noSurfaceFieldID, eglNoSurfaceObject);
    104 }
    105 
    106 static void *
    107 fromEGLHandle(JNIEnv *_env, jmethodID mid, jobject obj) {
    108     if (obj == NULL){
    109         jniThrowException(_env, "java/lang/IllegalArgumentException",
    110                           "Object is set to null.");
    111     }
    112 
    113     jlong handle = _env->CallLongMethod(obj, mid);
    114     return reinterpret_cast<void*>(handle);
    115 }
    116 
    117 static jobject
    118 toEGLHandle(JNIEnv *_env, jclass cls, jmethodID con, void * handle) {
    119     if (cls == eglcontextClass &&
    120        (EGLContext)handle == EGL_NO_CONTEXT) {
    121            return eglNoContextObject;
    122     }
    123 
    124     if (cls == egldisplayClass &&
    125        (EGLDisplay)handle == EGL_NO_DISPLAY) {
    126            return eglNoDisplayObject;
    127     }
    128 
    129     if (cls == eglsurfaceClass &&
    130        (EGLSurface)handle == EGL_NO_SURFACE) {
    131            return eglNoSurfaceObject;
    132     }
    133 
    134     return _env->NewObject(cls, con, reinterpret_cast<jlong>(handle));
    135 }
    136 
    137 // --------------------------------------------------------------------------
    138 /* EGLint eglGetError ( void ) */
    139 static jint
    140 android_eglGetError
    141   (JNIEnv *_env, jobject _this) {
    142     EGLint _returnValue = (EGLint) 0;
    143     _returnValue = eglGetError();
    144     return (jint)_returnValue;
    145 }
    146 
    147 /* EGLDisplay eglGetDisplay ( EGLNativeDisplayType display_id ) */
    148 static jobject
    149 android_eglGetDisplay
    150   (JNIEnv *_env, jobject _this, jlong display_id) {
    151     EGLDisplay _returnValue = (EGLDisplay) 0;
    152     _returnValue = eglGetDisplay(
    153         reinterpret_cast<EGLNativeDisplayType>(display_id)
    154     );
    155     return toEGLHandle(_env, egldisplayClass, egldisplayConstructor, _returnValue);
    156 }
    157 
    158 /* EGLDisplay eglGetDisplay ( EGLNativeDisplayType display_id ) */
    159 static jobject
    160 android_eglGetDisplayInt
    161   (JNIEnv *_env, jobject _this, jint display_id) {
    162 
    163     if (static_cast<uintptr_t>(display_id) !=
    164         reinterpret_cast<uintptr_t>(EGL_DEFAULT_DISPLAY)) {
    165         jniThrowException(_env, "java/lang/UnsupportedOperationException", "eglGetDisplay");
    166         return 0;
    167     }
    168     return android_eglGetDisplay(_env, _this, display_id);
    169 }
    170 
    171 /* EGLBoolean eglInitialize ( EGLDisplay dpy, EGLint *major, EGLint *minor ) */
    172 static jboolean
    173 android_eglInitialize
    174   (JNIEnv *_env, jobject _this, jobject dpy, jintArray major_ref, jint majorOffset, jintArray minor_ref, jint minorOffset) {
    175     jint _exception = 0;
    176     const char * _exceptionType = NULL;
    177     const char * _exceptionMessage = NULL;
    178     EGLBoolean _returnValue = (EGLBoolean) 0;
    179     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    180     EGLint *major_base = (EGLint *) 0;
    181     jint _majorRemaining;
    182     EGLint *major = (EGLint *) 0;
    183     EGLint *minor_base = (EGLint *) 0;
    184     jint _minorRemaining;
    185     EGLint *minor = (EGLint *) 0;
    186 
    187     if (!major_ref) {
    188         _exception = 1;
    189         _exceptionType = "java/lang/IllegalArgumentException";
    190         _exceptionMessage = "major == null";
    191         goto exit;
    192     }
    193     if (majorOffset < 0) {
    194         _exception = 1;
    195         _exceptionType = "java/lang/IllegalArgumentException";
    196         _exceptionMessage = "majorOffset < 0";
    197         goto exit;
    198     }
    199     _majorRemaining = _env->GetArrayLength(major_ref) - majorOffset;
    200     if (_majorRemaining < 1) {
    201         _exception = 1;
    202         _exceptionType = "java/lang/IllegalArgumentException";
    203         _exceptionMessage = "length - majorOffset < 1 < needed";
    204         goto exit;
    205     }
    206     major_base = (EGLint *)
    207         _env->GetIntArrayElements(major_ref, (jboolean *)0);
    208     major = major_base + majorOffset;
    209 
    210     if (!minor_ref) {
    211         _exception = 1;
    212         _exceptionType = "java/lang/IllegalArgumentException";
    213         _exceptionMessage = "minor == null";
    214         goto exit;
    215     }
    216     if (minorOffset < 0) {
    217         _exception = 1;
    218         _exceptionType = "java/lang/IllegalArgumentException";
    219         _exceptionMessage = "minorOffset < 0";
    220         goto exit;
    221     }
    222     _minorRemaining = _env->GetArrayLength(minor_ref) - minorOffset;
    223     if (_minorRemaining < 1) {
    224         _exception = 1;
    225         _exceptionType = "java/lang/IllegalArgumentException";
    226         _exceptionMessage = "length - minorOffset < 1 < needed";
    227         goto exit;
    228     }
    229     minor_base = (EGLint *)
    230         _env->GetIntArrayElements(minor_ref, (jboolean *)0);
    231     minor = minor_base + minorOffset;
    232 
    233     _returnValue = eglInitialize(
    234         (EGLDisplay)dpy_native,
    235         (EGLint *)major,
    236         (EGLint *)minor
    237     );
    238 
    239 exit:
    240     if (minor_base) {
    241         _env->ReleaseIntArrayElements(minor_ref, (jint*)minor_base,
    242             _exception ? JNI_ABORT: 0);
    243     }
    244     if (major_base) {
    245         _env->ReleaseIntArrayElements(major_ref, (jint*)major_base,
    246             _exception ? JNI_ABORT: 0);
    247     }
    248     if (_exception) {
    249         jniThrowException(_env, _exceptionType, _exceptionMessage);
    250     }
    251     return (jboolean)_returnValue;
    252 }
    253 
    254 /* EGLBoolean eglTerminate ( EGLDisplay dpy ) */
    255 static jboolean
    256 android_eglTerminate
    257   (JNIEnv *_env, jobject _this, jobject dpy) {
    258     EGLBoolean _returnValue = (EGLBoolean) 0;
    259     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    260 
    261     _returnValue = eglTerminate(
    262         (EGLDisplay)dpy_native
    263     );
    264     return (jboolean)_returnValue;
    265 }
    266 
    267 /* const char * eglQueryString ( EGLDisplay dpy, EGLint name ) */
    268 static jstring
    269 android_eglQueryString__Landroind_opengl_EGLDisplay_2I
    270   (JNIEnv *_env, jobject _this, jobject dpy, jint name) {
    271     const char* chars = (const char*) eglQueryString(
    272         (EGLDisplay)fromEGLHandle(_env, egldisplayGetHandleID, dpy),
    273         (EGLint)name
    274     );
    275     return _env->NewStringUTF(chars);
    276 }
    277 /* EGLBoolean eglGetConfigs ( EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config ) */
    278 static jboolean
    279 android_eglGetConfigs
    280   (JNIEnv *_env, jobject _this, jobject dpy, jobjectArray configs_ref, jint configsOffset, jint config_size, jintArray num_config_ref, jint num_configOffset) {
    281     jint _exception = 0;
    282     const char * _exceptionType = NULL;
    283     const char * _exceptionMessage = NULL;
    284     EGLBoolean _returnValue = (EGLBoolean) 0;
    285     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    286     jint _configsRemaining;
    287     EGLConfig *configs = (EGLConfig *) 0;
    288     EGLint *num_config_base = (EGLint *) 0;
    289     jint _num_configRemaining;
    290     EGLint *num_config = (EGLint *) 0;
    291 
    292     if (!configs_ref) {
    293         _exception = 1;
    294         _exceptionType = "java/lang/IllegalArgumentException";
    295         _exceptionMessage = "configs == null";
    296         goto exit;
    297     }
    298     if (configsOffset < 0) {
    299         _exception = 1;
    300         _exceptionType = "java/lang/IllegalArgumentException";
    301         _exceptionMessage = "configsOffset < 0";
    302         goto exit;
    303     }
    304     _configsRemaining = _env->GetArrayLength(configs_ref) - configsOffset;
    305     if (_configsRemaining < config_size) {
    306         _exception = 1;
    307         _exceptionType = "java/lang/IllegalArgumentException";
    308         _exceptionMessage = "length - configsOffset < config_size < needed";
    309         goto exit;
    310     }
    311     configs = new EGLConfig[_configsRemaining];
    312 
    313     if (!num_config_ref) {
    314         _exception = 1;
    315         _exceptionType = "java/lang/IllegalArgumentException";
    316         _exceptionMessage = "num_config == null";
    317         goto exit;
    318     }
    319     if (num_configOffset < 0) {
    320         _exception = 1;
    321         _exceptionType = "java/lang/IllegalArgumentException";
    322         _exceptionMessage = "num_configOffset < 0";
    323         goto exit;
    324     }
    325     _num_configRemaining = _env->GetArrayLength(num_config_ref) - num_configOffset;
    326     num_config_base = (EGLint *)
    327         _env->GetIntArrayElements(num_config_ref, (jboolean *)0);
    328     num_config = num_config_base + num_configOffset;
    329 
    330     _returnValue = eglGetConfigs(
    331         (EGLDisplay)dpy_native,
    332         (EGLConfig *)configs,
    333         (EGLint)config_size,
    334         (EGLint *)num_config
    335     );
    336 
    337 exit:
    338     if (num_config_base) {
    339         _env->ReleaseIntArrayElements(num_config_ref, (jint*)num_config_base,
    340             _exception ? JNI_ABORT: 0);
    341     }
    342     if (configs) {
    343         for (int i = 0; i < _configsRemaining; i++) {
    344             jobject configs_new = toEGLHandle(_env, eglconfigClass, eglconfigConstructor, configs[i]);
    345             _env->SetObjectArrayElement(configs_ref, i + configsOffset, configs_new);
    346         }
    347         delete[] configs;
    348     }
    349     if (_exception) {
    350         jniThrowException(_env, _exceptionType, _exceptionMessage);
    351     }
    352     return (jboolean)_returnValue;
    353 }
    354 
    355 /* EGLBoolean eglChooseConfig ( EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config ) */
    356 static jboolean
    357 android_eglChooseConfig
    358   (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) {
    359     jint _exception = 0;
    360     const char * _exceptionType = NULL;
    361     const char * _exceptionMessage = NULL;
    362     EGLBoolean _returnValue = (EGLBoolean) 0;
    363     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    364     bool attrib_list_sentinel = false;
    365     EGLint *attrib_list_base = (EGLint *) 0;
    366     jint _attrib_listRemaining;
    367     EGLint *attrib_list = (EGLint *) 0;
    368     jint _configsRemaining;
    369     EGLConfig *configs = (EGLConfig *) 0;
    370     EGLint *num_config_base = (EGLint *) 0;
    371     jint _num_configRemaining;
    372     EGLint *num_config = (EGLint *) 0;
    373 
    374     if (!attrib_list_ref) {
    375         _exception = 1;
    376         _exceptionType = "java/lang/IllegalArgumentException";
    377         _exceptionMessage = "attrib_list == null";
    378         goto exit;
    379     }
    380     if (attrib_listOffset < 0) {
    381         _exception = 1;
    382         _exceptionType = "java/lang/IllegalArgumentException";
    383         _exceptionMessage = "attrib_listOffset < 0";
    384         goto exit;
    385     }
    386     _attrib_listRemaining = _env->GetArrayLength(attrib_list_ref) - attrib_listOffset;
    387     attrib_list_base = (EGLint *)
    388         _env->GetIntArrayElements(attrib_list_ref, (jboolean *)0);
    389     attrib_list = attrib_list_base + attrib_listOffset;
    390     attrib_list_sentinel = false;
    391     for (int i = _attrib_listRemaining - 1; i >= 0; i--)  {
    392         if (attrib_list[i] == EGL_NONE){
    393             attrib_list_sentinel = true;
    394             break;
    395         }
    396     }
    397     if (attrib_list_sentinel == false) {
    398         _exception = 1;
    399         _exceptionType = "java/lang/IllegalArgumentException";
    400         _exceptionMessage = "attrib_list must contain EGL_NONE!";
    401         goto exit;
    402     }
    403 
    404     if (!configs_ref) {
    405         _exception = 1;
    406         _exceptionType = "java/lang/IllegalArgumentException";
    407         _exceptionMessage = "configs == null";
    408         goto exit;
    409     }
    410     if (configsOffset < 0) {
    411         _exception = 1;
    412         _exceptionType = "java/lang/IllegalArgumentException";
    413         _exceptionMessage = "configsOffset < 0";
    414         goto exit;
    415     }
    416     _configsRemaining = _env->GetArrayLength(configs_ref) - configsOffset;
    417     if (_configsRemaining < config_size) {
    418         _exception = 1;
    419         _exceptionType = "java/lang/IllegalArgumentException";
    420         _exceptionMessage = "length - configsOffset < config_size < needed";
    421         goto exit;
    422     }
    423     configs = new EGLConfig[_configsRemaining];
    424 
    425     if (!num_config_ref) {
    426         _exception = 1;
    427         _exceptionType = "java/lang/IllegalArgumentException";
    428         _exceptionMessage = "num_config == null";
    429         goto exit;
    430     }
    431     if (num_configOffset < 0) {
    432         _exception = 1;
    433         _exceptionType = "java/lang/IllegalArgumentException";
    434         _exceptionMessage = "num_configOffset < 0";
    435         goto exit;
    436     }
    437     _num_configRemaining = _env->GetArrayLength(num_config_ref) - num_configOffset;
    438     if (_num_configRemaining < 1) {
    439         _exception = 1;
    440         _exceptionType = "java/lang/IllegalArgumentException";
    441         _exceptionMessage = "length - num_configOffset < 1 < needed";
    442         goto exit;
    443     }
    444     num_config_base = (EGLint *)
    445         _env->GetIntArrayElements(num_config_ref, (jboolean *)0);
    446     num_config = num_config_base + num_configOffset;
    447 
    448     _returnValue = eglChooseConfig(
    449         (EGLDisplay)dpy_native,
    450         (EGLint *)attrib_list,
    451         (EGLConfig *)configs,
    452         (EGLint)config_size,
    453         (EGLint *)num_config
    454     );
    455 
    456 exit:
    457     if (num_config_base) {
    458         _env->ReleaseIntArrayElements(num_config_ref, (jint*)num_config_base,
    459             _exception ? JNI_ABORT: 0);
    460     }
    461     if (attrib_list_base) {
    462         _env->ReleaseIntArrayElements(attrib_list_ref, (jint*)attrib_list_base,
    463             JNI_ABORT);
    464     }
    465     if (configs) {
    466         for (int i = 0; i < _configsRemaining; i++) {
    467             jobject configs_new = toEGLHandle(_env, eglconfigClass, eglconfigConstructor, configs[i]);
    468             _env->SetObjectArrayElement(configs_ref, i + configsOffset, configs_new);
    469         }
    470         delete[] configs;
    471     }
    472     if (_exception) {
    473         jniThrowException(_env, _exceptionType, _exceptionMessage);
    474     }
    475     return (jboolean)_returnValue;
    476 }
    477 
    478 /* EGLBoolean eglGetConfigAttrib ( EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value ) */
    479 static jboolean
    480 android_eglGetConfigAttrib
    481   (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jint attribute, jintArray value_ref, jint offset) {
    482     jint _exception = 0;
    483     const char * _exceptionType = NULL;
    484     const char * _exceptionMessage = NULL;
    485     EGLBoolean _returnValue = (EGLBoolean) 0;
    486     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    487     EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config);
    488     EGLint *value_base = (EGLint *) 0;
    489     jint _remaining;
    490     EGLint *value = (EGLint *) 0;
    491 
    492     if (!value_ref) {
    493         _exception = 1;
    494         _exceptionType = "java/lang/IllegalArgumentException";
    495         _exceptionMessage = "value == null";
    496         goto exit;
    497     }
    498     if (offset < 0) {
    499         _exception = 1;
    500         _exceptionType = "java/lang/IllegalArgumentException";
    501         _exceptionMessage = "offset < 0";
    502         goto exit;
    503     }
    504     _remaining = _env->GetArrayLength(value_ref) - offset;
    505     if (_remaining < 1) {
    506         _exception = 1;
    507         _exceptionType = "java/lang/IllegalArgumentException";
    508         _exceptionMessage = "length - offset < 1 < needed";
    509         goto exit;
    510     }
    511     value_base = (EGLint *)
    512         _env->GetIntArrayElements(value_ref, (jboolean *)0);
    513     value = value_base + offset;
    514 
    515     _returnValue = eglGetConfigAttrib(
    516         (EGLDisplay)dpy_native,
    517         (EGLConfig)config_native,
    518         (EGLint)attribute,
    519         (EGLint *)value
    520     );
    521 
    522 exit:
    523     if (value_base) {
    524         _env->ReleaseIntArrayElements(value_ref, (jint*)value_base,
    525             _exception ? JNI_ABORT: 0);
    526     }
    527     if (_exception) {
    528         jniThrowException(_env, _exceptionType, _exceptionMessage);
    529     }
    530     return (jboolean)_returnValue;
    531 }
    532 
    533 /* EGLSurface eglCreateWindowSurface ( EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list ) */
    534 static jobject
    535 android_eglCreateWindowSurface
    536   (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jobject win, jintArray attrib_list_ref, jint offset) {
    537     jint _exception = 0;
    538     const char * _exceptionType = "";
    539     const char * _exceptionMessage = "";
    540     EGLSurface _returnValue = (EGLSurface) 0;
    541     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    542     EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config);
    543     int attrib_list_sentinel = 0;
    544     EGLint *attrib_list_base = (EGLint *) 0;
    545     jint _remaining;
    546     EGLint *attrib_list = (EGLint *) 0;
    547     android::sp<ANativeWindow> window;
    548 
    549     if (!attrib_list_ref) {
    550         _exception = 1;
    551         _exceptionType = "java/lang/IllegalArgumentException";
    552         _exceptionMessage = "attrib_list == null";
    553         goto exit;
    554     }
    555     if (offset < 0) {
    556         _exception = 1;
    557         _exceptionType = "java/lang/IllegalArgumentException";
    558         _exceptionMessage = "offset < 0";
    559         goto exit;
    560     }
    561     if (win == NULL) {
    562 not_valid_surface:
    563         _exception = 1;
    564         _exceptionType = "java/lang/IllegalArgumentException";
    565         _exceptionMessage = "Make sure the SurfaceView or associated SurfaceHolder has a valid Surface";
    566         goto exit;
    567     }
    568 
    569     window = android::android_view_Surface_getNativeWindow(_env, win);
    570 
    571     if (window == NULL)
    572         goto not_valid_surface;
    573 
    574     _remaining = _env->GetArrayLength(attrib_list_ref) - offset;
    575     attrib_list_base = (EGLint *)
    576         _env->GetIntArrayElements(attrib_list_ref, (jboolean *)0);
    577     attrib_list = attrib_list_base + offset;
    578     attrib_list_sentinel = 0;
    579     for (int i = _remaining - 1; i >= 0; i--)  {
    580         if (*((EGLint*)(attrib_list + i)) == EGL_NONE){
    581             attrib_list_sentinel = 1;
    582             break;
    583         }
    584     }
    585     if (attrib_list_sentinel == 0) {
    586         _exception = 1;
    587         _exceptionType = "java/lang/IllegalArgumentException";
    588         _exceptionMessage = "attrib_list must contain EGL_NONE!";
    589         goto exit;
    590     }
    591 
    592     _returnValue = eglCreateWindowSurface(
    593         (EGLDisplay)dpy_native,
    594         (EGLConfig)config_native,
    595         (EGLNativeWindowType)window.get(),
    596         (EGLint *)attrib_list
    597     );
    598 
    599 exit:
    600     if (attrib_list_base) {
    601         _env->ReleaseIntArrayElements(attrib_list_ref, attrib_list_base,
    602             JNI_ABORT);
    603     }
    604     if (_exception) {
    605         jniThrowException(_env, _exceptionType, _exceptionMessage);
    606     }
    607     return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue);
    608 }
    609 
    610 /* EGLSurface eglCreateWindowSurface ( EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list ) */
    611 static jobject
    612 android_eglCreateWindowSurfaceTexture
    613   (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jobject win, jintArray attrib_list_ref, jint offset) {
    614     jint _exception = 0;
    615     const char * _exceptionType = "";
    616     const char * _exceptionMessage = "";
    617     EGLSurface _returnValue = (EGLSurface) 0;
    618     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    619     EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config);
    620     int attrib_list_sentinel = 0;
    621     EGLint *attrib_list_base = (EGLint *) 0;
    622     jint _remaining;
    623     EGLint *attrib_list = (EGLint *) 0;
    624     android::sp<ANativeWindow> window;
    625     android::sp<android::IGraphicBufferProducer> producer;
    626 
    627     if (!attrib_list_ref) {
    628         _exception = 1;
    629         _exceptionType = "java/lang/IllegalArgumentException";
    630         _exceptionMessage = "attrib_list == null";
    631         goto exit;
    632     }
    633     if (offset < 0) {
    634         _exception = 1;
    635         _exceptionType = "java/lang/IllegalArgumentException";
    636         _exceptionMessage = "offset < 0";
    637         goto exit;
    638     }
    639     if (win == NULL) {
    640 not_valid_surface:
    641         _exception = 1;
    642         _exceptionType = "java/lang/IllegalArgumentException";
    643         _exceptionMessage = "Make sure the SurfaceView or associated SurfaceHolder has a valid Surface";
    644         goto exit;
    645     }
    646     producer = android::SurfaceTexture_getProducer(_env, win);
    647 
    648     if (producer == NULL)
    649         goto not_valid_surface;
    650 
    651     window = new android::Surface(producer, true);
    652 
    653     if (window == NULL)
    654         goto not_valid_surface;
    655 
    656     _remaining = _env->GetArrayLength(attrib_list_ref) - offset;
    657     attrib_list_base = (EGLint *)
    658         _env->GetIntArrayElements(attrib_list_ref, (jboolean *)0);
    659     attrib_list = attrib_list_base + offset;
    660     attrib_list_sentinel = 0;
    661     for (int i = _remaining - 1; i >= 0; i--)  {
    662         if (*((EGLint*)(attrib_list + i)) == EGL_NONE){
    663             attrib_list_sentinel = 1;
    664             break;
    665         }
    666     }
    667     if (attrib_list_sentinel == 0) {
    668         _exception = 1;
    669         _exceptionType = "java/lang/IllegalArgumentException";
    670         _exceptionMessage = "attrib_list must contain EGL_NONE!";
    671         goto exit;
    672     }
    673 
    674     _returnValue = eglCreateWindowSurface(
    675         (EGLDisplay)dpy_native,
    676         (EGLConfig)config_native,
    677         (EGLNativeWindowType)window.get(),
    678         (EGLint *)attrib_list
    679     );
    680 
    681 exit:
    682     if (attrib_list_base) {
    683         _env->ReleaseIntArrayElements(attrib_list_ref, attrib_list_base,
    684             JNI_ABORT);
    685     }
    686     if (_exception) {
    687         jniThrowException(_env, _exceptionType, _exceptionMessage);
    688     }
    689     return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue);
    690 }
    691 /* EGLSurface eglCreatePbufferSurface ( EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list ) */
    692 static jobject
    693 android_eglCreatePbufferSurface
    694   (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jintArray attrib_list_ref, jint offset) {
    695     jint _exception = 0;
    696     const char * _exceptionType = NULL;
    697     const char * _exceptionMessage = NULL;
    698     EGLSurface _returnValue = (EGLSurface) 0;
    699     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    700     EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config);
    701     bool attrib_list_sentinel = false;
    702     EGLint *attrib_list_base = (EGLint *) 0;
    703     jint _remaining;
    704     EGLint *attrib_list = (EGLint *) 0;
    705 
    706     if (!attrib_list_ref) {
    707         _exception = 1;
    708         _exceptionType = "java/lang/IllegalArgumentException";
    709         _exceptionMessage = "attrib_list == null";
    710         goto exit;
    711     }
    712     if (offset < 0) {
    713         _exception = 1;
    714         _exceptionType = "java/lang/IllegalArgumentException";
    715         _exceptionMessage = "offset < 0";
    716         goto exit;
    717     }
    718     _remaining = _env->GetArrayLength(attrib_list_ref) - offset;
    719     attrib_list_base = (EGLint *)
    720         _env->GetIntArrayElements(attrib_list_ref, (jboolean *)0);
    721     attrib_list = attrib_list_base + offset;
    722     attrib_list_sentinel = false;
    723     for (int i = _remaining - 1; i >= 0; i--)  {
    724         if (attrib_list[i] == EGL_NONE){
    725             attrib_list_sentinel = true;
    726             break;
    727         }
    728     }
    729     if (attrib_list_sentinel == false) {
    730         _exception = 1;
    731         _exceptionType = "java/lang/IllegalArgumentException";
    732         _exceptionMessage = "attrib_list must contain EGL_NONE!";
    733         goto exit;
    734     }
    735 
    736     _returnValue = eglCreatePbufferSurface(
    737         (EGLDisplay)dpy_native,
    738         (EGLConfig)config_native,
    739         (EGLint *)attrib_list
    740     );
    741 
    742 exit:
    743     if (attrib_list_base) {
    744         _env->ReleaseIntArrayElements(attrib_list_ref, (jint*)attrib_list_base,
    745             JNI_ABORT);
    746     }
    747     if (_exception) {
    748         jniThrowException(_env, _exceptionType, _exceptionMessage);
    749     }
    750     return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue);
    751 }
    752 
    753 /* EGLSurface eglCreatePixmapSurface ( EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list ) */
    754 static jobject
    755 android_eglCreatePixmapSurface
    756   (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jint pixmap, jintArray attrib_list_ref, jint offset) {
    757     jniThrowException(_env, "java/lang/UnsupportedOperationException",
    758         "eglCreatePixmapSurface");
    759     return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, (EGLSurface) 0);
    760 }
    761 
    762 /* EGLBoolean eglDestroySurface ( EGLDisplay dpy, EGLSurface surface ) */
    763 static jboolean
    764 android_eglDestroySurface
    765   (JNIEnv *_env, jobject _this, jobject dpy, jobject surface) {
    766     EGLBoolean _returnValue = (EGLBoolean) 0;
    767     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    768     EGLSurface surface_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, surface);
    769 
    770     _returnValue = eglDestroySurface(
    771         (EGLDisplay)dpy_native,
    772         (EGLSurface)surface_native
    773     );
    774     return (jboolean)_returnValue;
    775 }
    776 
    777 /* EGLBoolean eglQuerySurface ( EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value ) */
    778 static jboolean
    779 android_eglQuerySurface
    780   (JNIEnv *_env, jobject _this, jobject dpy, jobject surface, jint attribute, jintArray value_ref, jint offset) {
    781     jint _exception = 0;
    782     const char * _exceptionType = NULL;
    783     const char * _exceptionMessage = NULL;
    784     EGLBoolean _returnValue = (EGLBoolean) 0;
    785     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    786     EGLSurface surface_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, surface);
    787     EGLint *value_base = (EGLint *) 0;
    788     jint _remaining;
    789     EGLint *value = (EGLint *) 0;
    790 
    791     if (!value_ref) {
    792         _exception = 1;
    793         _exceptionType = "java/lang/IllegalArgumentException";
    794         _exceptionMessage = "value == null";
    795         goto exit;
    796     }
    797     if (offset < 0) {
    798         _exception = 1;
    799         _exceptionType = "java/lang/IllegalArgumentException";
    800         _exceptionMessage = "offset < 0";
    801         goto exit;
    802     }
    803     _remaining = _env->GetArrayLength(value_ref) - offset;
    804     if (_remaining < 1) {
    805         _exception = 1;
    806         _exceptionType = "java/lang/IllegalArgumentException";
    807         _exceptionMessage = "length - offset < 1 < needed";
    808         goto exit;
    809     }
    810     value_base = (EGLint *)
    811         _env->GetIntArrayElements(value_ref, (jboolean *)0);
    812     value = value_base + offset;
    813 
    814     _returnValue = eglQuerySurface(
    815         (EGLDisplay)dpy_native,
    816         (EGLSurface)surface_native,
    817         (EGLint)attribute,
    818         (EGLint *)value
    819     );
    820 
    821 exit:
    822     if (value_base) {
    823         _env->ReleaseIntArrayElements(value_ref, (jint*)value_base,
    824             _exception ? JNI_ABORT: 0);
    825     }
    826     if (_exception) {
    827         jniThrowException(_env, _exceptionType, _exceptionMessage);
    828     }
    829     return (jboolean)_returnValue;
    830 }
    831 
    832 /* EGLBoolean eglBindAPI ( EGLenum api ) */
    833 static jboolean
    834 android_eglBindAPI
    835   (JNIEnv *_env, jobject _this, jint api) {
    836     EGLBoolean _returnValue = (EGLBoolean) 0;
    837     _returnValue = eglBindAPI(
    838         (EGLenum)api
    839     );
    840     return (jboolean)_returnValue;
    841 }
    842 
    843 /* EGLenum eglQueryAPI ( void ) */
    844 static jint
    845 android_eglQueryAPI
    846   (JNIEnv *_env, jobject _this) {
    847     EGLenum _returnValue = (EGLenum) 0;
    848     _returnValue = eglQueryAPI();
    849     return (jint)_returnValue;
    850 }
    851 
    852 /* EGLBoolean eglWaitClient ( void ) */
    853 static jboolean
    854 android_eglWaitClient
    855   (JNIEnv *_env, jobject _this) {
    856     EGLBoolean _returnValue = (EGLBoolean) 0;
    857     _returnValue = eglWaitClient();
    858     return (jboolean)_returnValue;
    859 }
    860 
    861 /* EGLBoolean eglReleaseThread ( void ) */
    862 static jboolean
    863 android_eglReleaseThread
    864   (JNIEnv *_env, jobject _this) {
    865     EGLBoolean _returnValue = (EGLBoolean) 0;
    866     _returnValue = eglReleaseThread();
    867     return (jboolean)_returnValue;
    868 }
    869 
    870 /* EGLSurface eglCreatePbufferFromClientBuffer ( EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list ) */
    871 static jobject
    872 android_eglCreatePbufferFromClientBuffer
    873   (JNIEnv *_env, jobject _this, jobject dpy, jint buftype, jlong buffer, jobject config, jintArray attrib_list_ref, jint offset) {
    874     jint _exception = 0;
    875     const char * _exceptionType = NULL;
    876     const char * _exceptionMessage = NULL;
    877     EGLSurface _returnValue = (EGLSurface) 0;
    878     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    879     EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config);
    880     bool attrib_list_sentinel = false;
    881     EGLint *attrib_list_base = (EGLint *) 0;
    882     jint _remaining;
    883     EGLint *attrib_list = (EGLint *) 0;
    884 
    885     if (!attrib_list_ref) {
    886         _exception = 1;
    887         _exceptionType = "java/lang/IllegalArgumentException";
    888         _exceptionMessage = "attrib_list == null";
    889         goto exit;
    890     }
    891     if (offset < 0) {
    892         _exception = 1;
    893         _exceptionType = "java/lang/IllegalArgumentException";
    894         _exceptionMessage = "offset < 0";
    895         goto exit;
    896     }
    897     _remaining = _env->GetArrayLength(attrib_list_ref) - offset;
    898     attrib_list_base = (EGLint *)
    899         _env->GetIntArrayElements(attrib_list_ref, (jboolean *)0);
    900     attrib_list = attrib_list_base + offset;
    901     attrib_list_sentinel = false;
    902     for (int i = _remaining - 1; i >= 0; i--)  {
    903         if (attrib_list[i] == EGL_NONE){
    904             attrib_list_sentinel = true;
    905             break;
    906         }
    907     }
    908     if (attrib_list_sentinel == false) {
    909         _exception = 1;
    910         _exceptionType = "java/lang/IllegalArgumentException";
    911         _exceptionMessage = "attrib_list must contain EGL_NONE!";
    912         goto exit;
    913     }
    914 
    915     _returnValue = eglCreatePbufferFromClientBuffer(
    916         (EGLDisplay)dpy_native,
    917         (EGLenum)buftype,
    918         reinterpret_cast<EGLClientBuffer>(buffer),
    919         (EGLConfig)config_native,
    920         (EGLint *)attrib_list
    921     );
    922 
    923 exit:
    924     if (attrib_list_base) {
    925         _env->ReleaseIntArrayElements(attrib_list_ref, attrib_list_base,
    926             JNI_ABORT);
    927     }
    928     if (_exception) {
    929         jniThrowException(_env, _exceptionType, _exceptionMessage);
    930     }
    931     return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue);
    932 }
    933 
    934 static jobject
    935 android_eglCreatePbufferFromClientBufferInt
    936   (JNIEnv *_env, jobject _this, jobject dpy, jint buftype, jint buffer, jobject config, jintArray attrib_list_ref, jint offset) {
    937     if(sizeof(void*) != sizeof(uint32_t)) {
    938         jniThrowException(_env, "java/lang/UnsupportedOperationException", "eglCreatePbufferFromClientBuffer");
    939         return 0;
    940     }
    941     return android_eglCreatePbufferFromClientBuffer(_env, _this, dpy, buftype, buffer, config, attrib_list_ref, offset);
    942 }
    943 /* EGLBoolean eglSurfaceAttrib ( EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value ) */
    944 static jboolean
    945 android_eglSurfaceAttrib
    946   (JNIEnv *_env, jobject _this, jobject dpy, jobject surface, jint attribute, jint value) {
    947     EGLBoolean _returnValue = (EGLBoolean) 0;
    948     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    949     EGLSurface surface_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, surface);
    950 
    951     _returnValue = eglSurfaceAttrib(
    952         (EGLDisplay)dpy_native,
    953         (EGLSurface)surface_native,
    954         (EGLint)attribute,
    955         (EGLint)value
    956     );
    957     return (jboolean)_returnValue;
    958 }
    959 
    960 /* EGLBoolean eglBindTexImage ( EGLDisplay dpy, EGLSurface surface, EGLint buffer ) */
    961 static jboolean
    962 android_eglBindTexImage
    963   (JNIEnv *_env, jobject _this, jobject dpy, jobject surface, jint buffer) {
    964     EGLBoolean _returnValue = (EGLBoolean) 0;
    965     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    966     EGLSurface surface_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, surface);
    967 
    968     _returnValue = eglBindTexImage(
    969         (EGLDisplay)dpy_native,
    970         (EGLSurface)surface_native,
    971         (EGLint)buffer
    972     );
    973     return (jboolean)_returnValue;
    974 }
    975 
    976 /* EGLBoolean eglReleaseTexImage ( EGLDisplay dpy, EGLSurface surface, EGLint buffer ) */
    977 static jboolean
    978 android_eglReleaseTexImage
    979   (JNIEnv *_env, jobject _this, jobject dpy, jobject surface, jint buffer) {
    980     EGLBoolean _returnValue = (EGLBoolean) 0;
    981     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    982     EGLSurface surface_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, surface);
    983 
    984     _returnValue = eglReleaseTexImage(
    985         (EGLDisplay)dpy_native,
    986         (EGLSurface)surface_native,
    987         (EGLint)buffer
    988     );
    989     return (jboolean)_returnValue;
    990 }
    991 
    992 /* EGLBoolean eglSwapInterval ( EGLDisplay dpy, EGLint interval ) */
    993 static jboolean
    994 android_eglSwapInterval
    995   (JNIEnv *_env, jobject _this, jobject dpy, jint interval) {
    996     EGLBoolean _returnValue = (EGLBoolean) 0;
    997     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
    998 
    999     _returnValue = eglSwapInterval(
   1000         (EGLDisplay)dpy_native,
   1001         (EGLint)interval
   1002     );
   1003     return (jboolean)_returnValue;
   1004 }
   1005 
   1006 /* EGLContext eglCreateContext ( EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list ) */
   1007 static jobject
   1008 android_eglCreateContext
   1009   (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jobject share_context, jintArray attrib_list_ref, jint offset) {
   1010     jint _exception = 0;
   1011     const char * _exceptionType = NULL;
   1012     const char * _exceptionMessage = NULL;
   1013     EGLContext _returnValue = (EGLContext) 0;
   1014     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
   1015     EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config);
   1016     EGLContext share_context_native = (EGLContext) fromEGLHandle(_env, eglcontextGetHandleID, share_context);
   1017     bool attrib_list_sentinel = false;
   1018     EGLint *attrib_list_base = (EGLint *) 0;
   1019     jint _remaining;
   1020     EGLint *attrib_list = (EGLint *) 0;
   1021 
   1022     if (!attrib_list_ref) {
   1023         _exception = 1;
   1024         _exceptionType = "java/lang/IllegalArgumentException";
   1025         _exceptionMessage = "attrib_list == null";
   1026         goto exit;
   1027     }
   1028     if (offset < 0) {
   1029         _exception = 1;
   1030         _exceptionType = "java/lang/IllegalArgumentException";
   1031         _exceptionMessage = "offset < 0";
   1032         goto exit;
   1033     }
   1034     _remaining = _env->GetArrayLength(attrib_list_ref) - offset;
   1035     attrib_list_base = (EGLint *)
   1036         _env->GetIntArrayElements(attrib_list_ref, (jboolean *)0);
   1037     attrib_list = attrib_list_base + offset;
   1038     attrib_list_sentinel = false;
   1039     for (int i = _remaining - 1; i >= 0; i--)  {
   1040         if (attrib_list[i] == EGL_NONE){
   1041             attrib_list_sentinel = true;
   1042             break;
   1043         }
   1044     }
   1045     if (attrib_list_sentinel == false) {
   1046         _exception = 1;
   1047         _exceptionType = "java/lang/IllegalArgumentException";
   1048         _exceptionMessage = "attrib_list must contain EGL_NONE!";
   1049         goto exit;
   1050     }
   1051 
   1052     _returnValue = eglCreateContext(
   1053         (EGLDisplay)dpy_native,
   1054         (EGLConfig)config_native,
   1055         (EGLContext)share_context_native,
   1056         (EGLint *)attrib_list
   1057     );
   1058 
   1059 exit:
   1060     if (attrib_list_base) {
   1061         _env->ReleaseIntArrayElements(attrib_list_ref, (jint*)attrib_list_base,
   1062             JNI_ABORT);
   1063     }
   1064     if (_exception) {
   1065         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1066     }
   1067     return toEGLHandle(_env, eglcontextClass, eglcontextConstructor, _returnValue);
   1068 }
   1069 
   1070 /* EGLBoolean eglDestroyContext ( EGLDisplay dpy, EGLContext ctx ) */
   1071 static jboolean
   1072 android_eglDestroyContext
   1073   (JNIEnv *_env, jobject _this, jobject dpy, jobject ctx) {
   1074     EGLBoolean _returnValue = (EGLBoolean) 0;
   1075     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
   1076     EGLContext ctx_native = (EGLContext) fromEGLHandle(_env, eglcontextGetHandleID, ctx);
   1077 
   1078     _returnValue = eglDestroyContext(
   1079         (EGLDisplay)dpy_native,
   1080         (EGLContext)ctx_native
   1081     );
   1082     return (jboolean)_returnValue;
   1083 }
   1084 
   1085 /* EGLBoolean eglMakeCurrent ( EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx ) */
   1086 static jboolean
   1087 android_eglMakeCurrent
   1088   (JNIEnv *_env, jobject _this, jobject dpy, jobject draw, jobject read, jobject ctx) {
   1089     EGLBoolean _returnValue = (EGLBoolean) 0;
   1090     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
   1091     EGLSurface draw_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, draw);
   1092     EGLSurface read_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, read);
   1093     EGLContext ctx_native = (EGLContext) fromEGLHandle(_env, eglcontextGetHandleID, ctx);
   1094 
   1095     _returnValue = eglMakeCurrent(
   1096         (EGLDisplay)dpy_native,
   1097         (EGLSurface)draw_native,
   1098         (EGLSurface)read_native,
   1099         (EGLContext)ctx_native
   1100     );
   1101     return (jboolean)_returnValue;
   1102 }
   1103 
   1104 /* EGLContext eglGetCurrentContext ( void ) */
   1105 static jobject
   1106 android_eglGetCurrentContext
   1107   (JNIEnv *_env, jobject _this) {
   1108     EGLContext _returnValue = (EGLContext) 0;
   1109     _returnValue = eglGetCurrentContext();
   1110     return toEGLHandle(_env, eglcontextClass, eglcontextConstructor, _returnValue);
   1111 }
   1112 
   1113 /* EGLSurface eglGetCurrentSurface ( EGLint readdraw ) */
   1114 static jobject
   1115 android_eglGetCurrentSurface
   1116   (JNIEnv *_env, jobject _this, jint readdraw) {
   1117     EGLSurface _returnValue = (EGLSurface) 0;
   1118     _returnValue = eglGetCurrentSurface(
   1119         (EGLint)readdraw
   1120     );
   1121     return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue);
   1122 }
   1123 
   1124 /* EGLDisplay eglGetCurrentDisplay ( void ) */
   1125 static jobject
   1126 android_eglGetCurrentDisplay
   1127   (JNIEnv *_env, jobject _this) {
   1128     EGLDisplay _returnValue = (EGLDisplay) 0;
   1129     _returnValue = eglGetCurrentDisplay();
   1130     return toEGLHandle(_env, egldisplayClass, egldisplayConstructor, _returnValue);
   1131 }
   1132 
   1133 /* EGLBoolean eglQueryContext ( EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value ) */
   1134 static jboolean
   1135 android_eglQueryContext
   1136   (JNIEnv *_env, jobject _this, jobject dpy, jobject ctx, jint attribute, jintArray value_ref, jint offset) {
   1137     jint _exception = 0;
   1138     const char * _exceptionType = NULL;
   1139     const char * _exceptionMessage = NULL;
   1140     EGLBoolean _returnValue = (EGLBoolean) 0;
   1141     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
   1142     EGLContext ctx_native = (EGLContext) fromEGLHandle(_env, eglcontextGetHandleID, ctx);
   1143     EGLint *value_base = (EGLint *) 0;
   1144     jint _remaining;
   1145     EGLint *value = (EGLint *) 0;
   1146 
   1147     if (!value_ref) {
   1148         _exception = 1;
   1149         _exceptionType = "java/lang/IllegalArgumentException";
   1150         _exceptionMessage = "value == null";
   1151         goto exit;
   1152     }
   1153     if (offset < 0) {
   1154         _exception = 1;
   1155         _exceptionType = "java/lang/IllegalArgumentException";
   1156         _exceptionMessage = "offset < 0";
   1157         goto exit;
   1158     }
   1159     _remaining = _env->GetArrayLength(value_ref) - offset;
   1160     if (_remaining < 1) {
   1161         _exception = 1;
   1162         _exceptionType = "java/lang/IllegalArgumentException";
   1163         _exceptionMessage = "length - offset < 1 < needed";
   1164         goto exit;
   1165     }
   1166     value_base = (EGLint *)
   1167         _env->GetIntArrayElements(value_ref, (jboolean *)0);
   1168     value = value_base + offset;
   1169 
   1170     _returnValue = eglQueryContext(
   1171         (EGLDisplay)dpy_native,
   1172         (EGLContext)ctx_native,
   1173         (EGLint)attribute,
   1174         (EGLint *)value
   1175     );
   1176 
   1177 exit:
   1178     if (value_base) {
   1179         _env->ReleaseIntArrayElements(value_ref, (jint*)value_base,
   1180             _exception ? JNI_ABORT: 0);
   1181     }
   1182     if (_exception) {
   1183         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1184     }
   1185     return (jboolean)_returnValue;
   1186 }
   1187 
   1188 /* EGLBoolean eglWaitGL ( void ) */
   1189 static jboolean
   1190 android_eglWaitGL
   1191   (JNIEnv *_env, jobject _this) {
   1192     EGLBoolean _returnValue = (EGLBoolean) 0;
   1193     _returnValue = eglWaitGL();
   1194     return (jboolean)_returnValue;
   1195 }
   1196 
   1197 /* EGLBoolean eglWaitNative ( EGLint engine ) */
   1198 static jboolean
   1199 android_eglWaitNative
   1200   (JNIEnv *_env, jobject _this, jint engine) {
   1201     EGLBoolean _returnValue = (EGLBoolean) 0;
   1202     _returnValue = eglWaitNative(
   1203         (EGLint)engine
   1204     );
   1205     return (jboolean)_returnValue;
   1206 }
   1207 
   1208 /* EGLBoolean eglSwapBuffers ( EGLDisplay dpy, EGLSurface surface ) */
   1209 static jboolean
   1210 android_eglSwapBuffers
   1211   (JNIEnv *_env, jobject _this, jobject dpy, jobject surface) {
   1212     EGLBoolean _returnValue = (EGLBoolean) 0;
   1213     EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy);
   1214     EGLSurface surface_native = (EGLSurface) fromEGLHandle(_env, eglsurfaceGetHandleID, surface);
   1215 
   1216     _returnValue = eglSwapBuffers(
   1217         (EGLDisplay)dpy_native,
   1218         (EGLSurface)surface_native
   1219     );
   1220     return (jboolean)_returnValue;
   1221 }
   1222 
   1223 /* EGLBoolean eglCopyBuffers ( EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target ) */
   1224 static jboolean
   1225 android_eglCopyBuffers
   1226   (JNIEnv *_env, jobject _this, jobject dpy, jobject surface, jint target) {
   1227     jniThrowException(_env, "java/lang/UnsupportedOperationException",
   1228         "eglCopyBuffers");
   1229     return (EGLBoolean) 0;
   1230 }
   1231 
   1232 static const char *classPathName = "android/opengl/EGL14";
   1233 
   1234 static JNINativeMethod methods[] = {
   1235 {"_nativeClassInit", "()V", (void*)nativeClassInit },
   1236 {"eglGetError", "()I", (void *) android_eglGetError },
   1237 {"eglGetDisplay", "(I)Landroid/opengl/EGLDisplay;", (void *) android_eglGetDisplayInt },
   1238 {"eglGetDisplay", "(J)Landroid/opengl/EGLDisplay;", (void *) android_eglGetDisplay },
   1239 {"eglInitialize", "(Landroid/opengl/EGLDisplay;[II[II)Z", (void *) android_eglInitialize },
   1240 {"eglTerminate", "(Landroid/opengl/EGLDisplay;)Z", (void *) android_eglTerminate },
   1241 {"eglQueryString", "(Landroid/opengl/EGLDisplay;I)Ljava/lang/String;", (void *) android_eglQueryString__Landroind_opengl_EGLDisplay_2I },
   1242 {"eglGetConfigs", "(Landroid/opengl/EGLDisplay;[Landroid/opengl/EGLConfig;II[II)Z", (void *) android_eglGetConfigs },
   1243 {"eglChooseConfig", "(Landroid/opengl/EGLDisplay;[II[Landroid/opengl/EGLConfig;II[II)Z", (void *) android_eglChooseConfig },
   1244 {"eglGetConfigAttrib", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;I[II)Z", (void *) android_eglGetConfigAttrib },
   1245 {"_eglCreateWindowSurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;Ljava/lang/Object;[II)Landroid/opengl/EGLSurface;", (void *) android_eglCreateWindowSurface },
   1246 {"_eglCreateWindowSurfaceTexture", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;Ljava/lang/Object;[II)Landroid/opengl/EGLSurface;", (void *) android_eglCreateWindowSurfaceTexture },
   1247 {"eglCreatePbufferSurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;[II)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePbufferSurface },
   1248 {"eglCreatePixmapSurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;I[II)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePixmapSurface },
   1249 {"eglDestroySurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;)Z", (void *) android_eglDestroySurface },
   1250 {"eglQuerySurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;I[II)Z", (void *) android_eglQuerySurface },
   1251 {"eglBindAPI", "(I)Z", (void *) android_eglBindAPI },
   1252 {"eglQueryAPI", "()I", (void *) android_eglQueryAPI },
   1253 {"eglWaitClient", "()Z", (void *) android_eglWaitClient },
   1254 {"eglReleaseThread", "()Z", (void *) android_eglReleaseThread },
   1255 {"eglCreatePbufferFromClientBuffer", "(Landroid/opengl/EGLDisplay;IILandroid/opengl/EGLConfig;[II)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePbufferFromClientBufferInt },
   1256 {"eglCreatePbufferFromClientBuffer", "(Landroid/opengl/EGLDisplay;IJLandroid/opengl/EGLConfig;[II)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePbufferFromClientBuffer },
   1257 {"eglSurfaceAttrib", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;II)Z", (void *) android_eglSurfaceAttrib },
   1258 {"eglBindTexImage", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;I)Z", (void *) android_eglBindTexImage },
   1259 {"eglReleaseTexImage", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;I)Z", (void *) android_eglReleaseTexImage },
   1260 {"eglSwapInterval", "(Landroid/opengl/EGLDisplay;I)Z", (void *) android_eglSwapInterval },
   1261 {"eglCreateContext", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;Landroid/opengl/EGLContext;[II)Landroid/opengl/EGLContext;", (void *) android_eglCreateContext },
   1262 {"eglDestroyContext", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLContext;)Z", (void *) android_eglDestroyContext },
   1263 {"eglMakeCurrent", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;Landroid/opengl/EGLSurface;Landroid/opengl/EGLContext;)Z", (void *) android_eglMakeCurrent },
   1264 {"eglGetCurrentContext", "()Landroid/opengl/EGLContext;", (void *) android_eglGetCurrentContext },
   1265 {"eglGetCurrentSurface", "(I)Landroid/opengl/EGLSurface;", (void *) android_eglGetCurrentSurface },
   1266 {"eglGetCurrentDisplay", "()Landroid/opengl/EGLDisplay;", (void *) android_eglGetCurrentDisplay },
   1267 {"eglQueryContext", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLContext;I[II)Z", (void *) android_eglQueryContext },
   1268 {"eglWaitGL", "()Z", (void *) android_eglWaitGL },
   1269 {"eglWaitNative", "(I)Z", (void *) android_eglWaitNative },
   1270 {"eglSwapBuffers", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;)Z", (void *) android_eglSwapBuffers },
   1271 {"eglCopyBuffers", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSurface;I)Z", (void *) android_eglCopyBuffers },
   1272 };
   1273 
   1274 int register_android_opengl_jni_EGL14(JNIEnv *_env)
   1275 {
   1276     int err;
   1277     err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
   1278     return err;
   1279 }
   1280