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/SurfaceTexture.h>
31#include <gui/SurfaceTextureClient.h>
32
33#include <SkBitmap.h>
34#include <SkPixelRef.h>
35
36#include <ui/ANativeObjectBase.h>
37
38namespace android {
39
40static jclass gConfig_class;
41
42static jmethodID gConfig_ctorID;
43
44static jfieldID gDisplay_EGLDisplayFieldID;
45static jfieldID gContext_EGLContextFieldID;
46static jfieldID gSurface_EGLSurfaceFieldID;
47static jfieldID gSurface_NativePixelRefFieldID;
48static jfieldID gConfig_EGLConfigFieldID;
49static jfieldID gBitmap_NativeBitmapFieldID;
50
51static inline EGLDisplay getDisplay(JNIEnv* env, jobject o) {
52    if (!o) return EGL_NO_DISPLAY;
53    return (EGLDisplay)env->GetIntField(o, gDisplay_EGLDisplayFieldID);
54}
55static inline EGLSurface getSurface(JNIEnv* env, jobject o) {
56    if (!o) return EGL_NO_SURFACE;
57    return (EGLSurface)env->GetIntField(o, gSurface_EGLSurfaceFieldID);
58}
59static inline EGLContext getContext(JNIEnv* env, jobject o) {
60    if (!o) return EGL_NO_CONTEXT;
61    return (EGLContext)env->GetIntField(o, gContext_EGLContextFieldID);
62}
63static inline EGLConfig getConfig(JNIEnv* env, jobject o) {
64    if (!o) return 0;
65    return (EGLConfig)env->GetIntField(o, gConfig_EGLConfigFieldID);
66}
67static 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
88static const jint gNull_attrib_base[] = {EGL_NONE};
89
90static 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
103static 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
111static 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
117static 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
140static 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
159static 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
179static 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
185static jboolean jni_eglReleaseThread(JNIEnv *_env, jobject _this) {
186    return eglReleaseThread();
187}
188
189static 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
224static 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
240static 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
255static 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
266static 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
312static 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) {
323not_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
339static 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) {
350not_valid_surface:
351        jniThrowException(_env, "java/lang/IllegalArgumentException",
352                "Make sure the SurfaceTexture is valid");
353        return 0;
354    }
355
356    sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(_env, native_window));
357
358    window = new SurfaceTextureClient(surfaceTexture);
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
368static 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
386static 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
413static jint jni_eglGetError(JNIEnv *_env, jobject _this) {
414    EGLint error = eglGetError();
415    return error;
416}
417
418static jint jni_eglGetCurrentContext(JNIEnv *_env, jobject _this) {
419    return (jint)eglGetCurrentContext();
420}
421
422static jint jni_eglGetCurrentDisplay(JNIEnv *_env, jobject _this) {
423    return (jint)eglGetCurrentDisplay();
424}
425
426static 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
434static 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
444static 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
463static jint jni_eglGetDisplay(JNIEnv *_env, jobject _this, jobject native_display) {
464    return (jint)eglGetDisplay(EGL_DEFAULT_DISPLAY);
465}
466
467static 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
479static 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
489static 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
499static 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
508static 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
518static jboolean jni_eglWaitGL(JNIEnv *_env, jobject _this) {
519    return eglWaitGL();
520}
521
522static jboolean jni_eglWaitNative(JNIEnv *_env, jobject _this, jint engine, jobject bindTarget) {
523    return eglWaitNative(engine);
524}
525
526
527static 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
536static 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
569int 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