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#if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB) 25#include "utils/Timers.h" 26#endif 27 28#include <time.h> 29 30using namespace android; 31using namespace android::renderscript; 32 33 34namespace android { 35namespace renderscript { 36 37 38////////////////////////////////////////////////////////////////////////////// 39// Math routines 40////////////////////////////////////////////////////////////////////////////// 41 42#if 0 43static float SC_sinf_fast(float x) { 44 const float A = 1.0f / (2.0f * M_PI); 45 const float B = -16.0f; 46 const float C = 8.0f; 47 48 // scale angle for easy argument reduction 49 x *= A; 50 51 if (fabsf(x) >= 0.5f) { 52 // argument reduction 53 x = x - ceilf(x + 0.5f) + 1.0f; 54 } 55 56 const float y = B * x * fabsf(x) + C * x; 57 return 0.2215f * (y * fabsf(y) - y) + y; 58} 59 60static float SC_cosf_fast(float x) { 61 x += float(M_PI / 2); 62 63 const float A = 1.0f / (2.0f * M_PI); 64 const float B = -16.0f; 65 const float C = 8.0f; 66 67 // scale angle for easy argument reduction 68 x *= A; 69 70 if (fabsf(x) >= 0.5f) { 71 // argument reduction 72 x = x - ceilf(x + 0.5f) + 1.0f; 73 } 74 75 const float y = B * x * fabsf(x) + C * x; 76 return 0.2215f * (y * fabsf(y) - y) + y; 77} 78#endif 79 80////////////////////////////////////////////////////////////////////////////// 81// Time routines 82////////////////////////////////////////////////////////////////////////////// 83 84time_t rsrTime(Context *rsc, time_t *timer) { 85 return time(timer); 86} 87 88tm* rsrLocalTime(Context *rsc, tm *local, time_t *timer) { 89 if (!local) { 90 return NULL; 91 } 92 93 // The native localtime function is not thread-safe, so we 94 // have to apply locking for proper behavior in RenderScript. 95 pthread_mutex_lock(&rsc->gLibMutex); 96 tm *tmp = localtime(timer); 97#ifndef RS_COMPATIBILITY_LIB 98 memcpy(local, tmp, sizeof(*tmp)); 99#else 100 // WORKAROUND to struct rs_tm != struct tm 101 memcpy(local, tmp, sizeof(int)*9); 102#endif 103 pthread_mutex_unlock(&rsc->gLibMutex); 104 return local; 105} 106 107int64_t rsrUptimeMillis(Context *rsc) { 108#ifndef RS_SERVER 109 return nanoseconds_to_milliseconds(systemTime(SYSTEM_TIME_MONOTONIC)); 110#else 111 return 0; 112#endif 113} 114 115int64_t rsrUptimeNanos(Context *rsc) { 116#ifndef RS_SERVER 117 return systemTime(SYSTEM_TIME_MONOTONIC); 118#else 119 return 0; 120#endif 121} 122 123float rsrGetDt(Context *rsc, const Script *sc) { 124#ifndef RS_SERVER 125 int64_t l = sc->mEnviroment.mLastDtTime; 126 sc->mEnviroment.mLastDtTime = systemTime(SYSTEM_TIME_MONOTONIC); 127 return ((float)(sc->mEnviroment.mLastDtTime - l)) / 1.0e9; 128#else 129 return 0.f; 130#endif 131} 132 133////////////////////////////////////////////////////////////////////////////// 134// 135////////////////////////////////////////////////////////////////////////////// 136 137static void SetObjectRef(const Context *rsc, const ObjectBase *dst, const ObjectBase *src) { 138 //ALOGE("setObjectRef %p,%p %p", rsc, dst, src); 139 if (src) { 140 CHECK_OBJ(src); 141 src->incSysRef(); 142 } 143 if (dst) { 144 CHECK_OBJ(dst); 145 dst->decSysRef(); 146 } 147} 148 149// Legacy, remove when drivers are updated 150void rsrSetObject(const Context *rsc, void *dst, ObjectBase *src) { 151 ObjectBase **odst = (ObjectBase **)dst; 152 //ALOGE("rsrSetObject (base) %p,%p %p", dst, *odst, src); 153 SetObjectRef(rsc, odst[0], src); 154 if (src != NULL) { 155 src->callUpdateCacheObject(rsc, dst); 156 } 157} 158 159void rsrSetObject(const Context *rsc, rs_object_base *dst, const ObjectBase *src) { 160 ObjectBase **odst = (ObjectBase **)dst; 161 //ALOGE("rsrSetObject (base) %p,%p %p", dst, *odst, src); 162 SetObjectRef(rsc, odst[0], src); 163 if (src != NULL) { 164 src->callUpdateCacheObject(rsc, dst); 165 } 166} 167 168// Legacy, remove when drivers are updated 169void rsrClearObject(const Context *rsc, void *dst) { 170 ObjectBase **odst = (ObjectBase **)dst; 171 //ALOGE("rsrClearObject %p,%p", odst, *odst); 172 if (odst[0]) { 173 CHECK_OBJ(odst[0]); 174 odst[0]->decSysRef(); 175 } 176 *odst = NULL; 177} 178 179void rsrClearObject(const Context *rsc, rs_object_base *dst) { 180 //ALOGE("rsrClearObject %p,%p", odst, *odst); 181 if (dst->p) { 182 CHECK_OBJ(dst->p); 183 dst->p->decSysRef(); 184 } 185 dst->p = NULL; 186} 187 188// Legacy, remove when drivers are updated 189bool rsrIsObject(const Context *, ObjectBase* src) { 190 ObjectBase **osrc = (ObjectBase **)src; 191 return osrc != NULL; 192} 193 194bool rsrIsObject(const Context *rsc, rs_object_base o) { 195 return o.p != NULL; 196} 197 198 199 200uint32_t rsrToClient(Context *rsc, int cmdID, const void *data, int len) { 201 //ALOGE("SC_toClient %i %i %i", cmdID, len); 202 return rsc->sendMessageToClient(data, RS_MESSAGE_TO_CLIENT_USER, cmdID, len, false); 203} 204 205uint32_t rsrToClientBlocking(Context *rsc, int cmdID, const void *data, int len) { 206 //ALOGE("SC_toClientBlocking %i %i", cmdID, len); 207 return rsc->sendMessageToClient(data, RS_MESSAGE_TO_CLIENT_USER, cmdID, len, true); 208} 209 210// Keep these two routines (using non-const void pointers) so that we can 211// still use existing GPU drivers. 212uint32_t rsrToClient(Context *rsc, int cmdID, void *data, int len) { 213 return rsrToClient(rsc, cmdID, (const void *)data, len); 214} 215 216uint32_t rsrToClientBlocking(Context *rsc, int cmdID, void *data, int len) { 217 return rsrToClientBlocking(rsc, cmdID, (const void *)data, len); 218} 219 220void rsrAllocationIoSend(Context *rsc, Allocation *src) { 221 src->ioSend(rsc); 222} 223 224void rsrAllocationIoReceive(Context *rsc, Allocation *src) { 225 src->ioReceive(rsc); 226} 227 228void rsrForEach(Context *rsc, 229 Script *target, 230 Allocation *in, Allocation *out, 231 const void *usr, uint32_t usrBytes, 232 const RsScriptCall *call) { 233 target->runForEach(rsc, /* root slot */ 0, in, out, usr, usrBytes, call); 234} 235 236void rsrAllocationSyncAll(Context *rsc, Allocation *a, RsAllocationUsageType usage) { 237 a->syncAll(rsc, usage); 238} 239 240void rsrAllocationCopy1DRange(Context *rsc, Allocation *dstAlloc, 241 uint32_t dstOff, 242 uint32_t dstMip, 243 uint32_t count, 244 Allocation *srcAlloc, 245 uint32_t srcOff, uint32_t srcMip) { 246 rsi_AllocationCopy2DRange(rsc, dstAlloc, dstOff, 0, 247 dstMip, 0, count, 1, 248 srcAlloc, srcOff, 0, srcMip, 0); 249} 250 251void rsrAllocationCopy2DRange(Context *rsc, Allocation *dstAlloc, 252 uint32_t dstXoff, uint32_t dstYoff, 253 uint32_t dstMip, uint32_t dstFace, 254 uint32_t width, uint32_t height, 255 Allocation *srcAlloc, 256 uint32_t srcXoff, uint32_t srcYoff, 257 uint32_t srcMip, uint32_t srcFace) { 258 rsi_AllocationCopy2DRange(rsc, dstAlloc, dstXoff, dstYoff, 259 dstMip, dstFace, width, height, 260 srcAlloc, srcXoff, srcYoff, srcMip, srcFace); 261} 262 263 264} 265} 266