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