1 /* 2 * Copyright (C) 2009-2012 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 "rsMatrix4x4.h" 20 #include "rsMatrix3x3.h" 21 #include "rsMatrix2x2.h" 22 #include "rsgApiStructs.h" 23 24 #include <time.h> 25 #include <sstream> 26 27 28 namespace android { 29 namespace renderscript { 30 31 32 ////////////////////////////////////////////////////////////////////////////// 33 // Math routines 34 ////////////////////////////////////////////////////////////////////////////// 35 36 #if 0 37 static float SC_sinf_fast(float x) { 38 const float A = 1.0f / (2.0f * M_PI); 39 const float B = -16.0f; 40 const float C = 8.0f; 41 42 // scale angle for easy argument reduction 43 x *= A; 44 45 if (fabsf(x) >= 0.5f) { 46 // argument reduction 47 x = x - ceilf(x + 0.5f) + 1.0f; 48 } 49 50 const float y = B * x * fabsf(x) + C * x; 51 return 0.2215f * (y * fabsf(y) - y) + y; 52 } 53 54 static float SC_cosf_fast(float x) { 55 x += float(M_PI / 2); 56 57 const float A = 1.0f / (2.0f * M_PI); 58 const float B = -16.0f; 59 const float C = 8.0f; 60 61 // scale angle for easy argument reduction 62 x *= A; 63 64 if (fabsf(x) >= 0.5f) { 65 // argument reduction 66 x = x - ceilf(x + 0.5f) + 1.0f; 67 } 68 69 const float y = B * x * fabsf(x) + C * x; 70 return 0.2215f * (y * fabsf(y) - y) + y; 71 } 72 #endif 73 74 ////////////////////////////////////////////////////////////////////////////// 75 // Time routines 76 ////////////////////////////////////////////////////////////////////////////// 77 rsrTime(Context * rsc,time_t * timer)78 time_t rsrTime(Context *rsc, time_t *timer) { 79 return time(timer); 80 } 81 rsrLocalTime(Context * rsc,tm * local,time_t * timer)82 tm* rsrLocalTime(Context *rsc, tm *local, time_t *timer) { 83 if (!local) { 84 return nullptr; 85 } 86 87 // The native localtime function is not thread-safe, so we 88 // have to apply locking for proper behavior in RenderScript. 89 pthread_mutex_lock(&rsc->gLibMutex); 90 tm *tmp = localtime(timer); 91 memcpy(local, tmp, sizeof(int)*9); 92 pthread_mutex_unlock(&rsc->gLibMutex); 93 return local; 94 } 95 rsrUptimeMillis(Context * rsc)96 int64_t rsrUptimeMillis(Context *rsc) { 97 return nanoseconds_to_milliseconds(systemTime(SYSTEM_TIME_MONOTONIC)); 98 } 99 rsrUptimeNanos(Context * rsc)100 int64_t rsrUptimeNanos(Context *rsc) { 101 return systemTime(SYSTEM_TIME_MONOTONIC); 102 } 103 rsrGetDt(Context * rsc,const Script * sc)104 float rsrGetDt(Context *rsc, const Script *sc) { 105 int64_t l = sc->mEnviroment.mLastDtTime; 106 sc->mEnviroment.mLastDtTime = systemTime(SYSTEM_TIME_MONOTONIC); 107 return ((float)(sc->mEnviroment.mLastDtTime - l)) / 1.0e9; 108 } 109 110 ////////////////////////////////////////////////////////////////////////////// 111 // 112 ////////////////////////////////////////////////////////////////////////////// 113 SetObjectRef(const Context * rsc,const ObjectBase * dst,const ObjectBase * src)114 static void SetObjectRef(const Context *rsc, const ObjectBase *dst, const ObjectBase *src) { 115 //ALOGE("setObjectRef %p,%p %p", rsc, dst, src); 116 if (src) { 117 CHECK_OBJ(src); 118 src->incSysRef(); 119 } 120 if (dst) { 121 CHECK_OBJ(dst); 122 dst->decSysRef(); 123 } 124 } 125 126 // Legacy, remove when drivers are updated rsrClearObject(const Context * rsc,void * dst)127 void rsrClearObject(const Context *rsc, void *dst) { 128 ObjectBase **odst = (ObjectBase **)dst; 129 if (ObjectBase::gDebugReferences) { 130 ALOGE("rsrClearObject %p,%p", odst, *odst); 131 } 132 if (odst[0]) { 133 CHECK_OBJ(odst[0]); 134 odst[0]->decSysRef(); 135 } 136 *odst = nullptr; 137 } 138 rsrClearObject(rs_object_base * dst)139 void rsrClearObject(rs_object_base *dst) { 140 if (ObjectBase::gDebugReferences) { 141 ALOGE("rsrClearObject %p,%p", dst, dst->p); 142 } 143 if (dst->p) { 144 CHECK_OBJ(dst->p); 145 dst->p->decSysRef(); 146 } 147 dst->p = nullptr; 148 } 149 150 // Legacy, remove when drivers are updated rsrClearObject(const Context * rsc,rs_object_base * dst)151 void rsrClearObject(const Context *rsc, rs_object_base *dst) { 152 rsrClearObject(dst); 153 } 154 155 // Legacy, remove when drivers are updated rsrSetObject(const Context * rsc,void * dst,ObjectBase * src)156 void rsrSetObject(const Context *rsc, void *dst, ObjectBase *src) { 157 if (src == nullptr) { 158 rsrClearObject(rsc, dst); 159 return; 160 } 161 162 ObjectBase **odst = (ObjectBase **)dst; 163 if (ObjectBase::gDebugReferences) { 164 ALOGE("rsrSetObject (base) %p,%p %p", dst, *odst, src); 165 } 166 SetObjectRef(rsc, odst[0], src); 167 src->callUpdateCacheObject(rsc, dst); 168 } 169 rsrSetObject(const Context * rsc,rs_object_base * dst,const ObjectBase * src)170 void rsrSetObject(const Context *rsc, rs_object_base *dst, const ObjectBase *src) { 171 if (src == nullptr) { 172 rsrClearObject(rsc, dst); 173 return; 174 } 175 176 ObjectBase **odst = (ObjectBase **)dst; 177 if (ObjectBase::gDebugReferences) { 178 ALOGE("rsrSetObject (base) %p,%p %p", dst, *odst, src); 179 } 180 SetObjectRef(rsc, odst[0], src); 181 src->callUpdateCacheObject(rsc, dst); 182 } 183 184 // Legacy, remove when drivers are updated rsrIsObject(const Context *,ObjectBase * src)185 bool rsrIsObject(const Context *, ObjectBase* src) { 186 ObjectBase **osrc = (ObjectBase **)src; 187 return osrc != nullptr; 188 } 189 rsrIsObject(const Context * rsc,rs_object_base o)190 bool rsrIsObject(const Context *rsc, rs_object_base o) { 191 return o.p != nullptr; 192 } 193 194 195 rsrToClient(Context * rsc,int cmdID,const void * data,int len)196 uint32_t rsrToClient(Context *rsc, int cmdID, const void *data, int len) { 197 //ALOGE("SC_toClient %i %i %i", cmdID, len); 198 return rsc->sendMessageToClient(data, RS_MESSAGE_TO_CLIENT_USER, cmdID, len, false); 199 } 200 rsrToClientBlocking(Context * rsc,int cmdID,const void * data,int len)201 uint32_t rsrToClientBlocking(Context *rsc, int cmdID, const void *data, int len) { 202 //ALOGE("SC_toClientBlocking %i %i", cmdID, len); 203 return rsc->sendMessageToClient(data, RS_MESSAGE_TO_CLIENT_USER, cmdID, len, true); 204 } 205 206 // Keep these two routines (using non-const void pointers) so that we can 207 // still use existing GPU drivers. rsrToClient(Context * rsc,int cmdID,void * data,int len)208 uint32_t rsrToClient(Context *rsc, int cmdID, void *data, int len) { 209 return rsrToClient(rsc, cmdID, (const void *)data, len); 210 } 211 rsrToClientBlocking(Context * rsc,int cmdID,void * data,int len)212 uint32_t rsrToClientBlocking(Context *rsc, int cmdID, void *data, int len) { 213 return rsrToClientBlocking(rsc, cmdID, (const void *)data, len); 214 } 215 rsrAllocationIoSend(Context * rsc,Allocation * src)216 void rsrAllocationIoSend(Context *rsc, Allocation *src) { 217 src->ioSend(rsc); 218 } 219 rsrAllocationIoReceive(Context * rsc,Allocation * src)220 void rsrAllocationIoReceive(Context *rsc, Allocation *src) { 221 src->ioReceive(rsc); 222 } 223 rsrForEach(Context * rsc,Script * target,uint32_t slot,uint32_t numInputs,Allocation ** in,Allocation * out,const void * usr,uint32_t usrBytes,const RsScriptCall * call)224 void rsrForEach(Context *rsc, 225 Script *target, 226 uint32_t slot, 227 uint32_t numInputs, 228 Allocation **in, Allocation *out, 229 const void *usr, uint32_t usrBytes, 230 const RsScriptCall *call) { 231 target->runForEach(rsc, slot, (const Allocation**)in, numInputs, out, usr, usrBytes, call); 232 } 233 rsrAllocationSyncAll(Context * rsc,Allocation * a,RsAllocationUsageType usage)234 void rsrAllocationSyncAll(Context *rsc, Allocation *a, RsAllocationUsageType usage) { 235 a->syncAll(rsc, usage); 236 } 237 238 // Helper for validateCopyArgs() - initialize the error message; only called on 239 // infrequently executed paths initializeErrorMsg(std::stringstream & ss,int expectDim,bool isSrc)240 static void initializeErrorMsg(std::stringstream &ss, int expectDim, bool isSrc) { 241 ss << (expectDim == 1 ? "rsAllocationCopy1DRange" : "rsAllocationCopy2DRange") << ": "; 242 ss << (isSrc? "source" : "destination") << " "; 243 } 244 245 // We are doing the check even in a non-debug context, which is permissible because in that case 246 // a failed bound check results in unspecified behavior. validateCopyArgs(Context * rsc,bool isSrc,uint32_t expectDim,const Allocation * alloc,uint32_t xoff,uint32_t yoff,uint32_t lod,uint32_t w,uint32_t h)247 static bool validateCopyArgs(Context *rsc, bool isSrc, uint32_t expectDim, 248 const Allocation *alloc, uint32_t xoff, uint32_t yoff, 249 uint32_t lod, uint32_t w, uint32_t h) { 250 std::stringstream ss; 251 252 if (lod >= alloc->mHal.drvState.lodCount) { 253 initializeErrorMsg(ss, expectDim, isSrc); 254 ss << "Mip level out of range: "; 255 ss << lod << " >= " << alloc->mHal.drvState.lodCount; 256 rsc->setError(RS_ERROR_FATAL_DEBUG, ss.str().c_str()); 257 return false; 258 } 259 260 const uint32_t allocDimX = alloc->mHal.drvState.lod[lod].dimX; 261 262 // Check both in case xoff + w overflows 263 if (xoff >= allocDimX || (xoff + w) > allocDimX) { 264 initializeErrorMsg(ss, expectDim, isSrc); 265 ss << "X range: "; 266 ss << "[" << xoff << ", " << xoff + w << ") outside "; 267 ss << "[0, " << allocDimX << ")"; 268 rsc->setError(RS_ERROR_FATAL_DEBUG, ss.str().c_str()); 269 return false; 270 } 271 272 const uint32_t allocDimY = alloc->mHal.drvState.lod[lod].dimY; 273 274 if (expectDim > 1) { 275 if (allocDimY == 0) { // Copy2D was given an allocation of 1D 276 initializeErrorMsg(ss, expectDim, isSrc); 277 ss << "dimensionality invalid: expected 2D; given 1D rs_allocation"; 278 rsc->setError(RS_ERROR_FATAL_DEBUG, ss.str().c_str()); 279 return false; 280 } 281 // Check both in case yoff + h overflows 282 if (yoff >= allocDimY || (yoff + h) > allocDimY) { 283 initializeErrorMsg(ss, expectDim, isSrc); 284 ss << "Y range: "; 285 ss << "[" << yoff << ", " << yoff + h << ") outside "; 286 ss << "[0, " << allocDimY << ")"; 287 rsc->setError(RS_ERROR_FATAL_DEBUG, ss.str().c_str()); 288 return false; 289 } 290 } else { 291 if (allocDimY != 0) { // Copy1D was given an allocation of 2D 292 initializeErrorMsg(ss, expectDim, isSrc); 293 ss << "dimensionality invalid: expected 1D; given 2D rs_allocation"; 294 rsc->setError(RS_ERROR_FATAL_DEBUG, ss.str().c_str()); 295 return false; 296 } 297 } 298 299 return true; 300 } 301 rsrAllocationCopy1DRange(Context * rsc,Allocation * dstAlloc,uint32_t dstOff,uint32_t dstMip,uint32_t count,Allocation * srcAlloc,uint32_t srcOff,uint32_t srcMip)302 void rsrAllocationCopy1DRange(Context *rsc, Allocation *dstAlloc, 303 uint32_t dstOff, 304 uint32_t dstMip, 305 uint32_t count, 306 Allocation *srcAlloc, 307 uint32_t srcOff, uint32_t srcMip) { 308 if (!validateCopyArgs(rsc, false, 1, dstAlloc, dstOff, 0, dstMip, count, 1) || 309 !validateCopyArgs(rsc, true, 1, srcAlloc, srcOff, 0, srcMip, count, 1)) { 310 return; 311 } 312 rsi_AllocationCopy2DRange(rsc, dstAlloc, dstOff, 0, 313 dstMip, 0, count, 1, 314 srcAlloc, srcOff, 0, srcMip, 0); 315 } 316 rsrAllocationCopy2DRange(Context * rsc,Allocation * dstAlloc,uint32_t dstXoff,uint32_t dstYoff,uint32_t dstMip,uint32_t dstFace,uint32_t width,uint32_t height,Allocation * srcAlloc,uint32_t srcXoff,uint32_t srcYoff,uint32_t srcMip,uint32_t srcFace)317 void rsrAllocationCopy2DRange(Context *rsc, Allocation *dstAlloc, 318 uint32_t dstXoff, uint32_t dstYoff, 319 uint32_t dstMip, uint32_t dstFace, 320 uint32_t width, uint32_t height, 321 Allocation *srcAlloc, 322 uint32_t srcXoff, uint32_t srcYoff, 323 uint32_t srcMip, uint32_t srcFace) { 324 if (!validateCopyArgs(rsc, false, 2, dstAlloc, dstXoff, dstYoff, dstMip, width, height) || 325 !validateCopyArgs(rsc, true, 2, srcAlloc, srcXoff, srcYoff, srcMip, width, height)) { 326 return; 327 } 328 329 rsi_AllocationCopy2DRange(rsc, dstAlloc, dstXoff, dstYoff, 330 dstMip, dstFace, width, height, 331 srcAlloc, srcXoff, srcYoff, srcMip, srcFace); 332 } 333 rsrElementCreate(Context * rsc,RsDataType dt,RsDataKind dk,bool norm,uint32_t vecSize)334 RsElement rsrElementCreate(Context *rsc, RsDataType dt, RsDataKind dk, 335 bool norm, uint32_t vecSize) { 336 return rsi_ElementCreate(rsc, dt, dk, norm, vecSize); 337 } 338 rsrTypeCreate(Context * rsc,const RsElement element,uint32_t dimX,uint32_t dimY,uint32_t dimZ,bool mipmaps,bool faces,uint32_t yuv)339 RsType rsrTypeCreate(Context *rsc, const RsElement element, uint32_t dimX, 340 uint32_t dimY, uint32_t dimZ, bool mipmaps, bool faces, 341 uint32_t yuv) { 342 return rsi_TypeCreate(rsc, element, dimX, dimY, dimZ, mipmaps, faces, yuv); 343 } 344 rsrAllocationCreateTyped(Context * rsc,const RsType type,RsAllocationMipmapControl mipmaps,uint32_t usages,uintptr_t ptr)345 RsAllocation rsrAllocationCreateTyped(Context *rsc, const RsType type, 346 RsAllocationMipmapControl mipmaps, 347 uint32_t usages, uintptr_t ptr) { 348 return rsi_AllocationCreateTyped(rsc, type, mipmaps, usages, ptr); 349 } 350 351 } // namespace renderscript 352 } // namespace android 353