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