rsContext.cpp revision ef21edcc70fc2734a3dc7995d3c3af1f90d16ef8
1/* 2 * Copyright (C) 2009 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#include "rsDevice.h" 18#include "rsContext.h" 19#include "rsThreadIO.h" 20#include <ui/FramebufferNativeWindow.h> 21#include <ui/EGLUtils.h> 22#include <ui/egl/android_natives.h> 23 24#include <sys/types.h> 25#include <sys/resource.h> 26 27#include <cutils/properties.h> 28 29#include <GLES/gl.h> 30#include <GLES/glext.h> 31#include <GLES2/gl2.h> 32#include <GLES2/gl2ext.h> 33 34#include <cutils/sched_policy.h> 35 36using namespace android; 37using namespace android::renderscript; 38 39pthread_key_t Context::gThreadTLSKey = 0; 40uint32_t Context::gThreadTLSKeyCount = 0; 41uint32_t Context::gGLContextCount = 0; 42pthread_mutex_t Context::gInitMutex = PTHREAD_MUTEX_INITIALIZER; 43 44static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) { 45 if (returnVal != EGL_TRUE) { 46 fprintf(stderr, "%s() returned %d\n", op, returnVal); 47 } 48 49 for (EGLint error = eglGetError(); error != EGL_SUCCESS; error 50 = eglGetError()) { 51 fprintf(stderr, "after %s() eglError %s (0x%x)\n", op, EGLUtils::strerror(error), 52 error); 53 } 54} 55 56void Context::initEGL(bool useGL2) 57{ 58 mEGL.mNumConfigs = -1; 59 EGLint configAttribs[128]; 60 EGLint *configAttribsPtr = configAttribs; 61 EGLint context_attribs2[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; 62 63 memset(configAttribs, 0, sizeof(configAttribs)); 64 65 configAttribsPtr[0] = EGL_SURFACE_TYPE; 66 configAttribsPtr[1] = EGL_WINDOW_BIT; 67 configAttribsPtr += 2; 68 69 if (useGL2) { 70 configAttribsPtr[0] = EGL_RENDERABLE_TYPE; 71 configAttribsPtr[1] = EGL_OPENGL_ES2_BIT; 72 configAttribsPtr += 2; 73 } 74 75 if (mUseDepth) { 76 configAttribsPtr[0] = EGL_DEPTH_SIZE; 77 configAttribsPtr[1] = 16; 78 configAttribsPtr += 2; 79 } 80 81 if (mDev->mForceSW) { 82 configAttribsPtr[0] = EGL_CONFIG_CAVEAT; 83 configAttribsPtr[1] = EGL_SLOW_CONFIG; 84 configAttribsPtr += 2; 85 } 86 87 configAttribsPtr[0] = EGL_NONE; 88 rsAssert(configAttribsPtr < (configAttribs + (sizeof(configAttribs) / sizeof(EGLint)))); 89 90 LOGV("initEGL start"); 91 mEGL.mDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); 92 checkEglError("eglGetDisplay"); 93 94 eglInitialize(mEGL.mDisplay, &mEGL.mMajorVersion, &mEGL.mMinorVersion); 95 checkEglError("eglInitialize"); 96 97 status_t err = EGLUtils::selectConfigForNativeWindow(mEGL.mDisplay, configAttribs, mWndSurface, &mEGL.mConfig); 98 if (err) { 99 LOGE("couldn't find an EGLConfig matching the screen format\n"); 100 } 101 //eglChooseConfig(mEGL.mDisplay, configAttribs, &mEGL.mConfig, 1, &mEGL.mNumConfigs); 102 103 104 if (useGL2) { 105 mEGL.mContext = eglCreateContext(mEGL.mDisplay, mEGL.mConfig, EGL_NO_CONTEXT, context_attribs2); 106 } else { 107 mEGL.mContext = eglCreateContext(mEGL.mDisplay, mEGL.mConfig, EGL_NO_CONTEXT, NULL); 108 } 109 checkEglError("eglCreateContext"); 110 if (mEGL.mContext == EGL_NO_CONTEXT) { 111 LOGE("eglCreateContext returned EGL_NO_CONTEXT"); 112 } 113 gGLContextCount++; 114} 115 116void Context::deinitEGL() 117{ 118 LOGV("deinitEGL"); 119 setSurface(0, 0, NULL); 120 eglDestroyContext(mEGL.mDisplay, mEGL.mContext); 121 checkEglError("eglDestroyContext"); 122 123 gGLContextCount--; 124 if (!gGLContextCount) { 125 eglTerminate(mEGL.mDisplay); 126 } 127} 128 129 130uint32_t Context::runScript(Script *s, uint32_t launchID) 131{ 132 ObjectBaseRef<ProgramFragment> frag(mFragment); 133 ObjectBaseRef<ProgramVertex> vtx(mVertex); 134 ObjectBaseRef<ProgramFragmentStore> store(mFragmentStore); 135 ObjectBaseRef<ProgramRaster> raster(mRaster); 136 137 uint32_t ret = s->run(this, launchID); 138 139 mFragment.set(frag); 140 mVertex.set(vtx); 141 mFragmentStore.set(store); 142 mRaster.set(raster); 143 return ret; 144} 145 146void Context::checkError(const char *msg) const 147{ 148 GLenum err = glGetError(); 149 if (err != GL_NO_ERROR) { 150 LOGE("GL Error, 0x%x, from %s", err, msg); 151 } 152} 153 154uint32_t Context::runRootScript() 155{ 156 timerSet(RS_TIMER_CLEAR_SWAP); 157 rsAssert(mRootScript->mEnviroment.mIsRoot); 158 159 eglQuerySurface(mEGL.mDisplay, mEGL.mSurface, EGL_WIDTH, &mEGL.mWidth); 160 eglQuerySurface(mEGL.mDisplay, mEGL.mSurface, EGL_HEIGHT, &mEGL.mHeight); 161 glViewport(0, 0, mEGL.mWidth, mEGL.mHeight); 162 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); 163 164 glClearColor(mRootScript->mEnviroment.mClearColor[0], 165 mRootScript->mEnviroment.mClearColor[1], 166 mRootScript->mEnviroment.mClearColor[2], 167 mRootScript->mEnviroment.mClearColor[3]); 168 if (mUseDepth) { 169 glDepthMask(GL_TRUE); 170 glClearDepthf(mRootScript->mEnviroment.mClearDepth); 171 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 172 } else { 173 glClear(GL_COLOR_BUFFER_BIT); 174 } 175 176 timerSet(RS_TIMER_SCRIPT); 177 mStateFragmentStore.mLast.clear(); 178 uint32_t ret = runScript(mRootScript.get(), 0); 179 180 checkError("runRootScript"); 181 return ret; 182} 183 184uint64_t Context::getTime() const 185{ 186 struct timespec t; 187 clock_gettime(CLOCK_MONOTONIC, &t); 188 return t.tv_nsec + ((uint64_t)t.tv_sec * 1000 * 1000 * 1000); 189} 190 191void Context::timerReset() 192{ 193 for (int ct=0; ct < _RS_TIMER_TOTAL; ct++) { 194 mTimers[ct] = 0; 195 } 196} 197 198void Context::timerInit() 199{ 200 mTimeLast = getTime(); 201 mTimeFrame = mTimeLast; 202 mTimeLastFrame = mTimeLast; 203 mTimerActive = RS_TIMER_INTERNAL; 204 timerReset(); 205} 206 207void Context::timerFrame() 208{ 209 mTimeLastFrame = mTimeFrame; 210 mTimeFrame = getTime(); 211} 212 213void Context::timerSet(Timers tm) 214{ 215 uint64_t last = mTimeLast; 216 mTimeLast = getTime(); 217 mTimers[mTimerActive] += mTimeLast - last; 218 mTimerActive = tm; 219} 220 221void Context::timerPrint() 222{ 223 double total = 0; 224 for (int ct = 0; ct < _RS_TIMER_TOTAL; ct++) { 225 total += mTimers[ct]; 226 } 227 uint64_t frame = mTimeFrame - mTimeLastFrame; 228 mTimeMSLastFrame = frame / 1000000; 229 mTimeMSLastScript = mTimers[RS_TIMER_SCRIPT] / 1000000; 230 mTimeMSLastSwap = mTimers[RS_TIMER_CLEAR_SWAP] / 1000000; 231 232 233 if (props.mLogTimes) { 234 LOGV("RS: Frame (%i), Script %2.1f (%i), Clear & Swap %2.1f (%i), Idle %2.1f (%lli), Internal %2.1f (%lli)", 235 mTimeMSLastFrame, 236 100.0 * mTimers[RS_TIMER_SCRIPT] / total, mTimeMSLastScript, 237 100.0 * mTimers[RS_TIMER_CLEAR_SWAP] / total, mTimeMSLastSwap, 238 100.0 * mTimers[RS_TIMER_IDLE] / total, mTimers[RS_TIMER_IDLE] / 1000000, 239 100.0 * mTimers[RS_TIMER_INTERNAL] / total, mTimers[RS_TIMER_INTERNAL] / 1000000); 240 } 241} 242 243void Context::setupCheck() 244{ 245 if (checkVersion2_0()) { 246 mShaderCache.lookup(this, mVertex.get(), mFragment.get()); 247 248 mFragmentStore->setupGL2(this, &mStateFragmentStore); 249 mFragment->setupGL2(this, &mStateFragment, &mShaderCache); 250 mRaster->setupGL2(this, &mStateRaster); 251 mVertex->setupGL2(this, &mStateVertex, &mShaderCache); 252 253 } else { 254 mFragmentStore->setupGL(this, &mStateFragmentStore); 255 mFragment->setupGL(this, &mStateFragment); 256 mRaster->setupGL(this, &mStateRaster); 257 mVertex->setupGL(this, &mStateVertex); 258 } 259} 260 261static bool getProp(const char *str) 262{ 263 char buf[PROPERTY_VALUE_MAX]; 264 property_get(str, buf, "0"); 265 return 0 != strcmp(buf, "0"); 266} 267 268void * Context::threadProc(void *vrsc) 269{ 270 Context *rsc = static_cast<Context *>(vrsc); 271 rsc->mNativeThreadId = gettid(); 272 273 setpriority(PRIO_PROCESS, rsc->mNativeThreadId, ANDROID_PRIORITY_DISPLAY); 274 rsc->mThreadPriority = ANDROID_PRIORITY_DISPLAY; 275 276 rsc->props.mLogTimes = getProp("debug.rs.profile"); 277 rsc->props.mLogScripts = getProp("debug.rs.script"); 278 rsc->props.mLogObjects = getProp("debug.rs.object"); 279 rsc->props.mLogShaders = getProp("debug.rs.shader"); 280 281 ScriptTLSStruct *tlsStruct = new ScriptTLSStruct; 282 if (!tlsStruct) { 283 LOGE("Error allocating tls storage"); 284 return NULL; 285 } 286 tlsStruct->mContext = rsc; 287 tlsStruct->mScript = NULL; 288 int status = pthread_setspecific(rsc->gThreadTLSKey, tlsStruct); 289 if (status) { 290 LOGE("pthread_setspecific %i", status); 291 } 292 293 if (rsc->mIsGraphicsContext) { 294 rsc->mStateRaster.init(rsc, rsc->mEGL.mWidth, rsc->mEGL.mHeight); 295 rsc->setRaster(NULL); 296 rsc->mStateVertex.init(rsc, rsc->mEGL.mWidth, rsc->mEGL.mHeight); 297 rsc->setVertex(NULL); 298 rsc->mStateFragment.init(rsc, rsc->mEGL.mWidth, rsc->mEGL.mHeight); 299 rsc->setFragment(NULL); 300 rsc->mStateFragmentStore.init(rsc, rsc->mEGL.mWidth, rsc->mEGL.mHeight); 301 rsc->setFragmentStore(NULL); 302 rsc->mStateVertexArray.init(rsc); 303 } 304 305 rsc->mRunning = true; 306 bool mDraw = true; 307 while (!rsc->mExit) { 308 mDraw |= rsc->mIO.playCoreCommands(rsc, !mDraw); 309 mDraw &= (rsc->mRootScript.get() != NULL); 310 mDraw &= (rsc->mWndSurface != NULL); 311 312 uint32_t targetTime = 0; 313 if (mDraw && rsc->mIsGraphicsContext) { 314 targetTime = rsc->runRootScript(); 315 mDraw = targetTime && !rsc->mPaused; 316 rsc->timerSet(RS_TIMER_CLEAR_SWAP); 317 eglSwapBuffers(rsc->mEGL.mDisplay, rsc->mEGL.mSurface); 318 rsc->timerFrame(); 319 rsc->timerSet(RS_TIMER_INTERNAL); 320 rsc->timerPrint(); 321 rsc->timerReset(); 322 } 323 if (rsc->mObjDestroy.mNeedToEmpty) { 324 rsc->objDestroyOOBRun(); 325 } 326 if (rsc->mThreadPriority > 0 && targetTime) { 327 int32_t t = (targetTime - (int32_t)(rsc->mTimeMSLastScript + rsc->mTimeMSLastSwap)) * 1000; 328 if (t > 0) { 329 usleep(t); 330 } 331 } 332 } 333 334 LOGV("RS Thread exiting"); 335 if (rsc->mIsGraphicsContext) { 336 rsc->mRaster.clear(); 337 rsc->mFragment.clear(); 338 rsc->mVertex.clear(); 339 rsc->mFragmentStore.clear(); 340 rsc->mRootScript.clear(); 341 rsc->mStateRaster.deinit(rsc); 342 rsc->mStateVertex.deinit(rsc); 343 rsc->mStateFragment.deinit(rsc); 344 rsc->mStateFragmentStore.deinit(rsc); 345 } 346 ObjectBase::zeroAllUserRef(rsc); 347 348 rsc->mObjDestroy.mNeedToEmpty = true; 349 rsc->objDestroyOOBRun(); 350 351 if (rsc->mIsGraphicsContext) { 352 pthread_mutex_lock(&gInitMutex); 353 rsc->deinitEGL(); 354 pthread_mutex_unlock(&gInitMutex); 355 } 356 357 LOGV("RS Thread exited"); 358 return NULL; 359} 360 361void Context::setPriority(int32_t p) 362{ 363 // Note: If we put this in the proper "background" policy 364 // the wallpapers can become completly unresponsive at times. 365 // This is probably not what we want for something the user is actively 366 // looking at. 367 mThreadPriority = p; 368#if 0 369 SchedPolicy pol = SP_FOREGROUND; 370 if (p > 0) { 371 pol = SP_BACKGROUND; 372 } 373 if (!set_sched_policy(mNativeThreadId, pol)) { 374 // success; reset the priority as well 375 } 376#else 377 setpriority(PRIO_PROCESS, mNativeThreadId, p); 378#endif 379} 380 381Context::Context(Device *dev, bool isGraphics, bool useDepth) 382{ 383 pthread_mutex_lock(&gInitMutex); 384 385 dev->addContext(this); 386 mDev = dev; 387 mRunning = false; 388 mExit = false; 389 mUseDepth = useDepth; 390 mPaused = false; 391 mObjHead = NULL; 392 memset(&mEGL, 0, sizeof(mEGL)); 393 memset(&mGL, 0, sizeof(mGL)); 394 mIsGraphicsContext = isGraphics; 395 396 int status; 397 pthread_attr_t threadAttr; 398 399 if (!gThreadTLSKeyCount) { 400 status = pthread_key_create(&gThreadTLSKey, NULL); 401 if (status) { 402 LOGE("Failed to init thread tls key."); 403 pthread_mutex_unlock(&gInitMutex); 404 return; 405 } 406 } 407 gThreadTLSKeyCount++; 408 pthread_mutex_unlock(&gInitMutex); 409 410 // Global init done at this point. 411 412 status = pthread_attr_init(&threadAttr); 413 if (status) { 414 LOGE("Failed to init thread attribute."); 415 return; 416 } 417 418 mWndSurface = NULL; 419 420 objDestroyOOBInit(); 421 timerInit(); 422 timerSet(RS_TIMER_INTERNAL); 423 424 LOGV("RS Launching thread"); 425 status = pthread_create(&mThreadId, &threadAttr, threadProc, this); 426 if (status) { 427 LOGE("Failed to start rs context thread."); 428 } 429 430 while(!mRunning) { 431 usleep(100); 432 } 433 434 pthread_attr_destroy(&threadAttr); 435} 436 437Context::~Context() 438{ 439 LOGV("Context::~Context"); 440 mExit = true; 441 mPaused = false; 442 void *res; 443 444 mIO.shutdown(); 445 int status = pthread_join(mThreadId, &res); 446 mObjDestroy.mNeedToEmpty = true; 447 objDestroyOOBRun(); 448 449 // Global structure cleanup. 450 pthread_mutex_lock(&gInitMutex); 451 if (mDev) { 452 mDev->removeContext(this); 453 --gThreadTLSKeyCount; 454 if (!gThreadTLSKeyCount) { 455 pthread_key_delete(gThreadTLSKey); 456 } 457 mDev = NULL; 458 } 459 pthread_mutex_unlock(&gInitMutex); 460 461 objDestroyOOBDestroy(); 462} 463 464void Context::setSurface(uint32_t w, uint32_t h, android_native_window_t *sur) 465{ 466 rsAssert(mIsGraphicsContext); 467 468 EGLBoolean ret; 469 if (mEGL.mSurface != NULL) { 470 ret = eglMakeCurrent(mEGL.mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); 471 checkEglError("eglMakeCurrent", ret); 472 473 ret = eglDestroySurface(mEGL.mDisplay, mEGL.mSurface); 474 checkEglError("eglDestroySurface", ret); 475 476 mEGL.mSurface = NULL; 477 mEGL.mWidth = 0; 478 mEGL.mHeight = 0; 479 mWidth = 0; 480 mHeight = 0; 481 } 482 483 mWndSurface = sur; 484 if (mWndSurface != NULL) { 485 bool first = false; 486 if (!mEGL.mContext) { 487 first = true; 488 pthread_mutex_lock(&gInitMutex); 489 initEGL(true); 490 pthread_mutex_unlock(&gInitMutex); 491 } 492 493 mEGL.mSurface = eglCreateWindowSurface(mEGL.mDisplay, mEGL.mConfig, mWndSurface, NULL); 494 checkEglError("eglCreateWindowSurface"); 495 if (mEGL.mSurface == EGL_NO_SURFACE) { 496 LOGE("eglCreateWindowSurface returned EGL_NO_SURFACE"); 497 } 498 499 ret = eglMakeCurrent(mEGL.mDisplay, mEGL.mSurface, mEGL.mSurface, mEGL.mContext); 500 checkEglError("eglMakeCurrent", ret); 501 502 eglQuerySurface(mEGL.mDisplay, mEGL.mSurface, EGL_WIDTH, &mEGL.mWidth); 503 eglQuerySurface(mEGL.mDisplay, mEGL.mSurface, EGL_HEIGHT, &mEGL.mHeight); 504 mWidth = w; 505 mHeight = h; 506 mStateVertex.updateSize(this, w, h); 507 508 if ((int)mWidth != mEGL.mWidth || (int)mHeight != mEGL.mHeight) { 509 LOGE("EGL/Surface mismatch EGL (%i x %i) SF (%i x %i)", mEGL.mWidth, mEGL.mHeight, mWidth, mHeight); 510 } 511 512 if (first) { 513 mGL.mVersion = glGetString(GL_VERSION); 514 mGL.mVendor = glGetString(GL_VENDOR); 515 mGL.mRenderer = glGetString(GL_RENDERER); 516 mGL.mExtensions = glGetString(GL_EXTENSIONS); 517 518 //LOGV("EGL Version %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion); 519 LOGV("GL Version %s", mGL.mVersion); 520 //LOGV("GL Vendor %s", mGL.mVendor); 521 LOGV("GL Renderer %s", mGL.mRenderer); 522 //LOGV("GL Extensions %s", mGL.mExtensions); 523 524 const char *verptr = NULL; 525 if (strlen((const char *)mGL.mVersion) > 9) { 526 if (!memcmp(mGL.mVersion, "OpenGL ES-CM", 12)) { 527 verptr = (const char *)mGL.mVersion + 12; 528 } 529 if (!memcmp(mGL.mVersion, "OpenGL ES ", 10)) { 530 verptr = (const char *)mGL.mVersion + 9; 531 } 532 } 533 534 if (!verptr) { 535 LOGE("Error, OpenGL ES Lite not supported"); 536 } else { 537 sscanf(verptr, " %i.%i", &mGL.mMajorVersion, &mGL.mMinorVersion); 538 } 539 540 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &mGL.mMaxVertexAttribs); 541 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &mGL.mMaxVertexUniformVectors); 542 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &mGL.mMaxVertexTextureUnits); 543 544 glGetIntegerv(GL_MAX_VARYING_VECTORS, &mGL.mMaxVaryingVectors); 545 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &mGL.mMaxTextureImageUnits); 546 547 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &mGL.mMaxFragmentTextureImageUnits); 548 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &mGL.mMaxFragmentUniformVectors); 549 550 mGL.OES_texture_npot = NULL != strstr((const char *)mGL.mExtensions, "GL_OES_texture_npot"); 551 } 552 553 } 554} 555 556void Context::pause() 557{ 558 rsAssert(mIsGraphicsContext); 559 mPaused = true; 560} 561 562void Context::resume() 563{ 564 rsAssert(mIsGraphicsContext); 565 mPaused = false; 566} 567 568void Context::setRootScript(Script *s) 569{ 570 rsAssert(mIsGraphicsContext); 571 mRootScript.set(s); 572} 573 574void Context::setFragmentStore(ProgramFragmentStore *pfs) 575{ 576 rsAssert(mIsGraphicsContext); 577 if (pfs == NULL) { 578 mFragmentStore.set(mStateFragmentStore.mDefault); 579 } else { 580 mFragmentStore.set(pfs); 581 } 582} 583 584void Context::setFragment(ProgramFragment *pf) 585{ 586 rsAssert(mIsGraphicsContext); 587 if (pf == NULL) { 588 mFragment.set(mStateFragment.mDefault); 589 } else { 590 mFragment.set(pf); 591 } 592} 593 594void Context::setRaster(ProgramRaster *pr) 595{ 596 rsAssert(mIsGraphicsContext); 597 if (pr == NULL) { 598 mRaster.set(mStateRaster.mDefault); 599 } else { 600 mRaster.set(pr); 601 } 602} 603 604void Context::setVertex(ProgramVertex *pv) 605{ 606 rsAssert(mIsGraphicsContext); 607 if (pv == NULL) { 608 mVertex.set(mStateVertex.mDefault); 609 } else { 610 mVertex.set(pv); 611 } 612} 613 614void Context::assignName(ObjectBase *obj, const char *name, uint32_t len) 615{ 616 rsAssert(!obj->getName()); 617 obj->setName(name, len); 618 mNames.add(obj); 619} 620 621void Context::removeName(ObjectBase *obj) 622{ 623 for(size_t ct=0; ct < mNames.size(); ct++) { 624 if (obj == mNames[ct]) { 625 mNames.removeAt(ct); 626 return; 627 } 628 } 629} 630 631ObjectBase * Context::lookupName(const char *name) const 632{ 633 for(size_t ct=0; ct < mNames.size(); ct++) { 634 if (!strcmp(name, mNames[ct]->getName())) { 635 return mNames[ct]; 636 } 637 } 638 return NULL; 639} 640 641void Context::appendNameDefines(String8 *str) const 642{ 643 char buf[256]; 644 for (size_t ct=0; ct < mNames.size(); ct++) { 645 str->append("#define NAMED_"); 646 str->append(mNames[ct]->getName()); 647 str->append(" "); 648 sprintf(buf, "%i\n", (int)mNames[ct]); 649 str->append(buf); 650 } 651} 652 653bool Context::objDestroyOOBInit() 654{ 655 int status = pthread_mutex_init(&mObjDestroy.mMutex, NULL); 656 if (status) { 657 LOGE("Context::ObjDestroyOOBInit mutex init failure"); 658 return false; 659 } 660 return true; 661} 662 663void Context::objDestroyOOBRun() 664{ 665 if (mObjDestroy.mNeedToEmpty) { 666 int status = pthread_mutex_lock(&mObjDestroy.mMutex); 667 if (status) { 668 LOGE("Context::ObjDestroyOOBRun: error %i locking for OOBRun.", status); 669 return; 670 } 671 672 for (size_t ct = 0; ct < mObjDestroy.mDestroyList.size(); ct++) { 673 mObjDestroy.mDestroyList[ct]->decUserRef(); 674 } 675 mObjDestroy.mDestroyList.clear(); 676 mObjDestroy.mNeedToEmpty = false; 677 678 status = pthread_mutex_unlock(&mObjDestroy.mMutex); 679 if (status) { 680 LOGE("Context::ObjDestroyOOBRun: error %i unlocking for set condition.", status); 681 } 682 } 683} 684 685void Context::objDestroyOOBDestroy() 686{ 687 rsAssert(!mObjDestroy.mNeedToEmpty); 688 pthread_mutex_destroy(&mObjDestroy.mMutex); 689} 690 691void Context::objDestroyAdd(ObjectBase *obj) 692{ 693 int status = pthread_mutex_lock(&mObjDestroy.mMutex); 694 if (status) { 695 LOGE("Context::ObjDestroyOOBRun: error %i locking for OOBRun.", status); 696 return; 697 } 698 699 mObjDestroy.mNeedToEmpty = true; 700 mObjDestroy.mDestroyList.add(obj); 701 702 status = pthread_mutex_unlock(&mObjDestroy.mMutex); 703 if (status) { 704 LOGE("Context::ObjDestroyOOBRun: error %i unlocking for set condition.", status); 705 } 706} 707 708uint32_t Context::getMessageToClient(void *data, size_t *receiveLen, size_t bufferLen, bool wait) 709{ 710 //LOGE("getMessageToClient %i %i", bufferLen, wait); 711 if (!wait) { 712 if (mIO.mToClient.isEmpty()) { 713 // No message to get and not going to wait for one. 714 receiveLen = 0; 715 return 0; 716 } 717 } 718 719 //LOGE("getMessageToClient 2 con=%p", this); 720 uint32_t bytesData = 0; 721 uint32_t commandID = 0; 722 const void *d = mIO.mToClient.get(&commandID, &bytesData); 723 //LOGE("getMessageToClient 3 %i %i", commandID, bytesData); 724 725 *receiveLen = bytesData; 726 if (bufferLen >= bytesData) { 727 memcpy(data, d, bytesData); 728 mIO.mToClient.next(); 729 return commandID; 730 } 731 return 0; 732} 733 734bool Context::sendMessageToClient(void *data, uint32_t cmdID, size_t len, bool waitForSpace) 735{ 736 //LOGE("sendMessageToClient %i %i %i", cmdID, len, waitForSpace); 737 if (cmdID == 0) { 738 LOGE("Attempting to send invalid command 0 to client."); 739 return false; 740 } 741 if (!waitForSpace) { 742 if (mIO.mToClient.getFreeSpace() < len) { 743 // Not enough room, and not waiting. 744 return false; 745 } 746 } 747 //LOGE("sendMessageToClient 2"); 748 void *p = mIO.mToClient.reserve(len); 749 memcpy(p, data, len); 750 mIO.mToClient.commit(cmdID, len); 751 //LOGE("sendMessageToClient 3"); 752 return true; 753} 754 755void Context::initToClient() 756{ 757 while(!mRunning) { 758 usleep(100); 759 } 760} 761 762void Context::deinitToClient() 763{ 764 mIO.mToClient.shutdown(); 765} 766 767void Context::dumpDebug() const 768{ 769 LOGE("RS Context debug %p", this); 770 LOGE("RS Context debug"); 771 772 LOGE(" EGL ver %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion); 773 LOGE(" EGL context %p surface %p, w=%i h=%i Display=%p", mEGL.mContext, 774 mEGL.mSurface, mEGL.mWidth, mEGL.mHeight, mEGL.mDisplay); 775 LOGE(" GL vendor: %s", mGL.mVendor); 776 LOGE(" GL renderer: %s", mGL.mRenderer); 777 LOGE(" GL Version: %s", mGL.mVersion); 778 LOGE(" GL Extensions: %s", mGL.mExtensions); 779 LOGE(" GL int Versions %i %i", mGL.mMajorVersion, mGL.mMinorVersion); 780 LOGE(" RS width %i, height %i", mWidth, mHeight); 781 LOGE(" RS running %i, exit %i, useDepth %i, paused %i", mRunning, mExit, mUseDepth, mPaused); 782 LOGE(" RS pThreadID %li, nativeThreadID %i", mThreadId, mNativeThreadId); 783 784 LOGV("MAX Textures %i, %i %i", mGL.mMaxVertexTextureUnits, mGL.mMaxFragmentTextureImageUnits, mGL.mMaxTextureImageUnits); 785 LOGV("MAX Attribs %i", mGL.mMaxVertexAttribs); 786 LOGV("MAX Uniforms %i, %i", mGL.mMaxVertexUniformVectors, mGL.mMaxFragmentUniformVectors); 787 LOGV("MAX Varyings %i", mGL.mMaxVaryingVectors); 788} 789 790/////////////////////////////////////////////////////////////////////////////////////////// 791// 792 793namespace android { 794namespace renderscript { 795 796 797void rsi_ContextBindRootScript(Context *rsc, RsScript vs) 798{ 799 Script *s = static_cast<Script *>(vs); 800 rsc->setRootScript(s); 801} 802 803void rsi_ContextBindSampler(Context *rsc, uint32_t slot, RsSampler vs) 804{ 805 Sampler *s = static_cast<Sampler *>(vs); 806 807 if (slot > RS_MAX_SAMPLER_SLOT) { 808 LOGE("Invalid sampler slot"); 809 return; 810 } 811 812 s->bindToContext(&rsc->mStateSampler, slot); 813} 814 815void rsi_ContextBindProgramFragmentStore(Context *rsc, RsProgramFragmentStore vpfs) 816{ 817 ProgramFragmentStore *pfs = static_cast<ProgramFragmentStore *>(vpfs); 818 rsc->setFragmentStore(pfs); 819} 820 821void rsi_ContextBindProgramFragment(Context *rsc, RsProgramFragment vpf) 822{ 823 ProgramFragment *pf = static_cast<ProgramFragment *>(vpf); 824 rsc->setFragment(pf); 825} 826 827void rsi_ContextBindProgramRaster(Context *rsc, RsProgramRaster vpr) 828{ 829 ProgramRaster *pr = static_cast<ProgramRaster *>(vpr); 830 rsc->setRaster(pr); 831} 832 833void rsi_ContextBindProgramVertex(Context *rsc, RsProgramVertex vpv) 834{ 835 ProgramVertex *pv = static_cast<ProgramVertex *>(vpv); 836 rsc->setVertex(pv); 837} 838 839void rsi_AssignName(Context *rsc, void * obj, const char *name, uint32_t len) 840{ 841 ObjectBase *ob = static_cast<ObjectBase *>(obj); 842 rsc->assignName(ob, name, len); 843} 844 845void rsi_ObjDestroy(Context *rsc, void *obj) 846{ 847 ObjectBase *ob = static_cast<ObjectBase *>(obj); 848 rsc->removeName(ob); 849 ob->decUserRef(); 850} 851 852void rsi_ContextPause(Context *rsc) 853{ 854 rsc->pause(); 855} 856 857void rsi_ContextResume(Context *rsc) 858{ 859 rsc->resume(); 860} 861 862void rsi_ContextSetSurface(Context *rsc, uint32_t w, uint32_t h, android_native_window_t *sur) 863{ 864 rsc->setSurface(w, h, sur); 865} 866 867void rsi_ContextSetPriority(Context *rsc, int32_t p) 868{ 869 rsc->setPriority(p); 870} 871 872void rsi_ContextDump(Context *rsc, int32_t bits) 873{ 874 ObjectBase::dumpAll(rsc); 875} 876 877} 878} 879 880 881RsContext rsContextCreate(RsDevice vdev, uint32_t version) 882{ 883 LOGV("rsContextCreate %p", vdev); 884 Device * dev = static_cast<Device *>(vdev); 885 Context *rsc = new Context(dev, false, false); 886 return rsc; 887} 888 889RsContext rsContextCreateGL(RsDevice vdev, uint32_t version, bool useDepth) 890{ 891 LOGV("rsContextCreateGL %p, %i", vdev, useDepth); 892 Device * dev = static_cast<Device *>(vdev); 893 Context *rsc = new Context(dev, true, useDepth); 894 return rsc; 895} 896 897void rsContextDestroy(RsContext vrsc) 898{ 899 Context * rsc = static_cast<Context *>(vrsc); 900 delete rsc; 901} 902 903void rsObjDestroyOOB(RsContext vrsc, void *obj) 904{ 905 Context * rsc = static_cast<Context *>(vrsc); 906 rsc->objDestroyAdd(static_cast<ObjectBase *>(obj)); 907} 908 909uint32_t rsContextGetMessage(RsContext vrsc, void *data, size_t *receiveLen, size_t bufferLen, bool wait) 910{ 911 Context * rsc = static_cast<Context *>(vrsc); 912 return rsc->getMessageToClient(data, receiveLen, bufferLen, wait); 913} 914 915void rsContextInitToClient(RsContext vrsc) 916{ 917 Context * rsc = static_cast<Context *>(vrsc); 918 rsc->initToClient(); 919} 920 921void rsContextDeinitToClient(RsContext vrsc) 922{ 923 Context * rsc = static_cast<Context *>(vrsc); 924 rsc->deinitToClient(); 925} 926 927