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