Home | History | Annotate | Download | only in jni 
      1 /*
      2 **
      3 ** Copyright 2006, The Android Open Source Project
      4 **
      5 ** Licensed under the Apache License, Version 2.0 (the "License");
      6 ** you may not use this file except in compliance with the License.
      7 ** You may obtain a copy of the License at
      8 **
      9 **     http://www.apache.org/licenses/LICENSE-2.0
     10 **
     11 ** Unless required by applicable law or agreed to in writing, software
     12 ** distributed under the License is distributed on an "AS IS" BASIS,
     13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14 ** See the License for the specific language governing permissions and
     15 ** limitations under the License.
     16 */
     17 
     18 #include "JNIHelp.h"
     19 #include <android_runtime/AndroidRuntime.h>
     20 #include <android_runtime/android_view_Surface.h>
     21 #include <android_runtime/android_graphics_SurfaceTexture.h>
     22 #include <utils/misc.h>
     23 
     24 
     25 #include <EGL/egl_display.h>
     26 #include <EGL/egl.h>
     27 #include <GLES/gl.h>
     28 
     29 #include <gui/Surface.h>
     30 #include <gui/GLConsumer.h>
     31 #include <gui/Surface.h>
     32 
     33 #include <SkBitmap.h>
     34 #include <SkPixelRef.h>
     35 
     36 #include <ui/ANativeObjectBase.h>
     37 
     38 namespace android {
     39 
     40 static jclass gConfig_class;
     41 
     42 static jmethodID gConfig_ctorID;
     43 
     44 static jfieldID gDisplay_EGLDisplayFieldID;
     45 static jfieldID gContext_EGLContextFieldID;
     46 static jfieldID gSurface_EGLSurfaceFieldID;
     47 static jfieldID gSurface_NativePixelRefFieldID;
     48 static jfieldID gConfig_EGLConfigFieldID;
     49 static jfieldID gBitmap_NativeBitmapFieldID;
     50 
     51 static inline EGLDisplay getDisplay(JNIEnv* env, jobject o) {
     52     if (!o) return EGL_NO_DISPLAY;
     53     return (EGLDisplay)env->GetLongField(o, gDisplay_EGLDisplayFieldID);
     54 }
     55 static inline EGLSurface getSurface(JNIEnv* env, jobject o) {
     56     if (!o) return EGL_NO_SURFACE;
     57     return (EGLSurface)env->GetLongField(o, gSurface_EGLSurfaceFieldID);
     58 }
     59 static inline EGLContext getContext(JNIEnv* env, jobject o) {
     60     if (!o) return EGL_NO_CONTEXT;
     61     return (EGLContext)env->GetLongField(o, gContext_EGLContextFieldID);
     62 }
     63 static inline EGLConfig getConfig(JNIEnv* env, jobject o) {
     64     if (!o) return 0;
     65     return (EGLConfig)env->GetLongField(o, gConfig_EGLConfigFieldID);
     66 }
     67 
     68 static inline jboolean EglBoolToJBool(EGLBoolean eglBool) {
     69     return eglBool == EGL_TRUE ? JNI_TRUE : JNI_FALSE;
     70 }
     71 
     72 static void nativeClassInit(JNIEnv *_env, jclass eglImplClass)
     73 {
     74     jclass config_class = _env->FindClass("com/google/android/gles_jni/EGLConfigImpl");
     75     gConfig_class = (jclass) _env->NewGlobalRef(config_class);
     76     gConfig_ctorID = _env->GetMethodID(gConfig_class,  "<init>", "(J)V");
     77     gConfig_EGLConfigFieldID = _env->GetFieldID(gConfig_class,  "mEGLConfig",  "J");
     78 
     79     jclass display_class = _env->FindClass("com/google/android/gles_jni/EGLDisplayImpl");
     80     gDisplay_EGLDisplayFieldID = _env->GetFieldID(display_class, "mEGLDisplay", "J");
     81 
     82     jclass context_class = _env->FindClass("com/google/android/gles_jni/EGLContextImpl");
     83     gContext_EGLContextFieldID = _env->GetFieldID(context_class, "mEGLContext", "J");
     84 
     85     jclass surface_class = _env->FindClass("com/google/android/gles_jni/EGLSurfaceImpl");
     86     gSurface_EGLSurfaceFieldID = _env->GetFieldID(surface_class, "mEGLSurface", "J");
     87     gSurface_NativePixelRefFieldID = _env->GetFieldID(surface_class, "mNativePixelRef", "J");
     88 
     89     jclass bitmap_class = _env->FindClass("android/graphics/Bitmap");
     90     gBitmap_NativeBitmapFieldID = _env->GetFieldID(bitmap_class, "mNativeBitmap", "J");
     91 }
     92 
     93 static const jint gNull_attrib_base[] = {EGL_NONE};
     94 
     95 static bool validAttribList(JNIEnv *_env, jintArray attrib_list) {
     96     if (attrib_list == NULL) {
     97         return true;
     98     }
     99     jsize len = _env->GetArrayLength(attrib_list);
    100     if (len < 1) {
    101         return false;
    102     }
    103     jint item = 0;
    104     _env->GetIntArrayRegion(attrib_list, len-1, 1, &item);
    105     return item == EGL_NONE;
    106 }
    107 
    108 static jint* beginNativeAttribList(JNIEnv *_env, jintArray attrib_list) {
    109     if (attrib_list != NULL) {
    110         return _env->GetIntArrayElements(attrib_list, (jboolean *)0);
    111     } else {
    112         return(jint*) gNull_attrib_base;
    113     }
    114 }
    115 
    116 static void endNativeAttributeList(JNIEnv *_env, jintArray attrib_list, jint* attrib_base) {
    117     if (attrib_list != NULL) {
    118         _env->ReleaseIntArrayElements(attrib_list, attrib_base, 0);
    119     }
    120 }
    121 
    122 static jboolean jni_eglInitialize(JNIEnv *_env, jobject _this, jobject display,
    123         jintArray major_minor) {
    124     if (display == NULL || (major_minor != NULL &&
    125             _env->GetArrayLength(major_minor) < 2)) {
    126         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    127         return JNI_FALSE;
    128     }
    129 
    130     EGLDisplay dpy = getDisplay(_env, display);
    131     EGLBoolean success = eglInitialize(dpy, NULL, NULL);
    132     if (success && major_minor) {
    133         int len = _env->GetArrayLength(major_minor);
    134         if (len) {
    135             // we're exposing only EGL 1.0
    136             jint* base = (jint *)_env->GetPrimitiveArrayCritical(major_minor, (jboolean *)0);
    137             if (len >= 1) base[0] = 1;
    138             if (len >= 2) base[1] = 0;
    139             _env->ReleasePrimitiveArrayCritical(major_minor, base, 0);
    140         }
    141     }
    142     return EglBoolToJBool(success);
    143 }
    144 
    145 static jboolean jni_eglQueryContext(JNIEnv *_env, jobject _this, jobject display,
    146         jobject context, jint attribute, jintArray value) {
    147     if (display == NULL || context == NULL || value == NULL
    148         || _env->GetArrayLength(value) < 1) {
    149         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    150         return JNI_FALSE;
    151     }
    152     EGLDisplay dpy = getDisplay(_env, display);
    153     EGLContext ctx = getContext(_env, context);
    154     EGLBoolean success = EGL_FALSE;
    155     int len = _env->GetArrayLength(value);
    156     if (len) {
    157         jint* base = _env->GetIntArrayElements(value, (jboolean *)0);
    158         success = eglQueryContext(dpy, ctx, attribute, base);
    159         _env->ReleaseIntArrayElements(value, base, 0);
    160     }
    161     return EglBoolToJBool(success);
    162 }
    163 
    164 static jboolean jni_eglQuerySurface(JNIEnv *_env, jobject _this, jobject display,
    165         jobject surface, jint attribute, jintArray value) {
    166     if (display == NULL || surface == NULL || value == NULL
    167         || _env->GetArrayLength(value) < 1) {
    168         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    169         return JNI_FALSE;
    170     }
    171     EGLDisplay dpy = getDisplay(_env, display);
    172     EGLContext sur = getSurface(_env, surface);
    173 
    174     EGLBoolean success = EGL_FALSE;
    175     int len = _env->GetArrayLength(value);
    176     if (len) {
    177         jint* base = _env->GetIntArrayElements(value, (jboolean *)0);
    178         success = eglQuerySurface(dpy, sur, attribute, base);
    179         _env->ReleaseIntArrayElements(value, base, 0);
    180     }
    181     return EglBoolToJBool(success);
    182 }
    183 
    184 static jint jni_getInitCount(JNIEnv *_env, jobject _clazz, jobject display) {
    185     EGLDisplay dpy = getDisplay(_env, display);
    186     egl_display_t* eglDisplay = get_display_nowake(dpy);
    187     return eglDisplay ? eglDisplay->getRefsCount() : 0;
    188 }
    189 
    190 static jboolean jni_eglReleaseThread(JNIEnv *_env, jobject _this) {
    191     return EglBoolToJBool(eglReleaseThread());
    192 }
    193 
    194 static jboolean jni_eglChooseConfig(JNIEnv *_env, jobject _this, jobject display,
    195         jintArray attrib_list, jobjectArray configs, jint config_size, jintArray num_config) {
    196     if (display == NULL
    197         || !validAttribList(_env, attrib_list)
    198         || (configs != NULL && _env->GetArrayLength(configs) < config_size)
    199         || (num_config != NULL && _env->GetArrayLength(num_config) < 1)) {
    200         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    201         return JNI_FALSE;
    202     }
    203     EGLDisplay dpy = getDisplay(_env, display);
    204     EGLBoolean success = EGL_FALSE;
    205 
    206     if (configs == NULL) {
    207         config_size = 0;
    208     }
    209     EGLConfig nativeConfigs[config_size];
    210 
    211     int num = 0;
    212     jint* attrib_base = beginNativeAttribList(_env, attrib_list);
    213     success = eglChooseConfig(dpy, attrib_base, configs ? nativeConfigs : 0, config_size, &num);
    214     endNativeAttributeList(_env, attrib_list, attrib_base);
    215 
    216     if (num_config != NULL) {
    217         _env->SetIntArrayRegion(num_config, 0, 1, (jint*) &num);
    218     }
    219 
    220     if (success && configs!=NULL) {
    221         for (int i=0 ; i<num ; i++) {
    222             jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, reinterpret_cast<jlong>(nativeConfigs[i]));
    223             _env->SetObjectArrayElement(configs, i, obj);
    224         }
    225     }
    226     return EglBoolToJBool(success);
    227 }
    228 
    229 static jlong jni_eglCreateContext(JNIEnv *_env, jobject _this, jobject display,
    230         jobject config, jobject share_context, jintArray attrib_list) {
    231     if (display == NULL || config == NULL || share_context == NULL
    232         || !validAttribList(_env, attrib_list)) {
    233         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    234         return JNI_FALSE;
    235     }
    236     EGLDisplay dpy = getDisplay(_env, display);
    237     EGLConfig  cnf = getConfig(_env, config);
    238     EGLContext shr = getContext(_env, share_context);
    239     jint* base = beginNativeAttribList(_env, attrib_list);
    240     EGLContext ctx = eglCreateContext(dpy, cnf, shr, base);
    241     endNativeAttributeList(_env, attrib_list, base);
    242     return reinterpret_cast<jlong>(ctx);
    243 }
    244 
    245 static jlong jni_eglCreatePbufferSurface(JNIEnv *_env, jobject _this, jobject display,
    246         jobject config, jintArray attrib_list) {
    247     if (display == NULL || config == NULL
    248         || !validAttribList(_env, attrib_list)) {
    249         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    250         return JNI_FALSE;
    251     }
    252     EGLDisplay dpy = getDisplay(_env, display);
    253     EGLConfig  cnf = getConfig(_env, config);
    254     jint* base = beginNativeAttribList(_env, attrib_list);
    255     EGLSurface sur = eglCreatePbufferSurface(dpy, cnf, base);
    256     endNativeAttributeList(_env, attrib_list, base);
    257     return reinterpret_cast<jlong>(sur);
    258 }
    259 
    260 static PixelFormat convertPixelFormat(SkColorType format)
    261 {
    262     switch (format) {
    263     case kN32_SkColorType:         return PIXEL_FORMAT_RGBA_8888;
    264     case kARGB_4444_SkColorType:   return PIXEL_FORMAT_RGBA_4444;
    265     case kRGB_565_SkColorType:     return PIXEL_FORMAT_RGB_565;
    266     default:                       return PIXEL_FORMAT_NONE;
    267     }
    268 }
    269 
    270 static void jni_eglCreatePixmapSurface(JNIEnv *_env, jobject _this, jobject out_sur,
    271         jobject display, jobject config, jobject native_pixmap,
    272         jintArray attrib_list)
    273 {
    274     if (display == NULL || config == NULL || native_pixmap == NULL
    275         || !validAttribList(_env, attrib_list)) {
    276         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    277         return;
    278     }
    279     EGLDisplay dpy = getDisplay(_env, display);
    280     EGLConfig  cnf = getConfig(_env, config);
    281     jint* base = 0;
    282 
    283     SkBitmap const * nativeBitmap =
    284             (SkBitmap const *)_env->GetLongField(native_pixmap,
    285                     gBitmap_NativeBitmapFieldID);
    286     SkPixelRef* ref = nativeBitmap ? nativeBitmap->pixelRef() : 0;
    287     if (ref == NULL) {
    288         jniThrowException(_env, "java/lang/IllegalArgumentException", "Bitmap has no PixelRef");
    289         return;
    290     }
    291 
    292     SkSafeRef(ref);
    293     ref->lockPixels();
    294 
    295     egl_native_pixmap_t pixmap;
    296     pixmap.version = sizeof(pixmap);
    297     pixmap.width  = nativeBitmap->width();
    298     pixmap.height = nativeBitmap->height();
    299     pixmap.stride = nativeBitmap->rowBytes() / nativeBitmap->bytesPerPixel();
    300     pixmap.format = convertPixelFormat(nativeBitmap->colorType());
    301     pixmap.data   = (uint8_t*)ref->pixels();
    302 
    303     base = beginNativeAttribList(_env, attrib_list);
    304     EGLSurface sur = eglCreatePixmapSurface(dpy, cnf, &pixmap, base);
    305     endNativeAttributeList(_env, attrib_list, base);
    306 
    307     if (sur != EGL_NO_SURFACE) {
    308         _env->SetLongField(out_sur, gSurface_EGLSurfaceFieldID, reinterpret_cast<jlong>(sur));
    309         _env->SetLongField(out_sur, gSurface_NativePixelRefFieldID, reinterpret_cast<jlong>(ref));
    310     } else {
    311         ref->unlockPixels();
    312         SkSafeUnref(ref);
    313     }
    314 }
    315 
    316 static jlong jni_eglCreateWindowSurface(JNIEnv *_env, jobject _this, jobject display,
    317         jobject config, jobject native_window, jintArray attrib_list) {
    318     if (display == NULL || config == NULL
    319         || !validAttribList(_env, attrib_list)) {
    320         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    321         return JNI_FALSE;
    322     }
    323     EGLDisplay dpy = getDisplay(_env, display);
    324     EGLContext cnf = getConfig(_env, config);
    325     sp<ANativeWindow> window;
    326     if (native_window == NULL) {
    327 not_valid_surface:
    328         jniThrowException(_env, "java/lang/IllegalArgumentException",
    329                 "Make sure the SurfaceView or associated SurfaceHolder has a valid Surface");
    330         return 0;
    331     }
    332 
    333     window = android_view_Surface_getNativeWindow(_env, native_window);
    334     if (window == NULL)
    335         goto not_valid_surface;
    336 
    337     jint* base = beginNativeAttribList(_env, attrib_list);
    338     EGLSurface sur = eglCreateWindowSurface(dpy, cnf, window.get(), base);
    339     endNativeAttributeList(_env, attrib_list, base);
    340     return reinterpret_cast<jlong>(sur);
    341 }
    342 
    343 static jlong jni_eglCreateWindowSurfaceTexture(JNIEnv *_env, jobject _this, jobject display,
    344         jobject config, jobject native_window, jintArray attrib_list) {
    345     if (display == NULL || config == NULL
    346         || !validAttribList(_env, attrib_list)) {
    347         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    348         return 0;
    349     }
    350     EGLDisplay dpy = getDisplay(_env, display);
    351     EGLContext cnf = getConfig(_env, config);
    352     sp<ANativeWindow> window;
    353     if (native_window == 0) {
    354 not_valid_surface:
    355         jniThrowException(_env, "java/lang/IllegalArgumentException",
    356                 "Make sure the SurfaceTexture is valid");
    357         return 0;
    358     }
    359 
    360     sp<IGraphicBufferProducer> producer(SurfaceTexture_getProducer(_env, native_window));
    361     window = new Surface(producer, true);
    362     if (window == NULL)
    363         goto not_valid_surface;
    364 
    365     jint* base = beginNativeAttribList(_env, attrib_list);
    366     EGLSurface sur = eglCreateWindowSurface(dpy, cnf, window.get(), base);
    367     endNativeAttributeList(_env, attrib_list, base);
    368     return reinterpret_cast<jlong>(sur);
    369 }
    370 
    371 static jboolean jni_eglGetConfigAttrib(JNIEnv *_env, jobject _this, jobject display,
    372         jobject config, jint attribute, jintArray value) {
    373     if (display == NULL || config == NULL
    374         || (value == NULL || _env->GetArrayLength(value) < 1)) {
    375         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    376         return JNI_FALSE;
    377     }
    378     EGLDisplay dpy = getDisplay(_env, display);
    379     EGLContext cnf = getConfig(_env, config);
    380     EGLBoolean success = EGL_FALSE;
    381     jint localValue;
    382     success = eglGetConfigAttrib(dpy, cnf, attribute, &localValue);
    383     if (success) {
    384         _env->SetIntArrayRegion(value, 0, 1, &localValue);
    385     }
    386     return EglBoolToJBool(success);
    387 }
    388 
    389 static jboolean jni_eglGetConfigs(JNIEnv *_env, jobject _this, jobject display,
    390         jobjectArray configs, jint config_size, jintArray num_config) {
    391     if (display == NULL || (configs != NULL && _env->GetArrayLength(configs) < config_size)
    392         || (num_config != NULL && _env->GetArrayLength(num_config) < 1)) {
    393         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    394         return JNI_FALSE;
    395     }
    396     EGLDisplay dpy = getDisplay(_env, display);
    397     EGLBoolean success = EGL_FALSE;
    398     if (configs == NULL) {
    399         config_size = 0;
    400     }
    401     EGLConfig nativeConfigs[config_size];
    402     int num;
    403     success = eglGetConfigs(dpy, configs ? nativeConfigs : 0, config_size, &num);
    404     if (num_config != NULL) {
    405         _env->SetIntArrayRegion(num_config, 0, 1, (jint*) &num);
    406     }
    407     if (success && configs) {
    408         for (int i=0 ; i<num ; i++) {
    409             jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, reinterpret_cast<jlong>(nativeConfigs[i]));
    410             _env->SetObjectArrayElement(configs, i, obj);
    411         }
    412     }
    413     return EglBoolToJBool(success);
    414 }
    415 
    416 static jint jni_eglGetError(JNIEnv *_env, jobject _this) {
    417     EGLint error = eglGetError();
    418     return error;
    419 }
    420 
    421 static jlong jni_eglGetCurrentContext(JNIEnv *_env, jobject _this) {
    422     return reinterpret_cast<jlong>(eglGetCurrentContext());
    423 }
    424 
    425 static jlong jni_eglGetCurrentDisplay(JNIEnv *_env, jobject _this) {
    426     return reinterpret_cast<jlong>(eglGetCurrentDisplay());
    427 }
    428 
    429 static jlong jni_eglGetCurrentSurface(JNIEnv *_env, jobject _this, jint readdraw) {
    430     if ((readdraw != EGL_READ) && (readdraw != EGL_DRAW)) {
    431         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    432         return 0;
    433     }
    434     return reinterpret_cast<jlong>(eglGetCurrentSurface(readdraw));
    435 }
    436 
    437 static jboolean jni_eglDestroyContext(JNIEnv *_env, jobject _this, jobject display, jobject context) {
    438     if (display == NULL || context == NULL) {
    439         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    440         return JNI_FALSE;
    441     }
    442     EGLDisplay dpy = getDisplay(_env, display);
    443     EGLContext ctx = getContext(_env, context);
    444     return EglBoolToJBool(eglDestroyContext(dpy, ctx));
    445 }
    446 
    447 static jboolean jni_eglDestroySurface(JNIEnv *_env, jobject _this, jobject display, jobject surface) {
    448     if (display == NULL || surface == NULL) {
    449         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    450         return JNI_FALSE;
    451     }
    452     EGLDisplay dpy = getDisplay(_env, display);
    453     EGLSurface sur = getSurface(_env, surface);
    454 
    455     if (sur) {
    456         SkPixelRef* ref = (SkPixelRef*)(_env->GetLongField(surface,
    457                 gSurface_NativePixelRefFieldID));
    458         if (ref) {
    459             ref->unlockPixels();
    460             SkSafeUnref(ref);
    461         }
    462     }
    463     return EglBoolToJBool(eglDestroySurface(dpy, sur));
    464 }
    465 
    466 static jlong jni_eglGetDisplay(JNIEnv *_env, jobject _this, jobject native_display) {
    467     return reinterpret_cast<jlong>(eglGetDisplay(EGL_DEFAULT_DISPLAY));
    468 }
    469 
    470 static jboolean jni_eglMakeCurrent(JNIEnv *_env, jobject _this, jobject display, jobject draw, jobject read, jobject context) {
    471     if (display == NULL || draw == NULL || read == NULL || context == NULL) {
    472         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    473         return JNI_FALSE;
    474     }
    475     EGLDisplay dpy = getDisplay(_env, display);
    476     EGLSurface sdr = getSurface(_env, draw);
    477     EGLSurface srd = getSurface(_env, read);
    478     EGLContext ctx = getContext(_env, context);
    479     return EglBoolToJBool(eglMakeCurrent(dpy, sdr, srd, ctx));
    480 }
    481 
    482 static jstring jni_eglQueryString(JNIEnv *_env, jobject _this, jobject display, jint name) {
    483     if (display == NULL) {
    484         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    485         return NULL;
    486     }
    487     EGLDisplay dpy = getDisplay(_env, display);
    488     const char* chars = eglQueryString(dpy, name);
    489     return _env->NewStringUTF(chars);
    490 }
    491 
    492 static jboolean jni_eglSwapBuffers(JNIEnv *_env, jobject _this, jobject display, jobject surface) {
    493     if (display == NULL || surface == NULL) {
    494         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    495         return JNI_FALSE;
    496     }
    497     EGLDisplay dpy = getDisplay(_env, display);
    498     EGLSurface sur = getSurface(_env, surface);
    499     return EglBoolToJBool(eglSwapBuffers(dpy, sur));
    500 }
    501 
    502 static jboolean jni_eglTerminate(JNIEnv *_env, jobject _this, jobject display) {
    503     if (display == NULL) {
    504         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    505         return JNI_FALSE;
    506     }
    507     EGLDisplay dpy = getDisplay(_env, display);
    508     return EglBoolToJBool(eglTerminate(dpy));
    509 }
    510 
    511 static jboolean jni_eglCopyBuffers(JNIEnv *_env, jobject _this, jobject display,
    512         jobject surface, jobject native_pixmap) {
    513     if (display == NULL || surface == NULL || native_pixmap == NULL) {
    514         jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
    515         return JNI_FALSE;
    516     }
    517     // TODO: Implement this
    518     return JNI_FALSE;
    519 }
    520 
    521 static jboolean jni_eglWaitGL(JNIEnv *_env, jobject _this) {
    522     return EglBoolToJBool(eglWaitGL());
    523 }
    524 
    525 static jboolean jni_eglWaitNative(JNIEnv *_env, jobject _this, jint engine, jobject bindTarget) {
    526     return EglBoolToJBool(eglWaitNative(engine));
    527 }
    528 
    529 
    530 static const char *classPathName = "com/google/android/gles_jni/EGLImpl";
    531 
    532 #define DISPLAY "Ljavax/microedition/khronos/egl/EGLDisplay;"
    533 #define CONTEXT "Ljavax/microedition/khronos/egl/EGLContext;"
    534 #define CONFIG  "Ljavax/microedition/khronos/egl/EGLConfig;"
    535 #define SURFACE "Ljavax/microedition/khronos/egl/EGLSurface;"
    536 #define OBJECT  "Ljava/lang/Object;"
    537 #define STRING  "Ljava/lang/String;"
    538 
    539 static JNINativeMethod methods[] = {
    540 {"_nativeClassInit","()V", (void*)nativeClassInit },
    541 {"eglWaitGL",       "()Z", (void*)jni_eglWaitGL },
    542 {"eglInitialize",   "(" DISPLAY "[I)Z", (void*)jni_eglInitialize },
    543 {"eglQueryContext", "(" DISPLAY CONTEXT "I[I)Z", (void*)jni_eglQueryContext },
    544 {"eglQuerySurface", "(" DISPLAY SURFACE "I[I)Z", (void*)jni_eglQuerySurface },
    545 {"eglReleaseThread","()Z", (void*)jni_eglReleaseThread },
    546 {"getInitCount",    "(" DISPLAY ")I", (void*)jni_getInitCount },
    547 {"eglChooseConfig", "(" DISPLAY "[I[" CONFIG "I[I)Z", (void*)jni_eglChooseConfig },
    548 {"_eglCreateContext","(" DISPLAY CONFIG CONTEXT "[I)J", (void*)jni_eglCreateContext },
    549 {"eglGetConfigs",   "(" DISPLAY "[" CONFIG "I[I)Z", (void*)jni_eglGetConfigs },
    550 {"eglTerminate",    "(" DISPLAY ")Z", (void*)jni_eglTerminate },
    551 {"eglCopyBuffers",  "(" DISPLAY SURFACE OBJECT ")Z", (void*)jni_eglCopyBuffers },
    552 {"eglWaitNative",   "(I" OBJECT ")Z", (void*)jni_eglWaitNative },
    553 {"eglGetError",     "()I", (void*)jni_eglGetError },
    554 {"eglGetConfigAttrib", "(" DISPLAY CONFIG "I[I)Z", (void*)jni_eglGetConfigAttrib },
    555 {"_eglGetDisplay",   "(" OBJECT ")J", (void*)jni_eglGetDisplay },
    556 {"_eglGetCurrentContext",  "()J", (void*)jni_eglGetCurrentContext },
    557 {"_eglGetCurrentDisplay",  "()J", (void*)jni_eglGetCurrentDisplay },
    558 {"_eglGetCurrentSurface",  "(I)J", (void*)jni_eglGetCurrentSurface },
    559 {"_eglCreatePbufferSurface","(" DISPLAY CONFIG "[I)J", (void*)jni_eglCreatePbufferSurface },
    560 {"_eglCreatePixmapSurface", "(" SURFACE DISPLAY CONFIG OBJECT "[I)V", (void*)jni_eglCreatePixmapSurface },
    561 {"_eglCreateWindowSurface", "(" DISPLAY CONFIG OBJECT "[I)J", (void*)jni_eglCreateWindowSurface },
    562 {"_eglCreateWindowSurfaceTexture", "(" DISPLAY CONFIG OBJECT "[I)J", (void*)jni_eglCreateWindowSurfaceTexture },
    563 {"eglDestroyContext",      "(" DISPLAY CONTEXT ")Z", (void*)jni_eglDestroyContext },
    564 {"eglDestroySurface",      "(" DISPLAY SURFACE ")Z", (void*)jni_eglDestroySurface },
    565 {"eglMakeCurrent",         "(" DISPLAY SURFACE SURFACE CONTEXT")Z", (void*)jni_eglMakeCurrent },
    566 {"eglQueryString",         "(" DISPLAY "I)" STRING, (void*)jni_eglQueryString },
    567 {"eglSwapBuffers",         "(" DISPLAY SURFACE ")Z", (void*)jni_eglSwapBuffers },
    568 };
    569 
    570 } // namespace android
    571 
    572 int register_com_google_android_gles_jni_EGLImpl(JNIEnv *_env)
    573 {
    574     int err;
    575     err = android::AndroidRuntime::registerNativeMethods(_env,
    576             android::classPathName, android::methods, NELEM(android::methods));
    577     return err;
    578 }
    579