Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 1 | /* |
Stephen Hines | 4419977 | 2012-02-21 20:13:12 -0800 | [diff] [blame] | 2 | * Copyright (C) 2009-2012 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 | |
| 17 | #include "rsContext.h" |
Stephen Hines | d2432b9 | 2011-11-09 18:02:20 -0800 | [diff] [blame] | 18 | #include <time.h> |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 19 | |
Chih-Hung Hsieh | 11496ac | 2016-11-15 15:14:05 -0800 | [diff] [blame] | 20 | namespace android { |
| 21 | namespace renderscript { |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 22 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 23 | Script::Script(Context *rsc) : ObjectBase(rsc) { |
Jason Sams | 928b734 | 2009-06-08 18:50:13 -0700 | [diff] [blame] | 24 | memset(&mEnviroment, 0, sizeof(mEnviroment)); |
Jason Sams | bad8074 | 2011-03-16 16:29:28 -0700 | [diff] [blame] | 25 | memset(&mHal, 0, sizeof(mHal)); |
Alex Sakhartchouk | 700ba38 | 2010-10-08 15:00:05 -0700 | [diff] [blame] | 26 | |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 27 | mSlots = nullptr; |
| 28 | mTypes = nullptr; |
Jason Sams | 77020c5 | 2011-11-22 12:49:11 -0800 | [diff] [blame] | 29 | mInitialized = false; |
Stephen Hines | c78839b | 2013-09-10 17:40:41 -0700 | [diff] [blame] | 30 | mHasObjectSlots = false; |
Stephen Hines | 5d95a78 | 2015-04-13 20:11:48 -0700 | [diff] [blame] | 31 | mApiLevel = 0; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 32 | } |
| 33 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 34 | Script::~Script() { |
| 35 | if (mSlots) { |
Alex Sakhartchouk | 700ba38 | 2010-10-08 15:00:05 -0700 | [diff] [blame] | 36 | delete [] mSlots; |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 37 | mSlots = nullptr; |
Alex Sakhartchouk | 700ba38 | 2010-10-08 15:00:05 -0700 | [diff] [blame] | 38 | } |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 39 | if (mTypes) { |
Alex Sakhartchouk | 700ba38 | 2010-10-08 15:00:05 -0700 | [diff] [blame] | 40 | delete [] mTypes; |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 41 | mTypes = nullptr; |
Alex Sakhartchouk | 700ba38 | 2010-10-08 15:00:05 -0700 | [diff] [blame] | 42 | } |
| 43 | } |
| 44 | |
Alex Sakhartchouk | 700ba38 | 2010-10-08 15:00:05 -0700 | [diff] [blame] | 45 | void Script::setSlot(uint32_t slot, Allocation *a) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 46 | //ALOGE("setSlot %i %p", slot, a); |
Jason Sams | bad8074 | 2011-03-16 16:29:28 -0700 | [diff] [blame] | 47 | if (slot >= mHal.info.exportedVariableCount) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 48 | ALOGE("Script::setSlot unable to set allocation, invalid slot index"); |
Alex Sakhartchouk | 700ba38 | 2010-10-08 15:00:05 -0700 | [diff] [blame] | 49 | return; |
| 50 | } |
| 51 | |
Jason Sams | 4efe3d3 | 2015-03-18 18:28:06 -0700 | [diff] [blame] | 52 | if (mRSC->hadFatalError()) return; |
| 53 | |
Alex Sakhartchouk | 700ba38 | 2010-10-08 15:00:05 -0700 | [diff] [blame] | 54 | mSlots[slot].set(a); |
Stephen Hines | c78839b | 2013-09-10 17:40:41 -0700 | [diff] [blame] | 55 | mHasObjectSlots = true; |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 56 | mRSC->mHal.funcs.script.setGlobalBind(mRSC, this, slot, a); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 57 | } |
| 58 | |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 59 | void Script::setVar(uint32_t slot, const void *val, size_t len) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 60 | //ALOGE("setVar %i %p %i", slot, val, len); |
Jason Sams | bad8074 | 2011-03-16 16:29:28 -0700 | [diff] [blame] | 61 | if (slot >= mHal.info.exportedVariableCount) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 62 | ALOGE("Script::setVar unable to set allocation, invalid slot index"); |
Jason Sams | bad8074 | 2011-03-16 16:29:28 -0700 | [diff] [blame] | 63 | return; |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 64 | } |
Jason Sams | 4efe3d3 | 2015-03-18 18:28:06 -0700 | [diff] [blame] | 65 | if (mRSC->hadFatalError()) return; |
| 66 | |
Jason Sams | bad8074 | 2011-03-16 16:29:28 -0700 | [diff] [blame] | 67 | mRSC->mHal.funcs.script.setGlobalVar(mRSC, this, slot, (void *)val, len); |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 68 | } |
| 69 | |
Tim Murray | 9c64239 | 2013-04-11 13:29:59 -0700 | [diff] [blame] | 70 | void Script::getVar(uint32_t slot, const void *val, size_t len) { |
| 71 | //ALOGE("getVar %i %p %i", slot, val, len); |
| 72 | if (slot >= mHal.info.exportedVariableCount) { |
Stephen Hines | cadee38 | 2013-12-12 13:21:00 -0800 | [diff] [blame] | 73 | ALOGE("Script::getVar unable to set allocation, invalid slot index: " |
Nick Kralevich | 02759d7 | 2013-12-15 21:04:00 -0800 | [diff] [blame] | 74 | "%u >= %zu", slot, mHal.info.exportedVariableCount); |
Tim Murray | 9c64239 | 2013-04-11 13:29:59 -0700 | [diff] [blame] | 75 | return; |
| 76 | } |
Jason Sams | 4efe3d3 | 2015-03-18 18:28:06 -0700 | [diff] [blame] | 77 | if (mRSC->hadFatalError()) return; |
| 78 | |
Tim Murray | 9c64239 | 2013-04-11 13:29:59 -0700 | [diff] [blame] | 79 | mRSC->mHal.funcs.script.getGlobalVar(mRSC, this, slot, (void *)val, len); |
| 80 | } |
| 81 | |
Stephen Hines | 2980f07 | 2012-04-09 18:26:29 -0700 | [diff] [blame] | 82 | void Script::setVar(uint32_t slot, const void *val, size_t len, Element *e, |
Stephen Hines | f0a5078 | 2014-06-25 13:41:10 -0700 | [diff] [blame] | 83 | const uint32_t *dims, size_t dimLen) { |
Stephen Hines | 2980f07 | 2012-04-09 18:26:29 -0700 | [diff] [blame] | 84 | if (slot >= mHal.info.exportedVariableCount) { |
Stephen Hines | cadee38 | 2013-12-12 13:21:00 -0800 | [diff] [blame] | 85 | ALOGE("Script::setVar unable to set allocation, invalid slot index: " |
Nick Kralevich | 02759d7 | 2013-12-15 21:04:00 -0800 | [diff] [blame] | 86 | "%u >= %zu", slot, mHal.info.exportedVariableCount); |
Stephen Hines | 2980f07 | 2012-04-09 18:26:29 -0700 | [diff] [blame] | 87 | return; |
| 88 | } |
Jason Sams | 4efe3d3 | 2015-03-18 18:28:06 -0700 | [diff] [blame] | 89 | if (mRSC->hadFatalError()) return; |
| 90 | |
Stephen Hines | 2980f07 | 2012-04-09 18:26:29 -0700 | [diff] [blame] | 91 | mRSC->mHal.funcs.script.setGlobalVarWithElemDims(mRSC, this, slot, |
| 92 | (void *)val, len, e, dims, dimLen); |
| 93 | } |
| 94 | |
Jason Sams | a5eb6e1 | 2010-11-16 17:37:02 -0800 | [diff] [blame] | 95 | void Script::setVarObj(uint32_t slot, ObjectBase *val) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 96 | //ALOGE("setVarObj %i %p", slot, val); |
Jason Sams | bad8074 | 2011-03-16 16:29:28 -0700 | [diff] [blame] | 97 | if (slot >= mHal.info.exportedVariableCount) { |
Stephen Hines | cadee38 | 2013-12-12 13:21:00 -0800 | [diff] [blame] | 98 | ALOGE("Script::setVarObj unable to set allocation, invalid slot index: " |
Nick Kralevich | 02759d7 | 2013-12-15 21:04:00 -0800 | [diff] [blame] | 99 | "%u >= %zu", slot, mHal.info.exportedVariableCount); |
Jason Sams | bad8074 | 2011-03-16 16:29:28 -0700 | [diff] [blame] | 100 | return; |
Jason Sams | a5eb6e1 | 2010-11-16 17:37:02 -0800 | [diff] [blame] | 101 | } |
Jason Sams | 4efe3d3 | 2015-03-18 18:28:06 -0700 | [diff] [blame] | 102 | if (mRSC->hadFatalError()) return; |
| 103 | |
Stephen Hines | c78839b | 2013-09-10 17:40:41 -0700 | [diff] [blame] | 104 | mHasObjectSlots = true; |
Jason Sams | bad8074 | 2011-03-16 16:29:28 -0700 | [diff] [blame] | 105 | mRSC->mHal.funcs.script.setGlobalObj(mRSC, this, slot, val); |
Jason Sams | a5eb6e1 | 2010-11-16 17:37:02 -0800 | [diff] [blame] | 106 | } |
| 107 | |
Jason Sams | a36c50a | 2014-06-17 12:06:06 -0700 | [diff] [blame] | 108 | void Script::callUpdateCacheObject(const Context *rsc, void *dstObj) const { |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 109 | if (rsc->mHal.funcs.script.updateCachedObject != nullptr) { |
Jason Sams | a36c50a | 2014-06-17 12:06:06 -0700 | [diff] [blame] | 110 | rsc->mHal.funcs.script.updateCachedObject(rsc, this, (rs_script *)dstObj); |
| 111 | } else { |
| 112 | *((const void **)dstObj) = this; |
| 113 | } |
| 114 | } |
| 115 | |
Stephen Hines | 4ee16ff | 2011-08-31 17:41:39 -0700 | [diff] [blame] | 116 | bool Script::freeChildren() { |
| 117 | incSysRef(); |
| 118 | mRSC->mHal.funcs.script.invokeFreeChildren(mRSC, this); |
| 119 | return decSysRef(); |
| 120 | } |
| 121 | |
Jason Sams | dbe66d6 | 2012-09-17 13:54:41 -0700 | [diff] [blame] | 122 | ScriptKernelID::ScriptKernelID(Context *rsc, Script *s, int slot, int sig) |
Yang Ni | eb9aa67 | 2015-01-27 14:32:25 -0800 | [diff] [blame] | 123 | : IDBase(rsc, s, slot) { |
Jason Sams | dbe66d6 | 2012-09-17 13:54:41 -0700 | [diff] [blame] | 124 | mHasKernelInput = (sig & 1) != 0; |
| 125 | mHasKernelOutput = (sig & 2) != 0; |
| 126 | } |
| 127 | |
Jason Sams | dbe66d6 | 2012-09-17 13:54:41 -0700 | [diff] [blame] | 128 | RsA3DClassID ScriptKernelID::getClassId() const { |
| 129 | return RS_A3D_CLASS_ID_SCRIPT_KERNEL_ID; |
| 130 | } |
| 131 | |
Yang Ni | eb9aa67 | 2015-01-27 14:32:25 -0800 | [diff] [blame] | 132 | ScriptInvokeID::ScriptInvokeID(Context *rsc, Script *s, int slot) |
| 133 | : IDBase(rsc, s, slot) { |
Jason Sams | dbe66d6 | 2012-09-17 13:54:41 -0700 | [diff] [blame] | 134 | } |
| 135 | |
Yang Ni | eb9aa67 | 2015-01-27 14:32:25 -0800 | [diff] [blame] | 136 | RsA3DClassID ScriptInvokeID::getClassId() const { |
| 137 | return RS_A3D_CLASS_ID_SCRIPT_INVOKE_ID; |
Jason Sams | dbe66d6 | 2012-09-17 13:54:41 -0700 | [diff] [blame] | 138 | } |
| 139 | |
Yang Ni | eb9aa67 | 2015-01-27 14:32:25 -0800 | [diff] [blame] | 140 | ScriptFieldID::ScriptFieldID(Context *rsc, Script *s, int slot) : |
| 141 | IDBase(rsc, s, slot) { |
Jason Sams | dbe66d6 | 2012-09-17 13:54:41 -0700 | [diff] [blame] | 142 | } |
| 143 | |
| 144 | RsA3DClassID ScriptFieldID::getClassId() const { |
| 145 | return RS_A3D_CLASS_ID_SCRIPT_FIELD_ID; |
| 146 | } |
| 147 | |
| 148 | |
Jason Sams | dbe66d6 | 2012-09-17 13:54:41 -0700 | [diff] [blame] | 149 | RsScriptKernelID rsi_ScriptKernelIDCreate(Context *rsc, RsScript vs, int slot, int sig) { |
Stephen Hines | 61c8695 | 2013-04-09 17:34:43 -0700 | [diff] [blame] | 150 | ScriptKernelID *kid = new ScriptKernelID(rsc, (Script *)vs, slot, sig); |
| 151 | kid->incUserRef(); |
| 152 | return kid; |
Jason Sams | dbe66d6 | 2012-09-17 13:54:41 -0700 | [diff] [blame] | 153 | } |
| 154 | |
Yang Ni | eb9aa67 | 2015-01-27 14:32:25 -0800 | [diff] [blame] | 155 | RsScriptInvokeID rsi_ScriptInvokeIDCreate(Context *rsc, RsScript vs, uint32_t slot) { |
| 156 | ScriptInvokeID *iid = new ScriptInvokeID(rsc, (Script *)vs, slot); |
| 157 | iid->incUserRef(); |
| 158 | return iid; |
| 159 | } |
| 160 | |
Jason Sams | dbe66d6 | 2012-09-17 13:54:41 -0700 | [diff] [blame] | 161 | RsScriptFieldID rsi_ScriptFieldIDCreate(Context *rsc, RsScript vs, int slot) { |
Stephen Hines | 61c8695 | 2013-04-09 17:34:43 -0700 | [diff] [blame] | 162 | ScriptFieldID *fid = new ScriptFieldID(rsc, (Script *)vs, slot); |
| 163 | fid->incUserRef(); |
| 164 | return fid; |
Jason Sams | dbe66d6 | 2012-09-17 13:54:41 -0700 | [diff] [blame] | 165 | } |
| 166 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 167 | void rsi_ScriptBindAllocation(Context * rsc, RsScript vs, RsAllocation va, uint32_t slot) { |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 168 | Script *s = static_cast<Script *>(vs); |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 169 | Allocation *a = static_cast<Allocation *>(va); |
Alex Sakhartchouk | 700ba38 | 2010-10-08 15:00:05 -0700 | [diff] [blame] | 170 | s->setSlot(slot, a); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 171 | } |
| 172 | |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 173 | void rsi_ScriptSetTimeZone(Context * rsc, RsScript vs, const char * timeZone, size_t length) { |
Stephen Hines | d2432b9 | 2011-11-09 18:02:20 -0800 | [diff] [blame] | 174 | // We unfortunately need to make a new copy of the string, since it is |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 175 | // not nullptr-terminated. We then use setenv(), which properly handles |
Stephen Hines | d2432b9 | 2011-11-09 18:02:20 -0800 | [diff] [blame] | 176 | // freeing/duplicating the actual string for the environment. |
| 177 | char *tz = (char *) malloc(length + 1); |
| 178 | if (!tz) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 179 | ALOGE("Couldn't allocate memory for timezone buffer"); |
Stephen Hines | d2432b9 | 2011-11-09 18:02:20 -0800 | [diff] [blame] | 180 | return; |
| 181 | } |
| 182 | strncpy(tz, timeZone, length); |
| 183 | tz[length] = '\0'; |
| 184 | if (setenv("TZ", tz, 1) == 0) { |
| 185 | tzset(); |
| 186 | } else { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 187 | ALOGE("Error setting timezone"); |
Stephen Hines | d2432b9 | 2011-11-09 18:02:20 -0800 | [diff] [blame] | 188 | } |
| 189 | free(tz); |
Jason Sams | d34b725 | 2009-08-04 16:58:20 -0700 | [diff] [blame] | 190 | } |
| 191 | |
Chris Wailes | 4b3c34e | 2014-06-11 12:00:29 -0700 | [diff] [blame] | 192 | void rsi_ScriptForEachMulti(Context *rsc, RsScript vs, uint32_t slot, |
| 193 | RsAllocation *vains, size_t inLen, |
| 194 | RsAllocation vaout, const void *params, |
| 195 | size_t paramLen, const RsScriptCall *sc, |
| 196 | size_t scLen) { |
Chris Wailes | f371213 | 2014-07-16 15:18:30 -0700 | [diff] [blame] | 197 | |
| 198 | Script *s = static_cast<Script *>(vs); |
Chris Wailes | 4b3c34e | 2014-06-11 12:00:29 -0700 | [diff] [blame] | 199 | Allocation **ains = (Allocation**)(vains); |
| 200 | |
| 201 | s->runForEach(rsc, slot, |
| 202 | const_cast<const Allocation **>(ains), inLen, |
| 203 | static_cast<Allocation *>(vaout), params, paramLen, sc); |
| 204 | |
| 205 | } |
| 206 | |
Chris Wailes | f371213 | 2014-07-16 15:18:30 -0700 | [diff] [blame] | 207 | void rsi_ScriptForEach(Context *rsc, RsScript vs, uint32_t slot, |
| 208 | RsAllocation vain, RsAllocation vaout, |
| 209 | const void *params, size_t paramLen, |
| 210 | const RsScriptCall *sc, size_t scLen) { |
| 211 | |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 212 | if (vain == nullptr) { |
| 213 | rsi_ScriptForEachMulti(rsc, vs, slot, nullptr, 0, vaout, params, paramLen, |
Chris Wailes | f371213 | 2014-07-16 15:18:30 -0700 | [diff] [blame] | 214 | sc, scLen); |
| 215 | } else { |
| 216 | RsAllocation ains[1] = {vain}; |
| 217 | |
| 218 | rsi_ScriptForEachMulti(rsc, vs, slot, ains, |
| 219 | sizeof(ains) / sizeof(RsAllocation), vaout, |
| 220 | params, paramLen, sc, scLen); |
| 221 | } |
| 222 | } |
| 223 | |
Matt Wala | 39a9d9b | 2015-07-20 15:38:17 -0700 | [diff] [blame] | 224 | void rsi_ScriptReduce(Context *rsc, RsScript vs, uint32_t slot, |
David Gross | ae2ec3f | 2016-06-01 14:45:47 -0700 | [diff] [blame] | 225 | RsAllocation *vains, size_t inLen, |
| 226 | RsAllocation vaout, const RsScriptCall *sc, |
| 227 | size_t scLen) { |
David Gross | 6c1876b | 2016-01-15 11:52:14 -0800 | [diff] [blame] | 228 | Script *s = static_cast<Script *>(vs); |
| 229 | Allocation **ains = (Allocation**)(vains); |
| 230 | |
David Gross | ae2ec3f | 2016-06-01 14:45:47 -0700 | [diff] [blame] | 231 | s->runReduce(rsc, slot, |
| 232 | const_cast<const Allocation **>(ains), inLen, |
| 233 | static_cast<Allocation *>(vaout), sc); |
David Gross | 6c1876b | 2016-01-15 11:52:14 -0800 | [diff] [blame] | 234 | } |
| 235 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 236 | void rsi_ScriptInvoke(Context *rsc, RsScript vs, uint32_t slot) { |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 237 | Script *s = static_cast<Script *>(vs); |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 238 | s->Invoke(rsc, slot, nullptr, 0); |
Jason Sams | 8c6bc69 | 2009-09-16 15:04:38 -0700 | [diff] [blame] | 239 | } |
| 240 | |
| 241 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 242 | void rsi_ScriptInvokeData(Context *rsc, RsScript vs, uint32_t slot, void *data) { |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 243 | Script *s = static_cast<Script *>(vs); |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 244 | s->Invoke(rsc, slot, nullptr, 0); |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 245 | } |
| 246 | |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 247 | void rsi_ScriptInvokeV(Context *rsc, RsScript vs, uint32_t slot, const void *data, size_t len) { |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 248 | Script *s = static_cast<Script *>(vs); |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 249 | s->Invoke(rsc, slot, data, len); |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 250 | } |
| 251 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 252 | void rsi_ScriptSetVarI(Context *rsc, RsScript vs, uint32_t slot, int value) { |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 253 | Script *s = static_cast<Script *>(vs); |
| 254 | s->setVar(slot, &value, sizeof(value)); |
| 255 | } |
| 256 | |
Jason Sams | a5eb6e1 | 2010-11-16 17:37:02 -0800 | [diff] [blame] | 257 | void rsi_ScriptSetVarObj(Context *rsc, RsScript vs, uint32_t slot, RsObjectBase value) { |
| 258 | Script *s = static_cast<Script *>(vs); |
| 259 | ObjectBase *o = static_cast<ObjectBase *>(value); |
| 260 | s->setVarObj(slot, o); |
| 261 | } |
| 262 | |
Tim Murray | 099bc26 | 2013-03-20 16:54:03 -0700 | [diff] [blame] | 263 | void rsi_ScriptSetVarJ(Context *rsc, RsScript vs, uint32_t slot, int64_t value) { |
Stephen Hines | 0977c94 | 2010-10-11 10:54:21 -0700 | [diff] [blame] | 264 | Script *s = static_cast<Script *>(vs); |
| 265 | s->setVar(slot, &value, sizeof(value)); |
| 266 | } |
| 267 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 268 | void rsi_ScriptSetVarF(Context *rsc, RsScript vs, uint32_t slot, float value) { |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 269 | Script *s = static_cast<Script *>(vs); |
| 270 | s->setVar(slot, &value, sizeof(value)); |
| 271 | } |
| 272 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 273 | void rsi_ScriptSetVarD(Context *rsc, RsScript vs, uint32_t slot, double value) { |
Stephen Hines | 6d0a074 | 2010-09-20 17:20:30 -0700 | [diff] [blame] | 274 | Script *s = static_cast<Script *>(vs); |
| 275 | s->setVar(slot, &value, sizeof(value)); |
| 276 | } |
| 277 | |
Alex Sakhartchouk | b81a0eb | 2011-06-03 10:18:01 -0700 | [diff] [blame] | 278 | void rsi_ScriptSetVarV(Context *rsc, RsScript vs, uint32_t slot, const void *data, size_t len) { |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 279 | Script *s = static_cast<Script *>(vs); |
| 280 | s->setVar(slot, data, len); |
Jason Sams | fa51719 | 2009-08-13 12:59:04 -0700 | [diff] [blame] | 281 | } |
| 282 | |
Tim Murray | 9c64239 | 2013-04-11 13:29:59 -0700 | [diff] [blame] | 283 | void rsi_ScriptGetVarV(Context *rsc, RsScript vs, uint32_t slot, void *data, size_t len) { |
| 284 | Script *s = static_cast<Script *>(vs); |
| 285 | s->getVar(slot, data, len); |
| 286 | } |
| 287 | |
Stephen Hines | 2980f07 | 2012-04-09 18:26:29 -0700 | [diff] [blame] | 288 | void rsi_ScriptSetVarVE(Context *rsc, RsScript vs, uint32_t slot, |
| 289 | const void *data, size_t len, RsElement ve, |
Stephen Hines | ac8d146 | 2014-06-25 00:01:23 -0700 | [diff] [blame] | 290 | const uint32_t *dims, size_t dimLen) { |
Stephen Hines | 2980f07 | 2012-04-09 18:26:29 -0700 | [diff] [blame] | 291 | Script *s = static_cast<Script *>(vs); |
| 292 | Element *e = static_cast<Element *>(ve); |
| 293 | s->setVar(slot, data, len, e, dims, dimLen); |
| 294 | } |
| 295 | |
Chih-Hung Hsieh | 11496ac | 2016-11-15 15:14:05 -0800 | [diff] [blame] | 296 | } // namespace renderscript |
| 297 | } // namespace android |