blob: dc30afc46d4eb51aad4c9de73f3bcbfc87038509 [file] [log] [blame]
Jason Samse45ac6e2009-07-20 14:31:06 -07001/*
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"
20
21#include "acc/acc.h"
Joe Onorato9c4e4ca2009-08-09 11:39:02 -070022#include "utils/Timers.h"
Jason Samse45ac6e2009-07-20 14:31:06 -070023
Romain Guy98e10fd2009-07-30 18:45:01 -070024#include <time.h>
Romain Guy98e10fd2009-07-30 18:45:01 -070025
Jason Samse45ac6e2009-07-20 14:31:06 -070026using namespace android;
27using namespace android::renderscript;
28
29#define GET_TLS() Context::ScriptTLSStruct * tls = \
30 (Context::ScriptTLSStruct *)pthread_getspecific(Context::gThreadTLSKey); \
31 Context * rsc = tls->mContext; \
32 ScriptC * sc = (ScriptC *) tls->mScript
33
Jason Samsbe36bf32010-05-11 14:03:58 -070034
Jason Samse45ac6e2009-07-20 14:31:06 -070035//////////////////////////////////////////////////////////////////////////////
36// Math routines
37//////////////////////////////////////////////////////////////////////////////
38
Romain Guy2275d632009-08-18 11:39:17 -070039static float SC_sinf_fast(float x)
40{
41 const float A = 1.0f / (2.0f * M_PI);
42 const float B = -16.0f;
43 const float C = 8.0f;
Jason Samsa57c0a72009-09-04 14:42:41 -070044
Romain Guy2275d632009-08-18 11:39:17 -070045 // scale angle for easy argument reduction
46 x *= A;
Jason Samsa57c0a72009-09-04 14:42:41 -070047
Romain Guy2275d632009-08-18 11:39:17 -070048 if (fabsf(x) >= 0.5f) {
49 // argument reduction
50 x = x - ceilf(x + 0.5f) + 1.0f;
51 }
Jason Samsa57c0a72009-09-04 14:42:41 -070052
Romain Guy2275d632009-08-18 11:39:17 -070053 const float y = B * x * fabsf(x) + C * x;
54 return 0.2215f * (y * fabsf(y) - y) + y;
55}
56
57static float SC_cosf_fast(float x)
58{
59 x += float(M_PI / 2);
60
61 const float A = 1.0f / (2.0f * M_PI);
62 const float B = -16.0f;
63 const float C = 8.0f;
Jason Samsa57c0a72009-09-04 14:42:41 -070064
Romain Guy2275d632009-08-18 11:39:17 -070065 // scale angle for easy argument reduction
66 x *= A;
Jason Samsa57c0a72009-09-04 14:42:41 -070067
Romain Guy2275d632009-08-18 11:39:17 -070068 if (fabsf(x) >= 0.5f) {
69 // argument reduction
70 x = x - ceilf(x + 0.5f) + 1.0f;
71 }
Jason Samsa57c0a72009-09-04 14:42:41 -070072
Romain Guy2275d632009-08-18 11:39:17 -070073 const float y = B * x * fabsf(x) + C * x;
74 return 0.2215f * (y * fabsf(y) - y) + y;
75}
76
Jason Sams22fa3712010-05-19 17:22:57 -070077
Jason Samse45ac6e2009-07-20 14:31:06 -070078static float SC_randf(float max)
79{
80 float r = (float)rand();
81 return r / RAND_MAX * max;
82}
83
Romain Guy39dbc802009-07-31 11:20:59 -070084static float SC_randf2(float min, float max)
85{
86 float r = (float)rand();
87 return r / RAND_MAX * (max - min) + min;
88}
89
Jason Sams22fa3712010-05-19 17:22:57 -070090static int SC_randi(int max)
91{
92 return (int)SC_randf(max);
93}
94
95static int SC_randi2(int min, int max)
96{
97 return (int)SC_randf2(min, max);
98}
99
Jason Samsbe36bf32010-05-11 14:03:58 -0700100static float SC_frac(float v)
101{
102 int i = (int)floor(v);
103 return fmin(v - i, 0x1.fffffep-1f);
104}
105
Romain Guy98e10fd2009-07-30 18:45:01 -0700106//////////////////////////////////////////////////////////////////////////////
107// Time routines
108//////////////////////////////////////////////////////////////////////////////
Jason Samse45ac6e2009-07-20 14:31:06 -0700109
Joe Onorato9c4e4ca2009-08-09 11:39:02 -0700110static int32_t SC_second()
Romain Guy98e10fd2009-07-30 18:45:01 -0700111{
112 GET_TLS();
113
114 time_t rawtime;
115 time(&rawtime);
116
Romain Guy519cdc92009-11-11 15:36:06 -0800117 struct tm *timeinfo;
118 timeinfo = localtime(&rawtime);
119 return timeinfo->tm_sec;
Romain Guy98e10fd2009-07-30 18:45:01 -0700120}
121
Joe Onorato9c4e4ca2009-08-09 11:39:02 -0700122static int32_t SC_minute()
Romain Guy98e10fd2009-07-30 18:45:01 -0700123{
124 GET_TLS();
Jason Samse5ffb872009-08-09 17:01:55 -0700125
Romain Guy98e10fd2009-07-30 18:45:01 -0700126 time_t rawtime;
127 time(&rawtime);
Jason Samse5ffb872009-08-09 17:01:55 -0700128
Romain Guy519cdc92009-11-11 15:36:06 -0800129 struct tm *timeinfo;
130 timeinfo = localtime(&rawtime);
131 return timeinfo->tm_min;
Jason Samse5ffb872009-08-09 17:01:55 -0700132}
Romain Guy98e10fd2009-07-30 18:45:01 -0700133
Joe Onorato9c4e4ca2009-08-09 11:39:02 -0700134static int32_t SC_hour()
Romain Guy98e10fd2009-07-30 18:45:01 -0700135{
136 GET_TLS();
Jason Samse5ffb872009-08-09 17:01:55 -0700137
Romain Guy98e10fd2009-07-30 18:45:01 -0700138 time_t rawtime;
139 time(&rawtime);
Jason Samse5ffb872009-08-09 17:01:55 -0700140
Romain Guy519cdc92009-11-11 15:36:06 -0800141 struct tm *timeinfo;
142 timeinfo = localtime(&rawtime);
143 return timeinfo->tm_hour;
Romain Guy39dbc802009-07-31 11:20:59 -0700144}
145
Joe Onorato9c4e4ca2009-08-09 11:39:02 -0700146static int32_t SC_day()
Romain Guy39dbc802009-07-31 11:20:59 -0700147{
148 GET_TLS();
Jason Samse5ffb872009-08-09 17:01:55 -0700149
Romain Guy39dbc802009-07-31 11:20:59 -0700150 time_t rawtime;
151 time(&rawtime);
Jason Samse5ffb872009-08-09 17:01:55 -0700152
Romain Guy519cdc92009-11-11 15:36:06 -0800153 struct tm *timeinfo;
154 timeinfo = localtime(&rawtime);
155 return timeinfo->tm_mday;
Jason Samse5ffb872009-08-09 17:01:55 -0700156}
Jason Samse45ac6e2009-07-20 14:31:06 -0700157
Joe Onorato9c4e4ca2009-08-09 11:39:02 -0700158static int32_t SC_month()
Romain Guy39dbc802009-07-31 11:20:59 -0700159{
160 GET_TLS();
Jason Samse5ffb872009-08-09 17:01:55 -0700161
Romain Guy39dbc802009-07-31 11:20:59 -0700162 time_t rawtime;
163 time(&rawtime);
Jason Samse5ffb872009-08-09 17:01:55 -0700164
Romain Guy519cdc92009-11-11 15:36:06 -0800165 struct tm *timeinfo;
166 timeinfo = localtime(&rawtime);
167 return timeinfo->tm_mon;
Jason Samse5ffb872009-08-09 17:01:55 -0700168}
Romain Guy39dbc802009-07-31 11:20:59 -0700169
Joe Onorato9c4e4ca2009-08-09 11:39:02 -0700170static int32_t SC_year()
Romain Guy39dbc802009-07-31 11:20:59 -0700171{
172 GET_TLS();
Jason Samse5ffb872009-08-09 17:01:55 -0700173
Romain Guy39dbc802009-07-31 11:20:59 -0700174 time_t rawtime;
175 time(&rawtime);
Jason Samse5ffb872009-08-09 17:01:55 -0700176
Romain Guy519cdc92009-11-11 15:36:06 -0800177 struct tm *timeinfo;
178 timeinfo = localtime(&rawtime);
179 return timeinfo->tm_year;
Romain Guy39dbc802009-07-31 11:20:59 -0700180}
181
Jason Samsef5867a2010-07-28 11:17:53 -0700182static int64_t SC_uptimeMillis()
Jason Sams22fa3712010-05-19 17:22:57 -0700183{
184 return nanoseconds_to_milliseconds(systemTime(SYSTEM_TIME_MONOTONIC));
185}
186
Jason Sams73495472010-07-29 17:31:14 -0700187static int64_t SC_uptimeNanos()
Jason Sams22fa3712010-05-19 17:22:57 -0700188{
Jason Sams73495472010-07-29 17:31:14 -0700189 return systemTime(SYSTEM_TIME_MONOTONIC);
Jason Sams22fa3712010-05-19 17:22:57 -0700190}
191
Jason Samsef5867a2010-07-28 11:17:53 -0700192static float SC_getDt()
Joe Onorato9c4e4ca2009-08-09 11:39:02 -0700193{
194 GET_TLS();
Jason Samsef5867a2010-07-28 11:17:53 -0700195 int64_t l = sc->mEnviroment.mLastDtTime;
196 sc->mEnviroment.mLastDtTime = systemTime(SYSTEM_TIME_MONOTONIC);
197 return ((float)(sc->mEnviroment.mLastDtTime - l)) / 1.0e9;
Jason Samse45ac6e2009-07-20 14:31:06 -0700198}
199
200
Jason Samse45ac6e2009-07-20 14:31:06 -0700201//////////////////////////////////////////////////////////////////////////////
202//
203//////////////////////////////////////////////////////////////////////////////
204
Jason Samsbe36bf32010-05-11 14:03:58 -0700205static uint32_t SC_allocGetDimX(RsAllocation va)
206{
207 GET_TLS();
208 const Allocation *a = static_cast<const Allocation *>(va);
209 //LOGE("SC_allocGetDimX a=%p", a);
210 //LOGE(" type=%p", a->getType());
211 return a->getType()->getDimX();
212}
213
214static uint32_t SC_allocGetDimY(RsAllocation va)
215{
216 GET_TLS();
217 const Allocation *a = static_cast<const Allocation *>(va);
218 return a->getType()->getDimY();
219}
220
221static uint32_t SC_allocGetDimZ(RsAllocation va)
222{
223 GET_TLS();
224 const Allocation *a = static_cast<const Allocation *>(va);
225 return a->getType()->getDimZ();
226}
227
228static uint32_t SC_allocGetDimLOD(RsAllocation va)
229{
230 GET_TLS();
231 const Allocation *a = static_cast<const Allocation *>(va);
232 return a->getType()->getDimLOD();
233}
234
235static uint32_t SC_allocGetDimFaces(RsAllocation va)
236{
237 GET_TLS();
238 const Allocation *a = static_cast<const Allocation *>(va);
239 return a->getType()->getDimFaces();
240}
241
Jason Sams7bf29dd2010-07-19 15:38:19 -0700242const void * SC_getElementAtX(RsAllocation va, uint32_t x)
243{
244 const Allocation *a = static_cast<const Allocation *>(va);
245 const Type *t = a->getType();
246 const uint8_t *p = (const uint8_t *)a->getPtr();
247 return &p[t->getElementSizeBytes() * x];
248}
249
250const void * SC_getElementAtXY(RsAllocation va, uint32_t x, uint32_t y)
251{
252 const Allocation *a = static_cast<const Allocation *>(va);
253 const Type *t = a->getType();
254 const uint8_t *p = (const uint8_t *)a->getPtr();
255 return &p[t->getElementSizeBytes() * (x + y*t->getDimX())];
256}
257
258const void * SC_getElementAtXYZ(RsAllocation va, uint32_t x, uint32_t y, uint32_t z)
259{
260 const Allocation *a = static_cast<const Allocation *>(va);
261 const Type *t = a->getType();
262 const uint8_t *p = (const uint8_t *)a->getPtr();
263 return &p[t->getElementSizeBytes() * (x + y*t->getDimX())];
264}
Jason Samsbe36bf32010-05-11 14:03:58 -0700265
Jason Samse45ac6e2009-07-20 14:31:06 -0700266
Jason Sams22fa3712010-05-19 17:22:57 -0700267static void SC_debugF(const char *s, float f) {
268 LOGE("%s %f, 0x%08x", s, f, *((int *) (&f)));
Jason Samsc9d43db2009-07-28 12:02:16 -0700269}
Jason Sams22fa3712010-05-19 17:22:57 -0700270static void SC_debugFv2(const char *s, rsvF_2 fv) {
271 float *f = (float *)&fv;
272 LOGE("%s {%f, %f}", s, f[0], f[1]);
Romain Guy370ed152009-08-20 17:08:33 -0700273}
Jason Sams22fa3712010-05-19 17:22:57 -0700274static void SC_debugFv3(const char *s, rsvF_4 fv) {
275 float *f = (float *)&fv;
276 LOGE("%s {%f, %f, %f}", s, f[0], f[1], f[2]);
Jason Samsc9d43db2009-07-28 12:02:16 -0700277}
Jason Sams22fa3712010-05-19 17:22:57 -0700278static void SC_debugFv4(const char *s, rsvF_4 fv) {
279 float *f = (float *)&fv;
280 LOGE("%s {%f, %f, %f, %f}", s, f[0], f[1], f[2], f[3]);
281}
282static void SC_debugI32(const char *s, int32_t i) {
283 LOGE("%s %i 0x%x", s, i, i);
Romain Guy370ed152009-08-20 17:08:33 -0700284}
Jason Samsef5867a2010-07-28 11:17:53 -0700285static void SC_debugU32(const char *s, uint32_t i) {
286 LOGE("%s %i 0x%x", s, i, i);
287}
Romain Guy370ed152009-08-20 17:08:33 -0700288
Jason Sams7bf29dd2010-07-19 15:38:19 -0700289static void SC_debugP(const char *s, const void *p) {
290 LOGE("%s %p", s, p);
291}
292
Jason Samsef5867a2010-07-28 11:17:53 -0700293static uint32_t SC_toClient2(int cmdID, void *data, int len)
Jason Sams8c401ef2009-10-06 13:58:47 -0700294{
295 GET_TLS();
Jason Samsef5867a2010-07-28 11:17:53 -0700296 //LOGE("SC_toClient %i %i %i", cmdID, len);
297 return rsc->sendMessageToClient(data, cmdID, len, false);
Jason Sams8c401ef2009-10-06 13:58:47 -0700298}
299
Jason Samsef5867a2010-07-28 11:17:53 -0700300static uint32_t SC_toClient(int cmdID)
Jason Sams3a27c952009-10-07 18:14:01 -0700301{
302 GET_TLS();
Jason Samsef5867a2010-07-28 11:17:53 -0700303 //LOGE("SC_toClient %i", cmdID);
304 return rsc->sendMessageToClient(NULL, cmdID, 0, false);
305}
306
307static uint32_t SC_toClientBlocking2(int cmdID, void *data, int len)
308{
309 GET_TLS();
310 //LOGE("SC_toClientBlocking %i %i", cmdID, len);
311 return rsc->sendMessageToClient(data, cmdID, len, true);
312}
313
314static uint32_t SC_toClientBlocking(int cmdID)
315{
316 GET_TLS();
317 //LOGE("SC_toClientBlocking %i", cmdID);
318 return rsc->sendMessageToClient(NULL, cmdID, 0, true);
Jason Sams3a27c952009-10-07 18:14:01 -0700319}
320
Jason Samsbe36bf32010-05-11 14:03:58 -0700321int SC_divsi3(int a, int b)
322{
323 return a / b;
324}
Jason Sams3a27c952009-10-07 18:14:01 -0700325
Jason Samsce92d4b2010-05-17 14:55:34 -0700326int SC_getAllocation(const void *ptr)
327{
328 GET_TLS();
329 const Allocation *alloc = sc->ptrToAllocation(ptr);
330 return (int)alloc;
331}
332
333
Jason Samsace3e012010-07-15 17:11:13 -0700334void SC_ForEach(RsScript vs,
335 RsAllocation vin,
336 RsAllocation vout,
337 const void *usr)
Jason Samsc61346b2010-05-28 18:23:22 -0700338{
339 GET_TLS();
Jason Samsace3e012010-07-15 17:11:13 -0700340 const Allocation *ain = static_cast<const Allocation *>(vin);
Jason Samsc61346b2010-05-28 18:23:22 -0700341 Allocation *aout = static_cast<Allocation *>(vout);
Jason Samsace3e012010-07-15 17:11:13 -0700342 Script *s = static_cast<Script *>(vs);
343 s->runForEach(rsc, ain, aout, usr);
Jason Samsc61346b2010-05-28 18:23:22 -0700344}
345
Jason Samsace3e012010-07-15 17:11:13 -0700346void SC_ForEach2(RsScript vs,
347 RsAllocation vin,
348 RsAllocation vout,
349 const void *usr,
350 const RsScriptCall *call)
Jason Samsc61346b2010-05-28 18:23:22 -0700351{
352 GET_TLS();
Jason Samsace3e012010-07-15 17:11:13 -0700353 const Allocation *ain = static_cast<const Allocation *>(vin);
Jason Samsc61346b2010-05-28 18:23:22 -0700354 Allocation *aout = static_cast<Allocation *>(vout);
Jason Samsc61346b2010-05-28 18:23:22 -0700355 Script *s = static_cast<Script *>(vs);
Jason Samsace3e012010-07-15 17:11:13 -0700356 s->runForEach(rsc, ain, aout, usr, call);
Jason Samsc61346b2010-05-28 18:23:22 -0700357}
358
Jason Samse45ac6e2009-07-20 14:31:06 -0700359//////////////////////////////////////////////////////////////////////////////
360// Class implementation
361//////////////////////////////////////////////////////////////////////////////
362
Jason Samsbe36bf32010-05-11 14:03:58 -0700363// llvm name mangling ref
364// <builtin-type> ::= v # void
365// ::= b # bool
366// ::= c # char
367// ::= a # signed char
368// ::= h # unsigned char
369// ::= s # short
370// ::= t # unsigned short
371// ::= i # int
372// ::= j # unsigned int
373// ::= l # long
374// ::= m # unsigned long
375// ::= x # long long, __int64
376// ::= y # unsigned long long, __int64
377// ::= f # float
378// ::= d # double
Jason Samse45ac6e2009-07-20 14:31:06 -0700379
Jason Samsaeb094b2010-05-18 13:35:45 -0700380static ScriptCState::SymbolTable_t gSyms[] = {
Jason Samsbe36bf32010-05-11 14:03:58 -0700381 { "__divsi3", (void *)&SC_divsi3 },
382
Jason Sams22fa3712010-05-19 17:22:57 -0700383 // allocation
Jason Samsef5867a2010-07-28 11:17:53 -0700384 { "_Z19rsAllocationGetDimX13rs_allocation", (void *)&SC_allocGetDimX },
385 { "_Z19rsAllocationGetDimY13rs_allocation", (void *)&SC_allocGetDimY },
386 { "_Z19rsAllocationGetDimZ13rs_allocation", (void *)&SC_allocGetDimZ },
387 { "_Z21rsAllocationGetDimLOD13rs_allocation", (void *)&SC_allocGetDimLOD },
388 { "_Z23rsAllocationGetDimFaces13rs_allocation", (void *)&SC_allocGetDimFaces },
389 { "_Z15rsGetAllocationPKv", (void *)&SC_getAllocation },
Jason Sams22fa3712010-05-19 17:22:57 -0700390
Jason Sams7bf29dd2010-07-19 15:38:19 -0700391 { "_Z14rsGetElementAt13rs_allocationj", (void *)&SC_getElementAtX },
392 { "_Z14rsGetElementAt13rs_allocationjj", (void *)&SC_getElementAtXY },
393 { "_Z14rsGetElementAt13rs_allocationjjj", (void *)&SC_getElementAtXYZ },
394
Jason Sams22fa3712010-05-19 17:22:57 -0700395 // Debug
396 { "_Z7rsDebugPKcf", (void *)&SC_debugF },
397 { "_Z7rsDebugPKcDv2_f", (void *)&SC_debugFv2 },
398 { "_Z7rsDebugPKcDv3_f", (void *)&SC_debugFv3 },
399 { "_Z7rsDebugPKcDv4_f", (void *)&SC_debugFv4 },
400 { "_Z7rsDebugPKci", (void *)&SC_debugI32 },
Jason Samsef5867a2010-07-28 11:17:53 -0700401 { "_Z7rsDebugPKcj", (void *)&SC_debugU32 },
Jason Sams7bf29dd2010-07-19 15:38:19 -0700402 { "_Z7rsDebugPKcPKv", (void *)&SC_debugP },
Jason Sams22fa3712010-05-19 17:22:57 -0700403
404 // RS Math
405 { "_Z6rsRandi", (void *)&SC_randi },
406 { "_Z6rsRandii", (void *)&SC_randi2 },
407 { "_Z6rsRandf", (void *)&SC_randf },
408 { "_Z6rsRandff", (void *)&SC_randf2 },
409 { "_Z6rsFracf", (void *)&SC_frac },
410
411 // time
Jason Sams73495472010-07-29 17:31:14 -0700412 { "_Z8rsSecondv", (void *)&SC_second },
413 { "_Z8rsMinutev", (void *)&SC_minute },
414 { "_Z6rsHourv", (void *)&SC_hour },
415 { "_Z5rsDayv", (void *)&SC_day },
416 { "_Z7rsMonthv", (void *)&SC_month },
417 { "_Z6rsYearv", (void *)&SC_year },
418 { "_Z14rsUptimeMillisv", (void*)&SC_uptimeMillis },
419 { "_Z13rsUptimeNanosv", (void*)&SC_uptimeNanos },
420 { "_Z7rsGetDtv", (void*)&SC_getDt },
Jason Sams22fa3712010-05-19 17:22:57 -0700421
Jason Samsef5867a2010-07-28 11:17:53 -0700422 { "_Z14rsSendToClienti", (void *)&SC_toClient },
423 { "_Z14rsSendToClientiPKvj", (void *)&SC_toClient2 },
424 { "_Z22rsSendToClientBlockingi", (void *)&SC_toClientBlocking },
425 { "_Z22rsSendToClientBlockingiPKvj", (void *)&SC_toClientBlocking2 },
Jason Sams22fa3712010-05-19 17:22:57 -0700426
Jason Samsace3e012010-07-15 17:11:13 -0700427 { "_Z9rsForEach9rs_script13rs_allocationS0_PKv", (void *)&SC_ForEach },
428 //{ "_Z9rsForEach9rs_script13rs_allocationS0_PKv", (void *)&SC_ForEach2 },
Jason Sams22fa3712010-05-19 17:22:57 -0700429
430////////////////////////////////////////////////////////////////////
431
Jason Samsbe36bf32010-05-11 14:03:58 -0700432 //{ "sinf_fast", (void *)&SC_sinf_fast },
433 //{ "cosf_fast", (void *)&SC_cosf_fast },
Jason Samse45ac6e2009-07-20 14:31:06 -0700434
Jason Samsbe36bf32010-05-11 14:03:58 -0700435 { NULL, NULL }
Jason Samse45ac6e2009-07-20 14:31:06 -0700436};
437
438const ScriptCState::SymbolTable_t * ScriptCState::lookupSymbol(const char *sym)
439{
440 ScriptCState::SymbolTable_t *syms = gSyms;
441
442 while (syms->mPtr) {
443 if (!strcmp(syms->mName, sym)) {
444 return syms;
445 }
446 syms++;
447 }
448 return NULL;
449}
450