Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2009 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include "rsContext.h" |
| 18 | #include "rsScriptC.h" |
| 19 | #include "rsMatrix.h" |
Joe Onorato | 9c4e4ca | 2009-08-09 11:39:02 -0700 | [diff] [blame] | 20 | #include "utils/Timers.h" |
Alex Sakhartchouk | b26fb04 | 2010-09-24 15:18:12 -0700 | [diff] [blame] | 21 | #include "utils/StopWatch.h" |
Shih-wei Liao | ce8a079 | 2010-12-20 20:45:56 +0800 | [diff] [blame] | 22 | extern "C" { |
| 23 | #include "libdex/ZipArchive.h" |
| 24 | } |
Jack Palevich | 1ef8b80 | 2009-05-28 15:53:04 -0700 | [diff] [blame] | 25 | |
Jason Sams | 1aa5a4e | 2009-06-22 17:15:15 -0700 | [diff] [blame] | 26 | #include <GLES/gl.h> |
| 27 | #include <GLES/glext.h> |
| 28 | |
Alex Sakhartchouk | 02000b3 | 2011-02-25 09:34:33 -0800 | [diff] [blame] | 29 | #include <bcc/bcc.h> |
| 30 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 31 | using namespace android; |
| 32 | using namespace android::renderscript; |
| 33 | |
Jason Sams | e576910 | 2009-06-19 16:03:18 -0700 | [diff] [blame] | 34 | #define GET_TLS() Context::ScriptTLSStruct * tls = \ |
| 35 | (Context::ScriptTLSStruct *)pthread_getspecific(Context::gThreadTLSKey); \ |
| 36 | Context * rsc = tls->mContext; \ |
| 37 | ScriptC * sc = (ScriptC *) tls->mScript |
| 38 | |
Shih-wei Liao | 2b2e621 | 2011-01-14 06:21:28 -0800 | [diff] [blame] | 39 | // Input: cacheDir |
| 40 | // Input: resName |
| 41 | // Input: extName |
| 42 | // |
| 43 | // Note: cacheFile = resName + extName |
| 44 | // |
| 45 | // Output: Returns cachePath == cacheDir + cacheFile |
| 46 | char *genCacheFileName(const char *cacheDir, |
| 47 | const char *resName, |
| 48 | const char *extName) { |
| 49 | char cachePath[512]; |
| 50 | char cacheFile[sizeof(cachePath)]; |
| 51 | const size_t kBufLen = sizeof(cachePath) - 1; |
| 52 | |
| 53 | cacheFile[0] = '\0'; |
| 54 | // Note: resName today is usually something like |
| 55 | // "/com.android.fountain:raw/fountain" |
| 56 | if (resName[0] != '/') { |
| 57 | // Get the absolute path of the raw/***.bc file. |
| 58 | |
| 59 | // Generate the absolute path. This doesn't do everything it |
| 60 | // should, e.g. if resName is "./out/whatever" it doesn't crunch |
| 61 | // the leading "./" out because this if-block is not triggered, |
| 62 | // but it'll make do. |
| 63 | // |
| 64 | if (getcwd(cacheFile, kBufLen) == NULL) { |
| 65 | LOGE("Can't get CWD while opening raw/***.bc file\n"); |
| 66 | return NULL; |
| 67 | } |
| 68 | // Append "/" at the end of cacheFile so far. |
| 69 | strncat(cacheFile, "/", kBufLen); |
| 70 | } |
| 71 | |
| 72 | // cacheFile = resName + extName |
| 73 | // |
| 74 | strncat(cacheFile, resName, kBufLen); |
| 75 | if (extName != NULL) { |
| 76 | // TODO(srhines): strncat() is a bit dangerous |
| 77 | strncat(cacheFile, extName, kBufLen); |
| 78 | } |
| 79 | |
| 80 | // Turn the path into a flat filename by replacing |
| 81 | // any slashes after the first one with '@' characters. |
| 82 | char *cp = cacheFile + 1; |
| 83 | while (*cp != '\0') { |
| 84 | if (*cp == '/') { |
| 85 | *cp = '@'; |
| 86 | } |
| 87 | cp++; |
| 88 | } |
| 89 | |
| 90 | // Tack on the file name for the actual cache file path. |
| 91 | strncpy(cachePath, cacheDir, kBufLen); |
| 92 | strncat(cachePath, cacheFile, kBufLen); |
| 93 | |
| 94 | LOGV("Cache file for '%s' '%s' is '%s'\n", resName, extName, cachePath); |
| 95 | return strdup(cachePath); |
| 96 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 97 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 98 | ScriptC::ScriptC(Context *rsc) : Script(rsc) { |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 99 | mBccScript = NULL; |
Jason Sams | efb8de1 | 2009-06-08 15:20:31 -0700 | [diff] [blame] | 100 | memset(&mProgram, 0, sizeof(mProgram)); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 101 | } |
| 102 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 103 | ScriptC::~ScriptC() { |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 104 | if (mBccScript) { |
Jason Sams | 2e8665d | 2011-01-27 00:14:13 -0800 | [diff] [blame] | 105 | if (mProgram.mObjectSlotList) { |
| 106 | for (size_t ct=0; ct < mProgram.mObjectSlotCount; ct++) { |
| 107 | setVarObj(mProgram.mObjectSlotList[ct], NULL); |
| 108 | } |
| 109 | delete [] mProgram.mObjectSlotList; |
| 110 | mProgram.mObjectSlotList = NULL; |
| 111 | mProgram.mObjectSlotCount = 0; |
| 112 | } |
| 113 | |
| 114 | |
| 115 | LOGD(">>>> ~ScriptC bccDisposeScript(%p)", mBccScript); |
Shih-wei Liao | 2b2e621 | 2011-01-14 06:21:28 -0800 | [diff] [blame] | 116 | bccDisposeScript(mBccScript); |
Jack Palevich | 1ef8b80 | 2009-05-28 15:53:04 -0700 | [diff] [blame] | 117 | } |
Jason Sams | e402ed3 | 2009-11-03 11:25:42 -0800 | [diff] [blame] | 118 | free(mEnviroment.mScriptText); |
| 119 | mEnviroment.mScriptText = NULL; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 120 | } |
| 121 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 122 | void ScriptC::setupScript(Context *rsc) { |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 123 | mEnviroment.mStartTimeMillis |
| 124 | = nanoseconds_to_milliseconds(systemTime(SYSTEM_TIME_MONOTONIC)); |
| 125 | |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 126 | for (uint32_t ct=0; ct < mEnviroment.mFieldCount; ct++) { |
Jason Sams | 900f161 | 2010-09-16 18:18:29 -0700 | [diff] [blame] | 127 | if (mSlots[ct].get() && !mTypes[ct].get()) { |
| 128 | mTypes[ct].set(mSlots[ct]->getType()); |
| 129 | } |
| 130 | |
| 131 | if (!mTypes[ct].get()) |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 132 | continue; |
Jason Sams | 900f161 | 2010-09-16 18:18:29 -0700 | [diff] [blame] | 133 | void *ptr = NULL; |
| 134 | if (mSlots[ct].get()) { |
| 135 | ptr = mSlots[ct]->getPtr(); |
| 136 | } |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 137 | void **dest = ((void ***)mEnviroment.mFieldAddress)[ct]; |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 138 | |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 139 | if (rsc->props.mLogScripts) { |
Jason Sams | 2fad7e4 | 2010-11-16 12:19:26 -0800 | [diff] [blame] | 140 | if (mSlots[ct].get() != NULL) { |
| 141 | LOGV("%p ScriptC::setupScript slot=%i dst=%p src=%p type=%p", rsc, ct, dest, ptr, mSlots[ct]->getType()); |
| 142 | } else { |
| 143 | LOGV("%p ScriptC::setupScript slot=%i dst=%p src=%p type=null", rsc, ct, dest, ptr); |
| 144 | } |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 145 | } |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 146 | |
| 147 | if (dest) { |
| 148 | *dest = ptr; |
Jason Sams | ada7f27 | 2009-09-24 14:55:38 -0700 | [diff] [blame] | 149 | } |
| 150 | } |
| 151 | } |
| 152 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 153 | const Allocation *ScriptC::ptrToAllocation(const void *ptr) const { |
Jason Sams | ce92d4b | 2010-05-17 14:55:34 -0700 | [diff] [blame] | 154 | if (!ptr) { |
| 155 | return NULL; |
| 156 | } |
| 157 | for (uint32_t ct=0; ct < mEnviroment.mFieldCount; ct++) { |
| 158 | if (!mSlots[ct].get()) |
| 159 | continue; |
| 160 | if (mSlots[ct]->getPtr() == ptr) { |
| 161 | return mSlots[ct].get(); |
| 162 | } |
| 163 | } |
| 164 | LOGE("ScriptC::ptrToAllocation, failed to find %p", ptr); |
| 165 | return NULL; |
| 166 | } |
| 167 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 168 | Script * ScriptC::setTLS(Script *sc) { |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 169 | Context::ScriptTLSStruct * tls = (Context::ScriptTLSStruct *) |
| 170 | pthread_getspecific(Context::gThreadTLSKey); |
| 171 | rsAssert(tls); |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 172 | Script *old = tls->mScript; |
| 173 | tls->mScript = sc; |
| 174 | return old; |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 175 | } |
| 176 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 177 | void ScriptC::setupGLState(Context *rsc) { |
Jason Sams | a0a1b6f | 2009-06-10 15:04:38 -0700 | [diff] [blame] | 178 | if (mEnviroment.mFragmentStore.get()) { |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 179 | rsc->setProgramStore(mEnviroment.mFragmentStore.get()); |
Jason Sams | a0a1b6f | 2009-06-10 15:04:38 -0700 | [diff] [blame] | 180 | } |
| 181 | if (mEnviroment.mFragment.get()) { |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 182 | rsc->setProgramFragment(mEnviroment.mFragment.get()); |
Jason Sams | a0a1b6f | 2009-06-10 15:04:38 -0700 | [diff] [blame] | 183 | } |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 184 | if (mEnviroment.mVertex.get()) { |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 185 | rsc->setProgramVertex(mEnviroment.mVertex.get()); |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 186 | } |
Jason Sams | b681c8a | 2009-09-28 18:12:56 -0700 | [diff] [blame] | 187 | if (mEnviroment.mRaster.get()) { |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 188 | rsc->setProgramRaster(mEnviroment.mRaster.get()); |
Jason Sams | b681c8a | 2009-09-28 18:12:56 -0700 | [diff] [blame] | 189 | } |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 190 | } |
Jason Sams | a0a1b6f | 2009-06-10 15:04:38 -0700 | [diff] [blame] | 191 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 192 | uint32_t ScriptC::run(Context *rsc) { |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 193 | if (mProgram.mRoot == NULL) { |
| 194 | rsc->setError(RS_ERROR_BAD_SCRIPT, "Attempted to run bad script"); |
| 195 | return 0; |
Joe Onorato | 9c4e4ca | 2009-08-09 11:39:02 -0700 | [diff] [blame] | 196 | } |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 197 | |
Jason Sams | 1f24db4 | 2010-12-11 17:42:30 -0800 | [diff] [blame] | 198 | setupGLState(rsc); |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 199 | setupScript(rsc); |
Jason Sams | 1d54f10 | 2009-09-03 15:43:13 -0700 | [diff] [blame] | 200 | |
Jason Sams | 2dca84d | 2009-12-09 11:05:45 -0800 | [diff] [blame] | 201 | uint32_t ret = 0; |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 202 | Script * oldTLS = setTLS(this); |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 203 | |
| 204 | if (rsc->props.mLogScripts) { |
| 205 | LOGV("%p ScriptC::run invoking root, ptr %p", rsc, mProgram.mRoot); |
| 206 | } |
| 207 | |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 208 | ret = mProgram.mRoot(); |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 209 | |
| 210 | if (rsc->props.mLogScripts) { |
| 211 | LOGV("%p ScriptC::run invoking complete, ret=%i", rsc, ret); |
| 212 | } |
| 213 | |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 214 | setTLS(oldTLS); |
Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 215 | return ret; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 216 | } |
| 217 | |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 218 | typedef struct { |
| 219 | Context *rsc; |
| 220 | ScriptC *script; |
| 221 | const Allocation * ain; |
| 222 | Allocation * aout; |
| 223 | const void * usr; |
| 224 | |
| 225 | uint32_t mSliceSize; |
| 226 | volatile int mSliceNum; |
| 227 | |
| 228 | const uint8_t *ptrIn; |
| 229 | uint32_t eStrideIn; |
| 230 | uint8_t *ptrOut; |
| 231 | uint32_t eStrideOut; |
| 232 | |
| 233 | uint32_t xStart; |
| 234 | uint32_t xEnd; |
| 235 | uint32_t yStart; |
| 236 | uint32_t yEnd; |
| 237 | uint32_t zStart; |
| 238 | uint32_t zEnd; |
| 239 | uint32_t arrayStart; |
| 240 | uint32_t arrayEnd; |
| 241 | |
| 242 | uint32_t dimX; |
| 243 | uint32_t dimY; |
| 244 | uint32_t dimZ; |
| 245 | uint32_t dimArray; |
| 246 | } MTLaunchStruct; |
| 247 | typedef int (*rs_t)(const void *, void *, const void *, uint32_t, uint32_t, uint32_t, uint32_t); |
| 248 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 249 | static void wc_xy(void *usr, uint32_t idx) { |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 250 | MTLaunchStruct *mtls = (MTLaunchStruct *)usr; |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 251 | |
| 252 | while (1) { |
| 253 | uint32_t slice = (uint32_t)android_atomic_inc(&mtls->mSliceNum); |
| 254 | uint32_t yStart = mtls->yStart + slice * mtls->mSliceSize; |
| 255 | uint32_t yEnd = yStart + mtls->mSliceSize; |
| 256 | yEnd = rsMin(yEnd, mtls->yEnd); |
| 257 | if (yEnd <= yStart) { |
| 258 | return; |
| 259 | } |
| 260 | |
| 261 | //LOGE("usr idx %i, x %i,%i y %i,%i", idx, mtls->xStart, mtls->xEnd, yStart, yEnd); |
Jason Sams | 8d957fa | 2010-09-28 14:41:22 -0700 | [diff] [blame] | 262 | //LOGE("usr ptr in %p, out %p", mtls->ptrIn, mtls->ptrOut); |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 263 | for (uint32_t y = yStart; y < yEnd; y++) { |
| 264 | uint32_t offset = mtls->dimX * y; |
| 265 | uint8_t *xPtrOut = mtls->ptrOut + (mtls->eStrideOut * offset); |
| 266 | const uint8_t *xPtrIn = mtls->ptrIn + (mtls->eStrideIn * offset); |
| 267 | |
| 268 | for (uint32_t x = mtls->xStart; x < mtls->xEnd; x++) { |
| 269 | ((rs_t)mtls->script->mProgram.mRoot) (xPtrIn, xPtrOut, mtls->usr, x, y, 0, 0); |
| 270 | xPtrIn += mtls->eStrideIn; |
| 271 | xPtrOut += mtls->eStrideOut; |
| 272 | } |
| 273 | } |
| 274 | } |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 275 | } |
| 276 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 277 | static void wc_x(void *usr, uint32_t idx) { |
Jason Sams | 177f844 | 2010-10-29 10:19:21 -0700 | [diff] [blame] | 278 | MTLaunchStruct *mtls = (MTLaunchStruct *)usr; |
| 279 | |
| 280 | while (1) { |
| 281 | uint32_t slice = (uint32_t)android_atomic_inc(&mtls->mSliceNum); |
| 282 | uint32_t xStart = mtls->xStart + slice * mtls->mSliceSize; |
| 283 | uint32_t xEnd = xStart + mtls->mSliceSize; |
| 284 | xEnd = rsMin(xEnd, mtls->xEnd); |
| 285 | if (xEnd <= xStart) { |
| 286 | return; |
| 287 | } |
| 288 | |
| 289 | //LOGE("usr idx %i, x %i,%i y %i,%i", idx, mtls->xStart, mtls->xEnd, yStart, yEnd); |
| 290 | //LOGE("usr ptr in %p, out %p", mtls->ptrIn, mtls->ptrOut); |
| 291 | uint8_t *xPtrOut = mtls->ptrOut + (mtls->eStrideOut * xStart); |
| 292 | const uint8_t *xPtrIn = mtls->ptrIn + (mtls->eStrideIn * xStart); |
| 293 | for (uint32_t x = xStart; x < xEnd; x++) { |
| 294 | ((rs_t)mtls->script->mProgram.mRoot) (xPtrIn, xPtrOut, mtls->usr, x, 0, 0, 0); |
| 295 | xPtrIn += mtls->eStrideIn; |
| 296 | xPtrOut += mtls->eStrideOut; |
| 297 | } |
| 298 | } |
Jason Sams | 177f844 | 2010-10-29 10:19:21 -0700 | [diff] [blame] | 299 | } |
| 300 | |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 301 | void ScriptC::runForEach(Context *rsc, |
| 302 | const Allocation * ain, |
| 303 | Allocation * aout, |
| 304 | const void * usr, |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 305 | const RsScriptCall *sc) { |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 306 | MTLaunchStruct mtls; |
| 307 | memset(&mtls, 0, sizeof(mtls)); |
Jason Sams | 6070925 | 2010-11-17 15:29:32 -0800 | [diff] [blame] | 308 | Context::PushState ps(rsc); |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 309 | |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 310 | if (ain) { |
| 311 | mtls.dimX = ain->getType()->getDimX(); |
| 312 | mtls.dimY = ain->getType()->getDimY(); |
| 313 | mtls.dimZ = ain->getType()->getDimZ(); |
| 314 | //mtls.dimArray = ain->getType()->getDimArray(); |
| 315 | } else if (aout) { |
| 316 | mtls.dimX = aout->getType()->getDimX(); |
| 317 | mtls.dimY = aout->getType()->getDimY(); |
| 318 | mtls.dimZ = aout->getType()->getDimZ(); |
| 319 | //mtls.dimArray = aout->getType()->getDimArray(); |
| 320 | } else { |
| 321 | rsc->setError(RS_ERROR_BAD_SCRIPT, "rsForEach called with null allocations"); |
| 322 | return; |
| 323 | } |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 324 | |
| 325 | if (!sc || (sc->xEnd == 0)) { |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 326 | mtls.xEnd = mtls.dimX; |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 327 | } else { |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 328 | rsAssert(sc->xStart < mtls.dimX); |
| 329 | rsAssert(sc->xEnd <= mtls.dimX); |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 330 | rsAssert(sc->xStart < sc->xEnd); |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 331 | mtls.xStart = rsMin(mtls.dimX, sc->xStart); |
| 332 | mtls.xEnd = rsMin(mtls.dimX, sc->xEnd); |
| 333 | if (mtls.xStart >= mtls.xEnd) return; |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 334 | } |
| 335 | |
| 336 | if (!sc || (sc->yEnd == 0)) { |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 337 | mtls.yEnd = mtls.dimY; |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 338 | } else { |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 339 | rsAssert(sc->yStart < mtls.dimY); |
| 340 | rsAssert(sc->yEnd <= mtls.dimY); |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 341 | rsAssert(sc->yStart < sc->yEnd); |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 342 | mtls.yStart = rsMin(mtls.dimY, sc->yStart); |
| 343 | mtls.yEnd = rsMin(mtls.dimY, sc->yEnd); |
| 344 | if (mtls.yStart >= mtls.yEnd) return; |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 345 | } |
| 346 | |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 347 | mtls.xEnd = rsMax((uint32_t)1, mtls.xEnd); |
| 348 | mtls.yEnd = rsMax((uint32_t)1, mtls.yEnd); |
| 349 | mtls.zEnd = rsMax((uint32_t)1, mtls.zEnd); |
| 350 | mtls.arrayEnd = rsMax((uint32_t)1, mtls.arrayEnd); |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 351 | |
| 352 | rsAssert(ain->getType()->getDimZ() == 0); |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 353 | |
Jason Sams | 1f24db4 | 2010-12-11 17:42:30 -0800 | [diff] [blame] | 354 | setupGLState(rsc); |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 355 | setupScript(rsc); |
| 356 | Script * oldTLS = setTLS(this); |
| 357 | |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 358 | mtls.rsc = rsc; |
| 359 | mtls.ain = ain; |
| 360 | mtls.aout = aout; |
| 361 | mtls.script = this; |
| 362 | mtls.usr = usr; |
| 363 | mtls.mSliceSize = 10; |
| 364 | mtls.mSliceNum = 0; |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 365 | |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 366 | mtls.ptrIn = NULL; |
| 367 | mtls.eStrideIn = 0; |
| 368 | if (ain) { |
| 369 | mtls.ptrIn = (const uint8_t *)ain->getPtr(); |
| 370 | mtls.eStrideIn = ain->getType()->getElementSizeBytes(); |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 371 | } |
| 372 | |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 373 | mtls.ptrOut = NULL; |
| 374 | mtls.eStrideOut = 0; |
| 375 | if (aout) { |
| 376 | mtls.ptrOut = (uint8_t *)aout->getPtr(); |
| 377 | mtls.eStrideOut = aout->getType()->getElementSizeBytes(); |
| 378 | } |
| 379 | |
Jason Sams | 177f844 | 2010-10-29 10:19:21 -0700 | [diff] [blame] | 380 | if ((rsc->getWorkerPoolSize() > 1) && mEnviroment.mIsThreadable) { |
| 381 | if (mtls.dimY > 1) { |
| 382 | rsc->launchThreads(wc_xy, &mtls); |
| 383 | } else { |
| 384 | rsc->launchThreads(wc_x, &mtls); |
| 385 | } |
Jason Sams | 1813340 | 2010-07-20 15:09:00 -0700 | [diff] [blame] | 386 | |
| 387 | //LOGE("launch 1"); |
Jason Sams | 1813340 | 2010-07-20 15:09:00 -0700 | [diff] [blame] | 388 | } else { |
Jason Sams | 8d957fa | 2010-09-28 14:41:22 -0700 | [diff] [blame] | 389 | //LOGE("launch 3"); |
Jason Sams | 1813340 | 2010-07-20 15:09:00 -0700 | [diff] [blame] | 390 | for (uint32_t ar = mtls.arrayStart; ar < mtls.arrayEnd; ar++) { |
| 391 | for (uint32_t z = mtls.zStart; z < mtls.zEnd; z++) { |
| 392 | for (uint32_t y = mtls.yStart; y < mtls.yEnd; y++) { |
| 393 | uint32_t offset = mtls.dimX * mtls.dimY * mtls.dimZ * ar + |
| 394 | mtls.dimX * mtls.dimY * z + |
| 395 | mtls.dimX * y; |
| 396 | uint8_t *xPtrOut = mtls.ptrOut + (mtls.eStrideOut * offset); |
| 397 | const uint8_t *xPtrIn = mtls.ptrIn + (mtls.eStrideIn * offset); |
Jason Sams | 7bf29dd | 2010-07-19 15:38:19 -0700 | [diff] [blame] | 398 | |
Jason Sams | 1813340 | 2010-07-20 15:09:00 -0700 | [diff] [blame] | 399 | for (uint32_t x = mtls.xStart; x < mtls.xEnd; x++) { |
| 400 | ((rs_t)mProgram.mRoot) (xPtrIn, xPtrOut, usr, x, y, z, ar); |
| 401 | xPtrIn += mtls.eStrideIn; |
| 402 | xPtrOut += mtls.eStrideOut; |
| 403 | } |
Jason Sams | ace3e01 | 2010-07-15 17:11:13 -0700 | [diff] [blame] | 404 | } |
| 405 | } |
| 406 | } |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 407 | } |
Jason Sams | 1813340 | 2010-07-20 15:09:00 -0700 | [diff] [blame] | 408 | |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 409 | setTLS(oldTLS); |
| 410 | } |
| 411 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 412 | void ScriptC::Invoke(Context *rsc, uint32_t slot, const void *data, uint32_t len) { |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 413 | if ((slot >= mEnviroment.mInvokeFunctionCount) || |
| 414 | (mEnviroment.mInvokeFunctions[slot] == NULL)) { |
| 415 | rsc->setError(RS_ERROR_BAD_SCRIPT, "Calling invoke on bad script"); |
| 416 | return; |
| 417 | } |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 418 | setupScript(rsc); |
| 419 | Script * oldTLS = setTLS(this); |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 420 | |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 421 | if (rsc->props.mLogScripts) { |
| 422 | LOGV("%p ScriptC::Invoke invoking slot %i, ptr %p", rsc, slot, mEnviroment.mInvokeFunctions[slot]); |
| 423 | } |
Jason Sams | 2a63bf6 | 2010-06-08 15:40:48 -0700 | [diff] [blame] | 424 | ((void (*)(const void *, uint32_t)) |
| 425 | mEnviroment.mInvokeFunctions[slot])(data, len); |
Jason Sams | b9077f4 | 2010-09-22 15:57:41 -0700 | [diff] [blame] | 426 | if (rsc->props.mLogScripts) { |
| 427 | LOGV("%p ScriptC::Invoke complete", rsc); |
| 428 | } |
Jason Sams | 2a63bf6 | 2010-06-08 15:40:48 -0700 | [diff] [blame] | 429 | |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 430 | setTLS(oldTLS); |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 431 | } |
| 432 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 433 | ScriptCState::ScriptCState() { |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 434 | } |
| 435 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 436 | ScriptCState::~ScriptCState() { |
Jason Sams | 1f52633 | 2009-06-05 17:35:09 -0700 | [diff] [blame] | 437 | } |
| 438 | |
Shih-wei Liao | 2b2e621 | 2011-01-14 06:21:28 -0800 | [diff] [blame] | 439 | static void* symbolLookup(void* pContext, char const* name) { |
Jason Sams | aeb094b | 2010-05-18 13:35:45 -0700 | [diff] [blame] | 440 | const ScriptCState::SymbolTable_t *sym; |
Jason Sams | dd663fa | 2010-08-11 13:26:28 -0700 | [diff] [blame] | 441 | ScriptC *s = (ScriptC *)pContext; |
Shih-wei Liao | f17b13b | 2010-12-07 13:44:10 -0800 | [diff] [blame] | 442 | if (!strcmp(name, "__isThreadable")) { |
Shih-wei Liao | 2b2e621 | 2011-01-14 06:21:28 -0800 | [diff] [blame] | 443 | return (void*) s->mEnviroment.mIsThreadable; |
Shih-wei Liao | f17b13b | 2010-12-07 13:44:10 -0800 | [diff] [blame] | 444 | } else if (!strcmp(name, "__clearThreadable")) { |
| 445 | s->mEnviroment.mIsThreadable = false; |
| 446 | return NULL; |
| 447 | } |
Jason Sams | aeb094b | 2010-05-18 13:35:45 -0700 | [diff] [blame] | 448 | sym = ScriptCState::lookupSymbol(name); |
Jason Sams | 6bfc1b9 | 2010-11-01 14:26:30 -0700 | [diff] [blame] | 449 | if (!sym) { |
| 450 | sym = ScriptCState::lookupSymbolCL(name); |
Jason Sams | aeb094b | 2010-05-18 13:35:45 -0700 | [diff] [blame] | 451 | } |
Jason Sams | 6bfc1b9 | 2010-11-01 14:26:30 -0700 | [diff] [blame] | 452 | if (!sym) { |
| 453 | sym = ScriptCState::lookupSymbolGL(name); |
Jason Sams | aeb094b | 2010-05-18 13:35:45 -0700 | [diff] [blame] | 454 | } |
Jason Sams | 29df66f | 2009-07-16 15:08:06 -0700 | [diff] [blame] | 455 | if (sym) { |
Jason Sams | 6bfc1b9 | 2010-11-01 14:26:30 -0700 | [diff] [blame] | 456 | s->mEnviroment.mIsThreadable &= sym->threadable; |
Jason Sams | 29df66f | 2009-07-16 15:08:06 -0700 | [diff] [blame] | 457 | return sym->mPtr; |
| 458 | } |
Jason Sams | 29df66f | 2009-07-16 15:08:06 -0700 | [diff] [blame] | 459 | LOGE("ScriptC sym lookup failed for %s", name); |
Jason Sams | 29df66f | 2009-07-16 15:08:06 -0700 | [diff] [blame] | 460 | return NULL; |
| 461 | } |
Jason Sams | a4a54e4 | 2009-06-10 18:39:40 -0700 | [diff] [blame] | 462 | |
Shih-wei Liao | 80761ec | 2011-01-16 02:23:04 -0800 | [diff] [blame] | 463 | #if 0 |
Shih-wei Liao | 1f9ba73 | 2010-10-23 02:15:57 -0700 | [diff] [blame] | 464 | extern const char rs_runtime_lib_bc[]; |
| 465 | extern unsigned rs_runtime_lib_bc_size; |
Shih-wei Liao | 80761ec | 2011-01-16 02:23:04 -0800 | [diff] [blame] | 466 | #endif |
Shih-wei Liao | 1f9ba73 | 2010-10-23 02:15:57 -0700 | [diff] [blame] | 467 | |
Jason Sams | 26b2c9f | 2011-01-19 16:14:21 -0800 | [diff] [blame] | 468 | bool ScriptCState::runCompiler(Context *rsc, |
Shih-wei Liao | ce8a079 | 2010-12-20 20:45:56 +0800 | [diff] [blame] | 469 | ScriptC *s, |
Shih-wei Liao | ce8a079 | 2010-12-20 20:45:56 +0800 | [diff] [blame] | 470 | const char *resName, |
| 471 | const char *cacheDir) { |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 472 | s->mBccScript = bccCreateScript(); |
Shih-wei Liao | 37150de | 2011-01-07 18:17:07 -0800 | [diff] [blame] | 473 | |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 474 | s->mEnviroment.mIsThreadable = true; |
Shih-wei Liao | 37150de | 2011-01-07 18:17:07 -0800 | [diff] [blame] | 475 | |
Shih-wei Liao | fa6113e | 2011-01-20 12:35:44 -0800 | [diff] [blame] | 476 | if (bccRegisterSymbolCallback(s->mBccScript, symbolLookup, s) != 0) { |
| 477 | LOGE("bcc: FAILS to register symbol callback"); |
| 478 | return false; |
| 479 | } |
Shih-wei Liao | 37150de | 2011-01-07 18:17:07 -0800 | [diff] [blame] | 480 | |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 481 | if (bccReadBC(s->mBccScript, |
| 482 | resName, |
| 483 | s->mEnviroment.mScriptText, |
| 484 | s->mEnviroment.mScriptTextLength, 0) != 0) { |
| 485 | LOGE("bcc: FAILS to read bitcode"); |
Jason Sams | 26b2c9f | 2011-01-19 16:14:21 -0800 | [diff] [blame] | 486 | return false; |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 487 | } |
Shih-wei Liao | 37150de | 2011-01-07 18:17:07 -0800 | [diff] [blame] | 488 | |
Shih-wei Liao | 5439184 | 2011-01-19 02:18:45 -0800 | [diff] [blame] | 489 | #if 1 |
Shih-wei Liao | afca6df | 2011-02-01 04:06:55 -0800 | [diff] [blame] | 490 | if (bccLinkFile(s->mBccScript, "/system/lib/libclcore.bc", 0) != 0) { |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 491 | LOGE("bcc: FAILS to link bitcode"); |
Jason Sams | 26b2c9f | 2011-01-19 16:14:21 -0800 | [diff] [blame] | 492 | return false; |
Alex Sakhartchouk | b26fb04 | 2010-09-24 15:18:12 -0700 | [diff] [blame] | 493 | } |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 494 | #endif |
| 495 | char *cachePath = genCacheFileName(cacheDir, resName, ".oBCC"); |
| 496 | |
| 497 | if (bccPrepareExecutable(s->mBccScript, cachePath, 0) != 0) { |
| 498 | LOGE("bcc: FAILS to prepare executable"); |
Jason Sams | 26b2c9f | 2011-01-19 16:14:21 -0800 | [diff] [blame] | 499 | return false; |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 500 | } |
| 501 | |
| 502 | free(cachePath); |
| 503 | |
| 504 | s->mProgram.mRoot = reinterpret_cast<int (*)()>(bccGetFuncAddr(s->mBccScript, "root")); |
| 505 | s->mProgram.mInit = reinterpret_cast<void (*)()>(bccGetFuncAddr(s->mBccScript, "init")); |
Jason Sams | f168504 | 2009-07-16 17:47:40 -0700 | [diff] [blame] | 506 | |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 507 | if (s->mProgram.mInit) { |
| 508 | s->mProgram.mInit(); |
Jason Sams | 1d54f10 | 2009-09-03 15:43:13 -0700 | [diff] [blame] | 509 | } |
| 510 | |
Shih-wei Liao | 2b2e621 | 2011-01-14 06:21:28 -0800 | [diff] [blame] | 511 | s->mEnviroment.mInvokeFunctionCount = bccGetExportFuncCount(s->mBccScript); |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 512 | if (s->mEnviroment.mInvokeFunctionCount <= 0) |
Jason Sams | 8c88090 | 2010-06-15 12:15:57 -0700 | [diff] [blame] | 513 | s->mEnviroment.mInvokeFunctions = NULL; |
| 514 | else { |
| 515 | s->mEnviroment.mInvokeFunctions = (Script::InvokeFunc_t*) calloc(s->mEnviroment.mInvokeFunctionCount, sizeof(Script::InvokeFunc_t)); |
Shih-wei Liao | 2b2e621 | 2011-01-14 06:21:28 -0800 | [diff] [blame] | 516 | bccGetExportFuncList(s->mBccScript, s->mEnviroment.mInvokeFunctionCount, (void **) s->mEnviroment.mInvokeFunctions); |
Jason Sams | 1d54f10 | 2009-09-03 15:43:13 -0700 | [diff] [blame] | 517 | } |
| 518 | |
Shih-wei Liao | 2b2e621 | 2011-01-14 06:21:28 -0800 | [diff] [blame] | 519 | s->mEnviroment.mFieldCount = bccGetExportVarCount(s->mBccScript); |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 520 | if (s->mEnviroment.mFieldCount <= 0) |
Shih-wei Liao | a226b16 | 2010-07-20 16:43:25 -0700 | [diff] [blame] | 521 | s->mEnviroment.mFieldAddress = NULL; |
| 522 | else { |
| 523 | s->mEnviroment.mFieldAddress = (void **) calloc(s->mEnviroment.mFieldCount, sizeof(void *)); |
Shih-wei Liao | 2b2e621 | 2011-01-14 06:21:28 -0800 | [diff] [blame] | 524 | bccGetExportVarList(s->mBccScript, s->mEnviroment.mFieldCount, (void **) s->mEnviroment.mFieldAddress); |
Alex Sakhartchouk | 700ba38 | 2010-10-08 15:00:05 -0700 | [diff] [blame] | 525 | s->initSlots(); |
Shih-wei Liao | a226b16 | 2010-07-20 16:43:25 -0700 | [diff] [blame] | 526 | } |
Jason Sams | a4a54e4 | 2009-06-10 18:39:40 -0700 | [diff] [blame] | 527 | |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 528 | s->mEnviroment.mFragment.set(rsc->getDefaultProgramFragment()); |
| 529 | s->mEnviroment.mVertex.set(rsc->getDefaultProgramVertex()); |
Jason Sams | ccc010b | 2010-05-13 18:30:11 -0700 | [diff] [blame] | 530 | s->mEnviroment.mFragmentStore.set(rsc->getDefaultProgramStore()); |
Jason Sams | b681c8a | 2009-09-28 18:12:56 -0700 | [diff] [blame] | 531 | s->mEnviroment.mRaster.set(rsc->getDefaultProgramRaster()); |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 532 | |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 533 | const static int pragmaMax = 16; |
| 534 | size_t pragmaCount = bccGetPragmaCount(s->mBccScript); |
| 535 | char const *keys[pragmaMax]; |
| 536 | char const *values[pragmaMax]; |
| 537 | bccGetPragmaList(s->mBccScript, pragmaMax, keys, values); |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 538 | |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 539 | for (size_t i=0; i < pragmaCount; ++i) { |
| 540 | //LOGE("pragma %s %s", keys[i], values[i]); |
| 541 | if (!strcmp(keys[i], "version")) { |
Stephen Hines | b5dc6af | 2011-01-18 14:10:44 -0800 | [diff] [blame] | 542 | if (!strcmp(values[i], "1")) { |
| 543 | continue; |
| 544 | } |
| 545 | LOGE("Invalid version pragma value: %s\n", values[i]); |
Jason Sams | 26b2c9f | 2011-01-19 16:14:21 -0800 | [diff] [blame] | 546 | return false; |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 547 | } |
| 548 | |
| 549 | if (!strcmp(keys[i], "stateVertex")) { |
| 550 | if (!strcmp(values[i], "default")) { |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 551 | continue; |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 552 | } |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 553 | if (!strcmp(values[i], "parent")) { |
| 554 | s->mEnviroment.mVertex.clear(); |
| 555 | continue; |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 556 | } |
Stephen Hines | b5dc6af | 2011-01-18 14:10:44 -0800 | [diff] [blame] | 557 | LOGE("Unrecognized value %s passed to stateVertex", values[i]); |
Jason Sams | 26b2c9f | 2011-01-19 16:14:21 -0800 | [diff] [blame] | 558 | return false; |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 559 | } |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 560 | |
| 561 | if (!strcmp(keys[i], "stateRaster")) { |
| 562 | if (!strcmp(values[i], "default")) { |
| 563 | continue; |
| 564 | } |
| 565 | if (!strcmp(values[i], "parent")) { |
| 566 | s->mEnviroment.mRaster.clear(); |
| 567 | continue; |
| 568 | } |
Stephen Hines | b5dc6af | 2011-01-18 14:10:44 -0800 | [diff] [blame] | 569 | LOGE("Unrecognized value %s passed to stateRaster", values[i]); |
Jason Sams | 26b2c9f | 2011-01-19 16:14:21 -0800 | [diff] [blame] | 570 | return false; |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 571 | } |
| 572 | |
| 573 | if (!strcmp(keys[i], "stateFragment")) { |
| 574 | if (!strcmp(values[i], "default")) { |
| 575 | continue; |
| 576 | } |
| 577 | if (!strcmp(values[i], "parent")) { |
| 578 | s->mEnviroment.mFragment.clear(); |
| 579 | continue; |
| 580 | } |
Stephen Hines | b5dc6af | 2011-01-18 14:10:44 -0800 | [diff] [blame] | 581 | LOGE("Unrecognized value %s passed to stateFragment", values[i]); |
Jason Sams | 26b2c9f | 2011-01-19 16:14:21 -0800 | [diff] [blame] | 582 | return false; |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 583 | } |
| 584 | |
| 585 | if (!strcmp(keys[i], "stateStore")) { |
| 586 | if (!strcmp(values[i], "default")) { |
| 587 | continue; |
| 588 | } |
| 589 | if (!strcmp(values[i], "parent")) { |
| 590 | s->mEnviroment.mFragmentStore.clear(); |
| 591 | continue; |
| 592 | } |
Stephen Hines | b5dc6af | 2011-01-18 14:10:44 -0800 | [diff] [blame] | 593 | LOGE("Unrecognized value %s passed to stateStore", values[i]); |
Jason Sams | 26b2c9f | 2011-01-19 16:14:21 -0800 | [diff] [blame] | 594 | return false; |
Stephen Hines | 7b337b1 | 2011-01-17 17:31:58 -0800 | [diff] [blame] | 595 | } |
Jason Sams | 1030893 | 2009-06-09 12:15:30 -0700 | [diff] [blame] | 596 | } |
Jason Sams | 2e8665d | 2011-01-27 00:14:13 -0800 | [diff] [blame] | 597 | |
| 598 | size_t objectSlotCount = bccGetObjectSlotCount(s->mBccScript); |
| 599 | uint32_t *objectSlots = NULL; |
| 600 | if (objectSlotCount) { |
| 601 | objectSlots = new uint32_t[objectSlotCount]; |
| 602 | bccGetObjectSlotList(s->mBccScript, objectSlotCount, objectSlots); |
| 603 | s->mProgram.mObjectSlotList = objectSlots; |
| 604 | s->mProgram.mObjectSlotCount = objectSlotCount; |
| 605 | } |
| 606 | |
Jason Sams | 26b2c9f | 2011-01-19 16:14:21 -0800 | [diff] [blame] | 607 | return true; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 608 | } |
| 609 | |
| 610 | namespace android { |
| 611 | namespace renderscript { |
| 612 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 613 | void rsi_ScriptCBegin(Context * rsc) { |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 614 | } |
| 615 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 616 | void rsi_ScriptCSetText(Context *rsc, const char *text, uint32_t len) { |
Jason Sams | 1f52633 | 2009-06-05 17:35:09 -0700 | [diff] [blame] | 617 | ScriptCState *ss = &rsc->mScriptC; |
Jason Sams | e402ed3 | 2009-11-03 11:25:42 -0800 | [diff] [blame] | 618 | |
| 619 | char *t = (char *)malloc(len + 1); |
| 620 | memcpy(t, text, len); |
| 621 | t[len] = 0; |
Jason Sams | 249d453 | 2011-01-23 17:48:45 -0800 | [diff] [blame] | 622 | ss->mScriptText = t; |
| 623 | ss->mScriptLen = len; |
Jason Sams | 1f52633 | 2009-06-05 17:35:09 -0700 | [diff] [blame] | 624 | } |
| 625 | |
Shih-wei Liao | ce8a079 | 2010-12-20 20:45:56 +0800 | [diff] [blame] | 626 | |
| 627 | RsScript rsi_ScriptCCreate(Context *rsc, |
Shih-wei Liao | 37150de | 2011-01-07 18:17:07 -0800 | [diff] [blame] | 628 | const char *packageName /* deprecated */, |
Shih-wei Liao | ce8a079 | 2010-12-20 20:45:56 +0800 | [diff] [blame] | 629 | const char *resName, |
| 630 | const char *cacheDir) |
Shih-wei Liao | 9503b66 | 2010-11-08 01:33:59 -0800 | [diff] [blame] | 631 | { |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 632 | ScriptCState *ss = &rsc->mScriptC; |
| 633 | |
Jason Sams | 249d453 | 2011-01-23 17:48:45 -0800 | [diff] [blame] | 634 | ScriptC *s = new ScriptC(rsc); |
| 635 | s->mEnviroment.mScriptText = ss->mScriptText; |
| 636 | s->mEnviroment.mScriptTextLength = ss->mScriptLen; |
| 637 | ss->mScriptText = NULL; |
| 638 | ss->mScriptLen = 0; |
Jason Sams | 225afd3 | 2010-10-21 14:06:55 -0700 | [diff] [blame] | 639 | s->incUserRef(); |
Jason Sams | 1f52633 | 2009-06-05 17:35:09 -0700 | [diff] [blame] | 640 | |
Jason Sams | 249d453 | 2011-01-23 17:48:45 -0800 | [diff] [blame] | 641 | if (!ss->runCompiler(rsc, s, resName, cacheDir)) { |
Jason Sams | 26b2c9f | 2011-01-19 16:14:21 -0800 | [diff] [blame] | 642 | // Error during compile, destroy s and return null. |
Jason Sams | 249d453 | 2011-01-23 17:48:45 -0800 | [diff] [blame] | 643 | delete s; |
Jason Sams | 26b2c9f | 2011-01-19 16:14:21 -0800 | [diff] [blame] | 644 | return NULL; |
| 645 | } |
Jason Sams | 249d453 | 2011-01-23 17:48:45 -0800 | [diff] [blame] | 646 | return s; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 647 | } |
| 648 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 649 | } |
| 650 | } |