rsContext.cpp revision 91dfcdb0f9d5402c26dd65d26d1163f05c2f1e50
1/* 2 * Copyright (C) 2011 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 "rs.h" 18#include "rsDevice.h" 19#include "rsContext.h" 20#include "rsThreadIO.h" 21#include "rsMesh.h" 22#include <ui/FramebufferNativeWindow.h> 23#include <gui/DisplayEventReceiver.h> 24 25#include <sys/types.h> 26#include <sys/resource.h> 27#include <sched.h> 28 29#include <cutils/properties.h> 30 31#include <sys/syscall.h> 32 33#include <dlfcn.h> 34 35using namespace android; 36using namespace android::renderscript; 37 38pthread_mutex_t Context::gInitMutex = PTHREAD_MUTEX_INITIALIZER; 39pthread_mutex_t Context::gLibMutex = PTHREAD_MUTEX_INITIALIZER; 40 41bool Context::initGLThread() { 42 pthread_mutex_lock(&gInitMutex); 43 44 if (!mHal.funcs.initGraphics(this)) { 45 pthread_mutex_unlock(&gInitMutex); 46 ALOGE("%p initGraphics failed", this); 47 return false; 48 } 49 50 pthread_mutex_unlock(&gInitMutex); 51 return true; 52} 53 54void Context::deinitEGL() { 55 mHal.funcs.shutdownGraphics(this); 56} 57 58Context::PushState::PushState(Context *con) { 59 mRsc = con; 60 if (con->mIsGraphicsContext) { 61 mFragment.set(con->getProgramFragment()); 62 mVertex.set(con->getProgramVertex()); 63 mStore.set(con->getProgramStore()); 64 mRaster.set(con->getProgramRaster()); 65 mFont.set(con->getFont()); 66 } 67} 68 69Context::PushState::~PushState() { 70 if (mRsc->mIsGraphicsContext) { 71 mRsc->setProgramFragment(mFragment.get()); 72 mRsc->setProgramVertex(mVertex.get()); 73 mRsc->setProgramStore(mStore.get()); 74 mRsc->setProgramRaster(mRaster.get()); 75 mRsc->setFont(mFont.get()); 76 } 77} 78 79 80uint32_t Context::runScript(Script *s) { 81 PushState ps(this); 82 83 uint32_t ret = s->run(this); 84 return ret; 85} 86 87uint32_t Context::runRootScript() { 88 timerSet(RS_TIMER_SCRIPT); 89 mStateFragmentStore.mLast.clear(); 90 watchdog.inRoot = true; 91 uint32_t ret = runScript(mRootScript.get()); 92 watchdog.inRoot = false; 93 94 return ret; 95} 96 97uint64_t Context::getTime() const { 98#ifndef ANDROID_RS_SERIALIZE 99 struct timespec t; 100 clock_gettime(CLOCK_MONOTONIC, &t); 101 return t.tv_nsec + ((uint64_t)t.tv_sec * 1000 * 1000 * 1000); 102#else 103 return 0; 104#endif //ANDROID_RS_SERIALIZE 105} 106 107void Context::timerReset() { 108 for (int ct=0; ct < _RS_TIMER_TOTAL; ct++) { 109 mTimers[ct] = 0; 110 } 111} 112 113void Context::timerInit() { 114 mTimeLast = getTime(); 115 mTimeFrame = mTimeLast; 116 mTimeLastFrame = mTimeLast; 117 mTimerActive = RS_TIMER_INTERNAL; 118 mAverageFPSFrameCount = 0; 119 mAverageFPSStartTime = mTimeLast; 120 mAverageFPS = 0; 121 timerReset(); 122} 123 124void Context::timerFrame() { 125 mTimeLastFrame = mTimeFrame; 126 mTimeFrame = getTime(); 127 // Update average fps 128 const uint64_t averageFramerateInterval = 1000 * 1000000; 129 mAverageFPSFrameCount ++; 130 uint64_t inverval = mTimeFrame - mAverageFPSStartTime; 131 if (inverval >= averageFramerateInterval) { 132 inverval = inverval / 1000000; 133 mAverageFPS = (mAverageFPSFrameCount * 1000) / inverval; 134 mAverageFPSFrameCount = 0; 135 mAverageFPSStartTime = mTimeFrame; 136 } 137} 138 139void Context::timerSet(Timers tm) { 140 uint64_t last = mTimeLast; 141 mTimeLast = getTime(); 142 mTimers[mTimerActive] += mTimeLast - last; 143 mTimerActive = tm; 144} 145 146void Context::timerPrint() { 147 double total = 0; 148 for (int ct = 0; ct < _RS_TIMER_TOTAL; ct++) { 149 total += mTimers[ct]; 150 } 151 uint64_t frame = mTimeFrame - mTimeLastFrame; 152 mTimeMSLastFrame = frame / 1000000; 153 mTimeMSLastScript = mTimers[RS_TIMER_SCRIPT] / 1000000; 154 mTimeMSLastSwap = mTimers[RS_TIMER_CLEAR_SWAP] / 1000000; 155 156 157 if (props.mLogTimes) { 158 ALOGV("RS: Frame (%i), Script %2.1f%% (%i), Swap %2.1f%% (%i), Idle %2.1f%% (%lli), Internal %2.1f%% (%lli), Avg fps: %u", 159 mTimeMSLastFrame, 160 100.0 * mTimers[RS_TIMER_SCRIPT] / total, mTimeMSLastScript, 161 100.0 * mTimers[RS_TIMER_CLEAR_SWAP] / total, mTimeMSLastSwap, 162 100.0 * mTimers[RS_TIMER_IDLE] / total, mTimers[RS_TIMER_IDLE] / 1000000, 163 100.0 * mTimers[RS_TIMER_INTERNAL] / total, mTimers[RS_TIMER_INTERNAL] / 1000000, 164 mAverageFPS); 165 } 166} 167 168bool Context::setupCheck() { 169 170 mFragmentStore->setup(this, &mStateFragmentStore); 171 mFragment->setup(this, &mStateFragment); 172 mRaster->setup(this, &mStateRaster); 173 mVertex->setup(this, &mStateVertex); 174 mFBOCache.setup(this); 175 return true; 176} 177 178void Context::setupProgramStore() { 179 mFragmentStore->setup(this, &mStateFragmentStore); 180} 181 182static uint32_t getProp(const char *str) { 183 char buf[PROPERTY_VALUE_MAX]; 184 property_get(str, buf, "0"); 185 return atoi(buf); 186} 187 188void Context::displayDebugStats() { 189 char buffer[128]; 190 sprintf(buffer, "Avg fps %u, Frame %i ms, Script %i ms", mAverageFPS, mTimeMSLastFrame, mTimeMSLastScript); 191 float oldR, oldG, oldB, oldA; 192 mStateFont.getFontColor(&oldR, &oldG, &oldB, &oldA); 193 uint32_t bufferLen = strlen(buffer); 194 195 ObjectBaseRef<Font> lastFont(getFont()); 196 setFont(NULL); 197 float shadowCol = 0.1f; 198 mStateFont.setFontColor(shadowCol, shadowCol, shadowCol, 1.0f); 199 mStateFont.renderText(buffer, bufferLen, 5, getHeight() - 6); 200 201 mStateFont.setFontColor(1.0f, 0.7f, 0.0f, 1.0f); 202 mStateFont.renderText(buffer, bufferLen, 4, getHeight() - 7); 203 204 setFont(lastFont.get()); 205 mStateFont.setFontColor(oldR, oldG, oldB, oldA); 206} 207 208void * Context::threadProc(void *vrsc) { 209 Context *rsc = static_cast<Context *>(vrsc); 210#ifndef ANDROID_RS_SERIALIZE 211 rsc->mNativeThreadId = gettid(); 212 setpriority(PRIO_PROCESS, rsc->mNativeThreadId, ANDROID_PRIORITY_DISPLAY); 213 rsc->mThreadPriority = ANDROID_PRIORITY_DISPLAY; 214#endif //ANDROID_RS_SERIALIZE 215 rsc->props.mLogTimes = getProp("debug.rs.profile") != 0; 216 rsc->props.mLogScripts = getProp("debug.rs.script") != 0; 217 rsc->props.mLogObjects = getProp("debug.rs.object") != 0; 218 rsc->props.mLogShaders = getProp("debug.rs.shader") != 0; 219 rsc->props.mLogShadersAttr = getProp("debug.rs.shader.attributes") != 0; 220 rsc->props.mLogShadersUniforms = getProp("debug.rs.shader.uniforms") != 0; 221 rsc->props.mLogVisual = getProp("debug.rs.visual") != 0; 222 rsc->props.mDebugMaxThreads = getProp("debug.rs.max-threads"); 223 224 void *driverSO = NULL; 225 226 // Provide a mechanism for dropping in a different RS driver. 227#ifdef OVERRIDE_RS_DRIVER 228#define XSTR(S) #S 229#define STR(S) XSTR(S) 230#define OVERRIDE_RS_DRIVER_STRING STR(OVERRIDE_RS_DRIVER) 231 driverSO = dlopen(OVERRIDE_RS_DRIVER_STRING, RTLD_LAZY); 232 if (driverSO == NULL) { 233 ALOGE("Failed loading %s: %s", OVERRIDE_RS_DRIVER_STRING, dlerror()); 234 // Continue to attempt loading fallback driver 235 } 236#undef XSTR 237#undef STR 238#endif // OVERRIDE_RS_DRIVER 239 240 // Attempt to load the reference RS driver (if necessary). 241 if (driverSO == NULL) { 242 driverSO = dlopen("libRSDriver.so", RTLD_LAZY); 243 if (driverSO == NULL) { 244 rsc->setError(RS_ERROR_FATAL_DRIVER, "Failed loading RS driver"); 245 ALOGE("Failed loading RS driver: %s", dlerror()); 246 return NULL; 247 } 248 } 249 250 // Need to call dlerror() to clear buffer before using it for dlsym(). 251 (void) dlerror(); 252 typedef bool (*HalSig)(Context*, uint32_t, uint32_t); 253 HalSig halInit = (HalSig) dlsym(driverSO, "rsdHalInit"); 254 255 // If we can't find the C variant, we go looking for the C++ version. 256 if (halInit == NULL) { 257 ALOGW("Falling back to find C++ rsdHalInit: %s", dlerror()); 258 halInit = (HalSig) dlsym(driverSO, 259 "_Z10rsdHalInitPN7android12renderscript7ContextEjj"); 260 } 261 262 if (halInit == NULL) { 263 rsc->setError(RS_ERROR_FATAL_DRIVER, "Failed to find rsdHalInit"); 264 dlclose(driverSO); 265 ALOGE("Failed to find rsdHalInit: %s", dlerror()); 266 return NULL; 267 } 268 269 if (!(*halInit)(rsc, 0, 0)) { 270 rsc->setError(RS_ERROR_FATAL_DRIVER, "Failed initializing RS Driver"); 271 dlclose(driverSO); 272 ALOGE("Hal init failed"); 273 return NULL; 274 } 275 rsc->mHal.funcs.setPriority(rsc, rsc->mThreadPriority); 276 277 if (rsc->mIsGraphicsContext) { 278 if (!rsc->initGLThread()) { 279 rsc->setError(RS_ERROR_OUT_OF_MEMORY, "Failed initializing GL"); 280 return NULL; 281 } 282 283 rsc->mStateRaster.init(rsc); 284 rsc->setProgramRaster(NULL); 285 rsc->mStateVertex.init(rsc); 286 rsc->setProgramVertex(NULL); 287 rsc->mStateFragment.init(rsc); 288 rsc->setProgramFragment(NULL); 289 rsc->mStateFragmentStore.init(rsc); 290 rsc->setProgramStore(NULL); 291 rsc->mStateFont.init(rsc); 292 rsc->setFont(NULL); 293 rsc->mStateSampler.init(rsc); 294 rsc->mFBOCache.init(rsc); 295 } 296 297 rsc->mRunning = true; 298 if (!rsc->mIsGraphicsContext) { 299 while (!rsc->mExit) { 300 rsc->mIO.playCoreCommands(rsc, -1); 301 } 302 } else { 303#ifndef ANDROID_RS_SERIALIZE 304 DisplayEventReceiver displayEvent; 305 DisplayEventReceiver::Event eventBuffer[1]; 306#endif 307 int vsyncRate = 0; 308 int targetRate = 0; 309 310 bool drawOnce = false; 311 while (!rsc->mExit) { 312 rsc->timerSet(RS_TIMER_IDLE); 313 314#ifndef ANDROID_RS_SERIALIZE 315 if (!rsc->mRootScript.get() || !rsc->mHasSurface || rsc->mPaused) { 316 targetRate = 0; 317 } 318 319 if (vsyncRate != targetRate) { 320 displayEvent.setVsyncRate(targetRate); 321 vsyncRate = targetRate; 322 } 323 if (targetRate) { 324 drawOnce |= rsc->mIO.playCoreCommands(rsc, displayEvent.getFd()); 325 while (displayEvent.getEvents(eventBuffer, 1) != 0) { 326 //ALOGE("vs2 time past %lld", (rsc->getTime() - eventBuffer[0].header.timestamp) / 1000000); 327 } 328 } else 329#endif 330 { 331 drawOnce |= rsc->mIO.playCoreCommands(rsc, -1); 332 } 333 334 if ((rsc->mRootScript.get() != NULL) && rsc->mHasSurface && 335 (targetRate || drawOnce) && !rsc->mPaused) { 336 337 drawOnce = false; 338 targetRate = ((rsc->runRootScript() + 15) / 16); 339 340 if (rsc->props.mLogVisual) { 341 rsc->displayDebugStats(); 342 } 343 344 rsc->timerSet(RS_TIMER_CLEAR_SWAP); 345 rsc->mHal.funcs.swap(rsc); 346 rsc->timerFrame(); 347 rsc->timerSet(RS_TIMER_INTERNAL); 348 rsc->timerPrint(); 349 rsc->timerReset(); 350 } 351 } 352 } 353 354 ALOGV("%p RS Thread exiting", rsc); 355 356 if (rsc->mIsGraphicsContext) { 357 pthread_mutex_lock(&gInitMutex); 358 rsc->deinitEGL(); 359 pthread_mutex_unlock(&gInitMutex); 360 } 361 362 ALOGV("%p RS Thread exited", rsc); 363 return NULL; 364} 365 366void Context::destroyWorkerThreadResources() { 367 //ALOGV("destroyWorkerThreadResources 1"); 368 ObjectBase::zeroAllUserRef(this); 369 if (mIsGraphicsContext) { 370 mRaster.clear(); 371 mFragment.clear(); 372 mVertex.clear(); 373 mFragmentStore.clear(); 374 mFont.clear(); 375 mRootScript.clear(); 376 mStateRaster.deinit(this); 377 mStateVertex.deinit(this); 378 mStateFragment.deinit(this); 379 mStateFragmentStore.deinit(this); 380 mStateFont.deinit(this); 381 mStateSampler.deinit(this); 382 mFBOCache.deinit(this); 383 } 384 ObjectBase::freeAllChildren(this); 385 mExit = true; 386 //ALOGV("destroyWorkerThreadResources 2"); 387} 388 389void Context::printWatchdogInfo(void *ctx) { 390 Context *rsc = (Context *)ctx; 391 if (rsc->watchdog.command && rsc->watchdog.file) { 392 ALOGE("RS watchdog timeout: %i %s line %i %s", rsc->watchdog.inRoot, 393 rsc->watchdog.command, rsc->watchdog.line, rsc->watchdog.file); 394 } else { 395 ALOGE("RS watchdog timeout: %i", rsc->watchdog.inRoot); 396 } 397} 398 399 400void Context::setPriority(int32_t p) { 401 // Note: If we put this in the proper "background" policy 402 // the wallpapers can become completly unresponsive at times. 403 // This is probably not what we want for something the user is actively 404 // looking at. 405 mThreadPriority = p; 406 setpriority(PRIO_PROCESS, mNativeThreadId, p); 407 mHal.funcs.setPriority(this, mThreadPriority); 408} 409 410Context::Context() { 411 mDev = NULL; 412 mRunning = false; 413 mExit = false; 414 mPaused = false; 415 mObjHead = NULL; 416 mError = RS_ERROR_NONE; 417 mTargetSdkVersion = 14; 418 mDPI = 96; 419 mIsContextLite = false; 420 memset(&watchdog, 0, sizeof(watchdog)); 421} 422 423Context * Context::createContext(Device *dev, const RsSurfaceConfig *sc) { 424 Context * rsc = new Context(); 425 426 if (!rsc->initContext(dev, sc)) { 427 delete rsc; 428 return NULL; 429 } 430 return rsc; 431} 432 433Context * Context::createContextLite() { 434 Context * rsc = new Context(); 435 rsc->mIsContextLite = true; 436 return rsc; 437} 438 439bool Context::initContext(Device *dev, const RsSurfaceConfig *sc) { 440 pthread_mutex_lock(&gInitMutex); 441 442 mIO.init(); 443 mIO.setTimeoutCallback(printWatchdogInfo, this, 2e9); 444 445 dev->addContext(this); 446 mDev = dev; 447 if (sc) { 448 mUserSurfaceConfig = *sc; 449 } else { 450 memset(&mUserSurfaceConfig, 0, sizeof(mUserSurfaceConfig)); 451 } 452 453 mIsGraphicsContext = sc != NULL; 454 455 int status; 456 pthread_attr_t threadAttr; 457 458 pthread_mutex_unlock(&gInitMutex); 459 460 // Global init done at this point. 461 462 status = pthread_attr_init(&threadAttr); 463 if (status) { 464 ALOGE("Failed to init thread attribute."); 465 return false; 466 } 467 468 mHasSurface = false; 469 470 timerInit(); 471 timerSet(RS_TIMER_INTERNAL); 472 473 status = pthread_create(&mThreadId, &threadAttr, threadProc, this); 474 if (status) { 475 ALOGE("Failed to start rs context thread."); 476 return false; 477 } 478 while (!mRunning && (mError == RS_ERROR_NONE)) { 479 usleep(100); 480 } 481 482 if (mError != RS_ERROR_NONE) { 483 ALOGE("Errors during thread init"); 484 return false; 485 } 486 487 pthread_attr_destroy(&threadAttr); 488 return true; 489} 490 491Context::~Context() { 492 ALOGV("%p Context::~Context", this); 493 494 if (!mIsContextLite) { 495 mPaused = false; 496 void *res; 497 498 mIO.shutdown(); 499 int status = pthread_join(mThreadId, &res); 500 rsAssert(mExit); 501 502 if (mHal.funcs.shutdownDriver) { 503 mHal.funcs.shutdownDriver(this); 504 } 505 506 // Global structure cleanup. 507 pthread_mutex_lock(&gInitMutex); 508 if (mDev) { 509 mDev->removeContext(this); 510 mDev = NULL; 511 } 512 pthread_mutex_unlock(&gInitMutex); 513 } 514 ALOGV("%p Context::~Context done", this); 515} 516 517void Context::setSurface(uint32_t w, uint32_t h, RsNativeWindow sur) { 518 rsAssert(mIsGraphicsContext); 519 mHal.funcs.setSurface(this, w, h, sur); 520 521 mHasSurface = sur != NULL; 522 mWidth = w; 523 mHeight = h; 524 525 if (mWidth && mHeight) { 526 mStateVertex.updateSize(this); 527 mFBOCache.updateSize(); 528 } 529} 530 531uint32_t Context::getCurrentSurfaceWidth() const { 532 for (uint32_t i = 0; i < mFBOCache.mHal.state.colorTargetsCount; i ++) { 533 if (mFBOCache.mHal.state.colorTargets[i] != NULL) { 534 return mFBOCache.mHal.state.colorTargets[i]->getType()->getDimX(); 535 } 536 } 537 if (mFBOCache.mHal.state.depthTarget != NULL) { 538 return mFBOCache.mHal.state.depthTarget->getType()->getDimX(); 539 } 540 return mWidth; 541} 542 543uint32_t Context::getCurrentSurfaceHeight() const { 544 for (uint32_t i = 0; i < mFBOCache.mHal.state.colorTargetsCount; i ++) { 545 if (mFBOCache.mHal.state.colorTargets[i] != NULL) { 546 return mFBOCache.mHal.state.colorTargets[i]->getType()->getDimY(); 547 } 548 } 549 if (mFBOCache.mHal.state.depthTarget != NULL) { 550 return mFBOCache.mHal.state.depthTarget->getType()->getDimY(); 551 } 552 return mHeight; 553} 554 555void Context::pause() { 556 rsAssert(mIsGraphicsContext); 557 mPaused = true; 558} 559 560void Context::resume() { 561 rsAssert(mIsGraphicsContext); 562 mPaused = false; 563} 564 565void Context::setRootScript(Script *s) { 566 rsAssert(mIsGraphicsContext); 567 mRootScript.set(s); 568} 569 570void Context::setProgramStore(ProgramStore *pfs) { 571 rsAssert(mIsGraphicsContext); 572 if (pfs == NULL) { 573 mFragmentStore.set(mStateFragmentStore.mDefault); 574 } else { 575 mFragmentStore.set(pfs); 576 } 577} 578 579void Context::setProgramFragment(ProgramFragment *pf) { 580 rsAssert(mIsGraphicsContext); 581 if (pf == NULL) { 582 mFragment.set(mStateFragment.mDefault); 583 } else { 584 mFragment.set(pf); 585 } 586} 587 588void Context::setProgramRaster(ProgramRaster *pr) { 589 rsAssert(mIsGraphicsContext); 590 if (pr == NULL) { 591 mRaster.set(mStateRaster.mDefault); 592 } else { 593 mRaster.set(pr); 594 } 595} 596 597void Context::setProgramVertex(ProgramVertex *pv) { 598 rsAssert(mIsGraphicsContext); 599 if (pv == NULL) { 600 mVertex.set(mStateVertex.mDefault); 601 } else { 602 mVertex.set(pv); 603 } 604} 605 606void Context::setFont(Font *f) { 607 rsAssert(mIsGraphicsContext); 608 if (f == NULL) { 609 mFont.set(mStateFont.mDefault); 610 } else { 611 mFont.set(f); 612 } 613} 614 615void Context::assignName(ObjectBase *obj, const char *name, uint32_t len) { 616 rsAssert(!obj->getName()); 617 obj->setName(name, len); 618 mNames.add(obj); 619} 620 621void Context::removeName(ObjectBase *obj) { 622 for (size_t ct=0; ct < mNames.size(); ct++) { 623 if (obj == mNames[ct]) { 624 mNames.removeAt(ct); 625 return; 626 } 627 } 628} 629 630RsMessageToClientType Context::peekMessageToClient(size_t *receiveLen, uint32_t *subID) { 631 return (RsMessageToClientType)mIO.getClientHeader(receiveLen, subID); 632} 633 634RsMessageToClientType Context::getMessageToClient(void *data, size_t *receiveLen, uint32_t *subID, size_t bufferLen) { 635 return (RsMessageToClientType)mIO.getClientPayload(data, receiveLen, subID, bufferLen); 636} 637 638bool Context::sendMessageToClient(const void *data, RsMessageToClientType cmdID, 639 uint32_t subID, size_t len, bool waitForSpace) const { 640 641 return mIO.sendToClient(cmdID, subID, data, len, waitForSpace); 642} 643 644void Context::initToClient() { 645 while (!mRunning) { 646 usleep(100); 647 } 648} 649 650void Context::deinitToClient() { 651 mIO.clientShutdown(); 652} 653 654void Context::setError(RsError e, const char *msg) const { 655 mError = e; 656 sendMessageToClient(msg, RS_MESSAGE_TO_CLIENT_ERROR, e, strlen(msg) + 1, true); 657} 658 659 660void Context::dumpDebug() const { 661 ALOGE("RS Context debug %p", this); 662 ALOGE("RS Context debug"); 663 664 ALOGE(" RS width %i, height %i", mWidth, mHeight); 665 ALOGE(" RS running %i, exit %i, paused %i", mRunning, mExit, mPaused); 666 ALOGE(" RS pThreadID %li, nativeThreadID %i", (long int)mThreadId, mNativeThreadId); 667} 668 669/////////////////////////////////////////////////////////////////////////////////////////// 670// 671 672namespace android { 673namespace renderscript { 674 675void rsi_ContextFinish(Context *rsc) { 676} 677 678void rsi_ContextBindRootScript(Context *rsc, RsScript vs) { 679 Script *s = static_cast<Script *>(vs); 680 rsc->setRootScript(s); 681} 682 683void rsi_ContextBindSampler(Context *rsc, uint32_t slot, RsSampler vs) { 684 Sampler *s = static_cast<Sampler *>(vs); 685 686 if (slot > RS_MAX_SAMPLER_SLOT) { 687 ALOGE("Invalid sampler slot"); 688 return; 689 } 690 691 s->bindToContext(&rsc->mStateSampler, slot); 692} 693 694void rsi_ContextBindProgramStore(Context *rsc, RsProgramStore vpfs) { 695 ProgramStore *pfs = static_cast<ProgramStore *>(vpfs); 696 rsc->setProgramStore(pfs); 697} 698 699void rsi_ContextBindProgramFragment(Context *rsc, RsProgramFragment vpf) { 700 ProgramFragment *pf = static_cast<ProgramFragment *>(vpf); 701 rsc->setProgramFragment(pf); 702} 703 704void rsi_ContextBindProgramRaster(Context *rsc, RsProgramRaster vpr) { 705 ProgramRaster *pr = static_cast<ProgramRaster *>(vpr); 706 rsc->setProgramRaster(pr); 707} 708 709void rsi_ContextBindProgramVertex(Context *rsc, RsProgramVertex vpv) { 710 ProgramVertex *pv = static_cast<ProgramVertex *>(vpv); 711 rsc->setProgramVertex(pv); 712} 713 714void rsi_ContextBindFont(Context *rsc, RsFont vfont) { 715 Font *font = static_cast<Font *>(vfont); 716 rsc->setFont(font); 717} 718 719void rsi_AssignName(Context *rsc, RsObjectBase obj, const char *name, size_t name_length) { 720 ObjectBase *ob = static_cast<ObjectBase *>(obj); 721 rsc->assignName(ob, name, name_length); 722} 723 724void rsi_ObjDestroy(Context *rsc, void *optr) { 725 ObjectBase *ob = static_cast<ObjectBase *>(optr); 726 rsc->removeName(ob); 727 ob->decUserRef(); 728} 729 730void rsi_ContextPause(Context *rsc) { 731 rsc->pause(); 732} 733 734void rsi_ContextResume(Context *rsc) { 735 rsc->resume(); 736} 737 738void rsi_ContextSetSurface(Context *rsc, uint32_t w, uint32_t h, RsNativeWindow sur) { 739 rsc->setSurface(w, h, sur); 740} 741 742void rsi_ContextSetPriority(Context *rsc, int32_t p) { 743 rsc->setPriority(p); 744} 745 746void rsi_ContextDump(Context *rsc, int32_t bits) { 747 ObjectBase::dumpAll(rsc); 748} 749 750void rsi_ContextDestroyWorker(Context *rsc) { 751 rsc->destroyWorkerThreadResources(); 752} 753 754void rsi_ContextDestroy(Context *rsc) { 755 ALOGV("%p rsContextDestroy", rsc); 756 rsContextDestroyWorker(rsc); 757 delete rsc; 758 ALOGV("%p rsContextDestroy done", rsc); 759} 760 761 762RsMessageToClientType rsi_ContextPeekMessage(Context *rsc, 763 size_t * receiveLen, size_t receiveLen_length, 764 uint32_t * subID, size_t subID_length) { 765 return rsc->peekMessageToClient(receiveLen, subID); 766} 767 768RsMessageToClientType rsi_ContextGetMessage(Context *rsc, void * data, size_t data_length, 769 size_t * receiveLen, size_t receiveLen_length, 770 uint32_t * subID, size_t subID_length) { 771 rsAssert(subID_length == sizeof(uint32_t)); 772 rsAssert(receiveLen_length == sizeof(size_t)); 773 return rsc->getMessageToClient(data, receiveLen, subID, data_length); 774} 775 776void rsi_ContextInitToClient(Context *rsc) { 777 rsc->initToClient(); 778} 779 780void rsi_ContextDeinitToClient(Context *rsc) { 781 rsc->deinitToClient(); 782} 783 784} 785} 786 787RsContext rsContextCreate(RsDevice vdev, uint32_t version, 788 uint32_t sdkVersion) { 789 ALOGV("rsContextCreate dev=%p", vdev); 790 Device * dev = static_cast<Device *>(vdev); 791 Context *rsc = Context::createContext(dev, NULL); 792 if (rsc) { 793 rsc->setTargetSdkVersion(sdkVersion); 794 } 795 return rsc; 796} 797 798RsContext rsContextCreateGL(RsDevice vdev, uint32_t version, 799 uint32_t sdkVersion, RsSurfaceConfig sc, 800 uint32_t dpi) { 801 ALOGV("rsContextCreateGL dev=%p", vdev); 802 Device * dev = static_cast<Device *>(vdev); 803 Context *rsc = Context::createContext(dev, &sc); 804 if (rsc) { 805 rsc->setTargetSdkVersion(sdkVersion); 806 rsc->setDPI(dpi); 807 } 808 ALOGV("%p rsContextCreateGL ret", rsc); 809 return rsc; 810} 811 812// Only to be called at a3d load time, before object is visible to user 813// not thread safe 814void rsaGetName(RsContext con, void * obj, const char **name) { 815 ObjectBase *ob = static_cast<ObjectBase *>(obj); 816 (*name) = ob->getName(); 817} 818