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