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. 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 56 uint32_t SC_abs_i32(int32_t v) {return abs(v);} 57 58 static void SC_MatrixLoadRotate(Matrix4x4 *m, float rot, float x, float y, float z) { 59 m->loadRotate(rot, x, y, z); 60 } 61 static void SC_MatrixLoadScale(Matrix4x4 *m, float x, float y, float z) { 62 m->loadScale(x, y, z); 63 } 64 static void SC_MatrixLoadTranslate(Matrix4x4 *m, float x, float y, float z) { 65 m->loadTranslate(x, y, z); 66 } 67 static void SC_MatrixRotate(Matrix4x4 *m, float rot, float x, float y, float z) { 68 m->rotate(rot, x, y, z); 69 } 70 static void SC_MatrixScale(Matrix4x4 *m, float x, float y, float z) { 71 m->scale(x, y, z); 72 } 73 static void SC_MatrixTranslate(Matrix4x4 *m, float x, float y, float z) { 74 m->translate(x, y, z); 75 } 76 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 } 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 } 83 static void SC_MatrixLoadPerspective(Matrix4x4 *m, float fovy, float aspect, float near, float far) { 84 m->loadPerspective(fovy, aspect, near, far); 85 } 86 87 static bool SC_MatrixInverse_4x4(Matrix4x4 *m) { 88 return m->inverse(); 89 } 90 static bool SC_MatrixInverseTranspose_4x4(Matrix4x4 *m) { 91 return m->inverseTranspose(); 92 } 93 static void SC_MatrixTranspose_4x4(Matrix4x4 *m) { 94 m->transpose(); 95 } 96 static void SC_MatrixTranspose_3x3(Matrix3x3 *m) { 97 m->transpose(); 98 } 99 static void SC_MatrixTranspose_2x2(Matrix2x2 *m) { 100 m->transpose(); 101 } 102 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 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) 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) 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) 141 EXPORT_F32_FN_F32(ilogbf) 142 float SC_ldexpf(float v, int i) {return ldexpf(v, i);} 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) 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) 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 float __attribute__((overloadable)) rsFrac(float f) { 163 return SC_frac(f); 164 } 165 void __attribute__((overloadable)) rsMatrixLoadRotate(rs_matrix4x4 *m, 166 float rot, float x, float y, float z) { 167 SC_MatrixLoadRotate((Matrix4x4 *) m, rot, x, y, z); 168 } 169 void __attribute__((overloadable)) rsMatrixLoadScale(rs_matrix4x4 *m, 170 float x, float y, float z) { 171 SC_MatrixLoadScale((Matrix4x4 *) m, x, y, z); 172 } 173 void __attribute__((overloadable)) rsMatrixLoadTranslate(rs_matrix4x4 *m, 174 float x, float y, float z) { 175 SC_MatrixLoadTranslate((Matrix4x4 *) m, x, y, z); 176 } 177 void __attribute__((overloadable)) rsMatrixRotate(rs_matrix4x4 *m, float rot, 178 float x, float y, float z) { 179 SC_MatrixRotate((Matrix4x4 *) m, rot, x, y, z); 180 } 181 void __attribute__((overloadable)) rsMatrixScale(rs_matrix4x4 *m, float x, 182 float y, float z) { 183 SC_MatrixScale((Matrix4x4 *) m, x, y, z); 184 } 185 void __attribute__((overloadable)) rsMatrixTranslate(rs_matrix4x4 *m, float x, 186 float y, float z) { 187 SC_MatrixTranslate((Matrix4x4 *) m, x, y, z); 188 } 189 void __attribute__((overloadable)) rsMatrixLoadOrtho(rs_matrix4x4 *m, float l, 190 float r, float b, float t, float n, float f) { 191 SC_MatrixLoadOrtho((Matrix4x4 *) m, l, r, b, t, n, f); 192 } 193 void __attribute__((overloadable)) rsMatrixLoadFrustum(rs_matrix4x4 *m, 194 float l, float r, float b, float t, float n, float f) { 195 SC_MatrixLoadFrustum((Matrix4x4 *) m, l, r, b, t, n, f); 196 } 197 void __attribute__((overloadable)) rsMatrixLoadPerspective(rs_matrix4x4 *m, 198 float fovy, float aspect, float near, float far) { 199 SC_MatrixLoadPerspective((Matrix4x4 *) m, fovy, aspect, near, far); 200 } 201 bool __attribute__((overloadable)) rsMatrixInverse(rs_matrix4x4 *m) { 202 return SC_MatrixInverse_4x4((Matrix4x4 *) m); 203 } 204 bool __attribute__((overloadable)) rsMatrixInverseTranspose(rs_matrix4x4 *m) { 205 return SC_MatrixInverseTranspose_4x4((Matrix4x4 *) m); 206 } 207 void __attribute__((overloadable)) rsMatrixTranspose(rs_matrix4x4 *m) { 208 SC_MatrixTranspose_4x4((Matrix4x4 *) m); 209 } 210 void __attribute__((overloadable)) rsMatrixTranspose(rs_matrix3x3 *m) { 211 SC_MatrixTranspose_3x3((Matrix3x3 *) m); 212 } 213 void __attribute__((overloadable)) rsMatrixTranspose(rs_matrix2x2 *m) { 214 SC_MatrixTranspose_2x2((Matrix2x2 *) m); 215 } 216 #endif 217 218 ////////////////////////////////////////////////////////////////////////////// 219 // Class implementation 220 ////////////////////////////////////////////////////////////////////////////// 221 222 // llvm name mangling ref 223 // <builtin-type> ::= v # void 224 // ::= b # bool 225 // ::= c # char 226 // ::= a # signed char 227 // ::= h # unsigned char 228 // ::= s # short 229 // ::= t # unsigned short 230 // ::= i # int 231 // ::= j # unsigned int 232 // ::= l # long 233 // ::= m # unsigned long 234 // ::= x # long long, __int64 235 // ::= y # unsigned long long, __int64 236 // ::= f # float 237 // ::= d # double 238 239 static RsdCpuReference::CpuSymbol gSyms[] = { 240 { "_Z4acosf", (void *)&acosf, true }, 241 { "_Z5acoshf", (void *)&acoshf, true }, 242 { "_Z4asinf", (void *)&asinf, true }, 243 { "_Z5asinhf", (void *)&asinhf, true }, 244 { "_Z4atanf", (void *)&atanf, true }, 245 { "_Z5atan2ff", (void *)&atan2f, true }, 246 { "_Z5atanhf", (void *)&atanhf, true }, 247 { "_Z4cbrtf", (void *)&cbrtf, true }, 248 { "_Z4ceilf", (void *)&ceilf, true }, 249 { "_Z8copysignff", (void *)©signf, true }, 250 { "_Z3cosf", (void *)&cosf, true }, 251 { "_Z4coshf", (void *)&coshf, true }, 252 { "_Z4erfcf", (void *)&erfcf, true }, 253 { "_Z3erff", (void *)&erff, true }, 254 { "_Z3expf", (void *)&expf, true }, 255 { "_Z4exp2f", (void *)&exp2f, true }, 256 { "exp2f", (void *)&exp2f, true }, 257 { "_Z5expm1f", (void *)&expm1f, true }, 258 { "_Z4fdimff", (void *)&fdimf, true }, 259 { "_Z5floorf", (void *)&floorf, true }, 260 { "_Z3fmafff", (void *)&fmaf, true }, 261 { "_Z4fmaxff", (void *)&fmaxf, true }, 262 { "_Z4fminff", (void *)&fminf, true }, // float fmin(float, float) 263 { "_Z4fmodff", (void *)&fmodf, true }, 264 { "_Z5frexpfPi", (void *)&frexpf, true }, 265 { "_Z5hypotff", (void *)&hypotf, true }, 266 { "_Z5ilogbf", (void *)&ilogbf, true }, 267 { "_Z5ldexpfi", (void *)&ldexpf, true }, 268 { "_Z6lgammaf", (void *)&lgammaf, true }, 269 { "_Z6lgammafPi", (void *)&lgammaf_r, true }, 270 { "_Z3logf", (void *)&logf, true }, 271 { "_Z5log10f", (void *)&log10f, true }, 272 { "_Z5log1pf", (void *)&log1pf, true }, 273 { "_Z4logbf", (void *)&logbf, true }, 274 { "_Z4modffPf", (void *)&modff, true }, 275 //{ "_Z3nanj", (void *)&SC_nan, true }, 276 { "_Z9nextafterff", (void *)&nextafterf, true }, 277 { "_Z3powff", (void *)&powf, true }, 278 { "powf", (void *)&powf, true }, 279 { "_Z9remainderff", (void *)&remainderf, true }, 280 { "_Z6remquoffPi", (void *)&remquof, true }, 281 { "_Z4rintf", (void *)&rintf, true }, 282 { "_Z5roundf", (void *)&roundf, true }, 283 { "_Z3sinf", (void *)&sinf, true }, 284 { "_Z4sinhf", (void *)&sinhf, true }, 285 { "_Z4sqrtf", (void *)&sqrtf, true }, 286 { "_Z3tanf", (void *)&tanf, true }, 287 { "_Z4tanhf", (void *)&tanhf, true }, 288 { "_Z6tgammaf", (void *)&SC_tgammaf, true }, 289 { "_Z5truncf", (void *)&truncf, true }, 290 291 //{ "smoothstep", (void *)&, true }, 292 293 // matrix 294 { "_Z18rsMatrixLoadRotateP12rs_matrix4x4ffff", (void *)&SC_MatrixLoadRotate, true }, 295 { "_Z17rsMatrixLoadScaleP12rs_matrix4x4fff", (void *)&SC_MatrixLoadScale, true }, 296 { "_Z21rsMatrixLoadTranslateP12rs_matrix4x4fff", (void *)&SC_MatrixLoadTranslate, true }, 297 { "_Z14rsMatrixRotateP12rs_matrix4x4ffff", (void *)&SC_MatrixRotate, true }, 298 { "_Z13rsMatrixScaleP12rs_matrix4x4fff", (void *)&SC_MatrixScale, true }, 299 { "_Z17rsMatrixTranslateP12rs_matrix4x4fff", (void *)&SC_MatrixTranslate, true }, 300 301 { "_Z17rsMatrixLoadOrthoP12rs_matrix4x4ffffff", (void *)&SC_MatrixLoadOrtho, true }, 302 { "_Z19rsMatrixLoadFrustumP12rs_matrix4x4ffffff", (void *)&SC_MatrixLoadFrustum, true }, 303 { "_Z23rsMatrixLoadPerspectiveP12rs_matrix4x4ffff", (void *)&SC_MatrixLoadPerspective, true }, 304 305 { "_Z15rsMatrixInverseP12rs_matrix4x4", (void *)&SC_MatrixInverse_4x4, true }, 306 { "_Z24rsMatrixInverseTransposeP12rs_matrix4x4", (void *)&SC_MatrixInverseTranspose_4x4, true }, 307 { "_Z17rsMatrixTransposeP12rs_matrix4x4", (void *)&SC_MatrixTranspose_4x4, true }, 308 { "_Z17rsMatrixTransposeP12rs_matrix3x3", (void *)&SC_MatrixTranspose_3x3, true }, 309 { "_Z17rsMatrixTransposeP12rs_matrix2x2", (void *)&SC_MatrixTranspose_2x2, true }, 310 311 // RS Math 312 { "_Z6rsRandff", (void *)&SC_randf2, true }, 313 { "_Z6rsFracf", (void *)&SC_frac, true }, 314 315 { NULL, NULL, false } 316 }; 317 318 const RsdCpuReference::CpuSymbol * RsdCpuScriptImpl::lookupSymbolMath(const char *sym) { 319 const RsdCpuReference::CpuSymbol *syms = gSyms; 320 321 while (syms->fnPtr) { 322 if (!strcmp(syms->name, sym)) { 323 return syms; 324 } 325 syms++; 326 } 327 return NULL; 328 } 329 330
