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