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