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