1 /* 2 * Copyright (C) 2011-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 #if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB) 18 #include <cutils/compiler.h> 19 #endif 20 21 #include "rsContext.h" 22 #include "rsScriptC.h" 23 #include "rsMatrix4x4.h" 24 #include "rsMatrix3x3.h" 25 #include "rsMatrix2x2.h" 26 27 #include "rsCpuCore.h" 28 #include "rsCpuScript.h" 29 30 using namespace android; 31 using namespace android::renderscript; 32 33 #define EXPORT_F32_FN_F32(func) \ 34 float __attribute__((overloadable)) SC_##func(float v) { \ 35 return func(v); \ 36 } 37 38 #define EXPORT_F32_FN_F32_F32(func) \ 39 float __attribute__((overloadable)) SC_##func(float t, float v) { \ 40 return func(t, v); \ 41 } 42 43 ////////////////////////////////////////////////////////////////////////////// 44 // Float util 45 ////////////////////////////////////////////////////////////////////////////// 46 47 // Handle missing Gingerbread functions like tgammaf. SC_tgammaf(float x)48 float SC_tgammaf(float x) { 49 #ifdef RS_COMPATIBILITY_LIB 50 return tgamma(x); 51 #else 52 return tgammaf(x); 53 #endif 54 } 55 SC_abs_i32(int32_t v)56 uint32_t SC_abs_i32(int32_t v) {return abs(v);} 57 SC_MatrixLoadRotate(Matrix4x4 * m,float rot,float x,float y,float z)58 static void SC_MatrixLoadRotate(Matrix4x4 *m, float rot, float x, float y, float z) { 59 m->loadRotate(rot, x, y, z); 60 } SC_MatrixLoadScale(Matrix4x4 * m,float x,float y,float z)61 static void SC_MatrixLoadScale(Matrix4x4 *m, float x, float y, float z) { 62 m->loadScale(x, y, z); 63 } SC_MatrixLoadTranslate(Matrix4x4 * m,float x,float y,float z)64 static void SC_MatrixLoadTranslate(Matrix4x4 *m, float x, float y, float z) { 65 m->loadTranslate(x, y, z); 66 } SC_MatrixRotate(Matrix4x4 * m,float rot,float x,float y,float z)67 static void SC_MatrixRotate(Matrix4x4 *m, float rot, float x, float y, float z) { 68 m->rotate(rot, x, y, z); 69 } SC_MatrixScale(Matrix4x4 * m,float x,float y,float z)70 static void SC_MatrixScale(Matrix4x4 *m, float x, float y, float z) { 71 m->scale(x, y, z); 72 } SC_MatrixTranslate(Matrix4x4 * m,float x,float y,float z)73 static void SC_MatrixTranslate(Matrix4x4 *m, float x, float y, float z) { 74 m->translate(x, y, z); 75 } 76 SC_MatrixLoadOrtho(Matrix4x4 * m,float l,float r,float b,float t,float n,float f)77 static void SC_MatrixLoadOrtho(Matrix4x4 *m, float l, float r, float b, float t, float n, float f) { 78 m->loadOrtho(l, r, b, t, n, f); 79 } SC_MatrixLoadFrustum(Matrix4x4 * m,float l,float r,float b,float t,float n,float f)80 static void SC_MatrixLoadFrustum(Matrix4x4 *m, float l, float r, float b, float t, float n, float f) { 81 m->loadFrustum(l, r, b, t, n, f); 82 } SC_MatrixLoadPerspective(Matrix4x4 * m,float fovy,float aspect,float near,float far)83 static void SC_MatrixLoadPerspective(Matrix4x4 *m, float fovy, float aspect, float near, float far) { 84 m->loadPerspective(fovy, aspect, near, far); 85 } 86 SC_MatrixInverse_4x4(Matrix4x4 * m)87 static bool SC_MatrixInverse_4x4(Matrix4x4 *m) { 88 return m->inverse(); 89 } SC_MatrixInverseTranspose_4x4(Matrix4x4 * m)90 static bool SC_MatrixInverseTranspose_4x4(Matrix4x4 *m) { 91 return m->inverseTranspose(); 92 } SC_MatrixTranspose_4x4(Matrix4x4 * m)93 static void SC_MatrixTranspose_4x4(Matrix4x4 *m) { 94 m->transpose(); 95 } SC_MatrixTranspose_3x3(Matrix3x3 * m)96 static void SC_MatrixTranspose_3x3(Matrix3x3 *m) { 97 m->transpose(); 98 } SC_MatrixTranspose_2x2(Matrix2x2 * m)99 static void SC_MatrixTranspose_2x2(Matrix2x2 *m) { 100 m->transpose(); 101 } 102 SC_randf2(float min,float max)103 float SC_randf2(float min, float max) { 104 float r = (float)rand(); 105 r /= RAND_MAX; 106 r = r * (max - min) + min; 107 return r; 108 } 109 SC_frac(float v)110 static float SC_frac(float v) { 111 int i = (int)floor(v); 112 return fmin(v - i, 0x1.fffffep-1f); 113 } 114 115 #ifdef RS_COMPATIBILITY_LIB 116 EXPORT_F32_FN_F32(acosf) EXPORT_F32_FN_F32(acoshf)117 EXPORT_F32_FN_F32(acoshf) 118 EXPORT_F32_FN_F32(asinf) 119 EXPORT_F32_FN_F32(asinhf) 120 EXPORT_F32_FN_F32(atanf) 121 EXPORT_F32_FN_F32_F32(atan2f) 122 EXPORT_F32_FN_F32(atanhf) 123 EXPORT_F32_FN_F32(cbrtf) 124 EXPORT_F32_FN_F32(ceilf) 125 EXPORT_F32_FN_F32_F32(copysignf) 126 EXPORT_F32_FN_F32(cosf) 127 EXPORT_F32_FN_F32(coshf) 128 EXPORT_F32_FN_F32(erfcf) 129 EXPORT_F32_FN_F32(erff) 130 EXPORT_F32_FN_F32(expf) 131 EXPORT_F32_FN_F32(exp2f) 132 EXPORT_F32_FN_F32(expm1f) 133 EXPORT_F32_FN_F32_F32(fdimf) 134 EXPORT_F32_FN_F32(floorf) 135 float SC_fmaf(float u, float t, float v) {return fmaf(u, t, v);} 136 EXPORT_F32_FN_F32_F32(fmaxf) EXPORT_F32_FN_F32_F32(fminf)137 EXPORT_F32_FN_F32_F32(fminf) 138 EXPORT_F32_FN_F32_F32(fmodf) 139 float SC_frexpf(float v, int* ptr) {return frexpf(v, ptr);} 140 EXPORT_F32_FN_F32_F32(hypotf) EXPORT_F32_FN_F32(ilogbf)141 EXPORT_F32_FN_F32(ilogbf) 142 float SC_ldexpf(float v, int i) {return ldexpf(v, i);} EXPORT_F32_FN_F32(lgammaf)143 EXPORT_F32_FN_F32(lgammaf) 144 float SC_lgammaf_r(float v, int* ptr) {return lgammaf_r(v, ptr);} 145 EXPORT_F32_FN_F32(logf) EXPORT_F32_FN_F32(log10f)146 EXPORT_F32_FN_F32(log10f) 147 EXPORT_F32_FN_F32(log1pf) 148 EXPORT_F32_FN_F32(logbf) 149 float SC_modff(float v, float* ptr) {return modff(v, ptr);} 150 EXPORT_F32_FN_F32_F32(nextafterf) EXPORT_F32_FN_F32_F32(powf)151 EXPORT_F32_FN_F32_F32(powf) 152 EXPORT_F32_FN_F32_F32(remainderf) 153 float SC_remquof(float t, float v, int* ptr) {return remquof(t, v, ptr);} 154 EXPORT_F32_FN_F32(rintf) 155 EXPORT_F32_FN_F32(roundf) 156 EXPORT_F32_FN_F32(sinf) 157 EXPORT_F32_FN_F32(sinhf) 158 EXPORT_F32_FN_F32(sqrtf) 159 EXPORT_F32_FN_F32(tanf) 160 EXPORT_F32_FN_F32(tanhf) 161 EXPORT_F32_FN_F32(truncf) 162 #endif 163 164 ////////////////////////////////////////////////////////////////////////////// 165 // Class implementation 166 ////////////////////////////////////////////////////////////////////////////// 167 168 // llvm name mangling ref 169 // <builtin-type> ::= v # void 170 // ::= b # bool 171 // ::= c # char 172 // ::= a # signed char 173 // ::= h # unsigned char 174 // ::= s # short 175 // ::= t # unsigned short 176 // ::= i # int 177 // ::= j # unsigned int 178 // ::= l # long 179 // ::= m # unsigned long 180 // ::= x # long long, __int64 181 // ::= y # unsigned long long, __int64 182 // ::= f # float 183 // ::= d # double 184 185 static RsdCpuReference::CpuSymbol gSyms[] = { 186 { "_Z4acosf", (void *)&acosf, true }, 187 { "_Z5acoshf", (void *)&acoshf, true }, 188 { "_Z4asinf", (void *)&asinf, true }, 189 { "_Z5asinhf", (void *)&asinhf, true }, 190 { "_Z4atanf", (void *)&atanf, true }, 191 { "_Z5atan2ff", (void *)&atan2f, true }, 192 { "_Z5atanhf", (void *)&atanhf, true }, 193 { "_Z4cbrtf", (void *)&cbrtf, true }, 194 { "_Z4ceilf", (void *)&ceilf, true }, 195 { "_Z8copysignff", (void *)©signf, true }, 196 { "_Z3cosf", (void *)&cosf, true }, 197 { "_Z4coshf", (void *)&coshf, true }, 198 { "_Z4erfcf", (void *)&erfcf, true }, 199 { "_Z3erff", (void *)&erff, true }, 200 { "_Z3expf", (void *)&expf, true }, 201 { "_Z4exp2f", (void *)&exp2f, true }, 202 { "_Z5expm1f", (void *)&expm1f, true }, 203 { "_Z4fdimff", (void *)&fdimf, true }, 204 { "_Z5floorf", (void *)&floorf, true }, 205 { "_Z3fmafff", (void *)&fmaf, true }, 206 { "_Z4fmaxff", (void *)&fmaxf, true }, 207 { "_Z4fminff", (void *)&fminf, true }, // float fmin(float, float) 208 { "_Z4fmodff", (void *)&fmodf, true }, 209 { "_Z5frexpfPi", (void *)&frexpf, true }, 210 { "_Z5hypotff", (void *)&hypotf, true }, 211 { "_Z5ilogbf", (void *)&ilogbf, true }, 212 { "_Z5ldexpfi", (void *)&ldexpf, true }, 213 { "_Z6lgammaf", (void *)&lgammaf, true }, 214 { "_Z6lgammafPi", (void *)&lgammaf_r, true }, 215 { "_Z3logf", (void *)&logf, true }, 216 { "_Z5log10f", (void *)&log10f, true }, 217 { "_Z5log1pf", (void *)&log1pf, true }, 218 { "_Z4logbf", (void *)&logbf, true }, 219 { "_Z4modffPf", (void *)&modff, true }, 220 //{ "_Z3nanj", (void *)&SC_nan, true }, 221 { "_Z9nextafterff", (void *)&nextafterf, true }, 222 { "_Z3powff", (void *)&powf, true }, 223 { "_Z9remainderff", (void *)&remainderf, true }, 224 { "_Z6remquoffPi", (void *)&remquof, true }, 225 { "_Z4rintf", (void *)&rintf, true }, 226 { "_Z5roundf", (void *)&roundf, true }, 227 { "_Z3sinf", (void *)&sinf, true }, 228 { "_Z4sinhf", (void *)&sinhf, true }, 229 { "_Z4sqrtf", (void *)&sqrtf, true }, 230 { "_Z3tanf", (void *)&tanf, true }, 231 { "_Z4tanhf", (void *)&tanhf, true }, 232 { "_Z6tgammaf", (void *)&SC_tgammaf, true }, 233 { "_Z5truncf", (void *)&truncf, true }, 234 235 //{ "smoothstep", (void *)&, true }, 236 237 // matrix 238 { "_Z18rsMatrixLoadRotateP12rs_matrix4x4ffff", (void *)&SC_MatrixLoadRotate, true }, 239 { "_Z17rsMatrixLoadScaleP12rs_matrix4x4fff", (void *)&SC_MatrixLoadScale, true }, 240 { "_Z21rsMatrixLoadTranslateP12rs_matrix4x4fff", (void *)&SC_MatrixLoadTranslate, true }, 241 { "_Z14rsMatrixRotateP12rs_matrix4x4ffff", (void *)&SC_MatrixRotate, true }, 242 { "_Z13rsMatrixScaleP12rs_matrix4x4fff", (void *)&SC_MatrixScale, true }, 243 { "_Z17rsMatrixTranslateP12rs_matrix4x4fff", (void *)&SC_MatrixTranslate, true }, 244 245 { "_Z17rsMatrixLoadOrthoP12rs_matrix4x4ffffff", (void *)&SC_MatrixLoadOrtho, true }, 246 { "_Z19rsMatrixLoadFrustumP12rs_matrix4x4ffffff", (void *)&SC_MatrixLoadFrustum, true }, 247 { "_Z23rsMatrixLoadPerspectiveP12rs_matrix4x4ffff", (void *)&SC_MatrixLoadPerspective, true }, 248 249 { "_Z15rsMatrixInverseP12rs_matrix4x4", (void *)&SC_MatrixInverse_4x4, true }, 250 { "_Z24rsMatrixInverseTransposeP12rs_matrix4x4", (void *)&SC_MatrixInverseTranspose_4x4, true }, 251 { "_Z17rsMatrixTransposeP12rs_matrix4x4", (void *)&SC_MatrixTranspose_4x4, true }, 252 { "_Z17rsMatrixTransposeP12rs_matrix3x3", (void *)&SC_MatrixTranspose_3x3, true }, 253 { "_Z17rsMatrixTransposeP12rs_matrix2x2", (void *)&SC_MatrixTranspose_2x2, true }, 254 255 // RS Math 256 { "_Z6rsRandff", (void *)&SC_randf2, true }, 257 { "_Z6rsFracf", (void *)&SC_frac, true }, 258 259 { NULL, NULL, false } 260 }; 261 lookupSymbolMath(const char * sym)262 const RsdCpuReference::CpuSymbol * RsdCpuScriptImpl::lookupSymbolMath(const char *sym) { 263 const RsdCpuReference::CpuSymbol *syms = gSyms; 264 265 while (syms->fnPtr) { 266 if (!strcmp(syms->name, sym)) { 267 return syms; 268 } 269 syms++; 270 } 271 return NULL; 272 } 273 274