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