rsScriptC_Lib.cpp revision 7349547db61d2d458b31c074b902d56d082e5d84 
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"
20
21#include "acc/acc.h"
22#include "utils/Timers.h"
23
24#include <time.h>
25
26using 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
34
35//////////////////////////////////////////////////////////////////////////////
36// Math routines
37//////////////////////////////////////////////////////////////////////////////
38
39static 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;
44
45    // scale angle for easy argument reduction
46    x *= A;
47
48    if (fabsf(x) >= 0.5f) {
49        // argument reduction
50        x = x - ceilf(x + 0.5f) + 1.0f;
51    }
52
53    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;
64
65    // scale angle for easy argument reduction
66    x *= A;
67
68    if (fabsf(x) >= 0.5f) {
69        // argument reduction
70        x = x - ceilf(x + 0.5f) + 1.0f;
71    }
72
73    const float y = B * x * fabsf(x) + C * x;
74    return 0.2215f * (y * fabsf(y) - y) + y;
75}
76
77
78static float SC_randf(float max)
79{
80    float r = (float)rand();
81    return r / RAND_MAX * max;
82}
83
84static float SC_randf2(float min, float max)
85{
86    float r = (float)rand();
87    return r / RAND_MAX * (max - min) + min;
88}
89
90static 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
100static float SC_frac(float v)
101{
102    int i = (int)floor(v);
103    return fmin(v - i, 0x1.fffffep-1f);
104}
105
106//////////////////////////////////////////////////////////////////////////////
107// Time routines
108//////////////////////////////////////////////////////////////////////////////
109
110static int32_t SC_second()
111{
112    GET_TLS();
113
114    time_t rawtime;
115    time(&rawtime);
116
117    struct tm *timeinfo;
118    timeinfo = localtime(&rawtime);
119    return timeinfo->tm_sec;
120}
121
122static int32_t SC_minute()
123{
124    GET_TLS();
125
126    time_t rawtime;
127    time(&rawtime);
128
129    struct tm *timeinfo;
130    timeinfo = localtime(&rawtime);
131    return timeinfo->tm_min;
132}
133
134static int32_t SC_hour()
135{
136    GET_TLS();
137
138    time_t rawtime;
139    time(&rawtime);
140
141    struct tm *timeinfo;
142    timeinfo = localtime(&rawtime);
143    return timeinfo->tm_hour;
144}
145
146static int32_t SC_day()
147{
148    GET_TLS();
149
150    time_t rawtime;
151    time(&rawtime);
152
153    struct tm *timeinfo;
154    timeinfo = localtime(&rawtime);
155    return timeinfo->tm_mday;
156}
157
158static int32_t SC_month()
159{
160    GET_TLS();
161
162    time_t rawtime;
163    time(&rawtime);
164
165    struct tm *timeinfo;
166    timeinfo = localtime(&rawtime);
167    return timeinfo->tm_mon;
168}
169
170static int32_t SC_year()
171{
172    GET_TLS();
173
174    time_t rawtime;
175    time(&rawtime);
176
177    struct tm *timeinfo;
178    timeinfo = localtime(&rawtime);
179    return timeinfo->tm_year;
180}
181
182static int64_t SC_uptimeMillis()
183{
184    return nanoseconds_to_milliseconds(systemTime(SYSTEM_TIME_MONOTONIC));
185}
186
187static int64_t SC_uptimeNanos()
188{
189    return systemTime(SYSTEM_TIME_MONOTONIC);
190}
191
192static float SC_getDt()
193{
194    GET_TLS();
195    int64_t l = sc->mEnviroment.mLastDtTime;
196    sc->mEnviroment.mLastDtTime = systemTime(SYSTEM_TIME_MONOTONIC);
197    return ((float)(sc->mEnviroment.mLastDtTime - l)) / 1.0e9;
198}
199
200
201//////////////////////////////////////////////////////////////////////////////
202//
203//////////////////////////////////////////////////////////////////////////////
204
205static 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
242const 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}
265
266
267static void SC_debugF(const char *s, float f) {
268    LOGE("%s %f, 0x%08x", s, f, *((int *) (&f)));
269}
270static void SC_debugFv2(const char *s, rsvF_2 fv) {
271    float *f = (float *)&fv;
272    LOGE("%s {%f, %f}", s, f[0], f[1]);
273}
274static 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]);
277}
278static 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);
284}
285static void SC_debugU32(const char *s, uint32_t i) {
286    LOGE("%s %i  0x%x", s, i, i);
287}
288
289static void SC_debugP(const char *s, const void *p) {
290    LOGE("%s %p", s, p);
291}
292
293static uint32_t SC_toClient2(int cmdID, void *data, int len)
294{
295    GET_TLS();
296    //LOGE("SC_toClient %i %i %i", cmdID, len);
297    return rsc->sendMessageToClient(data, cmdID, len, false);
298}
299
300static uint32_t SC_toClient(int cmdID)
301{
302    GET_TLS();
303    //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);
319}
320
321int SC_divsi3(int a, int b)
322{
323    return a / b;
324}
325
326int SC_getAllocation(const void *ptr)
327{
328    GET_TLS();
329    const Allocation *alloc = sc->ptrToAllocation(ptr);
330    return (int)alloc;
331}
332
333
334void SC_ForEach(RsScript vs,
335                RsAllocation vin,
336                RsAllocation vout,
337                const void *usr)
338{
339    GET_TLS();
340    const Allocation *ain = static_cast<const Allocation *>(vin);
341    Allocation *aout = static_cast<Allocation *>(vout);
342    Script *s = static_cast<Script *>(vs);
343    s->runForEach(rsc, ain, aout, usr);
344}
345
346void SC_ForEach2(RsScript vs,
347                RsAllocation vin,
348                RsAllocation vout,
349                const void *usr,
350                const RsScriptCall *call)
351{
352    GET_TLS();
353    const Allocation *ain = static_cast<const Allocation *>(vin);
354    Allocation *aout = static_cast<Allocation *>(vout);
355    Script *s = static_cast<Script *>(vs);
356    s->runForEach(rsc, ain, aout, usr, call);
357}
358
359//////////////////////////////////////////////////////////////////////////////
360// Class implementation
361//////////////////////////////////////////////////////////////////////////////
362
363// 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
379
380static ScriptCState::SymbolTable_t gSyms[] = {
381    { "__divsi3", (void *)&SC_divsi3 },
382
383    // allocation
384    { "_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 },
390
391    { "_Z14rsGetElementAt13rs_allocationj", (void *)&SC_getElementAtX },
392    { "_Z14rsGetElementAt13rs_allocationjj", (void *)&SC_getElementAtXY },
393    { "_Z14rsGetElementAt13rs_allocationjjj", (void *)&SC_getElementAtXYZ },
394
395    // 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 },
401    { "_Z7rsDebugPKcj", (void *)&SC_debugU32 },
402    { "_Z7rsDebugPKcPKv", (void *)&SC_debugP },
403
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
412    { "_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 },
421
422    { "_Z14rsSendToClienti", (void *)&SC_toClient },
423    { "_Z14rsSendToClientiPKvj", (void *)&SC_toClient2 },
424    { "_Z22rsSendToClientBlockingi", (void *)&SC_toClientBlocking },
425    { "_Z22rsSendToClientBlockingiPKvj", (void *)&SC_toClientBlocking2 },
426
427    { "_Z9rsForEach9rs_script13rs_allocationS0_PKv", (void *)&SC_ForEach },
428    //{ "_Z9rsForEach9rs_script13rs_allocationS0_PKv", (void *)&SC_ForEach2 },
429
430////////////////////////////////////////////////////////////////////
431
432    //{ "sinf_fast", (void *)&SC_sinf_fast },
433    //{ "cosf_fast", (void *)&SC_cosf_fast },
434
435    { NULL, NULL }
436};
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
451