rsdRuntimeStubs.cpp revision 64147ebf4f0b1c23d2caf2cf7c1675d27de97d99
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#include "rsContext.h" 18#include "rsScriptC.h" 19#include "rsMatrix4x4.h" 20#include "rsMatrix3x3.h" 21#include "rsMatrix2x2.h" 22#include "rsRuntime.h" 23 24#include "rsdCore.h" 25#include "rsdBcc.h" 26 27#include "rsdPath.h" 28#include "rsdAllocation.h" 29#include "rsdShaderCache.h" 30#include "rsdVertexArray.h" 31 32#include <time.h> 33 34using namespace android; 35using namespace android::renderscript; 36 37typedef float float2 __attribute__((ext_vector_type(2))); 38typedef float float3 __attribute__((ext_vector_type(3))); 39typedef float float4 __attribute__((ext_vector_type(4))); 40typedef double double2 __attribute__((ext_vector_type(2))); 41typedef double double3 __attribute__((ext_vector_type(3))); 42typedef double double4 __attribute__((ext_vector_type(4))); 43typedef char char2 __attribute__((ext_vector_type(2))); 44typedef char char3 __attribute__((ext_vector_type(3))); 45typedef char char4 __attribute__((ext_vector_type(4))); 46typedef unsigned char uchar2 __attribute__((ext_vector_type(2))); 47typedef unsigned char uchar3 __attribute__((ext_vector_type(3))); 48typedef unsigned char uchar4 __attribute__((ext_vector_type(4))); 49typedef short short2 __attribute__((ext_vector_type(2))); 50typedef short short3 __attribute__((ext_vector_type(3))); 51typedef short short4 __attribute__((ext_vector_type(4))); 52typedef unsigned short ushort2 __attribute__((ext_vector_type(2))); 53typedef unsigned short ushort3 __attribute__((ext_vector_type(3))); 54typedef unsigned short ushort4 __attribute__((ext_vector_type(4))); 55typedef int32_t int2 __attribute__((ext_vector_type(2))); 56typedef int32_t int3 __attribute__((ext_vector_type(3))); 57typedef int32_t int4 __attribute__((ext_vector_type(4))); 58typedef uint32_t uint2 __attribute__((ext_vector_type(2))); 59typedef uint32_t uint3 __attribute__((ext_vector_type(3))); 60typedef uint32_t uint4 __attribute__((ext_vector_type(4))); 61typedef long long long2 __attribute__((ext_vector_type(2))); 62typedef long long long3 __attribute__((ext_vector_type(3))); 63typedef long long long4 __attribute__((ext_vector_type(4))); 64typedef unsigned long long ulong2 __attribute__((ext_vector_type(2))); 65typedef unsigned long long ulong3 __attribute__((ext_vector_type(3))); 66typedef unsigned long long ulong4 __attribute__((ext_vector_type(4))); 67 68typedef uint8_t uchar; 69typedef uint16_t ushort; 70typedef uint32_t uint; 71#ifndef RS_SERVER 72typedef uint64_t ulong; 73#endif 74 75#ifdef RS_COMPATIBILITY_LIB 76#define OPAQUETYPE(t) \ 77 typedef struct { const int* const p; } __attribute__((packed, aligned(4))) t; 78 79OPAQUETYPE(rs_element) 80OPAQUETYPE(rs_type) 81OPAQUETYPE(rs_allocation) 82OPAQUETYPE(rs_sampler) 83OPAQUETYPE(rs_script) 84OPAQUETYPE(rs_script_call) 85#undef OPAQUETYPE 86 87typedef enum { 88 // Empty to avoid conflicting definitions with RsAllocationCubemapFace 89} rs_allocation_cubemap_face; 90 91typedef struct { 92 int tm_sec; ///< seconds 93 int tm_min; ///< minutes 94 int tm_hour; ///< hours 95 int tm_mday; ///< day of the month 96 int tm_mon; ///< month 97 int tm_year; ///< year 98 int tm_wday; ///< day of the week 99 int tm_yday; ///< day of the year 100 int tm_isdst; ///< daylight savings time 101} rs_tm; 102#endif 103 104////////////////////////////////////////////////////////////////////////////// 105// Allocation 106////////////////////////////////////////////////////////////////////////////// 107 108 109static void SC_AllocationSyncAll2(android::renderscript::rs_allocation a, RsAllocationUsageType source) { 110 Context *rsc = RsdCpuReference::getTlsContext(); 111 rsrAllocationSyncAll(rsc, (Allocation*)a.p, source); 112} 113 114static void SC_AllocationSyncAll(android::renderscript::rs_allocation a) { 115 Context *rsc = RsdCpuReference::getTlsContext(); 116 rsrAllocationSyncAll(rsc, (Allocation*)a.p, RS_ALLOCATION_USAGE_SCRIPT); 117} 118 119#ifndef RS_COMPATIBILITY_LIB 120 121static void SC_AllocationCopy1DRange(android::renderscript::rs_allocation dstAlloc, 122 uint32_t dstOff, 123 uint32_t dstMip, 124 uint32_t count, 125 android::renderscript::rs_allocation srcAlloc, 126 uint32_t srcOff, uint32_t srcMip) { 127 Context *rsc = RsdCpuReference::getTlsContext(); 128 rsrAllocationCopy1DRange(rsc, (Allocation*)dstAlloc.p, dstOff, dstMip, count, 129 (Allocation*)srcAlloc.p, srcOff, srcMip); 130} 131 132static void SC_AllocationCopy2DRange(android::renderscript::rs_allocation dstAlloc, 133 uint32_t dstXoff, uint32_t dstYoff, 134 uint32_t dstMip, uint32_t dstFace, 135 uint32_t width, uint32_t height, 136 android::renderscript::rs_allocation srcAlloc, 137 uint32_t srcXoff, uint32_t srcYoff, 138 uint32_t srcMip, uint32_t srcFace) { 139 Context *rsc = RsdCpuReference::getTlsContext(); 140 rsrAllocationCopy2DRange(rsc, (Allocation*)dstAlloc.p, 141 dstXoff, dstYoff, dstMip, dstFace, 142 width, height, 143 (Allocation*)srcAlloc.p, 144 srcXoff, srcYoff, srcMip, srcFace); 145} 146 147static void SC_AllocationIoSend(android::renderscript::rs_allocation alloc) { 148 Context *rsc = RsdCpuReference::getTlsContext(); 149 rsrAllocationIoSend(rsc, (Allocation*)alloc.p); 150} 151 152 153static void SC_AllocationIoReceive(android::renderscript::rs_allocation alloc) { 154 Context *rsc = RsdCpuReference::getTlsContext(); 155 rsrAllocationIoReceive(rsc, (Allocation*)alloc.p); 156} 157 158#else 159 160static void SC_AllocationCopy1DRange(::rs_allocation dstAlloc, 161 uint32_t dstOff, 162 uint32_t dstMip, 163 uint32_t count, 164 ::rs_allocation srcAlloc, 165 uint32_t srcOff, uint32_t srcMip) { 166 Context *rsc = RsdCpuReference::getTlsContext(); 167 rsrAllocationCopy1DRange(rsc, (Allocation*)dstAlloc.p, dstOff, dstMip, count, 168 (Allocation*)srcAlloc.p, srcOff, srcMip); 169} 170 171static void SC_AllocationCopy2DRange(::rs_allocation dstAlloc, 172 uint32_t dstXoff, uint32_t dstYoff, 173 uint32_t dstMip, uint32_t dstFace, 174 uint32_t width, uint32_t height, 175 ::rs_allocation srcAlloc, 176 uint32_t srcXoff, uint32_t srcYoff, 177 uint32_t srcMip, uint32_t srcFace) { 178 Context *rsc = RsdCpuReference::getTlsContext(); 179 rsrAllocationCopy2DRange(rsc, (Allocation*)dstAlloc.p, 180 dstXoff, dstYoff, dstMip, dstFace, 181 width, height, 182 (Allocation*)srcAlloc.p, 183 srcXoff, srcYoff, srcMip, srcFace); 184} 185 186static void SC_AllocationIoSend(Allocation* alloc) { 187 Context *rsc = RsdCpuReference::getTlsContext(); 188 rsrAllocationIoSend(rsc, alloc); 189} 190 191 192static void SC_AllocationIoReceive(Allocation* alloc) { 193 Context *rsc = RsdCpuReference::getTlsContext(); 194 rsrAllocationIoReceive(rsc, alloc); 195} 196 197#endif 198 199#ifndef RS_COMPATIBILITY_LIB 200 201////////////////////////////////////////////////////////////////////////////// 202// Context 203////////////////////////////////////////////////////////////////////////////// 204 205static void SC_BindTexture(ProgramFragment *pf, uint32_t slot, Allocation *a) { 206 Context *rsc = RsdCpuReference::getTlsContext(); 207 rsrBindTexture(rsc, pf, slot, a); 208} 209 210static void SC_BindVertexConstant(ProgramVertex *pv, uint32_t slot, Allocation *a) { 211 Context *rsc = RsdCpuReference::getTlsContext(); 212 rsrBindConstant(rsc, pv, slot, a); 213} 214 215static void SC_BindFragmentConstant(ProgramFragment *pf, uint32_t slot, Allocation *a) { 216 Context *rsc = RsdCpuReference::getTlsContext(); 217 rsrBindConstant(rsc, pf, slot, a); 218} 219 220static void SC_BindSampler(ProgramFragment *pf, uint32_t slot, Sampler *s) { 221 Context *rsc = RsdCpuReference::getTlsContext(); 222 rsrBindSampler(rsc, pf, slot, s); 223} 224 225static void SC_BindProgramStore(ProgramStore *ps) { 226 Context *rsc = RsdCpuReference::getTlsContext(); 227 rsrBindProgramStore(rsc, ps); 228} 229 230static void SC_BindProgramFragment(ProgramFragment *pf) { 231 Context *rsc = RsdCpuReference::getTlsContext(); 232 rsrBindProgramFragment(rsc, pf); 233} 234 235static void SC_BindProgramVertex(ProgramVertex *pv) { 236 Context *rsc = RsdCpuReference::getTlsContext(); 237 rsrBindProgramVertex(rsc, pv); 238} 239 240static void SC_BindProgramRaster(ProgramRaster *pr) { 241 Context *rsc = RsdCpuReference::getTlsContext(); 242 rsrBindProgramRaster(rsc, pr); 243} 244 245static void SC_BindFrameBufferObjectColorTarget(Allocation *a, uint32_t slot) { 246 Context *rsc = RsdCpuReference::getTlsContext(); 247 rsrBindFrameBufferObjectColorTarget(rsc, a, slot); 248} 249 250static void SC_BindFrameBufferObjectDepthTarget(Allocation *a) { 251 Context *rsc = RsdCpuReference::getTlsContext(); 252 rsrBindFrameBufferObjectDepthTarget(rsc, a); 253} 254 255static void SC_ClearFrameBufferObjectColorTarget(uint32_t slot) { 256 Context *rsc = RsdCpuReference::getTlsContext(); 257 rsrClearFrameBufferObjectColorTarget(rsc, slot); 258} 259 260static void SC_ClearFrameBufferObjectDepthTarget(Context *, Script *) { 261 Context *rsc = RsdCpuReference::getTlsContext(); 262 rsrClearFrameBufferObjectDepthTarget(rsc); 263} 264 265static void SC_ClearFrameBufferObjectTargets(Context *, Script *) { 266 Context *rsc = RsdCpuReference::getTlsContext(); 267 rsrClearFrameBufferObjectTargets(rsc); 268} 269 270 271////////////////////////////////////////////////////////////////////////////// 272// VP 273////////////////////////////////////////////////////////////////////////////// 274 275static void SC_VpLoadProjectionMatrix(const rsc_Matrix *m) { 276 Context *rsc = RsdCpuReference::getTlsContext(); 277 rsrVpLoadProjectionMatrix(rsc, m); 278} 279 280static void SC_VpLoadModelMatrix(const rsc_Matrix *m) { 281 Context *rsc = RsdCpuReference::getTlsContext(); 282 rsrVpLoadModelMatrix(rsc, m); 283} 284 285static void SC_VpLoadTextureMatrix(const rsc_Matrix *m) { 286 Context *rsc = RsdCpuReference::getTlsContext(); 287 rsrVpLoadTextureMatrix(rsc, m); 288} 289 290static void SC_PfConstantColor(ProgramFragment *pf, float r, float g, float b, float a) { 291 Context *rsc = RsdCpuReference::getTlsContext(); 292 rsrPfConstantColor(rsc, pf, r, g, b, a); 293} 294 295static void SC_VpGetProjectionMatrix(rsc_Matrix *m) { 296 Context *rsc = RsdCpuReference::getTlsContext(); 297 rsrVpGetProjectionMatrix(rsc, m); 298} 299 300 301////////////////////////////////////////////////////////////////////////////// 302// Drawing 303////////////////////////////////////////////////////////////////////////////// 304 305static void SC_DrawQuadTexCoords(float x1, float y1, float z1, float u1, float v1, 306 float x2, float y2, float z2, float u2, float v2, 307 float x3, float y3, float z3, float u3, float v3, 308 float x4, float y4, float z4, float u4, float v4) { 309 Context *rsc = RsdCpuReference::getTlsContext(); 310 311 if (!rsc->setupCheck()) { 312 return; 313 } 314 315 RsdHal *dc = (RsdHal *)rsc->mHal.drv; 316 if (!dc->gl.shaderCache->setup(rsc)) { 317 return; 318 } 319 320 //ALOGE("Quad"); 321 //ALOGE("%4.2f, %4.2f, %4.2f", x1, y1, z1); 322 //ALOGE("%4.2f, %4.2f, %4.2f", x2, y2, z2); 323 //ALOGE("%4.2f, %4.2f, %4.2f", x3, y3, z3); 324 //ALOGE("%4.2f, %4.2f, %4.2f", x4, y4, z4); 325 326 float vtx[] = {x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4}; 327 const float tex[] = {u1,v1, u2,v2, u3,v3, u4,v4}; 328 329 RsdVertexArray::Attrib attribs[2]; 330 attribs[0].set(GL_FLOAT, 3, 12, false, (size_t)vtx, "ATTRIB_position"); 331 attribs[1].set(GL_FLOAT, 2, 8, false, (size_t)tex, "ATTRIB_texture0"); 332 333 RsdVertexArray va(attribs, 2); 334 va.setup(rsc); 335 336 RSD_CALL_GL(glDrawArrays, GL_TRIANGLE_FAN, 0, 4); 337} 338 339static void SC_DrawQuad(float x1, float y1, float z1, 340 float x2, float y2, float z2, 341 float x3, float y3, float z3, 342 float x4, float y4, float z4) { 343 SC_DrawQuadTexCoords(x1, y1, z1, 0, 1, 344 x2, y2, z2, 1, 1, 345 x3, y3, z3, 1, 0, 346 x4, y4, z4, 0, 0); 347} 348 349static void SC_DrawSpriteScreenspace(float x, float y, float z, float w, float h) { 350 Context *rsc = RsdCpuReference::getTlsContext(); 351 352 ObjectBaseRef<const ProgramVertex> tmp(rsc->getProgramVertex()); 353 rsc->setProgramVertex(rsc->getDefaultProgramVertex()); 354 //rsc->setupCheck(); 355 356 //GLint crop[4] = {0, h, w, -h}; 357 358 float sh = rsc->getHeight(); 359 360 SC_DrawQuad(x, sh - y, z, 361 x+w, sh - y, z, 362 x+w, sh - (y+h), z, 363 x, sh - (y+h), z); 364 rsc->setProgramVertex((ProgramVertex *)tmp.get()); 365} 366 367static void SC_DrawRect(float x1, float y1, float x2, float y2, float z) { 368 SC_DrawQuad(x1, y2, z, x2, y2, z, x2, y1, z, x1, y1, z); 369} 370 371static void SC_DrawPath(Path *p) { 372 Context *rsc = RsdCpuReference::getTlsContext(); 373 rsdPathDraw(rsc, p); 374} 375 376static void SC_DrawMesh(Mesh *m) { 377 Context *rsc = RsdCpuReference::getTlsContext(); 378 rsrDrawMesh(rsc, m); 379} 380 381static void SC_DrawMeshPrimitive(Mesh *m, uint32_t primIndex) { 382 Context *rsc = RsdCpuReference::getTlsContext(); 383 rsrDrawMeshPrimitive(rsc, m, primIndex); 384} 385 386static void SC_DrawMeshPrimitiveRange(Mesh *m, uint32_t primIndex, uint32_t start, uint32_t len) { 387 Context *rsc = RsdCpuReference::getTlsContext(); 388 rsrDrawMeshPrimitiveRange(rsc, m, primIndex, start, len); 389} 390 391static void SC_MeshComputeBoundingBox(Mesh *m, 392 float *minX, float *minY, float *minZ, 393 float *maxX, float *maxY, float *maxZ) { 394 Context *rsc = RsdCpuReference::getTlsContext(); 395 rsrMeshComputeBoundingBox(rsc, m, minX, minY, minZ, maxX, maxY, maxZ); 396} 397 398 399 400////////////////////////////////////////////////////////////////////////////// 401// 402////////////////////////////////////////////////////////////////////////////// 403 404 405static void SC_Color(float r, float g, float b, float a) { 406 Context *rsc = RsdCpuReference::getTlsContext(); 407 rsrColor(rsc, r, g, b, a); 408} 409 410static void SC_Finish() { 411 Context *rsc = RsdCpuReference::getTlsContext(); 412 rsdGLFinish(rsc); 413} 414 415static void SC_ClearColor(float r, float g, float b, float a) { 416 Context *rsc = RsdCpuReference::getTlsContext(); 417 rsrPrepareClear(rsc); 418 rsdGLClearColor(rsc, r, g, b, a); 419} 420 421static void SC_ClearDepth(float v) { 422 Context *rsc = RsdCpuReference::getTlsContext(); 423 rsrPrepareClear(rsc); 424 rsdGLClearDepth(rsc, v); 425} 426 427static uint32_t SC_GetWidth() { 428 Context *rsc = RsdCpuReference::getTlsContext(); 429 return rsrGetWidth(rsc); 430} 431 432static uint32_t SC_GetHeight() { 433 Context *rsc = RsdCpuReference::getTlsContext(); 434 return rsrGetHeight(rsc); 435} 436 437static void SC_DrawTextAlloc(Allocation *a, int x, int y) { 438 Context *rsc = RsdCpuReference::getTlsContext(); 439 rsrDrawTextAlloc(rsc, a, x, y); 440} 441 442static void SC_DrawText(const char *text, int x, int y) { 443 Context *rsc = RsdCpuReference::getTlsContext(); 444 rsrDrawText(rsc, text, x, y); 445} 446 447static void SC_MeasureTextAlloc(Allocation *a, 448 int32_t *left, int32_t *right, int32_t *top, int32_t *bottom) { 449 Context *rsc = RsdCpuReference::getTlsContext(); 450 rsrMeasureTextAlloc(rsc, a, left, right, top, bottom); 451} 452 453static void SC_MeasureText(const char *text, 454 int32_t *left, int32_t *right, int32_t *top, int32_t *bottom) { 455 Context *rsc = RsdCpuReference::getTlsContext(); 456 rsrMeasureText(rsc, text, left, right, top, bottom); 457} 458 459static void SC_BindFont(Font *f) { 460 Context *rsc = RsdCpuReference::getTlsContext(); 461 rsrBindFont(rsc, f); 462} 463 464static void SC_FontColor(float r, float g, float b, float a) { 465 Context *rsc = RsdCpuReference::getTlsContext(); 466 rsrFontColor(rsc, r, g, b, a); 467} 468#endif 469 470 471////////////////////////////////////////////////////////////////////////////// 472// 473////////////////////////////////////////////////////////////////////////////// 474 475static void SC_ClearObject(rs_object_base *dst) { 476 Context *rsc = RsdCpuReference::getTlsContext(); 477 rsrClearObject(rsc, dst); 478} 479#ifndef RS_COMPATIBILITY_LIB 480static void SC_SetObject(rs_object_base *dst, rs_object_base src) { 481 // ALOGE("SC_SetObject: dst = %p, src = %p", dst, src.p); 482 // ALOGE("SC_SetObject: dst[0] = %p", dst[0]); 483 Context *rsc = RsdCpuReference::getTlsContext(); 484 rsrSetObject(rsc, dst, (ObjectBase*)src.p); 485} 486 487static bool SC_IsObject(rs_object_base o) { 488 Context *rsc = RsdCpuReference::getTlsContext(); 489 return rsrIsObject(rsc, o); 490} 491#else 492static void SC_SetObject(rs_object_base *dst, ObjectBase* src) { 493 // ALOGE("SC_SetObject: dst = %p, src = %p", dst, src.p); 494 // ALOGE("SC_SetObject: dst[0] = %p", dst[0]); 495 Context *rsc = RsdCpuReference::getTlsContext(); 496 rsrSetObject(rsc, dst, src); 497} 498 499static bool SC_IsObject(ObjectBase* o) { 500 Context *rsc = RsdCpuReference::getTlsContext(); 501 return rsrIsObject(rsc, o); 502} 503#endif 504 505 506 507static const Allocation * SC_GetAllocation(const void *ptr) { 508 Context *rsc = RsdCpuReference::getTlsContext(); 509 const Script *sc = RsdCpuReference::getTlsScript(); 510 return rsdScriptGetAllocationForPointer(rsc, sc, ptr); 511} 512 513#ifndef RS_COMPATIBILITY_LIB 514static void SC_ForEach_SAA(android::renderscript::rs_script target, 515 android::renderscript::rs_allocation in, 516 android::renderscript::rs_allocation out) { 517 Context *rsc = RsdCpuReference::getTlsContext(); 518 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, NULL, 0, NULL); 519} 520 521static void SC_ForEach_SAAU(android::renderscript::rs_script target, 522 android::renderscript::rs_allocation in, 523 android::renderscript::rs_allocation out, 524 const void *usr) { 525 Context *rsc = RsdCpuReference::getTlsContext(); 526 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, usr, 0, NULL); 527} 528 529static void SC_ForEach_SAAUS(android::renderscript::rs_script target, 530 android::renderscript::rs_allocation in, 531 android::renderscript::rs_allocation out, 532 const void *usr, 533 const RsScriptCall *call) { 534 Context *rsc = RsdCpuReference::getTlsContext(); 535 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, usr, 0, call); 536} 537 538static void SC_ForEach_SAAUL(android::renderscript::rs_script target, 539 android::renderscript::rs_allocation in, 540 android::renderscript::rs_allocation out, 541 const void *usr, 542 uint32_t usrLen) { 543 Context *rsc = RsdCpuReference::getTlsContext(); 544 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, usr, usrLen, NULL); 545} 546 547static void SC_ForEach_SAAULS(android::renderscript::rs_script target, 548 android::renderscript::rs_allocation in, 549 android::renderscript::rs_allocation out, 550 const void *usr, 551 uint32_t usrLen, 552 const RsScriptCall *call) { 553 Context *rsc = RsdCpuReference::getTlsContext(); 554 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, usr, usrLen, call); 555} 556#endif 557 558 559////////////////////////////////////////////////////////////////////////////// 560// Time routines 561////////////////////////////////////////////////////////////////////////////// 562 563static float SC_GetDt() { 564 Context *rsc = RsdCpuReference::getTlsContext(); 565 const Script *sc = RsdCpuReference::getTlsScript(); 566 return rsrGetDt(rsc, sc); 567} 568 569#ifndef RS_COMPATIBILITY_LIB 570time_t SC_Time(time_t *timer) { 571 Context *rsc = RsdCpuReference::getTlsContext(); 572 return rsrTime(rsc, timer); 573} 574#else 575static int SC_Time(int *timer) { 576 Context *rsc = RsdCpuReference::getTlsContext(); 577 return rsrTime(rsc, (long*)timer); 578} 579#endif 580 581tm* SC_LocalTime(tm *local, time_t *timer) { 582 Context *rsc = RsdCpuReference::getTlsContext(); 583 return rsrLocalTime(rsc, local, timer); 584} 585 586int64_t SC_UptimeMillis() { 587 Context *rsc = RsdCpuReference::getTlsContext(); 588 return rsrUptimeMillis(rsc); 589} 590 591int64_t SC_UptimeNanos() { 592 Context *rsc = RsdCpuReference::getTlsContext(); 593 return rsrUptimeNanos(rsc); 594} 595 596////////////////////////////////////////////////////////////////////////////// 597// Message routines 598////////////////////////////////////////////////////////////////////////////// 599 600static uint32_t SC_ToClient2(int cmdID, const void *data, uint32_t len) { 601 Context *rsc = RsdCpuReference::getTlsContext(); 602 return rsrToClient(rsc, cmdID, data, len); 603} 604 605static uint32_t SC_ToClient(int cmdID) { 606 Context *rsc = RsdCpuReference::getTlsContext(); 607 return rsrToClient(rsc, cmdID, (const void *)NULL, 0); 608} 609 610static uint32_t SC_ToClientBlocking2(int cmdID, const void *data, uint32_t len) { 611 Context *rsc = RsdCpuReference::getTlsContext(); 612 return rsrToClientBlocking(rsc, cmdID, data, len); 613} 614 615static uint32_t SC_ToClientBlocking(int cmdID) { 616 Context *rsc = RsdCpuReference::getTlsContext(); 617 return rsrToClientBlocking(rsc, cmdID, (const void *)NULL, 0); 618} 619 620 621static void * ElementAt1D(Allocation *a, RsDataType dt, uint32_t vecSize, uint32_t x) { 622 Context *rsc = RsdCpuReference::getTlsContext(); 623 const Type *t = a->getType(); 624 const Element *e = t->getElement(); 625 626 char buf[256]; 627 if (x >= t->getLODDimX(0)) { 628 sprintf(buf, "Out range ElementAt X %i of %i", x, t->getLODDimX(0)); 629 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 630 return NULL; 631 } 632 633 if (vecSize > 0) { 634 if (vecSize != e->getVectorSize()) { 635 sprintf(buf, "Vector size mismatch for ElementAt %i of %i", vecSize, e->getVectorSize()); 636 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 637 return NULL; 638 } 639 640 if (dt != e->getType()) { 641 sprintf(buf, "Data type mismatch for ElementAt %i of %i", dt, e->getType()); 642 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 643 return NULL; 644 } 645 } 646 647 uint8_t *p = (uint8_t *)a->mHal.drvState.lod[0].mallocPtr; 648 const uint32_t eSize = e->getSizeBytes(); 649 return &p[(eSize * x)]; 650} 651 652static void * ElementAt2D(Allocation *a, RsDataType dt, uint32_t vecSize, uint32_t x, uint32_t y) { 653 Context *rsc = RsdCpuReference::getTlsContext(); 654 const Type *t = a->getType(); 655 const Element *e = t->getElement(); 656 657 char buf[256]; 658 if (x >= t->getLODDimX(0)) { 659 sprintf(buf, "Out range ElementAt X %i of %i", x, t->getLODDimX(0)); 660 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 661 return NULL; 662 } 663 664 if (y >= t->getLODDimY(0)) { 665 sprintf(buf, "Out range ElementAt Y %i of %i", y, t->getLODDimY(0)); 666 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 667 return NULL; 668 } 669 670 if (vecSize > 0) { 671 if (vecSize != e->getVectorSize()) { 672 sprintf(buf, "Vector size mismatch for ElementAt %i of %i", vecSize, e->getVectorSize()); 673 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 674 return NULL; 675 } 676 677 if (dt != e->getType()) { 678 sprintf(buf, "Data type mismatch for ElementAt %i of %i", dt, e->getType()); 679 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 680 return NULL; 681 } 682 } 683 684 uint8_t *p = (uint8_t *)a->mHal.drvState.lod[0].mallocPtr; 685 const uint32_t eSize = e->getSizeBytes(); 686 const uint32_t stride = a->mHal.drvState.lod[0].stride; 687 return &p[(eSize * x) + (y * stride)]; 688} 689 690static void * ElementAt3D(Allocation *a, RsDataType dt, uint32_t vecSize, uint32_t x, uint32_t y, uint32_t z) { 691 Context *rsc = RsdCpuReference::getTlsContext(); 692 const Type *t = a->getType(); 693 const Element *e = t->getElement(); 694 695 char buf[256]; 696 if (x >= t->getLODDimX(0)) { 697 sprintf(buf, "Out range ElementAt X %i of %i", x, t->getLODDimX(0)); 698 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 699 return NULL; 700 } 701 702 if (y >= t->getLODDimY(0)) { 703 sprintf(buf, "Out range ElementAt Y %i of %i", y, t->getLODDimY(0)); 704 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 705 return NULL; 706 } 707 708 if (z >= t->getLODDimZ(0)) { 709 sprintf(buf, "Out range ElementAt Z %i of %i", z, t->getLODDimZ(0)); 710 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 711 return NULL; 712 } 713 714 if (vecSize > 0) { 715 if (vecSize != e->getVectorSize()) { 716 sprintf(buf, "Vector size mismatch for ElementAt %i of %i", vecSize, e->getVectorSize()); 717 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 718 return NULL; 719 } 720 721 if (dt != e->getType()) { 722 sprintf(buf, "Data type mismatch for ElementAt %i of %i", dt, e->getType()); 723 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 724 return NULL; 725 } 726 } 727 728 uint8_t *p = (uint8_t *)a->mHal.drvState.lod[0].mallocPtr; 729 const uint32_t eSize = e->getSizeBytes(); 730 const uint32_t stride = a->mHal.drvState.lod[0].stride; 731 return &p[(eSize * x) + (y * stride)]; 732} 733 734static const void * SC_GetElementAt1D(android::renderscript::rs_allocation a, uint32_t x) { 735 return ElementAt1D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x); 736} 737static const void * SC_GetElementAt2D(android::renderscript::rs_allocation a, uint32_t x, uint32_t y) { 738 return ElementAt2D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x, y); 739} 740static const void * SC_GetElementAt3D(android::renderscript::rs_allocation a, uint32_t x, uint32_t y, uint32_t z) { 741 return ElementAt3D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x, y, z); 742} 743 744static void SC_SetElementAt1D(android::renderscript::rs_allocation a, const void *ptr, uint32_t x) { 745 const Type *t = ((Allocation*)a.p)->getType(); 746 const Element *e = t->getElement(); 747 void *tmp = ElementAt1D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x); 748 if (tmp != NULL) { 749 memcpy(tmp, ptr, e->getSizeBytes()); 750 } 751} 752static void SC_SetElementAt2D(android::renderscript::rs_allocation a, const void *ptr, uint32_t x, uint32_t y) { 753 const Type *t = ((Allocation*)a.p)->getType(); 754 const Element *e = t->getElement(); 755 void *tmp = ElementAt2D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x, y); 756 if (tmp != NULL) { 757 memcpy(tmp, ptr, e->getSizeBytes()); 758 } 759} 760static void SC_SetElementAt3D(android::renderscript::rs_allocation a, const void *ptr, uint32_t x, uint32_t y, uint32_t z) { 761 const Type *t = ((Allocation*)a.p)->getType(); 762 const Element *e = t->getElement(); 763 void *tmp = ElementAt3D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x, y, z); 764 if (tmp != NULL) { 765 memcpy(tmp, ptr, e->getSizeBytes()); 766 } 767} 768 769#define ELEMENT_AT(T, DT, VS) \ 770 static void SC_SetElementAt1_##T(android::renderscript::rs_allocation a, const T *val, uint32_t x) { \ 771 void *r = ElementAt1D((Allocation*)a.p, DT, VS, x); \ 772 if (r != NULL) ((T *)r)[0] = *val; \ 773 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 774 } \ 775 static void SC_SetElementAt2_##T(android::renderscript::rs_allocation a, const T * val, uint32_t x, uint32_t y) { \ 776 void *r = ElementAt2D((Allocation*)a.p, DT, VS, x, y); \ 777 if (r != NULL) ((T *)r)[0] = *val; \ 778 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 779 } \ 780 static void SC_SetElementAt3_##T(android::renderscript::rs_allocation a, const T * val, uint32_t x, uint32_t y, uint32_t z) { \ 781 void *r = ElementAt3D((Allocation*)a.p, DT, VS, x, y, z); \ 782 if (r != NULL) ((T *)r)[0] = *val; \ 783 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 784 } \ 785 static void SC_GetElementAt1_##T(android::renderscript::rs_allocation a, T *val, uint32_t x) { \ 786 void *r = ElementAt1D((Allocation*)a.p, DT, VS, x); \ 787 if (r != NULL) *val = ((T *)r)[0]; \ 788 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 789 } \ 790 static void SC_GetElementAt2_##T(android::renderscript::rs_allocation a, T *val, uint32_t x, uint32_t y) { \ 791 void *r = ElementAt2D((Allocation*)a.p, DT, VS, x, y); \ 792 if (r != NULL) *val = ((T *)r)[0]; \ 793 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 794 } \ 795 static void SC_GetElementAt3_##T(android::renderscript::rs_allocation a, T *val, uint32_t x, uint32_t y, uint32_t z) { \ 796 void *r = ElementAt3D((Allocation*)a.p, DT, VS, x, y, z); \ 797 if (r != NULL) *val = ((T *)r)[0]; \ 798 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 799 } 800 801ELEMENT_AT(char, RS_TYPE_SIGNED_8, 1) 802ELEMENT_AT(char2, RS_TYPE_SIGNED_8, 2) 803ELEMENT_AT(char3, RS_TYPE_SIGNED_8, 3) 804ELEMENT_AT(char4, RS_TYPE_SIGNED_8, 4) 805ELEMENT_AT(uchar, RS_TYPE_UNSIGNED_8, 1) 806ELEMENT_AT(uchar2, RS_TYPE_UNSIGNED_8, 2) 807ELEMENT_AT(uchar3, RS_TYPE_UNSIGNED_8, 3) 808ELEMENT_AT(uchar4, RS_TYPE_UNSIGNED_8, 4) 809ELEMENT_AT(short, RS_TYPE_SIGNED_16, 1) 810ELEMENT_AT(short2, RS_TYPE_SIGNED_16, 2) 811ELEMENT_AT(short3, RS_TYPE_SIGNED_16, 3) 812ELEMENT_AT(short4, RS_TYPE_SIGNED_16, 4) 813ELEMENT_AT(ushort, RS_TYPE_UNSIGNED_16, 1) 814ELEMENT_AT(ushort2, RS_TYPE_UNSIGNED_16, 2) 815ELEMENT_AT(ushort3, RS_TYPE_UNSIGNED_16, 3) 816ELEMENT_AT(ushort4, RS_TYPE_UNSIGNED_16, 4) 817ELEMENT_AT(int, RS_TYPE_SIGNED_32, 1) 818ELEMENT_AT(int2, RS_TYPE_SIGNED_32, 2) 819ELEMENT_AT(int3, RS_TYPE_SIGNED_32, 3) 820ELEMENT_AT(int4, RS_TYPE_SIGNED_32, 4) 821ELEMENT_AT(uint, RS_TYPE_UNSIGNED_32, 1) 822ELEMENT_AT(uint2, RS_TYPE_UNSIGNED_32, 2) 823ELEMENT_AT(uint3, RS_TYPE_UNSIGNED_32, 3) 824ELEMENT_AT(uint4, RS_TYPE_UNSIGNED_32, 4) 825ELEMENT_AT(long, RS_TYPE_SIGNED_64, 1) 826ELEMENT_AT(long2, RS_TYPE_SIGNED_64, 2) 827ELEMENT_AT(long3, RS_TYPE_SIGNED_64, 3) 828ELEMENT_AT(long4, RS_TYPE_SIGNED_64, 4) 829ELEMENT_AT(ulong, RS_TYPE_UNSIGNED_64, 1) 830ELEMENT_AT(ulong2, RS_TYPE_UNSIGNED_64, 2) 831ELEMENT_AT(ulong3, RS_TYPE_UNSIGNED_64, 3) 832ELEMENT_AT(ulong4, RS_TYPE_UNSIGNED_64, 4) 833ELEMENT_AT(float, RS_TYPE_FLOAT_32, 1) 834ELEMENT_AT(float2, RS_TYPE_FLOAT_32, 2) 835ELEMENT_AT(float3, RS_TYPE_FLOAT_32, 3) 836ELEMENT_AT(float4, RS_TYPE_FLOAT_32, 4) 837ELEMENT_AT(double, RS_TYPE_FLOAT_64, 1) 838ELEMENT_AT(double2, RS_TYPE_FLOAT_64, 2) 839ELEMENT_AT(double3, RS_TYPE_FLOAT_64, 3) 840ELEMENT_AT(double4, RS_TYPE_FLOAT_64, 4) 841 842#undef ELEMENT_AT 843 844////////////////////////////////////////////////////////////////////////////// 845// Stub implementation 846////////////////////////////////////////////////////////////////////////////// 847 848// llvm name mangling ref 849// <builtin-type> ::= v # void 850// ::= b # bool 851// ::= c # char 852// ::= a # signed char 853// ::= h # unsigned char 854// ::= s # short 855// ::= t # unsigned short 856// ::= i # int 857// ::= j # unsigned int 858// ::= l # long 859// ::= m # unsigned long 860// ::= x # long long, __int64 861// ::= y # unsigned long long, __int64 862// ::= f # float 863// ::= d # double 864 865static RsdCpuReference::CpuSymbol gSyms[] = { 866 // Debug runtime 867 { "_Z14rsGetElementAt13rs_allocationj", (void *)&SC_GetElementAt1D, true }, 868 { "_Z14rsGetElementAt13rs_allocationjj", (void *)&SC_GetElementAt2D, true }, 869 { "_Z14rsGetElementAt13rs_allocationjjj", (void *)&SC_GetElementAt3D, true }, 870 { "_Z14rsSetElementAt13rs_allocationPKvj", (void *)&SC_SetElementAt1D, true }, 871 { "_Z14rsSetElementAt13rs_allocationPKvjj", (void *)&SC_SetElementAt2D, true }, 872 { "_Z14rsSetElementAt13rs_allocationPKvjjj", (void *)&SC_SetElementAt3D, true }, 873 874 875 { "_Z20rsGetElementAt_uchar13rs_allocationPhj", (void *)&SC_GetElementAt1_uchar, true }, 876 { "_Z21rsGetElementAt_uchar213rs_allocationPDv2_hj", (void *)&SC_GetElementAt1_uchar2, true }, 877 { "_Z21rsGetElementAt_uchar313rs_allocationPDv3_hj", (void *)&SC_GetElementAt1_uchar3, true }, 878 { "_Z21rsGetElementAt_uchar413rs_allocationPDv4_hj", (void *)&SC_GetElementAt1_uchar4, true }, 879 { "_Z20rsGetElementAt_uchar13rs_allocationPhjj", (void *)&SC_GetElementAt2_uchar, true }, 880 { "_Z21rsGetElementAt_uchar213rs_allocationPDv2_hjj", (void *)&SC_GetElementAt2_uchar2, true }, 881 { "_Z21rsGetElementAt_uchar313rs_allocationPDv3_hjj", (void *)&SC_GetElementAt2_uchar3, true }, 882 { "_Z21rsGetElementAt_uchar413rs_allocationPDv4_hjj", (void *)&SC_GetElementAt2_uchar4, true }, 883 { "_Z20rsGetElementAt_uchar13rs_allocationPhjjj", (void *)&SC_GetElementAt3_uchar, true }, 884 { "_Z21rsGetElementAt_uchar213rs_allocationPDv2_hjjj", (void *)&SC_GetElementAt3_uchar2, true }, 885 { "_Z21rsGetElementAt_uchar313rs_allocationPDv3_hjjj", (void *)&SC_GetElementAt3_uchar3, true }, 886 { "_Z21rsGetElementAt_uchar413rs_allocationPDv4_hjjj", (void *)&SC_GetElementAt3_uchar4, true }, 887 888 { "_Z19rsGetElementAt_char13rs_allocationPcj", (void *)&SC_GetElementAt1_char, true }, 889 { "_Z20rsGetElementAt_char213rs_allocationPDv2_cj", (void *)&SC_GetElementAt1_char2, true }, 890 { "_Z20rsGetElementAt_char313rs_allocationPDv3_cj", (void *)&SC_GetElementAt1_char3, true }, 891 { "_Z20rsGetElementAt_char413rs_allocationPDv4_cj", (void *)&SC_GetElementAt1_char4, true }, 892 { "_Z19rsGetElementAt_char13rs_allocationPcjj", (void *)&SC_GetElementAt2_char, true }, 893 { "_Z20rsGetElementAt_char213rs_allocationPDv2_cjj", (void *)&SC_GetElementAt2_char2, true }, 894 { "_Z20rsGetElementAt_char313rs_allocationPDv3_cjj", (void *)&SC_GetElementAt2_char3, true }, 895 { "_Z20rsGetElementAt_char413rs_allocationPDv4_cjj", (void *)&SC_GetElementAt2_char4, true }, 896 { "_Z19rsGetElementAt_char13rs_allocationPcjjj", (void *)&SC_GetElementAt3_char, true }, 897 { "_Z20rsGetElementAt_char213rs_allocationPDv2_cjjj", (void *)&SC_GetElementAt3_char2, true }, 898 { "_Z20rsGetElementAt_char313rs_allocationPDv3_cjjj", (void *)&SC_GetElementAt3_char3, true }, 899 { "_Z20rsGetElementAt_char413rs_allocationPDv4_cjjj", (void *)&SC_GetElementAt3_char4, true }, 900 901 { "_Z21rsGetElementAt_ushort13rs_allocationPtj", (void *)&SC_GetElementAt1_ushort, true }, 902 { "_Z22rsGetElementAt_ushort213rs_allocationPDv2_tj", (void *)&SC_GetElementAt1_ushort2, true }, 903 { "_Z22rsGetElementAt_ushort313rs_allocationPDv3_tj", (void *)&SC_GetElementAt1_ushort3, true }, 904 { "_Z22rsGetElementAt_ushort413rs_allocationPDv4_tj", (void *)&SC_GetElementAt1_ushort4, true }, 905 { "_Z21rsGetElementAt_ushort13rs_allocationPtjj", (void *)&SC_GetElementAt2_ushort, true }, 906 { "_Z22rsGetElementAt_ushort213rs_allocationPDv2_tjj", (void *)&SC_GetElementAt2_ushort2, true }, 907 { "_Z22rsGetElementAt_ushort313rs_allocationPDv3_tjj", (void *)&SC_GetElementAt2_ushort3, true }, 908 { "_Z22rsGetElementAt_ushort413rs_allocationPDv4_tjj", (void *)&SC_GetElementAt2_ushort4, true }, 909 { "_Z21rsGetElementAt_ushort13rs_allocationPtjjj", (void *)&SC_GetElementAt3_ushort, true }, 910 { "_Z22rsGetElementAt_ushort213rs_allocationPDv2_tjjj", (void *)&SC_GetElementAt3_ushort2, true }, 911 { "_Z22rsGetElementAt_ushort313rs_allocationPDv3_tjjj", (void *)&SC_GetElementAt3_ushort3, true }, 912 { "_Z22rsGetElementAt_ushort413rs_allocationPDv4_tjjj", (void *)&SC_GetElementAt3_ushort4, true }, 913 914 { "_Z20rsGetElementAt_short13rs_allocationPsj", (void *)&SC_GetElementAt1_short, true }, 915 { "_Z21rsGetElementAt_short213rs_allocationPDv2_sj", (void *)&SC_GetElementAt1_short2, true }, 916 { "_Z21rsGetElementAt_short313rs_allocationPDv3_sj", (void *)&SC_GetElementAt1_short3, true }, 917 { "_Z21rsGetElementAt_short413rs_allocationPDv4_sj", (void *)&SC_GetElementAt1_short4, true }, 918 { "_Z20rsGetElementAt_short13rs_allocationPsjj", (void *)&SC_GetElementAt2_short, true }, 919 { "_Z21rsGetElementAt_short213rs_allocationPDv2_sjj", (void *)&SC_GetElementAt2_short2, true }, 920 { "_Z21rsGetElementAt_short313rs_allocationPDv3_sjj", (void *)&SC_GetElementAt2_short3, true }, 921 { "_Z21rsGetElementAt_short413rs_allocationPDv4_sjj", (void *)&SC_GetElementAt2_short4, true }, 922 { "_Z20rsGetElementAt_short13rs_allocationPsjjj", (void *)&SC_GetElementAt3_short, true }, 923 { "_Z21rsGetElementAt_short213rs_allocationPDv2_sjjj", (void *)&SC_GetElementAt3_short2, true }, 924 { "_Z21rsGetElementAt_short313rs_allocationPDv3_sjjj", (void *)&SC_GetElementAt3_short3, true }, 925 { "_Z21rsGetElementAt_short413rs_allocationPDv4_sjjj", (void *)&SC_GetElementAt3_short4, true }, 926 927 { "_Z19rsGetElementAt_uint13rs_allocationPjj", (void *)&SC_GetElementAt1_uint, true }, 928 { "_Z20rsGetElementAt_uint213rs_allocationPDv2_jj", (void *)&SC_GetElementAt1_uint2, true }, 929 { "_Z20rsGetElementAt_uint313rs_allocationPDv3_jj", (void *)&SC_GetElementAt1_uint3, true }, 930 { "_Z20rsGetElementAt_uint413rs_allocationPDv4_jj", (void *)&SC_GetElementAt1_uint4, true }, 931 { "_Z19rsGetElementAt_uint13rs_allocationPjjj", (void *)&SC_GetElementAt2_uint, true }, 932 { "_Z20rsGetElementAt_uint213rs_allocationPDv2_jjj", (void *)&SC_GetElementAt2_uint2, true }, 933 { "_Z20rsGetElementAt_uint313rs_allocationPDv3_jjj", (void *)&SC_GetElementAt2_uint3, true }, 934 { "_Z20rsGetElementAt_uint413rs_allocationPDv4_jjj", (void *)&SC_GetElementAt2_uint4, true }, 935 { "_Z19rsGetElementAt_uint13rs_allocationPjjjj", (void *)&SC_GetElementAt3_uint, true }, 936 { "_Z20rsGetElementAt_uint213rs_allocationPDv2_jjjj", (void *)&SC_GetElementAt3_uint2, true }, 937 { "_Z20rsGetElementAt_uint313rs_allocationPDv3_jjjj", (void *)&SC_GetElementAt3_uint3, true }, 938 { "_Z20rsGetElementAt_uint413rs_allocationPDv4_jjjj", (void *)&SC_GetElementAt3_uint4, true }, 939 940 { "_Z18rsGetElementAt_int13rs_allocationPij", (void *)&SC_GetElementAt1_int, true }, 941 { "_Z19rsGetElementAt_int213rs_allocationPDv2_ij", (void *)&SC_GetElementAt1_int2, true }, 942 { "_Z19rsGetElementAt_int313rs_allocationPDv3_ij", (void *)&SC_GetElementAt1_int3, true }, 943 { "_Z19rsGetElementAt_int413rs_allocationPDv4_ij", (void *)&SC_GetElementAt1_int4, true }, 944 { "_Z18rsGetElementAt_int13rs_allocationPijj", (void *)&SC_GetElementAt2_int, true }, 945 { "_Z19rsGetElementAt_int213rs_allocationPDv2_ijj", (void *)&SC_GetElementAt2_int2, true }, 946 { "_Z19rsGetElementAt_int313rs_allocationPDv3_ijj", (void *)&SC_GetElementAt2_int3, true }, 947 { "_Z19rsGetElementAt_int413rs_allocationPDv4_ijj", (void *)&SC_GetElementAt2_int4, true }, 948 { "_Z18rsGetElementAt_int13rs_allocationPijjj", (void *)&SC_GetElementAt3_int, true }, 949 { "_Z19rsGetElementAt_int213rs_allocationPDv2_ijjj", (void *)&SC_GetElementAt3_int2, true }, 950 { "_Z19rsGetElementAt_int313rs_allocationPDv3_ijjj", (void *)&SC_GetElementAt3_int3, true }, 951 { "_Z19rsGetElementAt_int413rs_allocationPDv4_ijjj", (void *)&SC_GetElementAt3_int4, true }, 952 953 { "_Z20rsGetElementAt_ulong13rs_allocationPmj", (void *)&SC_GetElementAt1_ulong, true }, 954 { "_Z21rsGetElementAt_ulong213rs_allocationPDv2_mj", (void *)&SC_GetElementAt1_ulong2, true }, 955 { "_Z21rsGetElementAt_ulong313rs_allocationPDv3_mj", (void *)&SC_GetElementAt1_ulong3, true }, 956 { "_Z21rsGetElementAt_ulong413rs_allocationPDv4_mj", (void *)&SC_GetElementAt1_ulong4, true }, 957 { "_Z20rsGetElementAt_ulong13rs_allocationPmjj", (void *)&SC_GetElementAt2_ulong, true }, 958 { "_Z21rsGetElementAt_ulong213rs_allocationPDv2_mjj", (void *)&SC_GetElementAt2_ulong2, true }, 959 { "_Z21rsGetElementAt_ulong313rs_allocationPDv3_mjj", (void *)&SC_GetElementAt2_ulong3, true }, 960 { "_Z21rsGetElementAt_ulong413rs_allocationPDv4_mjj", (void *)&SC_GetElementAt2_ulong4, true }, 961 { "_Z20rsGetElementAt_ulong13rs_allocationPmjjj", (void *)&SC_GetElementAt3_ulong, true }, 962 { "_Z21rsGetElementAt_ulong213rs_allocationPDv2_mjjj", (void *)&SC_GetElementAt3_ulong2, true }, 963 { "_Z21rsGetElementAt_ulong313rs_allocationPDv3_mjjj", (void *)&SC_GetElementAt3_ulong3, true }, 964 { "_Z21rsGetElementAt_ulong413rs_allocationPDv4_mjjj", (void *)&SC_GetElementAt3_ulong4, true }, 965 966 { "_Z19rsGetElementAt_long13rs_allocationPlj", (void *)&SC_GetElementAt1_long, true }, 967 { "_Z20rsGetElementAt_long213rs_allocationPDv2_lj", (void *)&SC_GetElementAt1_long2, true }, 968 { "_Z20rsGetElementAt_long313rs_allocationPDv3_lj", (void *)&SC_GetElementAt1_long3, true }, 969 { "_Z20rsGetElementAt_long413rs_allocationPDv4_lj", (void *)&SC_GetElementAt1_long4, true }, 970 { "_Z19rsGetElementAt_long13rs_allocationPljj", (void *)&SC_GetElementAt2_long, true }, 971 { "_Z20rsGetElementAt_long213rs_allocationPDv2_ljj", (void *)&SC_GetElementAt2_long2, true }, 972 { "_Z20rsGetElementAt_long313rs_allocationPDv3_ljj", (void *)&SC_GetElementAt2_long3, true }, 973 { "_Z20rsGetElementAt_long413rs_allocationPDv4_ljj", (void *)&SC_GetElementAt2_long4, true }, 974 { "_Z19rsGetElementAt_long13rs_allocationPljjj", (void *)&SC_GetElementAt3_long, true }, 975 { "_Z20rsGetElementAt_long213rs_allocationPDv2_ljjj", (void *)&SC_GetElementAt3_long2, true }, 976 { "_Z20rsGetElementAt_long313rs_allocationPDv3_ljjj", (void *)&SC_GetElementAt3_long3, true }, 977 { "_Z20rsGetElementAt_long413rs_allocationPDv4_ljjj", (void *)&SC_GetElementAt3_long4, true }, 978 979 { "_Z20rsGetElementAt_float13rs_allocationPfj", (void *)&SC_GetElementAt1_float, true }, 980 { "_Z21rsGetElementAt_float213rs_allocationPDv2_fj", (void *)&SC_GetElementAt1_float2, true }, 981 { "_Z21rsGetElementAt_float313rs_allocationPDv3_fj", (void *)&SC_GetElementAt1_float3, true }, 982 { "_Z21rsGetElementAt_float413rs_allocationPDv4_fj", (void *)&SC_GetElementAt1_float4, true }, 983 { "_Z20rsGetElementAt_float13rs_allocationPfjj", (void *)&SC_GetElementAt2_float, true }, 984 { "_Z21rsGetElementAt_float213rs_allocationPDv2_fjj", (void *)&SC_GetElementAt2_float2, true }, 985 { "_Z21rsGetElementAt_float313rs_allocationPDv3_fjj", (void *)&SC_GetElementAt2_float3, true }, 986 { "_Z21rsGetElementAt_float413rs_allocationPDv4_fjj", (void *)&SC_GetElementAt2_float4, true }, 987 { "_Z20rsGetElementAt_float13rs_allocationPfjjj", (void *)&SC_GetElementAt3_float, true }, 988 { "_Z21rsGetElementAt_float213rs_allocationPDv2_fjjj", (void *)&SC_GetElementAt3_float2, true }, 989 { "_Z21rsGetElementAt_float313rs_allocationPDv3_fjjj", (void *)&SC_GetElementAt3_float3, true }, 990 { "_Z21rsGetElementAt_float413rs_allocationPDv4_fjjj", (void *)&SC_GetElementAt3_float4, true }, 991 992 { "_Z21rsGetElementAt_double13rs_allocationPdj", (void *)&SC_GetElementAt1_double, true }, 993 { "_Z22rsGetElementAt_double213rs_allocationPDv2_dj", (void *)&SC_GetElementAt1_double2, true }, 994 { "_Z22rsGetElementAt_double313rs_allocationPDv3_dj", (void *)&SC_GetElementAt1_double3, true }, 995 { "_Z22rsGetElementAt_double413rs_allocationPDv4_dj", (void *)&SC_GetElementAt1_double4, true }, 996 { "_Z21rsGetElementAt_double13rs_allocationPdjj", (void *)&SC_GetElementAt2_double, true }, 997 { "_Z22rsGetElementAt_double213rs_allocationPDv2_djj", (void *)&SC_GetElementAt2_double2, true }, 998 { "_Z22rsGetElementAt_double313rs_allocationPDv3_djj", (void *)&SC_GetElementAt2_double3, true }, 999 { "_Z22rsGetElementAt_double413rs_allocationPDv4_djj", (void *)&SC_GetElementAt2_double4, true }, 1000 { "_Z21rsGetElementAt_double13rs_allocationPdjjj", (void *)&SC_GetElementAt3_double, true }, 1001 { "_Z22rsGetElementAt_double213rs_allocationPDv2_djjj", (void *)&SC_GetElementAt3_double2, true }, 1002 { "_Z22rsGetElementAt_double313rs_allocationPDv3_djjj", (void *)&SC_GetElementAt3_double3, true }, 1003 { "_Z22rsGetElementAt_double413rs_allocationPDv4_djjj", (void *)&SC_GetElementAt3_double4, true }, 1004 1005 1006 1007 { "_Z20rsSetElementAt_uchar13rs_allocationPKhj", (void *)&SC_SetElementAt1_uchar, true }, 1008 { "_Z21rsSetElementAt_uchar213rs_allocationPKDv2_hj", (void *)&SC_SetElementAt1_uchar2, true }, 1009 { "_Z21rsSetElementAt_uchar313rs_allocationPKDv3_hj", (void *)&SC_SetElementAt1_uchar3, true }, 1010 { "_Z21rsSetElementAt_uchar413rs_allocationPKDv4_hj", (void *)&SC_SetElementAt1_uchar4, true }, 1011 { "_Z20rsSetElementAt_uchar13rs_allocationPKhjj", (void *)&SC_SetElementAt2_uchar, true }, 1012 { "_Z21rsSetElementAt_uchar213rs_allocationPKDv2_hjj", (void *)&SC_SetElementAt2_uchar2, true }, 1013 { "_Z21rsSetElementAt_uchar313rs_allocationPKDv3_hjj", (void *)&SC_SetElementAt2_uchar3, true }, 1014 { "_Z21rsSetElementAt_uchar413rs_allocationPKDv4_hjj", (void *)&SC_SetElementAt2_uchar4, true }, 1015 { "_Z20rsSetElementAt_uchar13rs_allocationPKhjjj", (void *)&SC_SetElementAt3_uchar, true }, 1016 { "_Z21rsSetElementAt_uchar213rs_allocationPKDv2_hjjj", (void *)&SC_SetElementAt3_uchar2, true }, 1017 { "_Z21rsSetElementAt_uchar313rs_allocationPKDv3_hjjj", (void *)&SC_SetElementAt3_uchar3, true }, 1018 { "_Z21rsSetElementAt_uchar413rs_allocationPKDv4_hjjj", (void *)&SC_SetElementAt3_uchar4, true }, 1019 1020 { "_Z19rsSetElementAt_char13rs_allocationPKcj", (void *)&SC_SetElementAt1_char, true }, 1021 { "_Z20rsSetElementAt_char213rs_allocationPKDv2_cj", (void *)&SC_SetElementAt1_char2, true }, 1022 { "_Z20rsSetElementAt_char313rs_allocationPKDv3_cj", (void *)&SC_SetElementAt1_char3, true }, 1023 { "_Z20rsSetElementAt_char413rs_allocationPKDv4_cj", (void *)&SC_SetElementAt1_char4, true }, 1024 { "_Z19rsSetElementAt_char13rs_allocationPKcjj", (void *)&SC_SetElementAt2_char, true }, 1025 { "_Z20rsSetElementAt_char213rs_allocationPKDv2_cjj", (void *)&SC_SetElementAt2_char2, true }, 1026 { "_Z20rsSetElementAt_char313rs_allocationPKDv3_cjj", (void *)&SC_SetElementAt2_char3, true }, 1027 { "_Z20rsSetElementAt_char413rs_allocationPKDv4_cjj", (void *)&SC_SetElementAt2_char4, true }, 1028 { "_Z19rsSetElementAt_char13rs_allocationPKcjjj", (void *)&SC_SetElementAt3_char, true }, 1029 { "_Z20rsSetElementAt_char213rs_allocationPKDv2_cjjj", (void *)&SC_SetElementAt3_char2, true }, 1030 { "_Z20rsSetElementAt_char313rs_allocationPKDv3_cjjj", (void *)&SC_SetElementAt3_char3, true }, 1031 { "_Z20rsSetElementAt_char413rs_allocationPKDv4_cjjj", (void *)&SC_SetElementAt3_char4, true }, 1032 1033 { "_Z21rsSetElementAt_ushort13rs_allocationPKht", (void *)&SC_SetElementAt1_ushort, true }, 1034 { "_Z22rsSetElementAt_ushort213rs_allocationPKDv2_tj", (void *)&SC_SetElementAt1_ushort2, true }, 1035 { "_Z22rsSetElementAt_ushort313rs_allocationPKDv3_tj", (void *)&SC_SetElementAt1_ushort3, true }, 1036 { "_Z22rsSetElementAt_ushort413rs_allocationPKDv4_tj", (void *)&SC_SetElementAt1_ushort4, true }, 1037 { "_Z21rsSetElementAt_ushort13rs_allocationPKtjj", (void *)&SC_SetElementAt2_ushort, true }, 1038 { "_Z22rsSetElementAt_ushort213rs_allocationPKDv2_tjj", (void *)&SC_SetElementAt2_ushort2, true }, 1039 { "_Z22rsSetElementAt_ushort313rs_allocationPKDv3_tjj", (void *)&SC_SetElementAt2_ushort3, true }, 1040 { "_Z22rsSetElementAt_ushort413rs_allocationPKDv4_tjj", (void *)&SC_SetElementAt2_ushort4, true }, 1041 { "_Z21rsSetElementAt_ushort13rs_allocationPKtjjj", (void *)&SC_SetElementAt3_ushort, true }, 1042 { "_Z22rsSetElementAt_ushort213rs_allocationPKDv2_tjjj", (void *)&SC_SetElementAt3_ushort2, true }, 1043 { "_Z22rsSetElementAt_ushort313rs_allocationPKDv3_tjjj", (void *)&SC_SetElementAt3_ushort3, true }, 1044 { "_Z22rsSetElementAt_ushort413rs_allocationPKDv4_tjjj", (void *)&SC_SetElementAt3_ushort4, true }, 1045 1046 { "_Z20rsSetElementAt_short13rs_allocationPKsj", (void *)&SC_SetElementAt1_short, true }, 1047 { "_Z21rsSetElementAt_short213rs_allocationPKDv2_sj", (void *)&SC_SetElementAt1_short2, true }, 1048 { "_Z21rsSetElementAt_short313rs_allocationPKDv3_sj", (void *)&SC_SetElementAt1_short3, true }, 1049 { "_Z21rsSetElementAt_short413rs_allocationPKDv4_sj", (void *)&SC_SetElementAt1_short4, true }, 1050 { "_Z20rsSetElementAt_short13rs_allocationPKsjj", (void *)&SC_SetElementAt2_short, true }, 1051 { "_Z21rsSetElementAt_short213rs_allocationPKDv2_sjj", (void *)&SC_SetElementAt2_short2, true }, 1052 { "_Z21rsSetElementAt_short313rs_allocationPKDv3_sjj", (void *)&SC_SetElementAt2_short3, true }, 1053 { "_Z21rsSetElementAt_short413rs_allocationPKDv4_sjj", (void *)&SC_SetElementAt2_short4, true }, 1054 { "_Z20rsSetElementAt_short13rs_allocationPKsjjj", (void *)&SC_SetElementAt3_short, true }, 1055 { "_Z21rsSetElementAt_short213rs_allocationPKDv2_sjjj", (void *)&SC_SetElementAt3_short2, true }, 1056 { "_Z21rsSetElementAt_short313rs_allocationPKDv3_sjjj", (void *)&SC_SetElementAt3_short3, true }, 1057 { "_Z21rsSetElementAt_short413rs_allocationPKDv4_sjjj", (void *)&SC_SetElementAt3_short4, true }, 1058 1059 { "_Z19rsSetElementAt_uint13rs_allocationPKjj", (void *)&SC_SetElementAt1_uint, true }, 1060 { "_Z20rsSetElementAt_uint213rs_allocationPKDv2_jj", (void *)&SC_SetElementAt1_uint2, true }, 1061 { "_Z20rsSetElementAt_uint313rs_allocationPKDv3_jj", (void *)&SC_SetElementAt1_uint3, true }, 1062 { "_Z20rsSetElementAt_uint413rs_allocationPKDv4_jj", (void *)&SC_SetElementAt1_uint4, true }, 1063 { "_Z19rsSetElementAt_uint13rs_allocationPKjjj", (void *)&SC_SetElementAt2_uint, true }, 1064 { "_Z20rsSetElementAt_uint213rs_allocationPKDv2_jjj", (void *)&SC_SetElementAt2_uint2, true }, 1065 { "_Z20rsSetElementAt_uint313rs_allocationPKDv3_jjj", (void *)&SC_SetElementAt2_uint3, true }, 1066 { "_Z20rsSetElementAt_uint413rs_allocationPKDv4_jjj", (void *)&SC_SetElementAt2_uint4, true }, 1067 { "_Z19rsSetElementAt_uint13rs_allocationPKjjjj", (void *)&SC_SetElementAt3_uint, true }, 1068 { "_Z20rsSetElementAt_uint213rs_allocationPKDv2_jjjj", (void *)&SC_SetElementAt3_uint2, true }, 1069 { "_Z20rsSetElementAt_uint313rs_allocationPKDv3_jjjj", (void *)&SC_SetElementAt3_uint3, true }, 1070 { "_Z20rsSetElementAt_uint413rs_allocationPKDv4_jjjj", (void *)&SC_SetElementAt3_uint4, true }, 1071 1072 { "_Z18rsSetElementAt_int13rs_allocationPKij", (void *)&SC_SetElementAt1_int, true }, 1073 { "_Z19rsSetElementAt_int213rs_allocationPKDv2_ij", (void *)&SC_SetElementAt1_int2, true }, 1074 { "_Z19rsSetElementAt_int313rs_allocationPKDv3_ij", (void *)&SC_SetElementAt1_int3, true }, 1075 { "_Z19rsSetElementAt_int413rs_allocationPKDv4_ij", (void *)&SC_SetElementAt1_int4, true }, 1076 { "_Z18rsSetElementAt_int13rs_allocationPKijj", (void *)&SC_SetElementAt2_int, true }, 1077 { "_Z19rsSetElementAt_int213rs_allocationPKDv2_ijj", (void *)&SC_SetElementAt2_int2, true }, 1078 { "_Z19rsSetElementAt_int313rs_allocationPKDv3_ijj", (void *)&SC_SetElementAt2_int3, true }, 1079 { "_Z19rsSetElementAt_int413rs_allocationPKDv4_ijj", (void *)&SC_SetElementAt2_int4, true }, 1080 { "_Z18rsSetElementAt_int13rs_allocationPKijjj", (void *)&SC_SetElementAt3_int, true }, 1081 { "_Z19rsSetElementAt_int213rs_allocationPKDv2_ijjj", (void *)&SC_SetElementAt3_int2, true }, 1082 { "_Z19rsSetElementAt_int313rs_allocationPKDv3_ijjj", (void *)&SC_SetElementAt3_int3, true }, 1083 { "_Z19rsSetElementAt_int413rs_allocationPKDv4_ijjj", (void *)&SC_SetElementAt3_int4, true }, 1084 1085 { "_Z20rsSetElementAt_ulong13rs_allocationPKmt", (void *)&SC_SetElementAt1_ulong, true }, 1086 { "_Z21rsSetElementAt_ulong213rs_allocationPKDv2_mj", (void *)&SC_SetElementAt1_ulong2, true }, 1087 { "_Z21rsSetElementAt_ulong313rs_allocationPKDv3_mj", (void *)&SC_SetElementAt1_ulong3, true }, 1088 { "_Z21rsSetElementAt_ulong413rs_allocationPKDv4_mj", (void *)&SC_SetElementAt1_ulong4, true }, 1089 { "_Z20rsSetElementAt_ulong13rs_allocationPKmjj", (void *)&SC_SetElementAt2_ulong, true }, 1090 { "_Z21rsSetElementAt_ulong213rs_allocationPKDv2_mjj", (void *)&SC_SetElementAt2_ulong2, true }, 1091 { "_Z21rsSetElementAt_ulong313rs_allocationPKDv3_mjj", (void *)&SC_SetElementAt2_ulong3, true }, 1092 { "_Z21rsSetElementAt_ulong413rs_allocationPKDv4_mjj", (void *)&SC_SetElementAt2_ulong4, true }, 1093 { "_Z20rsSetElementAt_ulong13rs_allocationPKmjjj", (void *)&SC_SetElementAt3_ulong, true }, 1094 { "_Z21rsSetElementAt_ulong213rs_allocationPKDv2_mjjj", (void *)&SC_SetElementAt3_ulong2, true }, 1095 { "_Z21rsSetElementAt_ulong313rs_allocationPKDv3_mjjj", (void *)&SC_SetElementAt3_ulong3, true }, 1096 { "_Z21rsSetElementAt_ulong413rs_allocationPKDv4_mjjj", (void *)&SC_SetElementAt3_ulong4, true }, 1097 1098 { "_Z19rsSetElementAt_long13rs_allocationPKlj", (void *)&SC_SetElementAt1_long, true }, 1099 { "_Z20rsSetElementAt_long213rs_allocationPKDv2_lj", (void *)&SC_SetElementAt1_long2, true }, 1100 { "_Z20rsSetElementAt_long313rs_allocationPKDv3_lj", (void *)&SC_SetElementAt1_long3, true }, 1101 { "_Z20rsSetElementAt_long413rs_allocationPKDv4_lj", (void *)&SC_SetElementAt1_long4, true }, 1102 { "_Z19rsSetElementAt_long13rs_allocationPKljj", (void *)&SC_SetElementAt2_long, true }, 1103 { "_Z20rsSetElementAt_long213rs_allocationPKDv2_ljj", (void *)&SC_SetElementAt2_long2, true }, 1104 { "_Z20rsSetElementAt_long313rs_allocationPKDv3_ljj", (void *)&SC_SetElementAt2_long3, true }, 1105 { "_Z20rsSetElementAt_long413rs_allocationPKDv4_ljj", (void *)&SC_SetElementAt2_long4, true }, 1106 { "_Z19rsSetElementAt_long13rs_allocationPKljjj", (void *)&SC_SetElementAt3_long, true }, 1107 { "_Z20rsSetElementAt_long213rs_allocationPKDv2_ljjj", (void *)&SC_SetElementAt3_long2, true }, 1108 { "_Z20rsSetElementAt_long313rs_allocationPKDv3_ljjj", (void *)&SC_SetElementAt3_long3, true }, 1109 { "_Z20rsSetElementAt_long413rs_allocationPKDv4_ljjj", (void *)&SC_SetElementAt3_long4, true }, 1110 1111 { "_Z20rsSetElementAt_float13rs_allocationPKft", (void *)&SC_SetElementAt1_float, true }, 1112 { "_Z21rsSetElementAt_float213rs_allocationPKDv2_fj", (void *)&SC_SetElementAt1_float2, true }, 1113 { "_Z21rsSetElementAt_float313rs_allocationPKDv3_fj", (void *)&SC_SetElementAt1_float3, true }, 1114 { "_Z21rsSetElementAt_float413rs_allocationPKDv4_fj", (void *)&SC_SetElementAt1_float4, true }, 1115 { "_Z20rsSetElementAt_float13rs_allocationPKfjj", (void *)&SC_SetElementAt2_float, true }, 1116 { "_Z21rsSetElementAt_float213rs_allocationPKDv2_fjj", (void *)&SC_SetElementAt2_float2, true }, 1117 { "_Z21rsSetElementAt_float313rs_allocationPKDv3_fjj", (void *)&SC_SetElementAt2_float3, true }, 1118 { "_Z21rsSetElementAt_float413rs_allocationPKDv4_fjj", (void *)&SC_SetElementAt2_float4, true }, 1119 { "_Z20rsSetElementAt_float13rs_allocationPKfjjj", (void *)&SC_SetElementAt3_float, true }, 1120 { "_Z21rsSetElementAt_float213rs_allocationPKDv2_fjjj", (void *)&SC_SetElementAt3_float2, true }, 1121 { "_Z21rsSetElementAt_float313rs_allocationPKDv3_fjjj", (void *)&SC_SetElementAt3_float3, true }, 1122 { "_Z21rsSetElementAt_float413rs_allocationPKDv4_fjjj", (void *)&SC_SetElementAt3_float4, true }, 1123 1124 { "_Z21rsSetElementAt_double13rs_allocationPKdt", (void *)&SC_SetElementAt1_double, true }, 1125 { "_Z22rsSetElementAt_double213rs_allocationPKDv2_dj", (void *)&SC_SetElementAt1_double2, true }, 1126 { "_Z22rsSetElementAt_double313rs_allocationPKDv3_dj", (void *)&SC_SetElementAt1_double3, true }, 1127 { "_Z22rsSetElementAt_double413rs_allocationPKDv4_dj", (void *)&SC_SetElementAt1_double4, true }, 1128 { "_Z21rsSetElementAt_double13rs_allocationPKdjj", (void *)&SC_SetElementAt2_double, true }, 1129 { "_Z22rsSetElementAt_double213rs_allocationPKDv2_djj", (void *)&SC_SetElementAt2_double2, true }, 1130 { "_Z22rsSetElementAt_double313rs_allocationPKDv3_djj", (void *)&SC_SetElementAt2_double3, true }, 1131 { "_Z22rsSetElementAt_double413rs_allocationPKDv4_djj", (void *)&SC_SetElementAt2_double4, true }, 1132 { "_Z21rsSetElementAt_double13rs_allocationPKdjjj", (void *)&SC_SetElementAt3_double, true }, 1133 { "_Z22rsSetElementAt_double213rs_allocationPKDv2_djjj", (void *)&SC_SetElementAt3_double2, true }, 1134 { "_Z22rsSetElementAt_double313rs_allocationPKDv3_djjj", (void *)&SC_SetElementAt3_double3, true }, 1135 { "_Z22rsSetElementAt_double413rs_allocationPKDv4_djjj", (void *)&SC_SetElementAt3_double4, true }, 1136 1137 1138 // Refcounting 1139 { "_Z11rsSetObjectP10rs_elementS_", (void *)&SC_SetObject, true }, 1140 { "_Z13rsClearObjectP10rs_element", (void *)&SC_ClearObject, true }, 1141 { "_Z10rsIsObject10rs_element", (void *)&SC_IsObject, true }, 1142 1143 { "_Z11rsSetObjectP7rs_typeS_", (void *)&SC_SetObject, true }, 1144 { "_Z13rsClearObjectP7rs_type", (void *)&SC_ClearObject, true }, 1145 { "_Z10rsIsObject7rs_type", (void *)&SC_IsObject, true }, 1146 1147 { "_Z11rsSetObjectP13rs_allocationS_", (void *)&SC_SetObject, true }, 1148 { "_Z13rsClearObjectP13rs_allocation", (void *)&SC_ClearObject, true }, 1149 { "_Z10rsIsObject13rs_allocation", (void *)&SC_IsObject, true }, 1150 1151 { "_Z11rsSetObjectP10rs_samplerS_", (void *)&SC_SetObject, true }, 1152 { "_Z13rsClearObjectP10rs_sampler", (void *)&SC_ClearObject, true }, 1153 { "_Z10rsIsObject10rs_sampler", (void *)&SC_IsObject, true }, 1154 1155 { "_Z11rsSetObjectP9rs_scriptS_", (void *)&SC_SetObject, true }, 1156 { "_Z13rsClearObjectP9rs_script", (void *)&SC_ClearObject, true }, 1157 { "_Z10rsIsObject9rs_script", (void *)&SC_IsObject, true }, 1158 1159 { "_Z11rsSetObjectP7rs_pathS_", (void *)&SC_SetObject, true }, 1160 { "_Z13rsClearObjectP7rs_path", (void *)&SC_ClearObject, true }, 1161 { "_Z10rsIsObject7rs_path", (void *)&SC_IsObject, true }, 1162 1163 { "_Z11rsSetObjectP7rs_meshS_", (void *)&SC_SetObject, true }, 1164 { "_Z13rsClearObjectP7rs_mesh", (void *)&SC_ClearObject, true }, 1165 { "_Z10rsIsObject7rs_mesh", (void *)&SC_IsObject, true }, 1166 1167 { "_Z11rsSetObjectP19rs_program_fragmentS_", (void *)&SC_SetObject, true }, 1168 { "_Z13rsClearObjectP19rs_program_fragment", (void *)&SC_ClearObject, true }, 1169 { "_Z10rsIsObject19rs_program_fragment", (void *)&SC_IsObject, true }, 1170 1171 { "_Z11rsSetObjectP17rs_program_vertexS_", (void *)&SC_SetObject, true }, 1172 { "_Z13rsClearObjectP17rs_program_vertex", (void *)&SC_ClearObject, true }, 1173 { "_Z10rsIsObject17rs_program_vertex", (void *)&SC_IsObject, true }, 1174 1175 { "_Z11rsSetObjectP17rs_program_rasterS_", (void *)&SC_SetObject, true }, 1176 { "_Z13rsClearObjectP17rs_program_raster", (void *)&SC_ClearObject, true }, 1177 { "_Z10rsIsObject17rs_program_raster", (void *)&SC_IsObject, true }, 1178 1179 { "_Z11rsSetObjectP16rs_program_storeS_", (void *)&SC_SetObject, true }, 1180 { "_Z13rsClearObjectP16rs_program_store", (void *)&SC_ClearObject, true }, 1181 { "_Z10rsIsObject16rs_program_store", (void *)&SC_IsObject, true }, 1182 1183 { "_Z11rsSetObjectP7rs_fontS_", (void *)&SC_SetObject, true }, 1184 { "_Z13rsClearObjectP7rs_font", (void *)&SC_ClearObject, true }, 1185 { "_Z10rsIsObject7rs_font", (void *)&SC_IsObject, true }, 1186 1187 // Allocation ops 1188 { "_Z21rsAllocationMarkDirty13rs_allocation", (void *)&SC_AllocationSyncAll, true }, 1189 { "_Z20rsgAllocationSyncAll13rs_allocation", (void *)&SC_AllocationSyncAll, false }, 1190 { "_Z20rsgAllocationSyncAll13rs_allocationj", (void *)&SC_AllocationSyncAll2, false }, 1191 { "_Z20rsgAllocationSyncAll13rs_allocation24rs_allocation_usage_type", (void *)&SC_AllocationSyncAll2, false }, 1192 { "_Z15rsGetAllocationPKv", (void *)&SC_GetAllocation, true }, 1193#ifndef RS_COMPATIBILITY_LIB 1194 { "_Z18rsAllocationIoSend13rs_allocation", (void *)&SC_AllocationIoSend, false }, 1195 { "_Z21rsAllocationIoReceive13rs_allocation", (void *)&SC_AllocationIoReceive, false }, 1196#endif 1197 { "_Z23rsAllocationCopy1DRange13rs_allocationjjjS_jj", (void *)&SC_AllocationCopy1DRange, false }, 1198 { "_Z23rsAllocationCopy2DRange13rs_allocationjjj26rs_allocation_cubemap_facejjS_jjjS0_", (void *)&SC_AllocationCopy2DRange, false }, 1199 1200 // Messaging 1201 1202 { "_Z14rsSendToClienti", (void *)&SC_ToClient, false }, 1203 { "_Z14rsSendToClientiPKvj", (void *)&SC_ToClient2, false }, 1204 { "_Z22rsSendToClientBlockingi", (void *)&SC_ToClientBlocking, false }, 1205 { "_Z22rsSendToClientBlockingiPKvj", (void *)&SC_ToClientBlocking2, false }, 1206#ifndef RS_COMPATIBILITY_LIB 1207 { "_Z22rsgBindProgramFragment19rs_program_fragment", (void *)&SC_BindProgramFragment, false }, 1208 { "_Z19rsgBindProgramStore16rs_program_store", (void *)&SC_BindProgramStore, false }, 1209 { "_Z20rsgBindProgramVertex17rs_program_vertex", (void *)&SC_BindProgramVertex, false }, 1210 { "_Z20rsgBindProgramRaster17rs_program_raster", (void *)&SC_BindProgramRaster, false }, 1211 { "_Z14rsgBindSampler19rs_program_fragmentj10rs_sampler", (void *)&SC_BindSampler, false }, 1212 { "_Z14rsgBindTexture19rs_program_fragmentj13rs_allocation", (void *)&SC_BindTexture, false }, 1213 { "_Z15rsgBindConstant19rs_program_fragmentj13rs_allocation", (void *)&SC_BindFragmentConstant, false }, 1214 { "_Z15rsgBindConstant17rs_program_vertexj13rs_allocation", (void *)&SC_BindVertexConstant, false }, 1215 1216 { "_Z36rsgProgramVertexLoadProjectionMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadProjectionMatrix, false }, 1217 { "_Z31rsgProgramVertexLoadModelMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadModelMatrix, false }, 1218 { "_Z33rsgProgramVertexLoadTextureMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadTextureMatrix, false }, 1219 1220 { "_Z35rsgProgramVertexGetProjectionMatrixP12rs_matrix4x4", (void *)&SC_VpGetProjectionMatrix, false }, 1221 1222 { "_Z31rsgProgramFragmentConstantColor19rs_program_fragmentffff", (void *)&SC_PfConstantColor, false }, 1223 1224 { "_Z11rsgGetWidthv", (void *)&SC_GetWidth, false }, 1225 { "_Z12rsgGetHeightv", (void *)&SC_GetHeight, false }, 1226 1227 1228 { "_Z11rsgDrawRectfffff", (void *)&SC_DrawRect, false }, 1229 { "_Z11rsgDrawQuadffffffffffff", (void *)&SC_DrawQuad, false }, 1230 { "_Z20rsgDrawQuadTexCoordsffffffffffffffffffff", (void *)&SC_DrawQuadTexCoords, false }, 1231 { "_Z24rsgDrawSpriteScreenspacefffff", (void *)&SC_DrawSpriteScreenspace, false }, 1232 1233 { "_Z11rsgDrawMesh7rs_mesh", (void *)&SC_DrawMesh, false }, 1234 { "_Z11rsgDrawMesh7rs_meshj", (void *)&SC_DrawMeshPrimitive, false }, 1235 { "_Z11rsgDrawMesh7rs_meshjjj", (void *)&SC_DrawMeshPrimitiveRange, false }, 1236 { "_Z25rsgMeshComputeBoundingBox7rs_meshPfS0_S0_S0_S0_S0_", (void *)&SC_MeshComputeBoundingBox, false }, 1237 1238 { "_Z11rsgDrawPath7rs_path", (void *)&SC_DrawPath, false }, 1239 1240 { "_Z13rsgClearColorffff", (void *)&SC_ClearColor, false }, 1241 { "_Z13rsgClearDepthf", (void *)&SC_ClearDepth, false }, 1242 1243 { "_Z11rsgDrawTextPKcii", (void *)&SC_DrawText, false }, 1244 { "_Z11rsgDrawText13rs_allocationii", (void *)&SC_DrawTextAlloc, false }, 1245 { "_Z14rsgMeasureTextPKcPiS1_S1_S1_", (void *)&SC_MeasureText, false }, 1246 { "_Z14rsgMeasureText13rs_allocationPiS0_S0_S0_", (void *)&SC_MeasureTextAlloc, false }, 1247 1248 { "_Z11rsgBindFont7rs_font", (void *)&SC_BindFont, false }, 1249 { "_Z12rsgFontColorffff", (void *)&SC_FontColor, false }, 1250 1251 { "_Z18rsgBindColorTarget13rs_allocationj", (void *)&SC_BindFrameBufferObjectColorTarget, false }, 1252 { "_Z18rsgBindDepthTarget13rs_allocation", (void *)&SC_BindFrameBufferObjectDepthTarget, false }, 1253 { "_Z19rsgClearColorTargetj", (void *)&SC_ClearFrameBufferObjectColorTarget, false }, 1254 { "_Z19rsgClearDepthTargetv", (void *)&SC_ClearFrameBufferObjectDepthTarget, false }, 1255 { "_Z24rsgClearAllRenderTargetsv", (void *)&SC_ClearFrameBufferObjectTargets, false }, 1256 1257 1258 { "_Z9rsForEach9rs_script13rs_allocationS0_", (void *)&SC_ForEach_SAA, true }, 1259 { "_Z9rsForEach9rs_script13rs_allocationS0_PKv", (void *)&SC_ForEach_SAAU, true }, 1260 { "_Z9rsForEach9rs_script13rs_allocationS0_PKvPK14rs_script_call", (void *)&SC_ForEach_SAAUS, true }, 1261 { "_Z9rsForEach9rs_script13rs_allocationS0_PKvj", (void *)&SC_ForEach_SAAUL, true }, 1262 { "_Z9rsForEach9rs_script13rs_allocationS0_PKvjPK14rs_script_call", (void *)&SC_ForEach_SAAULS, true }, 1263#endif // RS_COMPATIBILITY_LIB 1264 1265#ifndef __LP64__ 1266 // time 1267 { "_Z6rsTimePi", (void *)&SC_Time, true }, 1268 { "_Z11rsLocaltimeP5rs_tmPKi", (void *)&SC_LocalTime, true }, 1269#else 1270 // time 1271 { "_Z6rsTimePl", (void *)&SC_Time, true }, 1272 { "_Z11rsLocaltimeP5rs_tmPKl", (void *)&SC_LocalTime, true }, 1273#endif 1274 { "_Z14rsUptimeMillisv", (void*)&SC_UptimeMillis, true }, 1275 { "_Z13rsUptimeNanosv", (void*)&SC_UptimeNanos, true }, 1276 { "_Z7rsGetDtv", (void*)&SC_GetDt, false }, 1277 1278 // misc 1279#ifndef RS_COMPATIBILITY_LIB 1280 { "_Z5colorffff", (void *)&SC_Color, false }, 1281 { "_Z9rsgFinishv", (void *)&SC_Finish, false }, 1282#endif 1283 1284 { NULL, NULL, false } 1285}; 1286 1287#ifdef RS_COMPATIBILITY_LIB 1288 1289////////////////////////////////////////////////////////////////////////////// 1290// Compatibility Library entry points 1291////////////////////////////////////////////////////////////////////////////// 1292 1293#define IS_CLEAR_SET_OBJ(t) \ 1294 bool rsIsObject(t src) { \ 1295 return src.p != NULL; \ 1296 } \ 1297 void __attribute__((overloadable)) rsClearObject(t *dst) { \ 1298 return SC_ClearObject(reinterpret_cast<rs_object_base *>(dst)); \ 1299 } \ 1300 void __attribute__((overloadable)) rsSetObject(t *dst, t src) { \ 1301 return SC_SetObject(reinterpret_cast<rs_object_base *>(dst), (ObjectBase*)src.p); \ 1302 } 1303 1304IS_CLEAR_SET_OBJ(::rs_element) 1305IS_CLEAR_SET_OBJ(::rs_type) 1306IS_CLEAR_SET_OBJ(::rs_allocation) 1307IS_CLEAR_SET_OBJ(::rs_sampler) 1308IS_CLEAR_SET_OBJ(::rs_script) 1309#undef IS_CLEAR_SET_OBJ 1310 1311static void SC_ForEach_SAA(::rs_script target, 1312 ::rs_allocation in, 1313 ::rs_allocation out) { 1314 Context *rsc = RsdCpuReference::getTlsContext(); 1315 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, NULL, 0, NULL); 1316} 1317 1318static void SC_ForEach_SAAUS(::rs_script target, 1319 ::rs_allocation in, 1320 ::rs_allocation out, 1321 const void *usr, 1322 const RsScriptCall *call) { 1323 Context *rsc = RsdCpuReference::getTlsContext(); 1324 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, usr, 0, call); 1325} 1326 1327static void SC_ForEach_SAAUL(::rs_script target, 1328 ::rs_allocation in, 1329 ::rs_allocation out, 1330 const void *usr, 1331 uint32_t usrLen) { 1332 Context *rsc = RsdCpuReference::getTlsContext(); 1333 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, usr, usrLen, NULL); 1334} 1335 1336static void SC_ForEach_SAAULS(::rs_script target, 1337 ::rs_allocation in, 1338 ::rs_allocation out, 1339 const void *usr, 1340 uint32_t usrLen, 1341 const RsScriptCall *call) { 1342 Context *rsc = RsdCpuReference::getTlsContext(); 1343 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, usr, usrLen, call); 1344} 1345 1346const Allocation * rsGetAllocation(const void *ptr) { 1347 return SC_GetAllocation(ptr); 1348} 1349 1350void __attribute__((overloadable)) rsAllocationIoSend(::rs_allocation a) { 1351 SC_AllocationIoSend((Allocation *)a.p); 1352} 1353 1354void __attribute__((overloadable)) rsAllocationIoReceive(::rs_allocation a) { 1355 SC_AllocationIoReceive((Allocation *)a.p); 1356} 1357 1358 1359void __attribute__((overloadable)) rsAllocationCopy1DRange( 1360 ::rs_allocation dstAlloc, 1361 uint32_t dstOff, uint32_t dstMip, uint32_t count, 1362 ::rs_allocation srcAlloc, 1363 uint32_t srcOff, uint32_t srcMip) { 1364 SC_AllocationCopy1DRange(dstAlloc, dstOff, dstMip, count, 1365 srcAlloc, srcOff, srcMip); 1366} 1367 1368void __attribute__((overloadable)) rsAllocationCopy2DRange( 1369 ::rs_allocation dstAlloc, 1370 uint32_t dstXoff, uint32_t dstYoff, 1371 uint32_t dstMip, rs_allocation_cubemap_face dstFace, 1372 uint32_t width, uint32_t height, 1373 ::rs_allocation srcAlloc, 1374 uint32_t srcXoff, uint32_t srcYoff, 1375 uint32_t srcMip, rs_allocation_cubemap_face srcFace) { 1376 SC_AllocationCopy2DRange(dstAlloc, dstXoff, dstYoff, 1377 dstMip, dstFace, width, height, 1378 srcAlloc, srcXoff, srcYoff, 1379 srcMip, srcFace); 1380} 1381 1382void __attribute__((overloadable)) rsForEach(::rs_script script, 1383 ::rs_allocation in, 1384 ::rs_allocation out, 1385 const void *usr, 1386 const rs_script_call *call) { 1387 return SC_ForEach_SAAUS(script, in, out, usr, (RsScriptCall*)call); 1388} 1389 1390void __attribute__((overloadable)) rsForEach(::rs_script script, 1391 ::rs_allocation in, 1392 ::rs_allocation out) { 1393 return SC_ForEach_SAA(script, in, out); 1394} 1395 1396void __attribute__((overloadable)) rsForEach(::rs_script script, 1397 ::rs_allocation in, 1398 ::rs_allocation out, 1399 const void *usr, 1400 uint32_t usrLen) { 1401 return SC_ForEach_SAAUL(script, in, out, usr, usrLen); 1402} 1403 1404void __attribute__((overloadable)) rsForEach(::rs_script script, 1405 ::rs_allocation in, 1406 ::rs_allocation out, 1407 const void *usr, 1408 uint32_t usrLen, 1409 const rs_script_call *call) { 1410 return SC_ForEach_SAAULS(script, in, out, usr, usrLen, (RsScriptCall*)call); 1411} 1412 1413int rsTime(int *timer) { 1414 return SC_Time(timer); 1415} 1416 1417rs_tm* rsLocaltime(rs_tm* local, const int *timer) { 1418 return (rs_tm*)(SC_LocalTime((tm*)local, (long*)timer)); 1419} 1420 1421int64_t rsUptimeMillis() { 1422 Context *rsc = RsdCpuReference::getTlsContext(); 1423 return rsrUptimeMillis(rsc); 1424} 1425 1426int64_t rsUptimeNanos() { 1427 return SC_UptimeNanos(); 1428} 1429 1430float rsGetDt() { 1431 return SC_GetDt(); 1432} 1433 1434uint32_t rsSendToClient(int cmdID) { 1435 return SC_ToClient(cmdID); 1436} 1437 1438uint32_t rsSendToClient(int cmdID, const void *data, uint32_t len) { 1439 return SC_ToClient2(cmdID, data, len); 1440} 1441 1442uint32_t rsSendToClientBlocking(int cmdID) { 1443 return SC_ToClientBlocking(cmdID); 1444} 1445 1446uint32_t rsSendToClientBlocking(int cmdID, const void *data, uint32_t len) { 1447 return SC_ToClientBlocking2(cmdID, data, len); 1448} 1449 1450static void SC_debugF(const char *s, float f) { 1451 ALOGD("%s %f, 0x%08x", s, f, *((int *) (&f))); 1452} 1453static void SC_debugFv2(const char *s, float f1, float f2) { 1454 ALOGD("%s {%f, %f}", s, f1, f2); 1455} 1456static void SC_debugFv3(const char *s, float f1, float f2, float f3) { 1457 ALOGD("%s {%f, %f, %f}", s, f1, f2, f3); 1458} 1459static void SC_debugFv4(const char *s, float f1, float f2, float f3, float f4) { 1460 ALOGD("%s {%f, %f, %f, %f}", s, f1, f2, f3, f4); 1461} 1462static void SC_debugF2(const char *s, float2 f) { 1463 ALOGD("%s {%f, %f}", s, f.x, f.y); 1464} 1465static void SC_debugF3(const char *s, float3 f) { 1466 ALOGD("%s {%f, %f, %f}", s, f.x, f.y, f.z); 1467} 1468static void SC_debugF4(const char *s, float4 f) { 1469 ALOGD("%s {%f, %f, %f, %f}", s, f.x, f.y, f.z, f.w); 1470} 1471static void SC_debugD(const char *s, double d) { 1472 ALOGD("%s %f, 0x%08llx", s, d, *((long long *) (&d))); 1473} 1474static void SC_debugFM4v4(const char *s, const float *f) { 1475 ALOGD("%s {%f, %f, %f, %f", s, f[0], f[4], f[8], f[12]); 1476 ALOGD("%s %f, %f, %f, %f", s, f[1], f[5], f[9], f[13]); 1477 ALOGD("%s %f, %f, %f, %f", s, f[2], f[6], f[10], f[14]); 1478 ALOGD("%s %f, %f, %f, %f}", s, f[3], f[7], f[11], f[15]); 1479} 1480static void SC_debugFM3v3(const char *s, const float *f) { 1481 ALOGD("%s {%f, %f, %f", s, f[0], f[3], f[6]); 1482 ALOGD("%s %f, %f, %f", s, f[1], f[4], f[7]); 1483 ALOGD("%s %f, %f, %f}",s, f[2], f[5], f[8]); 1484} 1485static void SC_debugFM2v2(const char *s, const float *f) { 1486 ALOGD("%s {%f, %f", s, f[0], f[2]); 1487 ALOGD("%s %f, %f}",s, f[1], f[3]); 1488} 1489static void SC_debugI8(const char *s, char c) { 1490 ALOGD("%s %hhd 0x%hhx", s, c, (unsigned char)c); 1491} 1492static void SC_debugC2(const char *s, char2 c) { 1493 ALOGD("%s {%hhd, %hhd} 0x%hhx 0x%hhx", s, c.x, c.y, (unsigned char)c.x, (unsigned char)c.y); 1494} 1495static void SC_debugC3(const char *s, char3 c) { 1496 ALOGD("%s {%hhd, %hhd, %hhd} 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, (unsigned char)c.x, (unsigned char)c.y, (unsigned char)c.z); 1497} 1498static void SC_debugC4(const char *s, char4 c) { 1499 ALOGD("%s {%hhd, %hhd, %hhd, %hhd} 0x%hhx 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.w, (unsigned char)c.x, (unsigned char)c.y, (unsigned char)c.z, (unsigned char)c.w); 1500} 1501static void SC_debugU8(const char *s, unsigned char c) { 1502 ALOGD("%s %hhu 0x%hhx", s, c, c); 1503} 1504static void SC_debugUC2(const char *s, uchar2 c) { 1505 ALOGD("%s {%hhu, %hhu} 0x%hhx 0x%hhx", s, c.x, c.y, c.x, c.y); 1506} 1507static void SC_debugUC3(const char *s, uchar3 c) { 1508 ALOGD("%s {%hhu, %hhu, %hhu} 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.x, c.y, c.z); 1509} 1510static void SC_debugUC4(const char *s, uchar4 c) { 1511 ALOGD("%s {%hhu, %hhu, %hhu, %hhu} 0x%hhx 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.w, c.x, c.y, c.z, c.w); 1512} 1513static void SC_debugI16(const char *s, short c) { 1514 ALOGD("%s %hd 0x%hx", s, c, c); 1515} 1516static void SC_debugS2(const char *s, short2 c) { 1517 ALOGD("%s {%hd, %hd} 0x%hx 0x%hx", s, c.x, c.y, c.x, c.y); 1518} 1519static void SC_debugS3(const char *s, short3 c) { 1520 ALOGD("%s {%hd, %hd, %hd} 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z); 1521} 1522static void SC_debugS4(const char *s, short4 c) { 1523 ALOGD("%s {%hd, %hd, %hd, %hd} 0x%hx 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.w, c.x, c.y, c.z, c.w); 1524} 1525static void SC_debugU16(const char *s, unsigned short c) { 1526 ALOGD("%s %hu 0x%hx", s, c, c); 1527} 1528static void SC_debugUS2(const char *s, ushort2 c) { 1529 ALOGD("%s {%hu, %hu} 0x%hx 0x%hx", s, c.x, c.y, c.x, c.y); 1530} 1531static void SC_debugUS3(const char *s, ushort3 c) { 1532 ALOGD("%s {%hu, %hu, %hu} 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z); 1533} 1534static void SC_debugUS4(const char *s, ushort4 c) { 1535 ALOGD("%s {%hu, %hu, %hu, %hu} 0x%hx 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.w, c.x, c.y, c.z, c.w); 1536} 1537static void SC_debugI32(const char *s, int32_t i) { 1538 ALOGD("%s %d 0x%x", s, i, i); 1539} 1540static void SC_debugI2(const char *s, int2 i) { 1541 ALOGD("%s {%d, %d} 0x%x 0x%x", s, i.x, i.y, i.x, i.y); 1542} 1543static void SC_debugI3(const char *s, int3 i) { 1544 ALOGD("%s {%d, %d, %d} 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z); 1545} 1546static void SC_debugI4(const char *s, int4 i) { 1547 ALOGD("%s {%d, %d, %d, %d} 0x%x 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.w, i.x, i.y, i.z, i.w); 1548} 1549static void SC_debugU32(const char *s, uint32_t i) { 1550 ALOGD("%s %u 0x%x", s, i, i); 1551} 1552static void SC_debugUI2(const char *s, uint2 i) { 1553 ALOGD("%s {%u, %u} 0x%x 0x%x", s, i.x, i.y, i.x, i.y); 1554} 1555static void SC_debugUI3(const char *s, uint3 i) { 1556 ALOGD("%s {%u, %u, %u} 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z); 1557} 1558static void SC_debugUI4(const char *s, uint4 i) { 1559 ALOGD("%s {%u, %u, %u, %u} 0x%x 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.w, i.x, i.y, i.z, i.w); 1560} 1561static void SC_debugLL64(const char *s, long long ll) { 1562 ALOGD("%s %lld 0x%llx", s, ll, ll); 1563} 1564static void SC_debugL2(const char *s, long2 ll) { 1565 ALOGD("%s {%lld, %lld} 0x%llx 0x%llx", s, ll.x, ll.y, ll.x, ll.y); 1566} 1567static void SC_debugL3(const char *s, long3 ll) { 1568 ALOGD("%s {%lld, %lld, %lld} 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.x, ll.y, ll.z); 1569} 1570static void SC_debugL4(const char *s, long4 ll) { 1571 ALOGD("%s {%lld, %lld, %lld, %lld} 0x%llx 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.w, ll.x, ll.y, ll.z, ll.w); 1572} 1573static void SC_debugULL64(const char *s, unsigned long long ll) { 1574 ALOGD("%s %llu 0x%llx", s, ll, ll); 1575} 1576static void SC_debugUL2(const char *s, ulong2 ll) { 1577 ALOGD("%s {%llu, %llu} 0x%llx 0x%llx", s, ll.x, ll.y, ll.x, ll.y); 1578} 1579static void SC_debugUL3(const char *s, ulong3 ll) { 1580 ALOGD("%s {%llu, %llu, %llu} 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.x, ll.y, ll.z); 1581} 1582static void SC_debugUL4(const char *s, ulong4 ll) { 1583 ALOGD("%s {%llu, %llu, %llu, %llu} 0x%llx 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.w, ll.x, ll.y, ll.z, ll.w); 1584} 1585static void SC_debugP(const char *s, const void *p) { 1586 ALOGD("%s %p", s, p); 1587} 1588 1589// TODO: allocation ops, messaging, time 1590 1591void rsDebug(const char *s, float f) { 1592 SC_debugF(s, f); 1593} 1594 1595void rsDebug(const char *s, float f1, float f2) { 1596 SC_debugFv2(s, f1, f2); 1597} 1598 1599void rsDebug(const char *s, float f1, float f2, float f3) { 1600 SC_debugFv3(s, f1, f2, f3); 1601} 1602 1603void rsDebug(const char *s, float f1, float f2, float f3, float f4) { 1604 SC_debugFv4(s, f1, f2, f3, f4); 1605} 1606 1607void rsDebug(const char *s, const float2 *f) { 1608 SC_debugF2(s, *f); 1609} 1610 1611void rsDebug(const char *s, const float3 *f) { 1612 SC_debugF3(s, *f); 1613} 1614 1615void rsDebug(const char *s, const float4 *f) { 1616 SC_debugF4(s, *f); 1617} 1618 1619void rsDebug(const char *s, double d) { 1620 SC_debugD(s, d); 1621} 1622 1623void rsDebug(const char *s, const rs_matrix4x4 *m) { 1624 SC_debugFM4v4(s, (float *) m); 1625} 1626 1627void rsDebug(const char *s, const rs_matrix3x3 *m) { 1628 SC_debugFM3v3(s, (float *) m); 1629} 1630 1631void rsDebug(const char *s, const rs_matrix2x2 *m) { 1632 SC_debugFM2v2(s, (float *) m); 1633} 1634 1635void rsDebug(const char *s, char c) { 1636 SC_debugI8(s, c); 1637} 1638 1639void rsDebug(const char *s, const char2 *c) { 1640 SC_debugC2(s, *c); 1641} 1642 1643void rsDebug(const char *s, const char3 *c) { 1644 SC_debugC3(s, *c); 1645} 1646 1647void rsDebug(const char *s, const char4 *c) { 1648 SC_debugC4(s, *c); 1649} 1650 1651void rsDebug(const char *s, unsigned char c) { 1652 SC_debugU8(s, c); 1653} 1654 1655void rsDebug(const char *s, const uchar2 *c) { 1656 SC_debugUC2(s, *c); 1657} 1658 1659void rsDebug(const char *s, const uchar3 *c) { 1660 SC_debugUC3(s, *c); 1661} 1662 1663void rsDebug(const char *s, const uchar4 *c) { 1664 SC_debugUC4(s, *c); 1665} 1666 1667void rsDebug(const char *s, short c) { 1668 SC_debugI16(s, c); 1669} 1670 1671void rsDebug(const char *s, const short2 *c) { 1672 SC_debugS2(s, *c); 1673} 1674 1675void rsDebug(const char *s, const short3 *c) { 1676 SC_debugS3(s, *c); 1677} 1678 1679void rsDebug(const char *s, const short4 *c) { 1680 SC_debugS4(s, *c); 1681} 1682 1683void rsDebug(const char *s, unsigned short c) { 1684 SC_debugU16(s, c); 1685} 1686 1687void rsDebug(const char *s, const ushort2 *c) { 1688 SC_debugUS2(s, *c); 1689} 1690 1691void rsDebug(const char *s, const ushort3 *c) { 1692 SC_debugUS3(s, *c); 1693} 1694 1695void rsDebug(const char *s, const ushort4 *c) { 1696 SC_debugUS4(s, *c); 1697} 1698 1699void rsDebug(const char *s, int c) { 1700 SC_debugI32(s, c); 1701} 1702 1703void rsDebug(const char *s, const int2 *c) { 1704 SC_debugI2(s, *c); 1705} 1706 1707void rsDebug(const char *s, const int3 *c) { 1708 SC_debugI3(s, *c); 1709} 1710 1711void rsDebug(const char *s, const int4 *c) { 1712 SC_debugI4(s, *c); 1713} 1714 1715void rsDebug(const char *s, unsigned int c) { 1716 SC_debugU32(s, c); 1717} 1718 1719void rsDebug(const char *s, const uint2 *c) { 1720 SC_debugUI2(s, *c); 1721} 1722 1723void rsDebug(const char *s, const uint3 *c) { 1724 SC_debugUI3(s, *c); 1725} 1726 1727void rsDebug(const char *s, const uint4 *c) { 1728 SC_debugUI4(s, *c); 1729} 1730 1731void rsDebug(const char *s, long c) { 1732 SC_debugLL64(s, c); 1733} 1734 1735void rsDebug(const char *s, long long c) { 1736 SC_debugLL64(s, c); 1737} 1738 1739void rsDebug(const char *s, const long2 *c) { 1740 SC_debugL2(s, *c); 1741} 1742 1743void rsDebug(const char *s, const long3 *c) { 1744 SC_debugL3(s, *c); 1745} 1746 1747void rsDebug(const char *s, const long4 *c) { 1748 SC_debugL4(s, *c); 1749} 1750 1751void rsDebug(const char *s, unsigned long c) { 1752 SC_debugULL64(s, c); 1753} 1754 1755void rsDebug(const char *s, unsigned long long c) { 1756 SC_debugULL64(s, c); 1757} 1758 1759void rsDebug(const char *s, const ulong2 *c) { 1760 SC_debugUL2(s, *c); 1761} 1762 1763void rsDebug(const char *s, const ulong3 *c) { 1764 SC_debugUL3(s, *c); 1765} 1766 1767void rsDebug(const char *s, const ulong4 *c) { 1768 SC_debugUL4(s, *c); 1769} 1770 1771// FIXME: We need to export these function signatures for the compatibility 1772// library. The C++ name mangling that LLVM uses for ext_vector_type requires 1773// different versions for "long" vs. "long long". Note that the called 1774// functions are still using the appropriate 64-bit sizes. 1775typedef long l2 __attribute__((ext_vector_type(2))); 1776typedef long l3 __attribute__((ext_vector_type(3))); 1777typedef long l4 __attribute__((ext_vector_type(4))); 1778typedef unsigned long ul2 __attribute__((ext_vector_type(2))); 1779typedef unsigned long ul3 __attribute__((ext_vector_type(3))); 1780typedef unsigned long ul4 __attribute__((ext_vector_type(4))); 1781 1782void rsDebug(const char *s, const l2 *c) { 1783 SC_debugL2(s, *(const long2 *)c); 1784} 1785 1786void rsDebug(const char *s, const l3 *c) { 1787 SC_debugL3(s, *(const long3 *)c); 1788} 1789 1790void rsDebug(const char *s, const l4 *c) { 1791 SC_debugL4(s, *(const long4 *)c); 1792} 1793 1794void rsDebug(const char *s, const ul2 *c) { 1795 SC_debugUL2(s, *(const ulong2 *)c); 1796} 1797 1798void rsDebug(const char *s, const ul3 *c) { 1799 SC_debugUL3(s, *(const ulong3 *)c); 1800} 1801 1802void rsDebug(const char *s, const ul4 *c) { 1803 SC_debugUL4(s, *(const ulong4 *)c); 1804} 1805 1806void rsDebug(const char *s, const void *p) { 1807 SC_debugP(s, p); 1808} 1809#endif // RS_COMPATIBILITY_LIB 1810 1811extern const RsdCpuReference::CpuSymbol * rsdLookupRuntimeStub(Context * pContext, char const* name) { 1812 ScriptC *s = (ScriptC *)pContext; 1813 const RsdCpuReference::CpuSymbol *syms = gSyms; 1814 const RsdCpuReference::CpuSymbol *sym = NULL; 1815 1816 if (!sym) { 1817 while (syms->fnPtr) { 1818 if (!strcmp(syms->name, name)) { 1819 return syms; 1820 } 1821 syms++; 1822 } 1823 } 1824 1825 return NULL; 1826} 1827