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