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