Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 1 | /* |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 2 | * Copyright (C) 2011 The Android Open Source Project |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 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 | |
Alex Sakhartchouk | e23d239 | 2012-03-09 09:24:39 -0800 | [diff] [blame] | 17 | #include "rs.h" |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 18 | #include "rsDevice.h" |
| 19 | #include "rsContext.h" |
| 20 | #include "rsThreadIO.h" |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 21 | |
| 22 | #ifndef RS_COMPATIBILITY_LIB |
Alex Sakhartchouk | 4edf030 | 2012-03-09 10:47:27 -0800 | [diff] [blame] | 23 | #include "rsMesh.h" |
Mathias Agopian | 5ae678f | 2009-06-22 18:01:09 -0700 | [diff] [blame] | 24 | #include <ui/FramebufferNativeWindow.h> |
Jason Sams | 5f27d6f | 2012-02-07 15:32:08 -0800 | [diff] [blame] | 25 | #include <gui/DisplayEventReceiver.h> |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 26 | #endif |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 27 | |
Jason Sams | 1583244 | 2009-11-15 12:14:26 -0800 | [diff] [blame] | 28 | #include <sys/types.h> |
| 29 | #include <sys/resource.h> |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 30 | #include <sched.h> |
Jason Sams | 1583244 | 2009-11-15 12:14:26 -0800 | [diff] [blame] | 31 | |
Jason Sams | 8d957fa | 2010-09-28 14:41:22 -0700 | [diff] [blame] | 32 | #include <sys/syscall.h> |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 33 | #include <string.h> |
Stephen Hines | 414a461 | 2012-09-05 18:05:08 -0700 | [diff] [blame] | 34 | #include <dlfcn.h> |
| 35 | |
Tim Murray | 0b575de | 2013-03-15 15:56:43 -0700 | [diff] [blame] | 36 | #ifndef RS_SERVER |
| 37 | #include <cutils/properties.h> |
| 38 | #endif |
| 39 | |
| 40 | #ifdef RS_SERVER |
| 41 | // Android exposes gettid(), standard Linux does not |
| 42 | static pid_t gettid() { |
| 43 | return syscall(SYS_gettid); |
| 44 | } |
| 45 | #endif |
| 46 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 47 | using namespace android; |
| 48 | using namespace android::renderscript; |
| 49 | |
Jason Sams | fb03a22 | 2009-10-15 16:47:31 -0700 | [diff] [blame] | 50 | pthread_mutex_t Context::gInitMutex = PTHREAD_MUTEX_INITIALIZER; |
Jason Sams | 4961cce | 2013-04-11 16:11:46 -0700 | [diff] [blame^] | 51 | pthread_mutex_t Context::gMessageMutex = PTHREAD_MUTEX_INITIALIZER; |
Stephen Hines | ca3f09c | 2011-01-07 15:11:30 -0800 | [diff] [blame] | 52 | pthread_mutex_t Context::gLibMutex = PTHREAD_MUTEX_INITIALIZER; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 53 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 54 | bool Context::initGLThread() { |
Jason Sams | 6b8552a | 2010-10-13 15:31:10 -0700 | [diff] [blame] | 55 | pthread_mutex_lock(&gInitMutex); |
Jason Sams | 6b8552a | 2010-10-13 15:31:10 -0700 | [diff] [blame] | 56 | |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 57 | if (!mHal.funcs.initGraphics(this)) { |
Jason Sams | 5c1c79a | 2010-11-03 14:27:11 -0700 | [diff] [blame] | 58 | pthread_mutex_unlock(&gInitMutex); |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 59 | ALOGE("%p initGraphics failed", this); |
Jason Sams | 5c1c79a | 2010-11-03 14:27:11 -0700 | [diff] [blame] | 60 | return false; |
Jason Sams | 6b8552a | 2010-10-13 15:31:10 -0700 | [diff] [blame] | 61 | } |
| 62 | |
Jason Sams | 6b8552a | 2010-10-13 15:31:10 -0700 | [diff] [blame] | 63 | pthread_mutex_unlock(&gInitMutex); |
Jason Sams | 5c1c79a | 2010-11-03 14:27:11 -0700 | [diff] [blame] | 64 | return true; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 65 | } |
| 66 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 67 | void Context::deinitEGL() { |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 68 | #ifndef RS_COMPATIBILITY_LIB |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 69 | mHal.funcs.shutdownGraphics(this); |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 70 | #endif |
Jason Sams | 33b6e3b | 2009-10-27 14:44:31 -0700 | [diff] [blame] | 71 | } |
| 72 | |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 73 | Context::PushState::PushState(Context *con) { |
| 74 | mRsc = con; |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 75 | #ifndef RS_COMPATIBILITY_LIB |
Jason Sams | c946b61 | 2011-02-23 14:47:17 -0800 | [diff] [blame] | 76 | if (con->mIsGraphicsContext) { |
| 77 | mFragment.set(con->getProgramFragment()); |
| 78 | mVertex.set(con->getProgramVertex()); |
| 79 | mStore.set(con->getProgramStore()); |
| 80 | mRaster.set(con->getProgramRaster()); |
| 81 | mFont.set(con->getFont()); |
| 82 | } |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 83 | #endif |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 84 | } |
| 85 | |
| 86 | Context::PushState::~PushState() { |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 87 | #ifndef RS_COMPATIBILITY_LIB |
Jason Sams | c946b61 | 2011-02-23 14:47:17 -0800 | [diff] [blame] | 88 | if (mRsc->mIsGraphicsContext) { |
| 89 | mRsc->setProgramFragment(mFragment.get()); |
| 90 | mRsc->setProgramVertex(mVertex.get()); |
| 91 | mRsc->setProgramStore(mStore.get()); |
| 92 | mRsc->setProgramRaster(mRaster.get()); |
| 93 | mRsc->setFont(mFont.get()); |
| 94 | } |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 95 | #endif |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 96 | } |
| 97 | |
Jason Sams | 33b6e3b | 2009-10-27 14:44:31 -0700 | [diff] [blame] | 98 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 99 | uint32_t Context::runScript(Script *s) { |
Shih-wei Liao | da3b58d | 2012-08-03 04:24:33 -0700 | [diff] [blame] | 100 | PushState ps(this); |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 101 | |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 102 | uint32_t ret = s->run(this); |
Jason Sams | c9d43db | 2009-07-28 12:02:16 -0700 | [diff] [blame] | 103 | return ret; |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 104 | } |
| 105 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 106 | uint32_t Context::runRootScript() { |
Jason Sams | 2dca84d | 2009-12-09 11:05:45 -0800 | [diff] [blame] | 107 | timerSet(RS_TIMER_SCRIPT); |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 108 | #ifndef RS_COMPATIBILITY_LIB |
Jason Sams | 8c401ef | 2009-10-06 13:58:47 -0700 | [diff] [blame] | 109 | mStateFragmentStore.mLast.clear(); |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 110 | #endif |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 111 | watchdog.inRoot = true; |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 112 | uint32_t ret = runScript(mRootScript.get()); |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 113 | watchdog.inRoot = false; |
Jason Sams | 8cfdd24 | 2009-10-14 15:43:53 -0700 | [diff] [blame] | 114 | |
Jason Sams | cfb1d11 | 2009-08-05 13:57:03 -0700 | [diff] [blame] | 115 | return ret; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 116 | } |
| 117 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 118 | uint64_t Context::getTime() const { |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 119 | #ifndef ANDROID_RS_SERIALIZE |
Jason Sams | 24371d9 | 2009-08-19 12:17:14 -0700 | [diff] [blame] | 120 | struct timespec t; |
| 121 | clock_gettime(CLOCK_MONOTONIC, &t); |
| 122 | return t.tv_nsec + ((uint64_t)t.tv_sec * 1000 * 1000 * 1000); |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 123 | #else |
| 124 | return 0; |
| 125 | #endif //ANDROID_RS_SERIALIZE |
Jason Sams | 24371d9 | 2009-08-19 12:17:14 -0700 | [diff] [blame] | 126 | } |
| 127 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 128 | void Context::timerReset() { |
Jason Sams | 24371d9 | 2009-08-19 12:17:14 -0700 | [diff] [blame] | 129 | for (int ct=0; ct < _RS_TIMER_TOTAL; ct++) { |
| 130 | mTimers[ct] = 0; |
| 131 | } |
| 132 | } |
| 133 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 134 | void Context::timerInit() { |
Jason Sams | 24371d9 | 2009-08-19 12:17:14 -0700 | [diff] [blame] | 135 | mTimeLast = getTime(); |
Jason Sams | 1d54f10 | 2009-09-03 15:43:13 -0700 | [diff] [blame] | 136 | mTimeFrame = mTimeLast; |
| 137 | mTimeLastFrame = mTimeLast; |
Jason Sams | 24371d9 | 2009-08-19 12:17:14 -0700 | [diff] [blame] | 138 | mTimerActive = RS_TIMER_INTERNAL; |
Alex Sakhartchouk | c8fb69e | 2010-10-05 13:23:55 -0700 | [diff] [blame] | 139 | mAverageFPSFrameCount = 0; |
| 140 | mAverageFPSStartTime = mTimeLast; |
| 141 | mAverageFPS = 0; |
Jason Sams | 24371d9 | 2009-08-19 12:17:14 -0700 | [diff] [blame] | 142 | timerReset(); |
| 143 | } |
| 144 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 145 | void Context::timerFrame() { |
Jason Sams | 1d54f10 | 2009-09-03 15:43:13 -0700 | [diff] [blame] | 146 | mTimeLastFrame = mTimeFrame; |
| 147 | mTimeFrame = getTime(); |
Alex Sakhartchouk | c8fb69e | 2010-10-05 13:23:55 -0700 | [diff] [blame] | 148 | // Update average fps |
| 149 | const uint64_t averageFramerateInterval = 1000 * 1000000; |
| 150 | mAverageFPSFrameCount ++; |
| 151 | uint64_t inverval = mTimeFrame - mAverageFPSStartTime; |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 152 | if (inverval >= averageFramerateInterval) { |
Alex Sakhartchouk | c8fb69e | 2010-10-05 13:23:55 -0700 | [diff] [blame] | 153 | inverval = inverval / 1000000; |
| 154 | mAverageFPS = (mAverageFPSFrameCount * 1000) / inverval; |
| 155 | mAverageFPSFrameCount = 0; |
| 156 | mAverageFPSStartTime = mTimeFrame; |
| 157 | } |
Jason Sams | 1d54f10 | 2009-09-03 15:43:13 -0700 | [diff] [blame] | 158 | } |
| 159 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 160 | void Context::timerSet(Timers tm) { |
Jason Sams | 24371d9 | 2009-08-19 12:17:14 -0700 | [diff] [blame] | 161 | uint64_t last = mTimeLast; |
| 162 | mTimeLast = getTime(); |
| 163 | mTimers[mTimerActive] += mTimeLast - last; |
| 164 | mTimerActive = tm; |
| 165 | } |
| 166 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 167 | void Context::timerPrint() { |
Jason Sams | 24371d9 | 2009-08-19 12:17:14 -0700 | [diff] [blame] | 168 | double total = 0; |
| 169 | for (int ct = 0; ct < _RS_TIMER_TOTAL; ct++) { |
| 170 | total += mTimers[ct]; |
| 171 | } |
Jason Sams | 1d54f10 | 2009-09-03 15:43:13 -0700 | [diff] [blame] | 172 | uint64_t frame = mTimeFrame - mTimeLastFrame; |
Jason Sams | 2dca84d | 2009-12-09 11:05:45 -0800 | [diff] [blame] | 173 | mTimeMSLastFrame = frame / 1000000; |
| 174 | mTimeMSLastScript = mTimers[RS_TIMER_SCRIPT] / 1000000; |
| 175 | mTimeMSLastSwap = mTimers[RS_TIMER_CLEAR_SWAP] / 1000000; |
Jason Sams | 24371d9 | 2009-08-19 12:17:14 -0700 | [diff] [blame] | 176 | |
Jason Sams | 2dca84d | 2009-12-09 11:05:45 -0800 | [diff] [blame] | 177 | |
| 178 | if (props.mLogTimes) { |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 179 | ALOGV("RS: Frame (%i), Script %2.1f%% (%i), Swap %2.1f%% (%i), Idle %2.1f%% (%lli), Internal %2.1f%% (%lli), Avg fps: %u", |
Jason Sams | 2dca84d | 2009-12-09 11:05:45 -0800 | [diff] [blame] | 180 | mTimeMSLastFrame, |
| 181 | 100.0 * mTimers[RS_TIMER_SCRIPT] / total, mTimeMSLastScript, |
| 182 | 100.0 * mTimers[RS_TIMER_CLEAR_SWAP] / total, mTimeMSLastSwap, |
| 183 | 100.0 * mTimers[RS_TIMER_IDLE] / total, mTimers[RS_TIMER_IDLE] / 1000000, |
Alex Sakhartchouk | c8fb69e | 2010-10-05 13:23:55 -0700 | [diff] [blame] | 184 | 100.0 * mTimers[RS_TIMER_INTERNAL] / total, mTimers[RS_TIMER_INTERNAL] / 1000000, |
| 185 | mAverageFPS); |
Jason Sams | 2dca84d | 2009-12-09 11:05:45 -0800 | [diff] [blame] | 186 | } |
Jason Sams | 24371d9 | 2009-08-19 12:17:14 -0700 | [diff] [blame] | 187 | } |
| 188 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 189 | bool Context::setupCheck() { |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 190 | #ifndef RS_COMPATIBILITY_LIB |
Jason Sams | 721acc4 | 2011-04-06 11:23:54 -0700 | [diff] [blame] | 191 | mFragmentStore->setup(this, &mStateFragmentStore); |
Alex Sakhartchouk | c19ff01 | 2011-05-06 14:59:45 -0700 | [diff] [blame] | 192 | mFragment->setup(this, &mStateFragment); |
Jason Sams | 721acc4 | 2011-04-06 11:23:54 -0700 | [diff] [blame] | 193 | mRaster->setup(this, &mStateRaster); |
Alex Sakhartchouk | c19ff01 | 2011-05-06 14:59:45 -0700 | [diff] [blame] | 194 | mVertex->setup(this, &mStateVertex); |
| 195 | mFBOCache.setup(this); |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 196 | #endif |
Jason Sams | a2cf755 | 2010-03-03 13:03:18 -0800 | [diff] [blame] | 197 | return true; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 198 | } |
| 199 | |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 200 | #ifndef RS_COMPATIBILITY_LIB |
Alex Sakhartchouk | 889fe50 | 2010-10-01 10:54:06 -0700 | [diff] [blame] | 201 | void Context::setupProgramStore() { |
Jason Sams | 721acc4 | 2011-04-06 11:23:54 -0700 | [diff] [blame] | 202 | mFragmentStore->setup(this, &mStateFragmentStore); |
Alex Sakhartchouk | 889fe50 | 2010-10-01 10:54:06 -0700 | [diff] [blame] | 203 | } |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 204 | #endif |
Alex Sakhartchouk | 889fe50 | 2010-10-01 10:54:06 -0700 | [diff] [blame] | 205 | |
Jason Sams | d1f7da6 | 2012-03-15 19:18:03 -0700 | [diff] [blame] | 206 | static uint32_t getProp(const char *str) { |
Tim Murray | 0b575de | 2013-03-15 15:56:43 -0700 | [diff] [blame] | 207 | #ifndef RS_SERVER |
Joe Onorato | 76371ff | 2009-09-23 16:37:36 -0700 | [diff] [blame] | 208 | char buf[PROPERTY_VALUE_MAX]; |
Jason Sams | 1fddd90 | 2009-09-25 15:25:00 -0700 | [diff] [blame] | 209 | property_get(str, buf, "0"); |
Jason Sams | d1f7da6 | 2012-03-15 19:18:03 -0700 | [diff] [blame] | 210 | return atoi(buf); |
Tim Murray | 0b575de | 2013-03-15 15:56:43 -0700 | [diff] [blame] | 211 | #else |
| 212 | return 0; |
| 213 | #endif |
Joe Onorato | 76371ff | 2009-09-23 16:37:36 -0700 | [diff] [blame] | 214 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 215 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 216 | void Context::displayDebugStats() { |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 217 | #ifndef RS_COMPATIBILITY_LIB |
Alex Sakhartchouk | 0cae59f | 2010-08-03 12:03:16 -0700 | [diff] [blame] | 218 | char buffer[128]; |
Alex Sakhartchouk | c8fb69e | 2010-10-05 13:23:55 -0700 | [diff] [blame] | 219 | sprintf(buffer, "Avg fps %u, Frame %i ms, Script %i ms", mAverageFPS, mTimeMSLastFrame, mTimeMSLastScript); |
Alex Sakhartchouk | ca5a454 | 2010-08-05 11:24:14 -0700 | [diff] [blame] | 220 | float oldR, oldG, oldB, oldA; |
| 221 | mStateFont.getFontColor(&oldR, &oldG, &oldB, &oldA); |
Alex Sakhartchouk | 09c6735 | 2010-10-05 11:33:27 -0700 | [diff] [blame] | 222 | uint32_t bufferLen = strlen(buffer); |
Alex Sakhartchouk | 0cae59f | 2010-08-03 12:03:16 -0700 | [diff] [blame] | 223 | |
Alex Sakhartchouk | 1809bde | 2011-03-17 13:49:38 -0700 | [diff] [blame] | 224 | ObjectBaseRef<Font> lastFont(getFont()); |
| 225 | setFont(NULL); |
Alex Sakhartchouk | 09c6735 | 2010-10-05 11:33:27 -0700 | [diff] [blame] | 226 | float shadowCol = 0.1f; |
Alex Sakhartchouk | ca5a454 | 2010-08-05 11:24:14 -0700 | [diff] [blame] | 227 | mStateFont.setFontColor(shadowCol, shadowCol, shadowCol, 1.0f); |
Alex Sakhartchouk | c8fb69e | 2010-10-05 13:23:55 -0700 | [diff] [blame] | 228 | mStateFont.renderText(buffer, bufferLen, 5, getHeight() - 6); |
Alex Sakhartchouk | 0cae59f | 2010-08-03 12:03:16 -0700 | [diff] [blame] | 229 | |
Alex Sakhartchouk | 09c6735 | 2010-10-05 11:33:27 -0700 | [diff] [blame] | 230 | mStateFont.setFontColor(1.0f, 0.7f, 0.0f, 1.0f); |
Alex Sakhartchouk | c8fb69e | 2010-10-05 13:23:55 -0700 | [diff] [blame] | 231 | mStateFont.renderText(buffer, bufferLen, 4, getHeight() - 7); |
Alex Sakhartchouk | 0cae59f | 2010-08-03 12:03:16 -0700 | [diff] [blame] | 232 | |
Alex Sakhartchouk | 1809bde | 2011-03-17 13:49:38 -0700 | [diff] [blame] | 233 | setFont(lastFont.get()); |
Alex Sakhartchouk | ca5a454 | 2010-08-05 11:24:14 -0700 | [diff] [blame] | 234 | mStateFont.setFontColor(oldR, oldG, oldB, oldA); |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 235 | #endif |
Alex Sakhartchouk | 0cae59f | 2010-08-03 12:03:16 -0700 | [diff] [blame] | 236 | } |
| 237 | |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 238 | bool Context::loadRuntime(const char* filename, Context* rsc) { |
Joe Onorato | 76371ff | 2009-09-23 16:37:36 -0700 | [diff] [blame] | 239 | |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 240 | // TODO: store the driverSO somewhere so we can dlclose later |
Stephen Hines | 91dfcdb | 2012-09-07 18:23:35 -0700 | [diff] [blame] | 241 | void *driverSO = NULL; |
| 242 | |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 243 | driverSO = dlopen(filename, RTLD_LAZY); |
Stephen Hines | 91dfcdb | 2012-09-07 18:23:35 -0700 | [diff] [blame] | 244 | if (driverSO == NULL) { |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 245 | ALOGE("Failed loading RS driver: %s", dlerror()); |
| 246 | return false; |
Stephen Hines | 414a461 | 2012-09-05 18:05:08 -0700 | [diff] [blame] | 247 | } |
| 248 | |
| 249 | // Need to call dlerror() to clear buffer before using it for dlsym(). |
| 250 | (void) dlerror(); |
| 251 | typedef bool (*HalSig)(Context*, uint32_t, uint32_t); |
| 252 | HalSig halInit = (HalSig) dlsym(driverSO, "rsdHalInit"); |
| 253 | |
| 254 | // If we can't find the C variant, we go looking for the C++ version. |
| 255 | if (halInit == NULL) { |
| 256 | ALOGW("Falling back to find C++ rsdHalInit: %s", dlerror()); |
| 257 | halInit = (HalSig) dlsym(driverSO, |
| 258 | "_Z10rsdHalInitPN7android12renderscript7ContextEjj"); |
| 259 | } |
| 260 | |
| 261 | if (halInit == NULL) { |
Stephen Hines | 414a461 | 2012-09-05 18:05:08 -0700 | [diff] [blame] | 262 | dlclose(driverSO); |
| 263 | ALOGE("Failed to find rsdHalInit: %s", dlerror()); |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 264 | return false; |
Stephen Hines | 414a461 | 2012-09-05 18:05:08 -0700 | [diff] [blame] | 265 | } |
| 266 | |
| 267 | if (!(*halInit)(rsc, 0, 0)) { |
Stephen Hines | 414a461 | 2012-09-05 18:05:08 -0700 | [diff] [blame] | 268 | dlclose(driverSO); |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 269 | ALOGE("Hal init failed"); |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 270 | return false; |
Jason Sams | 83c451a | 2011-04-21 11:46:50 -0700 | [diff] [blame] | 271 | } |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 272 | |
| 273 | //validate HAL struct |
| 274 | |
| 275 | |
| 276 | return true; |
| 277 | } |
| 278 | |
Jason Sams | 110f181 | 2013-03-14 16:02:18 -0700 | [diff] [blame] | 279 | extern "C" bool rsdHalInit(RsContext c, uint32_t version_major, uint32_t version_minor); |
| 280 | |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 281 | void * Context::threadProc(void *vrsc) { |
| 282 | Context *rsc = static_cast<Context *>(vrsc); |
| 283 | #ifndef ANDROID_RS_SERIALIZE |
| 284 | rsc->mNativeThreadId = gettid(); |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 285 | #ifndef RS_COMPATIBILITY_LIB |
Tim Murray | 4d252d6 | 2012-11-29 14:37:59 -0800 | [diff] [blame] | 286 | if (!rsc->isSynchronous()) { |
| 287 | setpriority(PRIO_PROCESS, rsc->mNativeThreadId, ANDROID_PRIORITY_DISPLAY); |
| 288 | } |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 289 | rsc->mThreadPriority = ANDROID_PRIORITY_DISPLAY; |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 290 | #else |
| 291 | if (!rsc->isSynchronous()) { |
| 292 | setpriority(PRIO_PROCESS, rsc->mNativeThreadId, -4); |
| 293 | } |
| 294 | rsc->mThreadPriority = -4; |
| 295 | #endif |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 296 | #endif //ANDROID_RS_SERIALIZE |
| 297 | rsc->props.mLogTimes = getProp("debug.rs.profile") != 0; |
| 298 | rsc->props.mLogScripts = getProp("debug.rs.script") != 0; |
| 299 | rsc->props.mLogObjects = getProp("debug.rs.object") != 0; |
| 300 | rsc->props.mLogShaders = getProp("debug.rs.shader") != 0; |
| 301 | rsc->props.mLogShadersAttr = getProp("debug.rs.shader.attributes") != 0; |
| 302 | rsc->props.mLogShadersUniforms = getProp("debug.rs.shader.uniforms") != 0; |
| 303 | rsc->props.mLogVisual = getProp("debug.rs.visual") != 0; |
| 304 | rsc->props.mDebugMaxThreads = getProp("debug.rs.max-threads"); |
| 305 | |
| 306 | bool loadDefault = true; |
| 307 | |
| 308 | // Provide a mechanism for dropping in a different RS driver. |
Jason Sams | 110f181 | 2013-03-14 16:02:18 -0700 | [diff] [blame] | 309 | #ifndef RS_COMPATIBILITY_LIB |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 310 | #ifdef OVERRIDE_RS_DRIVER |
| 311 | #define XSTR(S) #S |
| 312 | #define STR(S) XSTR(S) |
| 313 | #define OVERRIDE_RS_DRIVER_STRING STR(OVERRIDE_RS_DRIVER) |
| 314 | |
| 315 | if (getProp("debug.rs.default-CPU-driver") != 0) { |
| 316 | ALOGE("Skipping override driver and loading default CPU driver"); |
Tim Murray | 0e92fa3 | 2012-11-06 14:36:38 -0800 | [diff] [blame] | 317 | } else if (rsc->mForceCpu) { |
| 318 | ALOGV("Application requested CPU execution"); |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 319 | } else { |
| 320 | if (loadRuntime(OVERRIDE_RS_DRIVER_STRING, rsc)) { |
| 321 | ALOGE("Successfully loaded runtime: %s", OVERRIDE_RS_DRIVER_STRING); |
| 322 | loadDefault = false; |
| 323 | } else { |
| 324 | ALOGE("Failed to load runtime %s, loading default", OVERRIDE_RS_DRIVER_STRING); |
| 325 | } |
| 326 | } |
| 327 | |
| 328 | #undef XSTR |
| 329 | #undef STR |
| 330 | #endif // OVERRIDE_RS_DRIVER |
| 331 | |
| 332 | if (loadDefault) { |
| 333 | if (!loadRuntime("libRSDriver.so", rsc)) { |
| 334 | ALOGE("Failed to load default runtime!"); |
Stephen Hines | 6f01bcf | 2012-11-19 15:18:16 -0800 | [diff] [blame] | 335 | rsc->setError(RS_ERROR_FATAL_DRIVER, "Failed loading RS driver"); |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 336 | return NULL; |
| 337 | } |
| 338 | } |
Jason Sams | 110f181 | 2013-03-14 16:02:18 -0700 | [diff] [blame] | 339 | #else // RS_COMPATIBILITY_LIB |
| 340 | if (rsdHalInit(rsc, 0, 0) != true) { |
| 341 | return NULL; |
| 342 | } |
| 343 | #endif |
| 344 | |
Tim Murray | 0c66f07 | 2012-10-23 14:05:02 -0700 | [diff] [blame] | 345 | |
Jason Sams | 83c451a | 2011-04-21 11:46:50 -0700 | [diff] [blame] | 346 | rsc->mHal.funcs.setPriority(rsc, rsc->mThreadPriority); |
Jason Sams | e576910 | 2009-06-19 16:03:18 -0700 | [diff] [blame] | 347 | |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 348 | #ifndef RS_COMPATIBILITY_LIB |
Jason Sams | 83c451a | 2011-04-21 11:46:50 -0700 | [diff] [blame] | 349 | if (rsc->mIsGraphicsContext) { |
Jason Sams | d3e7107 | 2011-05-03 15:01:58 -0700 | [diff] [blame] | 350 | if (!rsc->initGLThread()) { |
| 351 | rsc->setError(RS_ERROR_OUT_OF_MEMORY, "Failed initializing GL"); |
| 352 | return NULL; |
| 353 | } |
| 354 | |
Jason Sams | 83c451a | 2011-04-21 11:46:50 -0700 | [diff] [blame] | 355 | rsc->mStateRaster.init(rsc); |
| 356 | rsc->setProgramRaster(NULL); |
| 357 | rsc->mStateVertex.init(rsc); |
| 358 | rsc->setProgramVertex(NULL); |
| 359 | rsc->mStateFragment.init(rsc); |
| 360 | rsc->setProgramFragment(NULL); |
| 361 | rsc->mStateFragmentStore.init(rsc); |
| 362 | rsc->setProgramStore(NULL); |
| 363 | rsc->mStateFont.init(rsc); |
| 364 | rsc->setFont(NULL); |
Alex Sakhartchouk | c700e64 | 2011-08-16 13:09:46 -0700 | [diff] [blame] | 365 | rsc->mStateSampler.init(rsc); |
Alex Sakhartchouk | da6d34a | 2011-05-13 14:53:34 -0700 | [diff] [blame] | 366 | rsc->mFBOCache.init(rsc); |
Jason Sams | 83c451a | 2011-04-21 11:46:50 -0700 | [diff] [blame] | 367 | } |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 368 | #endif |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 369 | |
Jason Sams | 83c451a | 2011-04-21 11:46:50 -0700 | [diff] [blame] | 370 | rsc->mRunning = true; |
Tim Murray | 4d252d6 | 2012-11-29 14:37:59 -0800 | [diff] [blame] | 371 | |
| 372 | if (rsc->isSynchronous()) { |
| 373 | return NULL; |
| 374 | } |
| 375 | |
Jason Sams | 5f27d6f | 2012-02-07 15:32:08 -0800 | [diff] [blame] | 376 | if (!rsc->mIsGraphicsContext) { |
| 377 | while (!rsc->mExit) { |
Jason Sams | 963a2fb | 2012-02-09 14:36:14 -0800 | [diff] [blame] | 378 | rsc->mIO.playCoreCommands(rsc, -1); |
Jason Sams | e0aab4a | 2011-08-12 15:05:15 -0700 | [diff] [blame] | 379 | } |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 380 | #ifndef RS_COMPATIBILITY_LIB |
Jason Sams | 5f27d6f | 2012-02-07 15:32:08 -0800 | [diff] [blame] | 381 | } else { |
| 382 | #ifndef ANDROID_RS_SERIALIZE |
| 383 | DisplayEventReceiver displayEvent; |
| 384 | DisplayEventReceiver::Event eventBuffer[1]; |
| 385 | #endif |
| 386 | int vsyncRate = 0; |
| 387 | int targetRate = 0; |
Jason Sams | e0aab4a | 2011-08-12 15:05:15 -0700 | [diff] [blame] | 388 | |
Jason Sams | 5f27d6f | 2012-02-07 15:32:08 -0800 | [diff] [blame] | 389 | bool drawOnce = false; |
| 390 | while (!rsc->mExit) { |
| 391 | rsc->timerSet(RS_TIMER_IDLE); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 392 | |
Jason Sams | 5f27d6f | 2012-02-07 15:32:08 -0800 | [diff] [blame] | 393 | #ifndef ANDROID_RS_SERIALIZE |
Jason Sams | 9afd9a5 | 2012-02-17 16:59:50 -0800 | [diff] [blame] | 394 | if (!rsc->mRootScript.get() || !rsc->mHasSurface || rsc->mPaused) { |
| 395 | targetRate = 0; |
| 396 | } |
| 397 | |
Jason Sams | 5f27d6f | 2012-02-07 15:32:08 -0800 | [diff] [blame] | 398 | if (vsyncRate != targetRate) { |
| 399 | displayEvent.setVsyncRate(targetRate); |
| 400 | vsyncRate = targetRate; |
| 401 | } |
| 402 | if (targetRate) { |
Jason Sams | 963a2fb | 2012-02-09 14:36:14 -0800 | [diff] [blame] | 403 | drawOnce |= rsc->mIO.playCoreCommands(rsc, displayEvent.getFd()); |
Jason Sams | 5f27d6f | 2012-02-07 15:32:08 -0800 | [diff] [blame] | 404 | while (displayEvent.getEvents(eventBuffer, 1) != 0) { |
| 405 | //ALOGE("vs2 time past %lld", (rsc->getTime() - eventBuffer[0].header.timestamp) / 1000000); |
| 406 | } |
| 407 | } else |
| 408 | #endif |
| 409 | { |
Jason Sams | 963a2fb | 2012-02-09 14:36:14 -0800 | [diff] [blame] | 410 | drawOnce |= rsc->mIO.playCoreCommands(rsc, -1); |
Jason Sams | 83c451a | 2011-04-21 11:46:50 -0700 | [diff] [blame] | 411 | } |
Alex Sakhartchouk | 0cae59f | 2010-08-03 12:03:16 -0700 | [diff] [blame] | 412 | |
Jason Sams | 5f27d6f | 2012-02-07 15:32:08 -0800 | [diff] [blame] | 413 | if ((rsc->mRootScript.get() != NULL) && rsc->mHasSurface && |
| 414 | (targetRate || drawOnce) && !rsc->mPaused) { |
| 415 | |
| 416 | drawOnce = false; |
| 417 | targetRate = ((rsc->runRootScript() + 15) / 16); |
| 418 | |
| 419 | if (rsc->props.mLogVisual) { |
| 420 | rsc->displayDebugStats(); |
| 421 | } |
| 422 | |
| 423 | rsc->timerSet(RS_TIMER_CLEAR_SWAP); |
| 424 | rsc->mHal.funcs.swap(rsc); |
| 425 | rsc->timerFrame(); |
| 426 | rsc->timerSet(RS_TIMER_INTERNAL); |
| 427 | rsc->timerPrint(); |
| 428 | rsc->timerReset(); |
| 429 | } |
Jason Sams | 83c451a | 2011-04-21 11:46:50 -0700 | [diff] [blame] | 430 | } |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 431 | #endif |
Jason Sams | 83c451a | 2011-04-21 11:46:50 -0700 | [diff] [blame] | 432 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 433 | |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 434 | ALOGV("%p RS Thread exiting", rsc); |
Jason Sams | e514b45 | 2009-09-25 14:51:22 -0700 | [diff] [blame] | 435 | |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 436 | #ifndef RS_COMPATIBILITY_LIB |
Jason Sams | 83c451a | 2011-04-21 11:46:50 -0700 | [diff] [blame] | 437 | if (rsc->mIsGraphicsContext) { |
| 438 | pthread_mutex_lock(&gInitMutex); |
| 439 | rsc->deinitEGL(); |
| 440 | pthread_mutex_unlock(&gInitMutex); |
| 441 | } |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 442 | #endif |
Jason Sams | 33b6e3b | 2009-10-27 14:44:31 -0700 | [diff] [blame] | 443 | |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 444 | ALOGV("%p RS Thread exited", rsc); |
Jason Sams | 83c451a | 2011-04-21 11:46:50 -0700 | [diff] [blame] | 445 | return NULL; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 446 | } |
| 447 | |
Jason Sams | 741aac9 | 2010-12-24 14:38:39 -0800 | [diff] [blame] | 448 | void Context::destroyWorkerThreadResources() { |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 449 | //ALOGV("destroyWorkerThreadResources 1"); |
Jason Sams | 2e8665d | 2011-01-27 00:14:13 -0800 | [diff] [blame] | 450 | ObjectBase::zeroAllUserRef(this); |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 451 | #ifndef RS_COMPATIBILITY_LIB |
Jason Sams | 741aac9 | 2010-12-24 14:38:39 -0800 | [diff] [blame] | 452 | if (mIsGraphicsContext) { |
| 453 | mRaster.clear(); |
| 454 | mFragment.clear(); |
| 455 | mVertex.clear(); |
| 456 | mFragmentStore.clear(); |
| 457 | mFont.clear(); |
| 458 | mRootScript.clear(); |
| 459 | mStateRaster.deinit(this); |
| 460 | mStateVertex.deinit(this); |
| 461 | mStateFragment.deinit(this); |
| 462 | mStateFragmentStore.deinit(this); |
| 463 | mStateFont.deinit(this); |
Alex Sakhartchouk | c700e64 | 2011-08-16 13:09:46 -0700 | [diff] [blame] | 464 | mStateSampler.deinit(this); |
Alex Sakhartchouk | da6d34a | 2011-05-13 14:53:34 -0700 | [diff] [blame] | 465 | mFBOCache.deinit(this); |
Jason Sams | 741aac9 | 2010-12-24 14:38:39 -0800 | [diff] [blame] | 466 | } |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 467 | #endif |
Jason Sams | c7cec1e | 2011-08-18 18:01:33 -0700 | [diff] [blame] | 468 | ObjectBase::freeAllChildren(this); |
Jason Sams | cf912de | 2011-01-09 16:09:51 -0800 | [diff] [blame] | 469 | mExit = true; |
Jason Sams | 5f27d6f | 2012-02-07 15:32:08 -0800 | [diff] [blame] | 470 | //ALOGV("destroyWorkerThreadResources 2"); |
Jason Sams | 741aac9 | 2010-12-24 14:38:39 -0800 | [diff] [blame] | 471 | } |
| 472 | |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 473 | void Context::printWatchdogInfo(void *ctx) { |
| 474 | Context *rsc = (Context *)ctx; |
Jason Sams | ee80344 | 2011-10-13 16:05:27 -0700 | [diff] [blame] | 475 | if (rsc->watchdog.command && rsc->watchdog.file) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 476 | ALOGE("RS watchdog timeout: %i %s line %i %s", rsc->watchdog.inRoot, |
Jason Sams | ee80344 | 2011-10-13 16:05:27 -0700 | [diff] [blame] | 477 | rsc->watchdog.command, rsc->watchdog.line, rsc->watchdog.file); |
| 478 | } else { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 479 | ALOGE("RS watchdog timeout: %i", rsc->watchdog.inRoot); |
Jason Sams | ee80344 | 2011-10-13 16:05:27 -0700 | [diff] [blame] | 480 | } |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 481 | } |
| 482 | |
| 483 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 484 | void Context::setPriority(int32_t p) { |
Jason Sams | 1583244 | 2009-11-15 12:14:26 -0800 | [diff] [blame] | 485 | // Note: If we put this in the proper "background" policy |
| 486 | // the wallpapers can become completly unresponsive at times. |
| 487 | // This is probably not what we want for something the user is actively |
| 488 | // looking at. |
Jason Sams | 2dca84d | 2009-12-09 11:05:45 -0800 | [diff] [blame] | 489 | mThreadPriority = p; |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 490 | setpriority(PRIO_PROCESS, mNativeThreadId, p); |
Jason Sams | 9719bd4 | 2012-01-12 14:22:21 -0800 | [diff] [blame] | 491 | mHal.funcs.setPriority(this, mThreadPriority); |
Jason Sams | 1583244 | 2009-11-15 12:14:26 -0800 | [diff] [blame] | 492 | } |
| 493 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 494 | Context::Context() { |
Jason Sams | 5c1c79a | 2010-11-03 14:27:11 -0700 | [diff] [blame] | 495 | mDev = NULL; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 496 | mRunning = false; |
| 497 | mExit = false; |
Jason Sams | 86f1b23 | 2009-09-24 17:38:20 -0700 | [diff] [blame] | 498 | mPaused = false; |
Jason Sams | e514b45 | 2009-09-25 14:51:22 -0700 | [diff] [blame] | 499 | mObjHead = NULL; |
Jason Sams | a2cf755 | 2010-03-03 13:03:18 -0800 | [diff] [blame] | 500 | mError = RS_ERROR_NONE; |
Stephen Hines | cbb0b8a | 2011-08-01 15:02:34 -0700 | [diff] [blame] | 501 | mTargetSdkVersion = 14; |
Alex Sakhartchouk | 7b3e9bd | 2011-03-16 19:28:25 -0700 | [diff] [blame] | 502 | mDPI = 96; |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 503 | mIsContextLite = false; |
Stephen Hines | 86c6b5f | 2011-10-31 14:07:54 -0700 | [diff] [blame] | 504 | memset(&watchdog, 0, sizeof(watchdog)); |
Tim Murray | 0e92fa3 | 2012-11-06 14:36:38 -0800 | [diff] [blame] | 505 | mForceCpu = false; |
Tim Murray | 4d252d6 | 2012-11-29 14:37:59 -0800 | [diff] [blame] | 506 | mSynchronous = false; |
Tim Murray | 0e92fa3 | 2012-11-06 14:36:38 -0800 | [diff] [blame] | 507 | } |
| 508 | |
| 509 | Context * Context::createContext(Device *dev, const RsSurfaceConfig *sc, |
Tim Murray | 4d252d6 | 2012-11-29 14:37:59 -0800 | [diff] [blame] | 510 | bool forceCpu, bool synchronous) { |
Jason Sams | 5c1c79a | 2010-11-03 14:27:11 -0700 | [diff] [blame] | 511 | Context * rsc = new Context(); |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 512 | |
Tim Murray | 0e92fa3 | 2012-11-06 14:36:38 -0800 | [diff] [blame] | 513 | rsc->mForceCpu = forceCpu; |
Tim Murray | 4d252d6 | 2012-11-29 14:37:59 -0800 | [diff] [blame] | 514 | rsc->mSynchronous = synchronous; |
Tim Murray | 0e92fa3 | 2012-11-06 14:36:38 -0800 | [diff] [blame] | 515 | |
Jason Sams | 5c1c79a | 2010-11-03 14:27:11 -0700 | [diff] [blame] | 516 | if (!rsc->initContext(dev, sc)) { |
| 517 | delete rsc; |
| 518 | return NULL; |
| 519 | } |
| 520 | return rsc; |
| 521 | } |
| 522 | |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 523 | Context * Context::createContextLite() { |
| 524 | Context * rsc = new Context(); |
| 525 | rsc->mIsContextLite = true; |
| 526 | return rsc; |
| 527 | } |
| 528 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 529 | bool Context::initContext(Device *dev, const RsSurfaceConfig *sc) { |
Jason Sams | 5c1c79a | 2010-11-03 14:27:11 -0700 | [diff] [blame] | 530 | pthread_mutex_lock(&gInitMutex); |
| 531 | |
Jason Sams | 1a4efa3 | 2011-05-17 15:01:29 -0700 | [diff] [blame] | 532 | mIO.init(); |
Jason Sams | 5f27d6f | 2012-02-07 15:32:08 -0800 | [diff] [blame] | 533 | mIO.setTimeoutCallback(printWatchdogInfo, this, 2e9); |
Jason Sams | 1a4efa3 | 2011-05-17 15:01:29 -0700 | [diff] [blame] | 534 | |
Jason Sams | 5c1c79a | 2010-11-03 14:27:11 -0700 | [diff] [blame] | 535 | dev->addContext(this); |
| 536 | mDev = dev; |
Jason Sams | 6b8552a | 2010-10-13 15:31:10 -0700 | [diff] [blame] | 537 | if (sc) { |
| 538 | mUserSurfaceConfig = *sc; |
| 539 | } else { |
| 540 | memset(&mUserSurfaceConfig, 0, sizeof(mUserSurfaceConfig)); |
| 541 | } |
Jason Sams | a2cf755 | 2010-03-03 13:03:18 -0800 | [diff] [blame] | 542 | |
Jason Sams | 6b8552a | 2010-10-13 15:31:10 -0700 | [diff] [blame] | 543 | mIsGraphicsContext = sc != NULL; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 544 | |
Jason Sams | a658e90 | 2009-06-04 14:35:01 -0700 | [diff] [blame] | 545 | int status; |
| 546 | pthread_attr_t threadAttr; |
| 547 | |
Jason Sams | fb03a22 | 2009-10-15 16:47:31 -0700 | [diff] [blame] | 548 | pthread_mutex_unlock(&gInitMutex); |
| 549 | |
| 550 | // Global init done at this point. |
Jason Sams | e576910 | 2009-06-19 16:03:18 -0700 | [diff] [blame] | 551 | |
Jason Sams | a658e90 | 2009-06-04 14:35:01 -0700 | [diff] [blame] | 552 | status = pthread_attr_init(&threadAttr); |
| 553 | if (status) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 554 | ALOGE("Failed to init thread attribute."); |
Jason Sams | 5c1c79a | 2010-11-03 14:27:11 -0700 | [diff] [blame] | 555 | return false; |
Jason Sams | a658e90 | 2009-06-04 14:35:01 -0700 | [diff] [blame] | 556 | } |
| 557 | |
Alex Sakhartchouk | 7257c7e | 2011-05-17 12:32:47 -0700 | [diff] [blame] | 558 | mHasSurface = false; |
Jason Sams | 992a0b7 | 2009-06-23 12:22:47 -0700 | [diff] [blame] | 559 | |
Jason Sams | 24371d9 | 2009-08-19 12:17:14 -0700 | [diff] [blame] | 560 | timerInit(); |
Jason Sams | a891933 | 2009-09-24 15:42:52 -0700 | [diff] [blame] | 561 | timerSet(RS_TIMER_INTERNAL); |
Tim Murray | 4d252d6 | 2012-11-29 14:37:59 -0800 | [diff] [blame] | 562 | if (mSynchronous) { |
| 563 | threadProc(this); |
| 564 | } else { |
| 565 | status = pthread_create(&mThreadId, &threadAttr, threadProc, this); |
| 566 | if (status) { |
| 567 | ALOGE("Failed to start rs context thread."); |
| 568 | return false; |
| 569 | } |
| 570 | while (!mRunning && (mError == RS_ERROR_NONE)) { |
| 571 | usleep(100); |
| 572 | } |
Jason Sams | 5086938 | 2009-08-18 17:07:09 -0700 | [diff] [blame] | 573 | |
Tim Murray | 4d252d6 | 2012-11-29 14:37:59 -0800 | [diff] [blame] | 574 | if (mError != RS_ERROR_NONE) { |
| 575 | ALOGE("Errors during thread init"); |
| 576 | return false; |
| 577 | } |
Jason Sams | 1813340 | 2010-07-20 15:09:00 -0700 | [diff] [blame] | 578 | |
Tim Murray | 4d252d6 | 2012-11-29 14:37:59 -0800 | [diff] [blame] | 579 | pthread_attr_destroy(&threadAttr); |
Jason Sams | 5c1c79a | 2010-11-03 14:27:11 -0700 | [diff] [blame] | 580 | } |
Jason Sams | 5c1c79a | 2010-11-03 14:27:11 -0700 | [diff] [blame] | 581 | return true; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 582 | } |
| 583 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 584 | Context::~Context() { |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 585 | ALOGV("%p Context::~Context", this); |
Jason Sams | cf912de | 2011-01-09 16:09:51 -0800 | [diff] [blame] | 586 | |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 587 | if (!mIsContextLite) { |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 588 | mPaused = false; |
| 589 | void *res; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 590 | |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 591 | mIO.shutdown(); |
| 592 | int status = pthread_join(mThreadId, &res); |
Jason Sams | 5f27d6f | 2012-02-07 15:32:08 -0800 | [diff] [blame] | 593 | rsAssert(mExit); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 594 | |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 595 | if (mHal.funcs.shutdownDriver) { |
| 596 | mHal.funcs.shutdownDriver(this); |
| 597 | } |
| 598 | |
| 599 | // Global structure cleanup. |
| 600 | pthread_mutex_lock(&gInitMutex); |
| 601 | if (mDev) { |
| 602 | mDev->removeContext(this); |
| 603 | mDev = NULL; |
| 604 | } |
| 605 | pthread_mutex_unlock(&gInitMutex); |
Jason Sams | 51462c5 | 2011-01-25 00:26:25 -0800 | [diff] [blame] | 606 | } |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 607 | ALOGV("%p Context::~Context done", this); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 608 | } |
| 609 | |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 610 | #ifndef RS_COMPATIBILITY_LIB |
Alex Sakhartchouk | 7257c7e | 2011-05-17 12:32:47 -0700 | [diff] [blame] | 611 | void Context::setSurface(uint32_t w, uint32_t h, RsNativeWindow sur) { |
Jason Sams | 4820e8b | 2010-02-09 16:05:07 -0800 | [diff] [blame] | 612 | rsAssert(mIsGraphicsContext); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 613 | mHal.funcs.setSurface(this, w, h, sur); |
Jason Sams | 458f2dc | 2009-11-03 13:58:36 -0800 | [diff] [blame] | 614 | |
Alex Sakhartchouk | 7257c7e | 2011-05-17 12:32:47 -0700 | [diff] [blame] | 615 | mHasSurface = sur != NULL; |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 616 | mWidth = w; |
| 617 | mHeight = h; |
Jason Sams | 613cad1 | 2009-11-12 15:10:25 -0800 | [diff] [blame] | 618 | |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 619 | if (mWidth && mHeight) { |
Jason Sams | 771565f | 2010-05-14 15:30:29 -0700 | [diff] [blame] | 620 | mStateVertex.updateSize(this); |
Alex Sakhartchouk | a544b63 | 2011-07-19 17:50:29 -0700 | [diff] [blame] | 621 | mFBOCache.updateSize(); |
Jason Sams | 458f2dc | 2009-11-03 13:58:36 -0800 | [diff] [blame] | 622 | } |
| 623 | } |
| 624 | |
Alex Sakhartchouk | a74a8f6 | 2011-11-16 12:22:10 -0800 | [diff] [blame] | 625 | uint32_t Context::getCurrentSurfaceWidth() const { |
| 626 | for (uint32_t i = 0; i < mFBOCache.mHal.state.colorTargetsCount; i ++) { |
| 627 | if (mFBOCache.mHal.state.colorTargets[i] != NULL) { |
| 628 | return mFBOCache.mHal.state.colorTargets[i]->getType()->getDimX(); |
| 629 | } |
| 630 | } |
| 631 | if (mFBOCache.mHal.state.depthTarget != NULL) { |
| 632 | return mFBOCache.mHal.state.depthTarget->getType()->getDimX(); |
| 633 | } |
| 634 | return mWidth; |
| 635 | } |
| 636 | |
| 637 | uint32_t Context::getCurrentSurfaceHeight() const { |
| 638 | for (uint32_t i = 0; i < mFBOCache.mHal.state.colorTargetsCount; i ++) { |
| 639 | if (mFBOCache.mHal.state.colorTargets[i] != NULL) { |
| 640 | return mFBOCache.mHal.state.colorTargets[i]->getType()->getDimY(); |
| 641 | } |
| 642 | } |
| 643 | if (mFBOCache.mHal.state.depthTarget != NULL) { |
| 644 | return mFBOCache.mHal.state.depthTarget->getType()->getDimY(); |
| 645 | } |
| 646 | return mHeight; |
| 647 | } |
| 648 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 649 | void Context::pause() { |
Jason Sams | 4820e8b | 2010-02-09 16:05:07 -0800 | [diff] [blame] | 650 | rsAssert(mIsGraphicsContext); |
Jason Sams | 86f1b23 | 2009-09-24 17:38:20 -0700 | [diff] [blame] | 651 | mPaused = true; |
| 652 | } |
| 653 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 654 | void Context::resume() { |
Jason Sams | 4820e8b | 2010-02-09 16:05:07 -0800 | [diff] [blame] | 655 | rsAssert(mIsGraphicsContext); |
Jason Sams | 86f1b23 | 2009-09-24 17:38:20 -0700 | [diff] [blame] | 656 | mPaused = false; |
| 657 | } |
| 658 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 659 | void Context::setRootScript(Script *s) { |
Jason Sams | 4820e8b | 2010-02-09 16:05:07 -0800 | [diff] [blame] | 660 | rsAssert(mIsGraphicsContext); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 661 | mRootScript.set(s); |
| 662 | } |
| 663 | |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 664 | void Context::setProgramStore(ProgramStore *pfs) { |
Jason Sams | 4820e8b | 2010-02-09 16:05:07 -0800 | [diff] [blame] | 665 | rsAssert(mIsGraphicsContext); |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 666 | if (pfs == NULL) { |
| 667 | mFragmentStore.set(mStateFragmentStore.mDefault); |
| 668 | } else { |
| 669 | mFragmentStore.set(pfs); |
| 670 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 671 | } |
| 672 | |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 673 | void Context::setProgramFragment(ProgramFragment *pf) { |
Jason Sams | 4820e8b | 2010-02-09 16:05:07 -0800 | [diff] [blame] | 674 | rsAssert(mIsGraphicsContext); |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 675 | if (pf == NULL) { |
| 676 | mFragment.set(mStateFragment.mDefault); |
| 677 | } else { |
| 678 | mFragment.set(pf); |
| 679 | } |
Jason Sams | cfb1d11 | 2009-08-05 13:57:03 -0700 | [diff] [blame] | 680 | } |
| 681 | |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 682 | void Context::setProgramRaster(ProgramRaster *pr) { |
Jason Sams | 4820e8b | 2010-02-09 16:05:07 -0800 | [diff] [blame] | 683 | rsAssert(mIsGraphicsContext); |
Jason Sams | 5fd09d8 | 2009-09-23 13:57:02 -0700 | [diff] [blame] | 684 | if (pr == NULL) { |
| 685 | mRaster.set(mStateRaster.mDefault); |
| 686 | } else { |
| 687 | mRaster.set(pr); |
| 688 | } |
| 689 | } |
| 690 | |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 691 | void Context::setProgramVertex(ProgramVertex *pv) { |
Jason Sams | 4820e8b | 2010-02-09 16:05:07 -0800 | [diff] [blame] | 692 | rsAssert(mIsGraphicsContext); |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 693 | if (pv == NULL) { |
| 694 | mVertex.set(mStateVertex.mDefault); |
| 695 | } else { |
| 696 | mVertex.set(pv); |
| 697 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 698 | } |
| 699 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 700 | void Context::setFont(Font *f) { |
Alex Sakhartchouk | d3e0ad4 | 2010-06-24 17:15:34 -0700 | [diff] [blame] | 701 | rsAssert(mIsGraphicsContext); |
| 702 | if (f == NULL) { |
| 703 | mFont.set(mStateFont.mDefault); |
| 704 | } else { |
| 705 | mFont.set(f); |
| 706 | } |
| 707 | } |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 708 | #endif |
Alex Sakhartchouk | d3e0ad4 | 2010-06-24 17:15:34 -0700 | [diff] [blame] | 709 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 710 | void Context::assignName(ObjectBase *obj, const char *name, uint32_t len) { |
Jason Sams | a0a1b6f | 2009-06-10 15:04:38 -0700 | [diff] [blame] | 711 | rsAssert(!obj->getName()); |
Jason Sams | a4a54e4 | 2009-06-10 18:39:40 -0700 | [diff] [blame] | 712 | obj->setName(name, len); |
Jason Sams | a0a1b6f | 2009-06-10 15:04:38 -0700 | [diff] [blame] | 713 | mNames.add(obj); |
| 714 | } |
| 715 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 716 | void Context::removeName(ObjectBase *obj) { |
| 717 | for (size_t ct=0; ct < mNames.size(); ct++) { |
Jason Sams | a0a1b6f | 2009-06-10 15:04:38 -0700 | [diff] [blame] | 718 | if (obj == mNames[ct]) { |
| 719 | mNames.removeAt(ct); |
| 720 | return; |
| 721 | } |
| 722 | } |
| 723 | } |
| 724 | |
Jason Sams | 1a4efa3 | 2011-05-17 15:01:29 -0700 | [diff] [blame] | 725 | RsMessageToClientType Context::peekMessageToClient(size_t *receiveLen, uint32_t *subID) { |
| 726 | return (RsMessageToClientType)mIO.getClientHeader(receiveLen, subID); |
Jason Sams | aad4bc5 | 2010-11-08 17:06:46 -0800 | [diff] [blame] | 727 | } |
| 728 | |
Jason Sams | 1a4efa3 | 2011-05-17 15:01:29 -0700 | [diff] [blame] | 729 | RsMessageToClientType Context::getMessageToClient(void *data, size_t *receiveLen, uint32_t *subID, size_t bufferLen) { |
| 730 | return (RsMessageToClientType)mIO.getClientPayload(data, receiveLen, subID, bufferLen); |
Jason Sams | 8c401ef | 2009-10-06 13:58:47 -0700 | [diff] [blame] | 731 | } |
| 732 | |
Jason Sams | 87319de | 2010-11-22 16:20:16 -0800 | [diff] [blame] | 733 | bool Context::sendMessageToClient(const void *data, RsMessageToClientType cmdID, |
| 734 | uint32_t subID, size_t len, bool waitForSpace) const { |
Jason Sams | 1a4efa3 | 2011-05-17 15:01:29 -0700 | [diff] [blame] | 735 | |
Jason Sams | 4961cce | 2013-04-11 16:11:46 -0700 | [diff] [blame^] | 736 | pthread_mutex_lock(&gMessageMutex); |
| 737 | bool ret = mIO.sendToClient(cmdID, subID, data, len, waitForSpace); |
| 738 | pthread_mutex_unlock(&gMessageMutex); |
| 739 | return ret; |
Jason Sams | 8c401ef | 2009-10-06 13:58:47 -0700 | [diff] [blame] | 740 | } |
| 741 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 742 | void Context::initToClient() { |
| 743 | while (!mRunning) { |
Jason Sams | 8c401ef | 2009-10-06 13:58:47 -0700 | [diff] [blame] | 744 | usleep(100); |
| 745 | } |
| 746 | } |
| 747 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 748 | void Context::deinitToClient() { |
Jason Sams | 1a4efa3 | 2011-05-17 15:01:29 -0700 | [diff] [blame] | 749 | mIO.clientShutdown(); |
Jason Sams | 8c401ef | 2009-10-06 13:58:47 -0700 | [diff] [blame] | 750 | } |
Jason Sams | 5086938 | 2009-08-18 17:07:09 -0700 | [diff] [blame] | 751 | |
Jason Sams | 87319de | 2010-11-22 16:20:16 -0800 | [diff] [blame] | 752 | void Context::setError(RsError e, const char *msg) const { |
Jason Sams | a2cf755 | 2010-03-03 13:03:18 -0800 | [diff] [blame] | 753 | mError = e; |
Jason Sams | aad4bc5 | 2010-11-08 17:06:46 -0800 | [diff] [blame] | 754 | sendMessageToClient(msg, RS_MESSAGE_TO_CLIENT_ERROR, e, strlen(msg) + 1, true); |
Jason Sams | a2cf755 | 2010-03-03 13:03:18 -0800 | [diff] [blame] | 755 | } |
| 756 | |
| 757 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 758 | void Context::dumpDebug() const { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 759 | ALOGE("RS Context debug %p", this); |
| 760 | ALOGE("RS Context debug"); |
Jason Sams | 13e2634 | 2009-11-24 12:26:35 -0800 | [diff] [blame] | 761 | |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 762 | ALOGE(" RS width %i, height %i", mWidth, mHeight); |
| 763 | ALOGE(" RS running %i, exit %i, paused %i", mRunning, mExit, mPaused); |
| 764 | ALOGE(" RS pThreadID %li, nativeThreadID %i", (long int)mThreadId, mNativeThreadId); |
Jason Sams | 13e2634 | 2009-11-24 12:26:35 -0800 | [diff] [blame] | 765 | } |
Jason Sams | a4a54e4 | 2009-06-10 18:39:40 -0700 | [diff] [blame] | 766 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 767 | /////////////////////////////////////////////////////////////////////////////////////////// |
Jason Sams | a44cb29 | 2009-06-04 17:58:03 -0700 | [diff] [blame] | 768 | // |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 769 | |
| 770 | namespace android { |
| 771 | namespace renderscript { |
| 772 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 773 | void rsi_ContextFinish(Context *rsc) { |
Jason Sams | 8c88090 | 2010-06-15 12:15:57 -0700 | [diff] [blame] | 774 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 775 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 776 | void rsi_ContextBindRootScript(Context *rsc, RsScript vs) { |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 777 | #ifndef RS_COMPATIBILITY_LIB |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 778 | Script *s = static_cast<Script *>(vs); |
| 779 | rsc->setRootScript(s); |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 780 | #endif |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 781 | } |
| 782 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 783 | void rsi_ContextBindSampler(Context *rsc, uint32_t slot, RsSampler vs) { |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 784 | Sampler *s = static_cast<Sampler *>(vs); |
| 785 | |
| 786 | if (slot > RS_MAX_SAMPLER_SLOT) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 787 | ALOGE("Invalid sampler slot"); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 788 | return; |
| 789 | } |
| 790 | |
| 791 | s->bindToContext(&rsc->mStateSampler, slot); |
| 792 | } |
| 793 | |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 794 | #ifndef RS_COMPATIBILITY_LIB |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 795 | void rsi_ContextBindProgramStore(Context *rsc, RsProgramStore vpfs) { |
Jason Sams | ccc010b | 2010-05-13 18:30:11 -0700 | [diff] [blame] | 796 | ProgramStore *pfs = static_cast<ProgramStore *>(vpfs); |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 797 | rsc->setProgramStore(pfs); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 798 | } |
| 799 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 800 | void rsi_ContextBindProgramFragment(Context *rsc, RsProgramFragment vpf) { |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 801 | ProgramFragment *pf = static_cast<ProgramFragment *>(vpf); |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 802 | rsc->setProgramFragment(pf); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 803 | } |
| 804 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 805 | void rsi_ContextBindProgramRaster(Context *rsc, RsProgramRaster vpr) { |
Jason Sams | 5fd09d8 | 2009-09-23 13:57:02 -0700 | [diff] [blame] | 806 | ProgramRaster *pr = static_cast<ProgramRaster *>(vpr); |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 807 | rsc->setProgramRaster(pr); |
Jason Sams | 5fd09d8 | 2009-09-23 13:57:02 -0700 | [diff] [blame] | 808 | } |
| 809 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 810 | void rsi_ContextBindProgramVertex(Context *rsc, RsProgramVertex vpv) { |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 811 | ProgramVertex *pv = static_cast<ProgramVertex *>(vpv); |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 812 | rsc->setProgramVertex(pv); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 813 | } |
| 814 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 815 | void rsi_ContextBindFont(Context *rsc, RsFont vfont) { |
Alex Sakhartchouk | d3e0ad4 | 2010-06-24 17:15:34 -0700 | [diff] [blame] | 816 | Font *font = static_cast<Font *>(vfont); |
| 817 | rsc->setFont(font); |
| 818 | } |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 819 | #endif |
Alex Sakhartchouk | d3e0ad4 | 2010-06-24 17:15:34 -0700 | [diff] [blame] | 820 | |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 821 | void rsi_AssignName(Context *rsc, RsObjectBase obj, const char *name, size_t name_length) { |
Jason Sams | a0a1b6f | 2009-06-10 15:04:38 -0700 | [diff] [blame] | 822 | ObjectBase *ob = static_cast<ObjectBase *>(obj); |
Alex Sakhartchouk | 70b83c1 | 2011-04-06 10:57:51 -0700 | [diff] [blame] | 823 | rsc->assignName(ob, name, name_length); |
Jason Sams | a0a1b6f | 2009-06-10 15:04:38 -0700 | [diff] [blame] | 824 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 825 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 826 | void rsi_ObjDestroy(Context *rsc, void *optr) { |
Jason Sams | 2353ae3 | 2010-10-14 17:48:46 -0700 | [diff] [blame] | 827 | ObjectBase *ob = static_cast<ObjectBase *>(optr); |
Jason Sams | 707aaf3 | 2009-08-18 14:14:24 -0700 | [diff] [blame] | 828 | rsc->removeName(ob); |
Jason Sams | 9397e30 | 2009-08-27 20:23:34 -0700 | [diff] [blame] | 829 | ob->decUserRef(); |
Jason Sams | 707aaf3 | 2009-08-18 14:14:24 -0700 | [diff] [blame] | 830 | } |
| 831 | |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 832 | #ifndef RS_COMPATIBILITY_LIB |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 833 | void rsi_ContextPause(Context *rsc) { |
Jason Sams | 86f1b23 | 2009-09-24 17:38:20 -0700 | [diff] [blame] | 834 | rsc->pause(); |
| 835 | } |
| 836 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 837 | void rsi_ContextResume(Context *rsc) { |
Jason Sams | 86f1b23 | 2009-09-24 17:38:20 -0700 | [diff] [blame] | 838 | rsc->resume(); |
| 839 | } |
| 840 | |
Alex Sakhartchouk | 7257c7e | 2011-05-17 12:32:47 -0700 | [diff] [blame] | 841 | void rsi_ContextSetSurface(Context *rsc, uint32_t w, uint32_t h, RsNativeWindow sur) { |
Mathias Agopian | fa40286 | 2010-02-12 14:04:35 -0800 | [diff] [blame] | 842 | rsc->setSurface(w, h, sur); |
Jason Sams | 613cad1 | 2009-11-12 15:10:25 -0800 | [diff] [blame] | 843 | } |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 844 | #endif |
Jason Sams | 613cad1 | 2009-11-12 15:10:25 -0800 | [diff] [blame] | 845 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 846 | void rsi_ContextSetPriority(Context *rsc, int32_t p) { |
Jason Sams | 1583244 | 2009-11-15 12:14:26 -0800 | [diff] [blame] | 847 | rsc->setPriority(p); |
Jason Sams | 458f2dc | 2009-11-03 13:58:36 -0800 | [diff] [blame] | 848 | } |
| 849 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 850 | void rsi_ContextDump(Context *rsc, int32_t bits) { |
Jason Sams | c21cf40 | 2009-11-17 17:26:46 -0800 | [diff] [blame] | 851 | ObjectBase::dumpAll(rsc); |
| 852 | } |
| 853 | |
Jason Sams | 741aac9 | 2010-12-24 14:38:39 -0800 | [diff] [blame] | 854 | void rsi_ContextDestroyWorker(Context *rsc) { |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 855 | rsc->destroyWorkerThreadResources(); |
Jason Sams | 741aac9 | 2010-12-24 14:38:39 -0800 | [diff] [blame] | 856 | } |
| 857 | |
Jason Sams | c975cf4 | 2011-04-28 18:26:48 -0700 | [diff] [blame] | 858 | void rsi_ContextDestroy(Context *rsc) { |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 859 | ALOGV("%p rsContextDestroy", rsc); |
Jason Sams | 741aac9 | 2010-12-24 14:38:39 -0800 | [diff] [blame] | 860 | rsContextDestroyWorker(rsc); |
Jason Sams | 1dcefab | 2010-12-09 12:19:46 -0800 | [diff] [blame] | 861 | delete rsc; |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 862 | ALOGV("%p rsContextDestroy done", rsc); |
Jason Sams | 1dcefab | 2010-12-09 12:19:46 -0800 | [diff] [blame] | 863 | } |
| 864 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 865 | |
Jason Sams | c975cf4 | 2011-04-28 18:26:48 -0700 | [diff] [blame] | 866 | RsMessageToClientType rsi_ContextPeekMessage(Context *rsc, |
Jason Sams | 186e591 | 2011-04-26 14:50:00 -0700 | [diff] [blame] | 867 | size_t * receiveLen, size_t receiveLen_length, |
Jason Sams | 1a4efa3 | 2011-05-17 15:01:29 -0700 | [diff] [blame] | 868 | uint32_t * subID, size_t subID_length) { |
| 869 | return rsc->peekMessageToClient(receiveLen, subID); |
Jason Sams | aad4bc5 | 2010-11-08 17:06:46 -0800 | [diff] [blame] | 870 | } |
| 871 | |
Jason Sams | c975cf4 | 2011-04-28 18:26:48 -0700 | [diff] [blame] | 872 | RsMessageToClientType rsi_ContextGetMessage(Context *rsc, void * data, size_t data_length, |
Jason Sams | 186e591 | 2011-04-26 14:50:00 -0700 | [diff] [blame] | 873 | size_t * receiveLen, size_t receiveLen_length, |
Jason Sams | 1a4efa3 | 2011-05-17 15:01:29 -0700 | [diff] [blame] | 874 | uint32_t * subID, size_t subID_length) { |
Jason Sams | 186e591 | 2011-04-26 14:50:00 -0700 | [diff] [blame] | 875 | rsAssert(subID_length == sizeof(uint32_t)); |
| 876 | rsAssert(receiveLen_length == sizeof(size_t)); |
Jason Sams | 1a4efa3 | 2011-05-17 15:01:29 -0700 | [diff] [blame] | 877 | return rsc->getMessageToClient(data, receiveLen, subID, data_length); |
Jason Sams | 8c401ef | 2009-10-06 13:58:47 -0700 | [diff] [blame] | 878 | } |
| 879 | |
Jason Sams | c975cf4 | 2011-04-28 18:26:48 -0700 | [diff] [blame] | 880 | void rsi_ContextInitToClient(Context *rsc) { |
Jason Sams | 8c401ef | 2009-10-06 13:58:47 -0700 | [diff] [blame] | 881 | rsc->initToClient(); |
| 882 | } |
| 883 | |
Jason Sams | c975cf4 | 2011-04-28 18:26:48 -0700 | [diff] [blame] | 884 | void rsi_ContextDeinitToClient(Context *rsc) { |
Jason Sams | 8c401ef | 2009-10-06 13:58:47 -0700 | [diff] [blame] | 885 | rsc->deinitToClient(); |
| 886 | } |
| 887 | |
Jason Sams | 7026520 | 2013-02-05 19:20:47 -0800 | [diff] [blame] | 888 | void rsi_ContextSendMessage(Context *rsc, uint32_t id, const uint8_t *data, size_t len) { |
| 889 | rsc->sendMessageToClient(data, RS_MESSAGE_TO_CLIENT_USER, id, len, true); |
| 890 | } |
| 891 | |
Jason Sams | c975cf4 | 2011-04-28 18:26:48 -0700 | [diff] [blame] | 892 | } |
| 893 | } |
| 894 | |
Jason Sams | 14982c8 | 2013-02-22 18:17:05 -0800 | [diff] [blame] | 895 | RsContext rsContextCreate(RsDevice vdev, uint32_t version, uint32_t sdkVersion, |
| 896 | RsContextType ct, bool forceCpu, bool synchronous) { |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 897 | ALOGV("rsContextCreate dev=%p", vdev); |
Jason Sams | 789ca83 | 2011-05-18 17:36:02 -0700 | [diff] [blame] | 898 | Device * dev = static_cast<Device *>(vdev); |
Tim Murray | 4d252d6 | 2012-11-29 14:37:59 -0800 | [diff] [blame] | 899 | Context *rsc = Context::createContext(dev, NULL, forceCpu, synchronous); |
Stephen Hines | cbb0b8a | 2011-08-01 15:02:34 -0700 | [diff] [blame] | 900 | if (rsc) { |
| 901 | rsc->setTargetSdkVersion(sdkVersion); |
| 902 | } |
Jason Sams | 789ca83 | 2011-05-18 17:36:02 -0700 | [diff] [blame] | 903 | return rsc; |
| 904 | } |
| 905 | |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 906 | #ifndef RS_COMPATIBILITY_LIB |
Jason Sams | 789ca83 | 2011-05-18 17:36:02 -0700 | [diff] [blame] | 907 | RsContext rsContextCreateGL(RsDevice vdev, uint32_t version, |
Stephen Hines | cbb0b8a | 2011-08-01 15:02:34 -0700 | [diff] [blame] | 908 | uint32_t sdkVersion, RsSurfaceConfig sc, |
| 909 | uint32_t dpi) { |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 910 | ALOGV("rsContextCreateGL dev=%p", vdev); |
Jason Sams | 789ca83 | 2011-05-18 17:36:02 -0700 | [diff] [blame] | 911 | Device * dev = static_cast<Device *>(vdev); |
| 912 | Context *rsc = Context::createContext(dev, &sc); |
Jason Sams | 9544f76 | 2011-07-13 16:09:42 -0700 | [diff] [blame] | 913 | if (rsc) { |
Stephen Hines | cbb0b8a | 2011-08-01 15:02:34 -0700 | [diff] [blame] | 914 | rsc->setTargetSdkVersion(sdkVersion); |
Jason Sams | 9544f76 | 2011-07-13 16:09:42 -0700 | [diff] [blame] | 915 | rsc->setDPI(dpi); |
| 916 | } |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 917 | ALOGV("%p rsContextCreateGL ret", rsc); |
Jason Sams | 789ca83 | 2011-05-18 17:36:02 -0700 | [diff] [blame] | 918 | return rsc; |
| 919 | } |
Jason Sams | 93eacc7 | 2012-12-18 14:26:57 -0800 | [diff] [blame] | 920 | #endif |
Jason Sams | 789ca83 | 2011-05-18 17:36:02 -0700 | [diff] [blame] | 921 | |
Alex Sakhartchouk | dc763f3 | 2010-10-27 14:10:07 -0700 | [diff] [blame] | 922 | // Only to be called at a3d load time, before object is visible to user |
| 923 | // not thread safe |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 924 | void rsaGetName(RsContext con, void * obj, const char **name) { |
Alex Sakhartchouk | dc763f3 | 2010-10-27 14:10:07 -0700 | [diff] [blame] | 925 | ObjectBase *ob = static_cast<ObjectBase *>(obj); |
| 926 | (*name) = ob->getName(); |
| 927 | } |