rsdRuntimeStubs.cpp revision 5a45c938d8f5e66f0afff7b3a2a9afe06f79c76a
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 int16_t short2 __attribute__((ext_vector_type(2))); 50typedef int16_t short3 __attribute__((ext_vector_type(3))); 51typedef int16_t short4 __attribute__((ext_vector_type(4))); 52typedef uint16_t ushort2 __attribute__((ext_vector_type(2))); 53typedef uint16_t ushort3 __attribute__((ext_vector_type(3))); 54typedef uint16_t 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 int64_t long2 __attribute__((ext_vector_type(2))); 62typedef int64_t long3 __attribute__((ext_vector_type(3))); 63typedef int64_t long4 __attribute__((ext_vector_type(4))); 64typedef uint64_t ulong2 __attribute__((ext_vector_type(2))); 65typedef uint64_t ulong3 __attribute__((ext_vector_type(3))); 66typedef uint64_t 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 487#ifdef __LP64__ 488static void SC_SetObject_ByRef(rs_object_base *dst, rs_object_base *src) { 489 // ALOGE("SC_SetObject2: dst = %p, src = %p", dst, src->p); 490 Context *rsc = RsdCpuReference::getTlsContext(); 491 rsrSetObject(rsc, dst, (ObjectBase*)src->p); 492} 493#endif 494 495static bool SC_IsObject(rs_object_base o) { 496 Context *rsc = RsdCpuReference::getTlsContext(); 497 return rsrIsObject(rsc, o); 498} 499 500#ifdef __LP64__ 501static bool SC_IsObject_ByRef(rs_object_base *o) { 502 Context *rsc = RsdCpuReference::getTlsContext(); 503 return rsrIsObject(rsc, *o); 504} 505#endif 506 507#else 508static void SC_SetObject(rs_object_base *dst, ObjectBase* src) { 509 // ALOGE("SC_SetObject: dst = %p, src = %p", dst, src.p); 510 // ALOGE("SC_SetObject: dst[0] = %p", dst[0]); 511 Context *rsc = RsdCpuReference::getTlsContext(); 512 rsrSetObject(rsc, dst, src); 513} 514 515static bool SC_IsObject(ObjectBase* o) { 516 Context *rsc = RsdCpuReference::getTlsContext(); 517 return rsrIsObject(rsc, o); 518} 519#endif 520 521 522#ifndef RS_COMPATIBILITY_LIB 523#ifndef __LP64__ 524 525// i386 has different struct return passing to ARM; emulate with void* 526#ifdef __i386__ 527static const void* SC_GetAllocation(const void *ptr) { 528 Context *rsc = RsdCpuReference::getTlsContext(); 529 const Script *sc = RsdCpuReference::getTlsScript(); 530 Allocation* alloc = rsdScriptGetAllocationForPointer(rsc, sc, ptr); 531 android::renderscript::rs_allocation obj = {0}; 532 alloc->callUpdateCacheObject(rsc, &obj); 533 return (void*)obj.p; 534} 535#else 536// ARMv7/MIPS 537static const android::renderscript::rs_allocation SC_GetAllocation(const void *ptr) { 538 Context *rsc = RsdCpuReference::getTlsContext(); 539 const Script *sc = RsdCpuReference::getTlsScript(); 540 Allocation* alloc = rsdScriptGetAllocationForPointer(rsc, sc, ptr); 541 android::renderscript::rs_allocation obj = {0}; 542 alloc->callUpdateCacheObject(rsc, &obj); 543 return obj; 544} 545#endif 546#else 547// AArch64/x86_64/MIPS64 548static const android::renderscript::rs_allocation SC_GetAllocation(const void *ptr) { 549 Context *rsc = RsdCpuReference::getTlsContext(); 550 const Script *sc = RsdCpuReference::getTlsScript(); 551 Allocation* alloc = rsdScriptGetAllocationForPointer(rsc, sc, ptr); 552 android::renderscript::rs_allocation obj = {0, 0, 0, 0}; 553 alloc->callUpdateCacheObject(rsc, &obj); 554 return obj; 555} 556#endif 557#endif 558 559#ifndef RS_COMPATIBILITY_LIB 560#ifndef __LP64__ 561static void SC_ForEach_SAA(android::renderscript::rs_script target, 562 android::renderscript::rs_allocation in, 563 android::renderscript::rs_allocation out) { 564 Context *rsc = RsdCpuReference::getTlsContext(); 565 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 566 nullptr, 0, nullptr); 567} 568#else 569static void SC_ForEach_SAA(android::renderscript::rs_script *target, 570 android::renderscript::rs_allocation *in, 571 android::renderscript::rs_allocation *out) { 572 Context *rsc = RsdCpuReference::getTlsContext(); 573 rsrForEach(rsc, (Script*)target->p, (Allocation*)in->p, (Allocation*)out->p, NULL, 0, NULL); 574} 575#endif 576 577#ifndef __LP64__ 578static void SC_ForEach_SAAU(android::renderscript::rs_script target, 579 android::renderscript::rs_allocation in, 580 android::renderscript::rs_allocation out, 581 const void *usr) { 582 Context *rsc = RsdCpuReference::getTlsContext(); 583 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 584 usr, 0, nullptr); 585} 586#else 587static void SC_ForEach_SAAU(android::renderscript::rs_script *target, 588 android::renderscript::rs_allocation *in, 589 android::renderscript::rs_allocation *out, 590 const void *usr) { 591 Context *rsc = RsdCpuReference::getTlsContext(); 592 rsrForEach(rsc, (Script*)target->p, (Allocation*)in->p, (Allocation*)out->p, usr, 0, NULL); 593} 594#endif 595 596#ifndef __LP64__ 597static void SC_ForEach_SAAUS(android::renderscript::rs_script target, 598 android::renderscript::rs_allocation in, 599 android::renderscript::rs_allocation out, 600 const void *usr, 601 const RsScriptCall *call) { 602 Context *rsc = RsdCpuReference::getTlsContext(); 603 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, usr, 0, call); 604} 605#else 606static void SC_ForEach_SAAUS(android::renderscript::rs_script *target, 607 android::renderscript::rs_allocation *in, 608 android::renderscript::rs_allocation *out, 609 const void *usr, 610 const RsScriptCall *call) { 611 Context *rsc = RsdCpuReference::getTlsContext(); 612 rsrForEach(rsc, (Script*)target->p, (Allocation*)in->p, (Allocation*)out->p, usr, 0, call); 613} 614#endif 615 616#ifndef __LP64__ 617static void SC_ForEach_SAAUL(android::renderscript::rs_script target, 618 android::renderscript::rs_allocation in, 619 android::renderscript::rs_allocation out, 620 const void *usr, 621 uint32_t usrLen) { 622 Context *rsc = RsdCpuReference::getTlsContext(); 623 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 624 usr, usrLen, nullptr); 625} 626#else 627static void SC_ForEach_SAAUL(android::renderscript::rs_script *target, 628 android::renderscript::rs_allocation *in, 629 android::renderscript::rs_allocation *out, 630 const void *usr, 631 uint32_t usrLen) { 632 Context *rsc = RsdCpuReference::getTlsContext(); 633 rsrForEach(rsc, (Script*)target->p, (Allocation*)in->p, (Allocation*)out->p, usr, usrLen, NULL); 634} 635#endif 636 637#ifndef __LP64__ 638static void SC_ForEach_SAAULS(android::renderscript::rs_script target, 639 android::renderscript::rs_allocation in, 640 android::renderscript::rs_allocation out, 641 const void *usr, 642 uint32_t usrLen, 643 const RsScriptCall *call) { 644 Context *rsc = RsdCpuReference::getTlsContext(); 645 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, usr, usrLen, call); 646} 647#else 648static void SC_ForEach_SAAULS(android::renderscript::rs_script *target, 649 android::renderscript::rs_allocation *in, 650 android::renderscript::rs_allocation *out, 651 const void *usr, 652 uint32_t usrLen, 653 const RsScriptCall *call) { 654 Context *rsc = RsdCpuReference::getTlsContext(); 655 rsrForEach(rsc, (Script*)target->p, (Allocation*)in->p, (Allocation*)out->p, usr, usrLen, call); 656} 657#endif 658#endif 659 660 661////////////////////////////////////////////////////////////////////////////// 662// Time routines 663////////////////////////////////////////////////////////////////////////////// 664 665static float SC_GetDt() { 666 Context *rsc = RsdCpuReference::getTlsContext(); 667 const Script *sc = RsdCpuReference::getTlsScript(); 668 return rsrGetDt(rsc, sc); 669} 670 671#ifndef RS_COMPATIBILITY_LIB 672time_t SC_Time(time_t *timer) { 673 Context *rsc = RsdCpuReference::getTlsContext(); 674 return rsrTime(rsc, timer); 675} 676#else 677static int SC_Time(int *timer) { 678 Context *rsc = RsdCpuReference::getTlsContext(); 679 return rsrTime(rsc, (long*)timer); 680} 681#endif 682 683tm* SC_LocalTime(tm *local, time_t *timer) { 684 Context *rsc = RsdCpuReference::getTlsContext(); 685 return rsrLocalTime(rsc, local, timer); 686} 687 688int64_t SC_UptimeMillis() { 689 Context *rsc = RsdCpuReference::getTlsContext(); 690 return rsrUptimeMillis(rsc); 691} 692 693int64_t SC_UptimeNanos() { 694 Context *rsc = RsdCpuReference::getTlsContext(); 695 return rsrUptimeNanos(rsc); 696} 697 698////////////////////////////////////////////////////////////////////////////// 699// Message routines 700////////////////////////////////////////////////////////////////////////////// 701 702static uint32_t SC_ToClient2(int cmdID, const void *data, uint32_t len) { 703 Context *rsc = RsdCpuReference::getTlsContext(); 704 return rsrToClient(rsc, cmdID, data, len); 705} 706 707static uint32_t SC_ToClient(int cmdID) { 708 Context *rsc = RsdCpuReference::getTlsContext(); 709 return rsrToClient(rsc, cmdID, (const void *)nullptr, 0); 710} 711 712static uint32_t SC_ToClientBlocking2(int cmdID, const void *data, uint32_t len) { 713 Context *rsc = RsdCpuReference::getTlsContext(); 714 return rsrToClientBlocking(rsc, cmdID, data, len); 715} 716 717static uint32_t SC_ToClientBlocking(int cmdID) { 718 Context *rsc = RsdCpuReference::getTlsContext(); 719 return rsrToClientBlocking(rsc, cmdID, (const void *)nullptr, 0); 720} 721 722 723static void * ElementAt1D(Allocation *a, RsDataType dt, uint32_t vecSize, uint32_t x) { 724 Context *rsc = RsdCpuReference::getTlsContext(); 725 const Type *t = a->getType(); 726 const Element *e = t->getElement(); 727 728 char buf[256]; 729 if (x >= t->getLODDimX(0)) { 730 sprintf(buf, "Out range ElementAt X %i of %i", x, t->getLODDimX(0)); 731 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 732 return nullptr; 733 } 734 735 if (vecSize > 0) { 736 if (vecSize != e->getVectorSize()) { 737 sprintf(buf, "Vector size mismatch for ElementAt %i of %i", vecSize, e->getVectorSize()); 738 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 739 return nullptr; 740 } 741 742 if (dt != e->getType()) { 743 sprintf(buf, "Data type mismatch for ElementAt %i of %i", dt, e->getType()); 744 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 745 return nullptr; 746 } 747 } 748 749 uint8_t *p = (uint8_t *)a->mHal.drvState.lod[0].mallocPtr; 750 const uint32_t eSize = e->getSizeBytes(); 751 return &p[(eSize * x)]; 752} 753 754static void * ElementAt2D(Allocation *a, RsDataType dt, uint32_t vecSize, uint32_t x, uint32_t y) { 755 Context *rsc = RsdCpuReference::getTlsContext(); 756 const Type *t = a->getType(); 757 const Element *e = t->getElement(); 758 759 char buf[256]; 760 if (x >= t->getLODDimX(0)) { 761 sprintf(buf, "Out range ElementAt X %i of %i", x, t->getLODDimX(0)); 762 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 763 return nullptr; 764 } 765 766 if (y >= t->getLODDimY(0)) { 767 sprintf(buf, "Out range ElementAt Y %i of %i", y, t->getLODDimY(0)); 768 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 769 return nullptr; 770 } 771 772 if (vecSize > 0) { 773 if (vecSize != e->getVectorSize()) { 774 sprintf(buf, "Vector size mismatch for ElementAt %i of %i", vecSize, e->getVectorSize()); 775 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 776 return nullptr; 777 } 778 779 if (dt != e->getType()) { 780 sprintf(buf, "Data type mismatch for ElementAt %i of %i", dt, e->getType()); 781 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 782 return nullptr; 783 } 784 } 785 786 uint8_t *p = (uint8_t *)a->mHal.drvState.lod[0].mallocPtr; 787 const uint32_t eSize = e->getSizeBytes(); 788 const uint32_t stride = a->mHal.drvState.lod[0].stride; 789 return &p[(eSize * x) + (y * stride)]; 790} 791 792static void * ElementAt3D(Allocation *a, RsDataType dt, uint32_t vecSize, uint32_t x, uint32_t y, uint32_t z) { 793 Context *rsc = RsdCpuReference::getTlsContext(); 794 const Type *t = a->getType(); 795 const Element *e = t->getElement(); 796 797 char buf[256]; 798 if (x >= t->getLODDimX(0)) { 799 sprintf(buf, "Out range ElementAt X %i of %i", x, t->getLODDimX(0)); 800 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 801 return nullptr; 802 } 803 804 if (y >= t->getLODDimY(0)) { 805 sprintf(buf, "Out range ElementAt Y %i of %i", y, t->getLODDimY(0)); 806 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 807 return nullptr; 808 } 809 810 if (z >= t->getLODDimZ(0)) { 811 sprintf(buf, "Out range ElementAt Z %i of %i", z, t->getLODDimZ(0)); 812 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 813 return nullptr; 814 } 815 816 if (vecSize > 0) { 817 if (vecSize != e->getVectorSize()) { 818 sprintf(buf, "Vector size mismatch for ElementAt %i of %i", vecSize, e->getVectorSize()); 819 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 820 return nullptr; 821 } 822 823 if (dt != e->getType()) { 824 sprintf(buf, "Data type mismatch for ElementAt %i of %i", dt, e->getType()); 825 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 826 return nullptr; 827 } 828 } 829 830 uint8_t *p = (uint8_t *)a->mHal.drvState.lod[0].mallocPtr; 831 const uint32_t eSize = e->getSizeBytes(); 832 const uint32_t stride = a->mHal.drvState.lod[0].stride; 833 return &p[(eSize * x) + (y * stride)]; 834} 835 836static const void * SC_GetElementAt1D(android::renderscript::rs_allocation a, uint32_t x) { 837 return ElementAt1D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x); 838} 839static const void * SC_GetElementAt2D(android::renderscript::rs_allocation a, uint32_t x, uint32_t y) { 840 return ElementAt2D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x, y); 841} 842static const void * SC_GetElementAt3D(android::renderscript::rs_allocation a, uint32_t x, uint32_t y, uint32_t z) { 843 return ElementAt3D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x, y, z); 844} 845 846static void SC_SetElementAt1D(android::renderscript::rs_allocation a, const void *ptr, uint32_t x) { 847 const Type *t = ((Allocation*)a.p)->getType(); 848 const Element *e = t->getElement(); 849 void *tmp = ElementAt1D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x); 850 if (tmp != nullptr) { 851 memcpy(tmp, ptr, e->getSizeBytes()); 852 } 853} 854static void SC_SetElementAt2D(android::renderscript::rs_allocation a, const void *ptr, uint32_t x, uint32_t y) { 855 const Type *t = ((Allocation*)a.p)->getType(); 856 const Element *e = t->getElement(); 857 void *tmp = ElementAt2D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x, y); 858 if (tmp != nullptr) { 859 memcpy(tmp, ptr, e->getSizeBytes()); 860 } 861} 862static void SC_SetElementAt3D(android::renderscript::rs_allocation a, const void *ptr, uint32_t x, uint32_t y, uint32_t z) { 863 const Type *t = ((Allocation*)a.p)->getType(); 864 const Element *e = t->getElement(); 865 void *tmp = ElementAt3D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x, y, z); 866 if (tmp != nullptr) { 867 memcpy(tmp, ptr, e->getSizeBytes()); 868 } 869} 870 871#define ELEMENT_AT(T, DT, VS) \ 872 static void SC_SetElementAt1_##T(android::renderscript::rs_allocation a, const T *val, uint32_t x) { \ 873 void *r = ElementAt1D((Allocation*)a.p, DT, VS, x); \ 874 if (r != nullptr) ((T *)r)[0] = *val; \ 875 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 876 } \ 877 static void SC_SetElementAt2_##T(android::renderscript::rs_allocation a, const T * val, uint32_t x, uint32_t y) { \ 878 void *r = ElementAt2D((Allocation*)a.p, DT, VS, x, y); \ 879 if (r != nullptr) ((T *)r)[0] = *val; \ 880 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 881 } \ 882 static void SC_SetElementAt3_##T(android::renderscript::rs_allocation a, const T * val, uint32_t x, uint32_t y, uint32_t z) { \ 883 void *r = ElementAt3D((Allocation*)a.p, DT, VS, x, y, z); \ 884 if (r != nullptr) ((T *)r)[0] = *val; \ 885 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 886 } \ 887 static void SC_GetElementAt1_##T(android::renderscript::rs_allocation a, T *val, uint32_t x) { \ 888 void *r = ElementAt1D((Allocation*)a.p, DT, VS, x); \ 889 if (r != nullptr) *val = ((T *)r)[0]; \ 890 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 891 } \ 892 static void SC_GetElementAt2_##T(android::renderscript::rs_allocation a, T *val, uint32_t x, uint32_t y) { \ 893 void *r = ElementAt2D((Allocation*)a.p, DT, VS, x, y); \ 894 if (r != nullptr) *val = ((T *)r)[0]; \ 895 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 896 } \ 897 static void SC_GetElementAt3_##T(android::renderscript::rs_allocation a, T *val, uint32_t x, uint32_t y, uint32_t z) { \ 898 void *r = ElementAt3D((Allocation*)a.p, DT, VS, x, y, z); \ 899 if (r != nullptr) *val = ((T *)r)[0]; \ 900 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 901 } 902 903ELEMENT_AT(char, RS_TYPE_SIGNED_8, 1) 904ELEMENT_AT(char2, RS_TYPE_SIGNED_8, 2) 905ELEMENT_AT(char3, RS_TYPE_SIGNED_8, 3) 906ELEMENT_AT(char4, RS_TYPE_SIGNED_8, 4) 907ELEMENT_AT(uchar, RS_TYPE_UNSIGNED_8, 1) 908ELEMENT_AT(uchar2, RS_TYPE_UNSIGNED_8, 2) 909ELEMENT_AT(uchar3, RS_TYPE_UNSIGNED_8, 3) 910ELEMENT_AT(uchar4, RS_TYPE_UNSIGNED_8, 4) 911ELEMENT_AT(short, RS_TYPE_SIGNED_16, 1) 912ELEMENT_AT(short2, RS_TYPE_SIGNED_16, 2) 913ELEMENT_AT(short3, RS_TYPE_SIGNED_16, 3) 914ELEMENT_AT(short4, RS_TYPE_SIGNED_16, 4) 915ELEMENT_AT(ushort, RS_TYPE_UNSIGNED_16, 1) 916ELEMENT_AT(ushort2, RS_TYPE_UNSIGNED_16, 2) 917ELEMENT_AT(ushort3, RS_TYPE_UNSIGNED_16, 3) 918ELEMENT_AT(ushort4, RS_TYPE_UNSIGNED_16, 4) 919ELEMENT_AT(int, RS_TYPE_SIGNED_32, 1) 920ELEMENT_AT(int2, RS_TYPE_SIGNED_32, 2) 921ELEMENT_AT(int3, RS_TYPE_SIGNED_32, 3) 922ELEMENT_AT(int4, RS_TYPE_SIGNED_32, 4) 923ELEMENT_AT(uint, RS_TYPE_UNSIGNED_32, 1) 924ELEMENT_AT(uint2, RS_TYPE_UNSIGNED_32, 2) 925ELEMENT_AT(uint3, RS_TYPE_UNSIGNED_32, 3) 926ELEMENT_AT(uint4, RS_TYPE_UNSIGNED_32, 4) 927ELEMENT_AT(long, RS_TYPE_SIGNED_64, 1) 928ELEMENT_AT(long2, RS_TYPE_SIGNED_64, 2) 929ELEMENT_AT(long3, RS_TYPE_SIGNED_64, 3) 930ELEMENT_AT(long4, RS_TYPE_SIGNED_64, 4) 931ELEMENT_AT(ulong, RS_TYPE_UNSIGNED_64, 1) 932ELEMENT_AT(ulong2, RS_TYPE_UNSIGNED_64, 2) 933ELEMENT_AT(ulong3, RS_TYPE_UNSIGNED_64, 3) 934ELEMENT_AT(ulong4, RS_TYPE_UNSIGNED_64, 4) 935ELEMENT_AT(float, RS_TYPE_FLOAT_32, 1) 936ELEMENT_AT(float2, RS_TYPE_FLOAT_32, 2) 937ELEMENT_AT(float3, RS_TYPE_FLOAT_32, 3) 938ELEMENT_AT(float4, RS_TYPE_FLOAT_32, 4) 939ELEMENT_AT(double, RS_TYPE_FLOAT_64, 1) 940ELEMENT_AT(double2, RS_TYPE_FLOAT_64, 2) 941ELEMENT_AT(double3, RS_TYPE_FLOAT_64, 3) 942ELEMENT_AT(double4, RS_TYPE_FLOAT_64, 4) 943 944#undef ELEMENT_AT 945 946////////////////////////////////////////////////////////////////////////////// 947// Stub implementation 948////////////////////////////////////////////////////////////////////////////// 949 950// llvm name mangling ref 951// <builtin-type> ::= v # void 952// ::= b # bool 953// ::= c # char 954// ::= a # signed char 955// ::= h # unsigned char 956// ::= s # short 957// ::= t # unsigned short 958// ::= i # int 959// ::= j # unsigned int 960// ::= l # long 961// ::= m # unsigned long 962// ::= x # long long, __int64 963// ::= y # unsigned long long, __int64 964// ::= f # float 965// ::= d # double 966 967static RsdCpuReference::CpuSymbol gSyms[] = { 968 // Debug runtime 969 { "_Z14rsGetElementAt13rs_allocationj", (void *)&SC_GetElementAt1D, true }, 970 { "_Z14rsGetElementAt13rs_allocationjj", (void *)&SC_GetElementAt2D, true }, 971 { "_Z14rsGetElementAt13rs_allocationjjj", (void *)&SC_GetElementAt3D, true }, 972 { "_Z14rsSetElementAt13rs_allocationPKvj", (void *)&SC_SetElementAt1D, true }, 973 { "_Z14rsSetElementAt13rs_allocationPKvjj", (void *)&SC_SetElementAt2D, true }, 974 { "_Z14rsSetElementAt13rs_allocationPKvjjj", (void *)&SC_SetElementAt3D, true }, 975 976 977 { "_Z20rsGetElementAt_uchar13rs_allocationPhj", (void *)&SC_GetElementAt1_uchar, true }, 978 { "_Z21rsGetElementAt_uchar213rs_allocationPDv2_hj", (void *)&SC_GetElementAt1_uchar2, true }, 979 { "_Z21rsGetElementAt_uchar313rs_allocationPDv3_hj", (void *)&SC_GetElementAt1_uchar3, true }, 980 { "_Z21rsGetElementAt_uchar413rs_allocationPDv4_hj", (void *)&SC_GetElementAt1_uchar4, true }, 981 { "_Z20rsGetElementAt_uchar13rs_allocationPhjj", (void *)&SC_GetElementAt2_uchar, true }, 982 { "_Z21rsGetElementAt_uchar213rs_allocationPDv2_hjj", (void *)&SC_GetElementAt2_uchar2, true }, 983 { "_Z21rsGetElementAt_uchar313rs_allocationPDv3_hjj", (void *)&SC_GetElementAt2_uchar3, true }, 984 { "_Z21rsGetElementAt_uchar413rs_allocationPDv4_hjj", (void *)&SC_GetElementAt2_uchar4, true }, 985 { "_Z20rsGetElementAt_uchar13rs_allocationPhjjj", (void *)&SC_GetElementAt3_uchar, true }, 986 { "_Z21rsGetElementAt_uchar213rs_allocationPDv2_hjjj", (void *)&SC_GetElementAt3_uchar2, true }, 987 { "_Z21rsGetElementAt_uchar313rs_allocationPDv3_hjjj", (void *)&SC_GetElementAt3_uchar3, true }, 988 { "_Z21rsGetElementAt_uchar413rs_allocationPDv4_hjjj", (void *)&SC_GetElementAt3_uchar4, true }, 989 990 { "_Z19rsGetElementAt_char13rs_allocationPcj", (void *)&SC_GetElementAt1_char, true }, 991 { "_Z20rsGetElementAt_char213rs_allocationPDv2_cj", (void *)&SC_GetElementAt1_char2, true }, 992 { "_Z20rsGetElementAt_char313rs_allocationPDv3_cj", (void *)&SC_GetElementAt1_char3, true }, 993 { "_Z20rsGetElementAt_char413rs_allocationPDv4_cj", (void *)&SC_GetElementAt1_char4, true }, 994 { "_Z19rsGetElementAt_char13rs_allocationPcjj", (void *)&SC_GetElementAt2_char, true }, 995 { "_Z20rsGetElementAt_char213rs_allocationPDv2_cjj", (void *)&SC_GetElementAt2_char2, true }, 996 { "_Z20rsGetElementAt_char313rs_allocationPDv3_cjj", (void *)&SC_GetElementAt2_char3, true }, 997 { "_Z20rsGetElementAt_char413rs_allocationPDv4_cjj", (void *)&SC_GetElementAt2_char4, true }, 998 { "_Z19rsGetElementAt_char13rs_allocationPcjjj", (void *)&SC_GetElementAt3_char, true }, 999 { "_Z20rsGetElementAt_char213rs_allocationPDv2_cjjj", (void *)&SC_GetElementAt3_char2, true }, 1000 { "_Z20rsGetElementAt_char313rs_allocationPDv3_cjjj", (void *)&SC_GetElementAt3_char3, true }, 1001 { "_Z20rsGetElementAt_char413rs_allocationPDv4_cjjj", (void *)&SC_GetElementAt3_char4, true }, 1002 1003 { "_Z21rsGetElementAt_ushort13rs_allocationPtj", (void *)&SC_GetElementAt1_ushort, true }, 1004 { "_Z22rsGetElementAt_ushort213rs_allocationPDv2_tj", (void *)&SC_GetElementAt1_ushort2, true }, 1005 { "_Z22rsGetElementAt_ushort313rs_allocationPDv3_tj", (void *)&SC_GetElementAt1_ushort3, true }, 1006 { "_Z22rsGetElementAt_ushort413rs_allocationPDv4_tj", (void *)&SC_GetElementAt1_ushort4, true }, 1007 { "_Z21rsGetElementAt_ushort13rs_allocationPtjj", (void *)&SC_GetElementAt2_ushort, true }, 1008 { "_Z22rsGetElementAt_ushort213rs_allocationPDv2_tjj", (void *)&SC_GetElementAt2_ushort2, true }, 1009 { "_Z22rsGetElementAt_ushort313rs_allocationPDv3_tjj", (void *)&SC_GetElementAt2_ushort3, true }, 1010 { "_Z22rsGetElementAt_ushort413rs_allocationPDv4_tjj", (void *)&SC_GetElementAt2_ushort4, true }, 1011 { "_Z21rsGetElementAt_ushort13rs_allocationPtjjj", (void *)&SC_GetElementAt3_ushort, true }, 1012 { "_Z22rsGetElementAt_ushort213rs_allocationPDv2_tjjj", (void *)&SC_GetElementAt3_ushort2, true }, 1013 { "_Z22rsGetElementAt_ushort313rs_allocationPDv3_tjjj", (void *)&SC_GetElementAt3_ushort3, true }, 1014 { "_Z22rsGetElementAt_ushort413rs_allocationPDv4_tjjj", (void *)&SC_GetElementAt3_ushort4, true }, 1015 1016 { "_Z20rsGetElementAt_short13rs_allocationPsj", (void *)&SC_GetElementAt1_short, true }, 1017 { "_Z21rsGetElementAt_short213rs_allocationPDv2_sj", (void *)&SC_GetElementAt1_short2, true }, 1018 { "_Z21rsGetElementAt_short313rs_allocationPDv3_sj", (void *)&SC_GetElementAt1_short3, true }, 1019 { "_Z21rsGetElementAt_short413rs_allocationPDv4_sj", (void *)&SC_GetElementAt1_short4, true }, 1020 { "_Z20rsGetElementAt_short13rs_allocationPsjj", (void *)&SC_GetElementAt2_short, true }, 1021 { "_Z21rsGetElementAt_short213rs_allocationPDv2_sjj", (void *)&SC_GetElementAt2_short2, true }, 1022 { "_Z21rsGetElementAt_short313rs_allocationPDv3_sjj", (void *)&SC_GetElementAt2_short3, true }, 1023 { "_Z21rsGetElementAt_short413rs_allocationPDv4_sjj", (void *)&SC_GetElementAt2_short4, true }, 1024 { "_Z20rsGetElementAt_short13rs_allocationPsjjj", (void *)&SC_GetElementAt3_short, true }, 1025 { "_Z21rsGetElementAt_short213rs_allocationPDv2_sjjj", (void *)&SC_GetElementAt3_short2, true }, 1026 { "_Z21rsGetElementAt_short313rs_allocationPDv3_sjjj", (void *)&SC_GetElementAt3_short3, true }, 1027 { "_Z21rsGetElementAt_short413rs_allocationPDv4_sjjj", (void *)&SC_GetElementAt3_short4, true }, 1028 1029 { "_Z19rsGetElementAt_uint13rs_allocationPjj", (void *)&SC_GetElementAt1_uint, true }, 1030 { "_Z20rsGetElementAt_uint213rs_allocationPDv2_jj", (void *)&SC_GetElementAt1_uint2, true }, 1031 { "_Z20rsGetElementAt_uint313rs_allocationPDv3_jj", (void *)&SC_GetElementAt1_uint3, true }, 1032 { "_Z20rsGetElementAt_uint413rs_allocationPDv4_jj", (void *)&SC_GetElementAt1_uint4, true }, 1033 { "_Z19rsGetElementAt_uint13rs_allocationPjjj", (void *)&SC_GetElementAt2_uint, true }, 1034 { "_Z20rsGetElementAt_uint213rs_allocationPDv2_jjj", (void *)&SC_GetElementAt2_uint2, true }, 1035 { "_Z20rsGetElementAt_uint313rs_allocationPDv3_jjj", (void *)&SC_GetElementAt2_uint3, true }, 1036 { "_Z20rsGetElementAt_uint413rs_allocationPDv4_jjj", (void *)&SC_GetElementAt2_uint4, true }, 1037 { "_Z19rsGetElementAt_uint13rs_allocationPjjjj", (void *)&SC_GetElementAt3_uint, true }, 1038 { "_Z20rsGetElementAt_uint213rs_allocationPDv2_jjjj", (void *)&SC_GetElementAt3_uint2, true }, 1039 { "_Z20rsGetElementAt_uint313rs_allocationPDv3_jjjj", (void *)&SC_GetElementAt3_uint3, true }, 1040 { "_Z20rsGetElementAt_uint413rs_allocationPDv4_jjjj", (void *)&SC_GetElementAt3_uint4, true }, 1041 1042 { "_Z18rsGetElementAt_int13rs_allocationPij", (void *)&SC_GetElementAt1_int, true }, 1043 { "_Z19rsGetElementAt_int213rs_allocationPDv2_ij", (void *)&SC_GetElementAt1_int2, true }, 1044 { "_Z19rsGetElementAt_int313rs_allocationPDv3_ij", (void *)&SC_GetElementAt1_int3, true }, 1045 { "_Z19rsGetElementAt_int413rs_allocationPDv4_ij", (void *)&SC_GetElementAt1_int4, true }, 1046 { "_Z18rsGetElementAt_int13rs_allocationPijj", (void *)&SC_GetElementAt2_int, true }, 1047 { "_Z19rsGetElementAt_int213rs_allocationPDv2_ijj", (void *)&SC_GetElementAt2_int2, true }, 1048 { "_Z19rsGetElementAt_int313rs_allocationPDv3_ijj", (void *)&SC_GetElementAt2_int3, true }, 1049 { "_Z19rsGetElementAt_int413rs_allocationPDv4_ijj", (void *)&SC_GetElementAt2_int4, true }, 1050 { "_Z18rsGetElementAt_int13rs_allocationPijjj", (void *)&SC_GetElementAt3_int, true }, 1051 { "_Z19rsGetElementAt_int213rs_allocationPDv2_ijjj", (void *)&SC_GetElementAt3_int2, true }, 1052 { "_Z19rsGetElementAt_int313rs_allocationPDv3_ijjj", (void *)&SC_GetElementAt3_int3, true }, 1053 { "_Z19rsGetElementAt_int413rs_allocationPDv4_ijjj", (void *)&SC_GetElementAt3_int4, true }, 1054 1055 { "_Z20rsGetElementAt_ulong13rs_allocationPmj", (void *)&SC_GetElementAt1_ulong, true }, 1056 { "_Z21rsGetElementAt_ulong213rs_allocationPDv2_mj", (void *)&SC_GetElementAt1_ulong2, true }, 1057 { "_Z21rsGetElementAt_ulong313rs_allocationPDv3_mj", (void *)&SC_GetElementAt1_ulong3, true }, 1058 { "_Z21rsGetElementAt_ulong413rs_allocationPDv4_mj", (void *)&SC_GetElementAt1_ulong4, true }, 1059 { "_Z20rsGetElementAt_ulong13rs_allocationPmjj", (void *)&SC_GetElementAt2_ulong, true }, 1060 { "_Z21rsGetElementAt_ulong213rs_allocationPDv2_mjj", (void *)&SC_GetElementAt2_ulong2, true }, 1061 { "_Z21rsGetElementAt_ulong313rs_allocationPDv3_mjj", (void *)&SC_GetElementAt2_ulong3, true }, 1062 { "_Z21rsGetElementAt_ulong413rs_allocationPDv4_mjj", (void *)&SC_GetElementAt2_ulong4, true }, 1063 { "_Z20rsGetElementAt_ulong13rs_allocationPmjjj", (void *)&SC_GetElementAt3_ulong, true }, 1064 { "_Z21rsGetElementAt_ulong213rs_allocationPDv2_mjjj", (void *)&SC_GetElementAt3_ulong2, true }, 1065 { "_Z21rsGetElementAt_ulong313rs_allocationPDv3_mjjj", (void *)&SC_GetElementAt3_ulong3, true }, 1066 { "_Z21rsGetElementAt_ulong413rs_allocationPDv4_mjjj", (void *)&SC_GetElementAt3_ulong4, true }, 1067 1068 { "_Z19rsGetElementAt_long13rs_allocationPlj", (void *)&SC_GetElementAt1_long, true }, 1069 { "_Z20rsGetElementAt_long213rs_allocationPDv2_lj", (void *)&SC_GetElementAt1_long2, true }, 1070 { "_Z20rsGetElementAt_long313rs_allocationPDv3_lj", (void *)&SC_GetElementAt1_long3, true }, 1071 { "_Z20rsGetElementAt_long413rs_allocationPDv4_lj", (void *)&SC_GetElementAt1_long4, true }, 1072 { "_Z19rsGetElementAt_long13rs_allocationPljj", (void *)&SC_GetElementAt2_long, true }, 1073 { "_Z20rsGetElementAt_long213rs_allocationPDv2_ljj", (void *)&SC_GetElementAt2_long2, true }, 1074 { "_Z20rsGetElementAt_long313rs_allocationPDv3_ljj", (void *)&SC_GetElementAt2_long3, true }, 1075 { "_Z20rsGetElementAt_long413rs_allocationPDv4_ljj", (void *)&SC_GetElementAt2_long4, true }, 1076 { "_Z19rsGetElementAt_long13rs_allocationPljjj", (void *)&SC_GetElementAt3_long, true }, 1077 { "_Z20rsGetElementAt_long213rs_allocationPDv2_ljjj", (void *)&SC_GetElementAt3_long2, true }, 1078 { "_Z20rsGetElementAt_long313rs_allocationPDv3_ljjj", (void *)&SC_GetElementAt3_long3, true }, 1079 { "_Z20rsGetElementAt_long413rs_allocationPDv4_ljjj", (void *)&SC_GetElementAt3_long4, true }, 1080 1081 { "_Z20rsGetElementAt_float13rs_allocationPfj", (void *)&SC_GetElementAt1_float, true }, 1082 { "_Z21rsGetElementAt_float213rs_allocationPDv2_fj", (void *)&SC_GetElementAt1_float2, true }, 1083 { "_Z21rsGetElementAt_float313rs_allocationPDv3_fj", (void *)&SC_GetElementAt1_float3, true }, 1084 { "_Z21rsGetElementAt_float413rs_allocationPDv4_fj", (void *)&SC_GetElementAt1_float4, true }, 1085 { "_Z20rsGetElementAt_float13rs_allocationPfjj", (void *)&SC_GetElementAt2_float, true }, 1086 { "_Z21rsGetElementAt_float213rs_allocationPDv2_fjj", (void *)&SC_GetElementAt2_float2, true }, 1087 { "_Z21rsGetElementAt_float313rs_allocationPDv3_fjj", (void *)&SC_GetElementAt2_float3, true }, 1088 { "_Z21rsGetElementAt_float413rs_allocationPDv4_fjj", (void *)&SC_GetElementAt2_float4, true }, 1089 { "_Z20rsGetElementAt_float13rs_allocationPfjjj", (void *)&SC_GetElementAt3_float, true }, 1090 { "_Z21rsGetElementAt_float213rs_allocationPDv2_fjjj", (void *)&SC_GetElementAt3_float2, true }, 1091 { "_Z21rsGetElementAt_float313rs_allocationPDv3_fjjj", (void *)&SC_GetElementAt3_float3, true }, 1092 { "_Z21rsGetElementAt_float413rs_allocationPDv4_fjjj", (void *)&SC_GetElementAt3_float4, true }, 1093 1094 { "_Z21rsGetElementAt_double13rs_allocationPdj", (void *)&SC_GetElementAt1_double, true }, 1095 { "_Z22rsGetElementAt_double213rs_allocationPDv2_dj", (void *)&SC_GetElementAt1_double2, true }, 1096 { "_Z22rsGetElementAt_double313rs_allocationPDv3_dj", (void *)&SC_GetElementAt1_double3, true }, 1097 { "_Z22rsGetElementAt_double413rs_allocationPDv4_dj", (void *)&SC_GetElementAt1_double4, true }, 1098 { "_Z21rsGetElementAt_double13rs_allocationPdjj", (void *)&SC_GetElementAt2_double, true }, 1099 { "_Z22rsGetElementAt_double213rs_allocationPDv2_djj", (void *)&SC_GetElementAt2_double2, true }, 1100 { "_Z22rsGetElementAt_double313rs_allocationPDv3_djj", (void *)&SC_GetElementAt2_double3, true }, 1101 { "_Z22rsGetElementAt_double413rs_allocationPDv4_djj", (void *)&SC_GetElementAt2_double4, true }, 1102 { "_Z21rsGetElementAt_double13rs_allocationPdjjj", (void *)&SC_GetElementAt3_double, true }, 1103 { "_Z22rsGetElementAt_double213rs_allocationPDv2_djjj", (void *)&SC_GetElementAt3_double2, true }, 1104 { "_Z22rsGetElementAt_double313rs_allocationPDv3_djjj", (void *)&SC_GetElementAt3_double3, true }, 1105 { "_Z22rsGetElementAt_double413rs_allocationPDv4_djjj", (void *)&SC_GetElementAt3_double4, true }, 1106 1107 1108 1109 { "_Z20rsSetElementAt_uchar13rs_allocationPKhj", (void *)&SC_SetElementAt1_uchar, true }, 1110 { "_Z21rsSetElementAt_uchar213rs_allocationPKDv2_hj", (void *)&SC_SetElementAt1_uchar2, true }, 1111 { "_Z21rsSetElementAt_uchar313rs_allocationPKDv3_hj", (void *)&SC_SetElementAt1_uchar3, true }, 1112 { "_Z21rsSetElementAt_uchar413rs_allocationPKDv4_hj", (void *)&SC_SetElementAt1_uchar4, true }, 1113 { "_Z20rsSetElementAt_uchar13rs_allocationPKhjj", (void *)&SC_SetElementAt2_uchar, true }, 1114 { "_Z21rsSetElementAt_uchar213rs_allocationPKDv2_hjj", (void *)&SC_SetElementAt2_uchar2, true }, 1115 { "_Z21rsSetElementAt_uchar313rs_allocationPKDv3_hjj", (void *)&SC_SetElementAt2_uchar3, true }, 1116 { "_Z21rsSetElementAt_uchar413rs_allocationPKDv4_hjj", (void *)&SC_SetElementAt2_uchar4, true }, 1117 { "_Z20rsSetElementAt_uchar13rs_allocationPKhjjj", (void *)&SC_SetElementAt3_uchar, true }, 1118 { "_Z21rsSetElementAt_uchar213rs_allocationPKDv2_hjjj", (void *)&SC_SetElementAt3_uchar2, true }, 1119 { "_Z21rsSetElementAt_uchar313rs_allocationPKDv3_hjjj", (void *)&SC_SetElementAt3_uchar3, true }, 1120 { "_Z21rsSetElementAt_uchar413rs_allocationPKDv4_hjjj", (void *)&SC_SetElementAt3_uchar4, true }, 1121 1122 { "_Z19rsSetElementAt_char13rs_allocationPKcj", (void *)&SC_SetElementAt1_char, true }, 1123 { "_Z20rsSetElementAt_char213rs_allocationPKDv2_cj", (void *)&SC_SetElementAt1_char2, true }, 1124 { "_Z20rsSetElementAt_char313rs_allocationPKDv3_cj", (void *)&SC_SetElementAt1_char3, true }, 1125 { "_Z20rsSetElementAt_char413rs_allocationPKDv4_cj", (void *)&SC_SetElementAt1_char4, true }, 1126 { "_Z19rsSetElementAt_char13rs_allocationPKcjj", (void *)&SC_SetElementAt2_char, true }, 1127 { "_Z20rsSetElementAt_char213rs_allocationPKDv2_cjj", (void *)&SC_SetElementAt2_char2, true }, 1128 { "_Z20rsSetElementAt_char313rs_allocationPKDv3_cjj", (void *)&SC_SetElementAt2_char3, true }, 1129 { "_Z20rsSetElementAt_char413rs_allocationPKDv4_cjj", (void *)&SC_SetElementAt2_char4, true }, 1130 { "_Z19rsSetElementAt_char13rs_allocationPKcjjj", (void *)&SC_SetElementAt3_char, true }, 1131 { "_Z20rsSetElementAt_char213rs_allocationPKDv2_cjjj", (void *)&SC_SetElementAt3_char2, true }, 1132 { "_Z20rsSetElementAt_char313rs_allocationPKDv3_cjjj", (void *)&SC_SetElementAt3_char3, true }, 1133 { "_Z20rsSetElementAt_char413rs_allocationPKDv4_cjjj", (void *)&SC_SetElementAt3_char4, true }, 1134 1135 { "_Z21rsSetElementAt_ushort13rs_allocationPKht", (void *)&SC_SetElementAt1_ushort, true }, 1136 { "_Z22rsSetElementAt_ushort213rs_allocationPKDv2_tj", (void *)&SC_SetElementAt1_ushort2, true }, 1137 { "_Z22rsSetElementAt_ushort313rs_allocationPKDv3_tj", (void *)&SC_SetElementAt1_ushort3, true }, 1138 { "_Z22rsSetElementAt_ushort413rs_allocationPKDv4_tj", (void *)&SC_SetElementAt1_ushort4, true }, 1139 { "_Z21rsSetElementAt_ushort13rs_allocationPKtjj", (void *)&SC_SetElementAt2_ushort, true }, 1140 { "_Z22rsSetElementAt_ushort213rs_allocationPKDv2_tjj", (void *)&SC_SetElementAt2_ushort2, true }, 1141 { "_Z22rsSetElementAt_ushort313rs_allocationPKDv3_tjj", (void *)&SC_SetElementAt2_ushort3, true }, 1142 { "_Z22rsSetElementAt_ushort413rs_allocationPKDv4_tjj", (void *)&SC_SetElementAt2_ushort4, true }, 1143 { "_Z21rsSetElementAt_ushort13rs_allocationPKtjjj", (void *)&SC_SetElementAt3_ushort, true }, 1144 { "_Z22rsSetElementAt_ushort213rs_allocationPKDv2_tjjj", (void *)&SC_SetElementAt3_ushort2, true }, 1145 { "_Z22rsSetElementAt_ushort313rs_allocationPKDv3_tjjj", (void *)&SC_SetElementAt3_ushort3, true }, 1146 { "_Z22rsSetElementAt_ushort413rs_allocationPKDv4_tjjj", (void *)&SC_SetElementAt3_ushort4, true }, 1147 1148 { "_Z20rsSetElementAt_short13rs_allocationPKsj", (void *)&SC_SetElementAt1_short, true }, 1149 { "_Z21rsSetElementAt_short213rs_allocationPKDv2_sj", (void *)&SC_SetElementAt1_short2, true }, 1150 { "_Z21rsSetElementAt_short313rs_allocationPKDv3_sj", (void *)&SC_SetElementAt1_short3, true }, 1151 { "_Z21rsSetElementAt_short413rs_allocationPKDv4_sj", (void *)&SC_SetElementAt1_short4, true }, 1152 { "_Z20rsSetElementAt_short13rs_allocationPKsjj", (void *)&SC_SetElementAt2_short, true }, 1153 { "_Z21rsSetElementAt_short213rs_allocationPKDv2_sjj", (void *)&SC_SetElementAt2_short2, true }, 1154 { "_Z21rsSetElementAt_short313rs_allocationPKDv3_sjj", (void *)&SC_SetElementAt2_short3, true }, 1155 { "_Z21rsSetElementAt_short413rs_allocationPKDv4_sjj", (void *)&SC_SetElementAt2_short4, true }, 1156 { "_Z20rsSetElementAt_short13rs_allocationPKsjjj", (void *)&SC_SetElementAt3_short, true }, 1157 { "_Z21rsSetElementAt_short213rs_allocationPKDv2_sjjj", (void *)&SC_SetElementAt3_short2, true }, 1158 { "_Z21rsSetElementAt_short313rs_allocationPKDv3_sjjj", (void *)&SC_SetElementAt3_short3, true }, 1159 { "_Z21rsSetElementAt_short413rs_allocationPKDv4_sjjj", (void *)&SC_SetElementAt3_short4, true }, 1160 1161 { "_Z19rsSetElementAt_uint13rs_allocationPKjj", (void *)&SC_SetElementAt1_uint, true }, 1162 { "_Z20rsSetElementAt_uint213rs_allocationPKDv2_jj", (void *)&SC_SetElementAt1_uint2, true }, 1163 { "_Z20rsSetElementAt_uint313rs_allocationPKDv3_jj", (void *)&SC_SetElementAt1_uint3, true }, 1164 { "_Z20rsSetElementAt_uint413rs_allocationPKDv4_jj", (void *)&SC_SetElementAt1_uint4, true }, 1165 { "_Z19rsSetElementAt_uint13rs_allocationPKjjj", (void *)&SC_SetElementAt2_uint, true }, 1166 { "_Z20rsSetElementAt_uint213rs_allocationPKDv2_jjj", (void *)&SC_SetElementAt2_uint2, true }, 1167 { "_Z20rsSetElementAt_uint313rs_allocationPKDv3_jjj", (void *)&SC_SetElementAt2_uint3, true }, 1168 { "_Z20rsSetElementAt_uint413rs_allocationPKDv4_jjj", (void *)&SC_SetElementAt2_uint4, true }, 1169 { "_Z19rsSetElementAt_uint13rs_allocationPKjjjj", (void *)&SC_SetElementAt3_uint, true }, 1170 { "_Z20rsSetElementAt_uint213rs_allocationPKDv2_jjjj", (void *)&SC_SetElementAt3_uint2, true }, 1171 { "_Z20rsSetElementAt_uint313rs_allocationPKDv3_jjjj", (void *)&SC_SetElementAt3_uint3, true }, 1172 { "_Z20rsSetElementAt_uint413rs_allocationPKDv4_jjjj", (void *)&SC_SetElementAt3_uint4, true }, 1173 1174 { "_Z18rsSetElementAt_int13rs_allocationPKij", (void *)&SC_SetElementAt1_int, true }, 1175 { "_Z19rsSetElementAt_int213rs_allocationPKDv2_ij", (void *)&SC_SetElementAt1_int2, true }, 1176 { "_Z19rsSetElementAt_int313rs_allocationPKDv3_ij", (void *)&SC_SetElementAt1_int3, true }, 1177 { "_Z19rsSetElementAt_int413rs_allocationPKDv4_ij", (void *)&SC_SetElementAt1_int4, true }, 1178 { "_Z18rsSetElementAt_int13rs_allocationPKijj", (void *)&SC_SetElementAt2_int, true }, 1179 { "_Z19rsSetElementAt_int213rs_allocationPKDv2_ijj", (void *)&SC_SetElementAt2_int2, true }, 1180 { "_Z19rsSetElementAt_int313rs_allocationPKDv3_ijj", (void *)&SC_SetElementAt2_int3, true }, 1181 { "_Z19rsSetElementAt_int413rs_allocationPKDv4_ijj", (void *)&SC_SetElementAt2_int4, true }, 1182 { "_Z18rsSetElementAt_int13rs_allocationPKijjj", (void *)&SC_SetElementAt3_int, true }, 1183 { "_Z19rsSetElementAt_int213rs_allocationPKDv2_ijjj", (void *)&SC_SetElementAt3_int2, true }, 1184 { "_Z19rsSetElementAt_int313rs_allocationPKDv3_ijjj", (void *)&SC_SetElementAt3_int3, true }, 1185 { "_Z19rsSetElementAt_int413rs_allocationPKDv4_ijjj", (void *)&SC_SetElementAt3_int4, true }, 1186 1187 { "_Z20rsSetElementAt_ulong13rs_allocationPKmt", (void *)&SC_SetElementAt1_ulong, true }, 1188 { "_Z21rsSetElementAt_ulong213rs_allocationPKDv2_mj", (void *)&SC_SetElementAt1_ulong2, true }, 1189 { "_Z21rsSetElementAt_ulong313rs_allocationPKDv3_mj", (void *)&SC_SetElementAt1_ulong3, true }, 1190 { "_Z21rsSetElementAt_ulong413rs_allocationPKDv4_mj", (void *)&SC_SetElementAt1_ulong4, true }, 1191 { "_Z20rsSetElementAt_ulong13rs_allocationPKmjj", (void *)&SC_SetElementAt2_ulong, true }, 1192 { "_Z21rsSetElementAt_ulong213rs_allocationPKDv2_mjj", (void *)&SC_SetElementAt2_ulong2, true }, 1193 { "_Z21rsSetElementAt_ulong313rs_allocationPKDv3_mjj", (void *)&SC_SetElementAt2_ulong3, true }, 1194 { "_Z21rsSetElementAt_ulong413rs_allocationPKDv4_mjj", (void *)&SC_SetElementAt2_ulong4, true }, 1195 { "_Z20rsSetElementAt_ulong13rs_allocationPKmjjj", (void *)&SC_SetElementAt3_ulong, true }, 1196 { "_Z21rsSetElementAt_ulong213rs_allocationPKDv2_mjjj", (void *)&SC_SetElementAt3_ulong2, true }, 1197 { "_Z21rsSetElementAt_ulong313rs_allocationPKDv3_mjjj", (void *)&SC_SetElementAt3_ulong3, true }, 1198 { "_Z21rsSetElementAt_ulong413rs_allocationPKDv4_mjjj", (void *)&SC_SetElementAt3_ulong4, true }, 1199 1200 { "_Z19rsSetElementAt_long13rs_allocationPKlj", (void *)&SC_SetElementAt1_long, true }, 1201 { "_Z20rsSetElementAt_long213rs_allocationPKDv2_lj", (void *)&SC_SetElementAt1_long2, true }, 1202 { "_Z20rsSetElementAt_long313rs_allocationPKDv3_lj", (void *)&SC_SetElementAt1_long3, true }, 1203 { "_Z20rsSetElementAt_long413rs_allocationPKDv4_lj", (void *)&SC_SetElementAt1_long4, true }, 1204 { "_Z19rsSetElementAt_long13rs_allocationPKljj", (void *)&SC_SetElementAt2_long, true }, 1205 { "_Z20rsSetElementAt_long213rs_allocationPKDv2_ljj", (void *)&SC_SetElementAt2_long2, true }, 1206 { "_Z20rsSetElementAt_long313rs_allocationPKDv3_ljj", (void *)&SC_SetElementAt2_long3, true }, 1207 { "_Z20rsSetElementAt_long413rs_allocationPKDv4_ljj", (void *)&SC_SetElementAt2_long4, true }, 1208 { "_Z19rsSetElementAt_long13rs_allocationPKljjj", (void *)&SC_SetElementAt3_long, true }, 1209 { "_Z20rsSetElementAt_long213rs_allocationPKDv2_ljjj", (void *)&SC_SetElementAt3_long2, true }, 1210 { "_Z20rsSetElementAt_long313rs_allocationPKDv3_ljjj", (void *)&SC_SetElementAt3_long3, true }, 1211 { "_Z20rsSetElementAt_long413rs_allocationPKDv4_ljjj", (void *)&SC_SetElementAt3_long4, true }, 1212 1213 { "_Z20rsSetElementAt_float13rs_allocationPKft", (void *)&SC_SetElementAt1_float, true }, 1214 { "_Z21rsSetElementAt_float213rs_allocationPKDv2_fj", (void *)&SC_SetElementAt1_float2, true }, 1215 { "_Z21rsSetElementAt_float313rs_allocationPKDv3_fj", (void *)&SC_SetElementAt1_float3, true }, 1216 { "_Z21rsSetElementAt_float413rs_allocationPKDv4_fj", (void *)&SC_SetElementAt1_float4, true }, 1217 { "_Z20rsSetElementAt_float13rs_allocationPKfjj", (void *)&SC_SetElementAt2_float, true }, 1218 { "_Z21rsSetElementAt_float213rs_allocationPKDv2_fjj", (void *)&SC_SetElementAt2_float2, true }, 1219 { "_Z21rsSetElementAt_float313rs_allocationPKDv3_fjj", (void *)&SC_SetElementAt2_float3, true }, 1220 { "_Z21rsSetElementAt_float413rs_allocationPKDv4_fjj", (void *)&SC_SetElementAt2_float4, true }, 1221 { "_Z20rsSetElementAt_float13rs_allocationPKfjjj", (void *)&SC_SetElementAt3_float, true }, 1222 { "_Z21rsSetElementAt_float213rs_allocationPKDv2_fjjj", (void *)&SC_SetElementAt3_float2, true }, 1223 { "_Z21rsSetElementAt_float313rs_allocationPKDv3_fjjj", (void *)&SC_SetElementAt3_float3, true }, 1224 { "_Z21rsSetElementAt_float413rs_allocationPKDv4_fjjj", (void *)&SC_SetElementAt3_float4, true }, 1225 1226 { "_Z21rsSetElementAt_double13rs_allocationPKdt", (void *)&SC_SetElementAt1_double, true }, 1227 { "_Z22rsSetElementAt_double213rs_allocationPKDv2_dj", (void *)&SC_SetElementAt1_double2, true }, 1228 { "_Z22rsSetElementAt_double313rs_allocationPKDv3_dj", (void *)&SC_SetElementAt1_double3, true }, 1229 { "_Z22rsSetElementAt_double413rs_allocationPKDv4_dj", (void *)&SC_SetElementAt1_double4, true }, 1230 { "_Z21rsSetElementAt_double13rs_allocationPKdjj", (void *)&SC_SetElementAt2_double, true }, 1231 { "_Z22rsSetElementAt_double213rs_allocationPKDv2_djj", (void *)&SC_SetElementAt2_double2, true }, 1232 { "_Z22rsSetElementAt_double313rs_allocationPKDv3_djj", (void *)&SC_SetElementAt2_double3, true }, 1233 { "_Z22rsSetElementAt_double413rs_allocationPKDv4_djj", (void *)&SC_SetElementAt2_double4, true }, 1234 { "_Z21rsSetElementAt_double13rs_allocationPKdjjj", (void *)&SC_SetElementAt3_double, true }, 1235 { "_Z22rsSetElementAt_double213rs_allocationPKDv2_djjj", (void *)&SC_SetElementAt3_double2, true }, 1236 { "_Z22rsSetElementAt_double313rs_allocationPKDv3_djjj", (void *)&SC_SetElementAt3_double3, true }, 1237 { "_Z22rsSetElementAt_double413rs_allocationPKDv4_djjj", (void *)&SC_SetElementAt3_double4, true }, 1238 1239 1240 // Refcounting 1241#ifndef __LP64__ 1242 { "_Z11rsSetObjectP10rs_elementS_", (void *)&SC_SetObject, true }, 1243 { "_Z10rsIsObject10rs_element", (void *)&SC_IsObject, true }, 1244 1245 { "_Z11rsSetObjectP7rs_typeS_", (void *)&SC_SetObject, true }, 1246 { "_Z10rsIsObject7rs_type", (void *)&SC_IsObject, true }, 1247 1248 { "_Z11rsSetObjectP13rs_allocationS_", (void *)&SC_SetObject, true }, 1249 { "_Z10rsIsObject13rs_allocation", (void *)&SC_IsObject, true }, 1250 1251 { "_Z11rsSetObjectP10rs_samplerS_", (void *)&SC_SetObject, true }, 1252 { "_Z10rsIsObject10rs_sampler", (void *)&SC_IsObject, true }, 1253 1254 { "_Z11rsSetObjectP9rs_scriptS_", (void *)&SC_SetObject, true }, 1255 { "_Z10rsIsObject9rs_script", (void *)&SC_IsObject, true }, 1256#else 1257 { "_Z11rsSetObjectP10rs_elementS_", (void *)&SC_SetObject_ByRef, true }, 1258 { "_Z10rsIsObject10rs_element", (void *)&SC_IsObject_ByRef, true }, 1259 1260 { "_Z11rsSetObjectP7rs_typeS_", (void *)&SC_SetObject_ByRef, true }, 1261 { "_Z10rsIsObject7rs_type", (void *)&SC_IsObject_ByRef, true }, 1262 1263 { "_Z11rsSetObjectP13rs_allocationS_", (void *)&SC_SetObject_ByRef, true }, 1264 { "_Z10rsIsObject13rs_allocation", (void *)&SC_IsObject_ByRef, true }, 1265 1266 { "_Z11rsSetObjectP10rs_samplerS_", (void *)&SC_SetObject_ByRef, true }, 1267 { "_Z10rsIsObject10rs_sampler", (void *)&SC_IsObject_ByRef, true }, 1268 1269 { "_Z11rsSetObjectP9rs_scriptS_", (void *)&SC_SetObject_ByRef, true }, 1270 { "_Z10rsIsObject9rs_script", (void *)&SC_IsObject_ByRef, true }, 1271#endif 1272 { "_Z13rsClearObjectP10rs_element", (void *)&SC_ClearObject, true }, 1273 { "_Z13rsClearObjectP7rs_type", (void *)&SC_ClearObject, true }, 1274 { "_Z13rsClearObjectP13rs_allocation", (void *)&SC_ClearObject, true }, 1275 { "_Z13rsClearObjectP10rs_sampler", (void *)&SC_ClearObject, true }, 1276 { "_Z13rsClearObjectP9rs_script", (void *)&SC_ClearObject, true }, 1277 1278 { "_Z11rsSetObjectP7rs_pathS_", (void *)&SC_SetObject, true }, 1279 { "_Z13rsClearObjectP7rs_path", (void *)&SC_ClearObject, true }, 1280 { "_Z10rsIsObject7rs_path", (void *)&SC_IsObject, true }, 1281 1282 { "_Z11rsSetObjectP7rs_meshS_", (void *)&SC_SetObject, true }, 1283 { "_Z13rsClearObjectP7rs_mesh", (void *)&SC_ClearObject, true }, 1284 { "_Z10rsIsObject7rs_mesh", (void *)&SC_IsObject, true }, 1285 1286 { "_Z11rsSetObjectP19rs_program_fragmentS_", (void *)&SC_SetObject, true }, 1287 { "_Z13rsClearObjectP19rs_program_fragment", (void *)&SC_ClearObject, true }, 1288 { "_Z10rsIsObject19rs_program_fragment", (void *)&SC_IsObject, true }, 1289 1290 { "_Z11rsSetObjectP17rs_program_vertexS_", (void *)&SC_SetObject, true }, 1291 { "_Z13rsClearObjectP17rs_program_vertex", (void *)&SC_ClearObject, true }, 1292 { "_Z10rsIsObject17rs_program_vertex", (void *)&SC_IsObject, true }, 1293 1294 { "_Z11rsSetObjectP17rs_program_rasterS_", (void *)&SC_SetObject, true }, 1295 { "_Z13rsClearObjectP17rs_program_raster", (void *)&SC_ClearObject, true }, 1296 { "_Z10rsIsObject17rs_program_raster", (void *)&SC_IsObject, true }, 1297 1298 { "_Z11rsSetObjectP16rs_program_storeS_", (void *)&SC_SetObject, true }, 1299 { "_Z13rsClearObjectP16rs_program_store", (void *)&SC_ClearObject, true }, 1300 { "_Z10rsIsObject16rs_program_store", (void *)&SC_IsObject, true }, 1301 1302 { "_Z11rsSetObjectP7rs_fontS_", (void *)&SC_SetObject, true }, 1303 { "_Z13rsClearObjectP7rs_font", (void *)&SC_ClearObject, true }, 1304 { "_Z10rsIsObject7rs_font", (void *)&SC_IsObject, true }, 1305 1306 // Allocation ops 1307 { "_Z21rsAllocationMarkDirty13rs_allocation", (void *)&SC_AllocationSyncAll, true }, 1308 { "_Z20rsgAllocationSyncAll13rs_allocation", (void *)&SC_AllocationSyncAll, false }, 1309 { "_Z20rsgAllocationSyncAll13rs_allocationj", (void *)&SC_AllocationSyncAll2, false }, 1310 { "_Z20rsgAllocationSyncAll13rs_allocation24rs_allocation_usage_type", (void *)&SC_AllocationSyncAll2, false }, 1311#ifndef RS_COMPATIBILITY_LIB 1312 { "_Z15rsGetAllocationPKv", (void *)&SC_GetAllocation, true }, 1313 { "_Z18rsAllocationIoSend13rs_allocation", (void *)&SC_AllocationIoSend, false }, 1314 { "_Z21rsAllocationIoReceive13rs_allocation", (void *)&SC_AllocationIoReceive, false }, 1315#endif 1316 { "_Z23rsAllocationCopy1DRange13rs_allocationjjjS_jj", (void *)&SC_AllocationCopy1DRange, false }, 1317 { "_Z23rsAllocationCopy2DRange13rs_allocationjjj26rs_allocation_cubemap_facejjS_jjjS0_", (void *)&SC_AllocationCopy2DRange, false }, 1318 1319 // Messaging 1320 1321 { "_Z14rsSendToClienti", (void *)&SC_ToClient, false }, 1322 { "_Z14rsSendToClientiPKvj", (void *)&SC_ToClient2, false }, 1323 { "_Z22rsSendToClientBlockingi", (void *)&SC_ToClientBlocking, false }, 1324 { "_Z22rsSendToClientBlockingiPKvj", (void *)&SC_ToClientBlocking2, false }, 1325#ifndef RS_COMPATIBILITY_LIB 1326 { "_Z22rsgBindProgramFragment19rs_program_fragment", (void *)&SC_BindProgramFragment, false }, 1327 { "_Z19rsgBindProgramStore16rs_program_store", (void *)&SC_BindProgramStore, false }, 1328 { "_Z20rsgBindProgramVertex17rs_program_vertex", (void *)&SC_BindProgramVertex, false }, 1329 { "_Z20rsgBindProgramRaster17rs_program_raster", (void *)&SC_BindProgramRaster, false }, 1330 { "_Z14rsgBindSampler19rs_program_fragmentj10rs_sampler", (void *)&SC_BindSampler, false }, 1331 { "_Z14rsgBindTexture19rs_program_fragmentj13rs_allocation", (void *)&SC_BindTexture, false }, 1332 { "_Z15rsgBindConstant19rs_program_fragmentj13rs_allocation", (void *)&SC_BindFragmentConstant, false }, 1333 { "_Z15rsgBindConstant17rs_program_vertexj13rs_allocation", (void *)&SC_BindVertexConstant, false }, 1334 1335 { "_Z36rsgProgramVertexLoadProjectionMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadProjectionMatrix, false }, 1336 { "_Z31rsgProgramVertexLoadModelMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadModelMatrix, false }, 1337 { "_Z33rsgProgramVertexLoadTextureMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadTextureMatrix, false }, 1338 1339 { "_Z35rsgProgramVertexGetProjectionMatrixP12rs_matrix4x4", (void *)&SC_VpGetProjectionMatrix, false }, 1340 1341 { "_Z31rsgProgramFragmentConstantColor19rs_program_fragmentffff", (void *)&SC_PfConstantColor, false }, 1342 1343 { "_Z11rsgGetWidthv", (void *)&SC_GetWidth, false }, 1344 { "_Z12rsgGetHeightv", (void *)&SC_GetHeight, false }, 1345 1346 1347 { "_Z11rsgDrawRectfffff", (void *)&SC_DrawRect, false }, 1348 { "_Z11rsgDrawQuadffffffffffff", (void *)&SC_DrawQuad, false }, 1349 { "_Z20rsgDrawQuadTexCoordsffffffffffffffffffff", (void *)&SC_DrawQuadTexCoords, false }, 1350 { "_Z24rsgDrawSpriteScreenspacefffff", (void *)&SC_DrawSpriteScreenspace, false }, 1351 1352 { "_Z11rsgDrawMesh7rs_mesh", (void *)&SC_DrawMesh, false }, 1353 { "_Z11rsgDrawMesh7rs_meshj", (void *)&SC_DrawMeshPrimitive, false }, 1354 { "_Z11rsgDrawMesh7rs_meshjjj", (void *)&SC_DrawMeshPrimitiveRange, false }, 1355 { "_Z25rsgMeshComputeBoundingBox7rs_meshPfS0_S0_S0_S0_S0_", (void *)&SC_MeshComputeBoundingBox, false }, 1356 1357 { "_Z11rsgDrawPath7rs_path", (void *)&SC_DrawPath, false }, 1358 1359 { "_Z13rsgClearColorffff", (void *)&SC_ClearColor, false }, 1360 { "_Z13rsgClearDepthf", (void *)&SC_ClearDepth, false }, 1361 1362 { "_Z11rsgDrawTextPKcii", (void *)&SC_DrawText, false }, 1363 { "_Z11rsgDrawText13rs_allocationii", (void *)&SC_DrawTextAlloc, false }, 1364 { "_Z14rsgMeasureTextPKcPiS1_S1_S1_", (void *)&SC_MeasureText, false }, 1365 { "_Z14rsgMeasureText13rs_allocationPiS0_S0_S0_", (void *)&SC_MeasureTextAlloc, false }, 1366 1367 { "_Z11rsgBindFont7rs_font", (void *)&SC_BindFont, false }, 1368 { "_Z12rsgFontColorffff", (void *)&SC_FontColor, false }, 1369 1370 { "_Z18rsgBindColorTarget13rs_allocationj", (void *)&SC_BindFrameBufferObjectColorTarget, false }, 1371 { "_Z18rsgBindDepthTarget13rs_allocation", (void *)&SC_BindFrameBufferObjectDepthTarget, false }, 1372 { "_Z19rsgClearColorTargetj", (void *)&SC_ClearFrameBufferObjectColorTarget, false }, 1373 { "_Z19rsgClearDepthTargetv", (void *)&SC_ClearFrameBufferObjectDepthTarget, false }, 1374 { "_Z24rsgClearAllRenderTargetsv", (void *)&SC_ClearFrameBufferObjectTargets, false }, 1375 1376 1377 { "_Z9rsForEach9rs_script13rs_allocationS0_", (void *)&SC_ForEach_SAA, true }, 1378 { "_Z9rsForEach9rs_script13rs_allocationS0_PKv", (void *)&SC_ForEach_SAAU, true }, 1379 { "_Z9rsForEach9rs_script13rs_allocationS0_PKvPK14rs_script_call", (void *)&SC_ForEach_SAAUS, true }, 1380 { "_Z9rsForEach9rs_script13rs_allocationS0_PKvj", (void *)&SC_ForEach_SAAUL, true }, 1381 { "_Z9rsForEach9rs_script13rs_allocationS0_PKvjPK14rs_script_call", (void *)&SC_ForEach_SAAULS, true }, 1382#endif // RS_COMPATIBILITY_LIB 1383 1384#ifndef __LP64__ 1385 // time 1386 { "_Z6rsTimePi", (void *)&SC_Time, true }, 1387 { "_Z11rsLocaltimeP5rs_tmPKi", (void *)&SC_LocalTime, true }, 1388#else 1389 // time 1390 { "_Z6rsTimePl", (void *)&SC_Time, true }, 1391 { "_Z11rsLocaltimeP5rs_tmPKl", (void *)&SC_LocalTime, true }, 1392#endif 1393 { "_Z14rsUptimeMillisv", (void*)&SC_UptimeMillis, true }, 1394 { "_Z13rsUptimeNanosv", (void*)&SC_UptimeNanos, true }, 1395 { "_Z7rsGetDtv", (void*)&SC_GetDt, false }, 1396 1397 // misc 1398#ifndef RS_COMPATIBILITY_LIB 1399 { "_Z5colorffff", (void *)&SC_Color, false }, 1400 { "_Z9rsgFinishv", (void *)&SC_Finish, false }, 1401#endif 1402 1403 { nullptr, nullptr, false } 1404}; 1405 1406#ifdef RS_COMPATIBILITY_LIB 1407 1408////////////////////////////////////////////////////////////////////////////// 1409// Compatibility Library entry points 1410////////////////////////////////////////////////////////////////////////////// 1411 1412#define IS_CLEAR_SET_OBJ(t) \ 1413 bool rsIsObject(t src) { \ 1414 return src.p != nullptr; \ 1415 } \ 1416 void __attribute__((overloadable)) rsClearObject(t *dst) { \ 1417 return SC_ClearObject(reinterpret_cast<rs_object_base *>(dst)); \ 1418 } \ 1419 void __attribute__((overloadable)) rsSetObject(t *dst, t src) { \ 1420 return SC_SetObject(reinterpret_cast<rs_object_base *>(dst), (ObjectBase*)src.p); \ 1421 } 1422 1423IS_CLEAR_SET_OBJ(::rs_element) 1424IS_CLEAR_SET_OBJ(::rs_type) 1425IS_CLEAR_SET_OBJ(::rs_allocation) 1426IS_CLEAR_SET_OBJ(::rs_sampler) 1427IS_CLEAR_SET_OBJ(::rs_script) 1428#undef IS_CLEAR_SET_OBJ 1429 1430static void SC_ForEach_SAA(::rs_script target, 1431 ::rs_allocation in, 1432 ::rs_allocation out) { 1433 Context *rsc = RsdCpuReference::getTlsContext(); 1434 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 1435 nullptr, 0, nullptr); 1436} 1437 1438static void SC_ForEach_SAAUS(::rs_script target, 1439 ::rs_allocation in, 1440 ::rs_allocation out, 1441 const void *usr, 1442 const RsScriptCall *call) { 1443 Context *rsc = RsdCpuReference::getTlsContext(); 1444 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 1445 usr, 0, call); 1446} 1447 1448static void SC_ForEach_SAAUL(::rs_script target, 1449 ::rs_allocation in, 1450 ::rs_allocation out, 1451 const void *usr, 1452 uint32_t usrLen) { 1453 Context *rsc = RsdCpuReference::getTlsContext(); 1454 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 1455 usr, usrLen, nullptr); 1456} 1457 1458static void SC_ForEach_SAAULS(::rs_script target, 1459 ::rs_allocation in, 1460 ::rs_allocation out, 1461 const void *usr, 1462 uint32_t usrLen, 1463 const RsScriptCall *call) { 1464 Context *rsc = RsdCpuReference::getTlsContext(); 1465 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 1466 usr, usrLen, call); 1467} 1468 1469static const Allocation * SC_GetAllocation(const void *ptr) { 1470 Context *rsc = RsdCpuReference::getTlsContext(); 1471 const Script *sc = RsdCpuReference::getTlsScript(); 1472 return rsdScriptGetAllocationForPointer(rsc, sc, ptr); 1473} 1474 1475const Allocation * rsGetAllocation(const void *ptr) { 1476 return SC_GetAllocation(ptr); 1477} 1478 1479void __attribute__((overloadable)) rsAllocationIoSend(::rs_allocation a) { 1480 SC_AllocationIoSend((Allocation *)a.p); 1481} 1482 1483void __attribute__((overloadable)) rsAllocationIoReceive(::rs_allocation a) { 1484 SC_AllocationIoReceive((Allocation *)a.p); 1485} 1486 1487 1488void __attribute__((overloadable)) rsAllocationCopy1DRange( 1489 ::rs_allocation dstAlloc, 1490 uint32_t dstOff, uint32_t dstMip, uint32_t count, 1491 ::rs_allocation srcAlloc, 1492 uint32_t srcOff, uint32_t srcMip) { 1493 SC_AllocationCopy1DRange(dstAlloc, dstOff, dstMip, count, 1494 srcAlloc, srcOff, srcMip); 1495} 1496 1497void __attribute__((overloadable)) rsAllocationCopy2DRange( 1498 ::rs_allocation dstAlloc, 1499 uint32_t dstXoff, uint32_t dstYoff, 1500 uint32_t dstMip, rs_allocation_cubemap_face dstFace, 1501 uint32_t width, uint32_t height, 1502 ::rs_allocation srcAlloc, 1503 uint32_t srcXoff, uint32_t srcYoff, 1504 uint32_t srcMip, rs_allocation_cubemap_face srcFace) { 1505 SC_AllocationCopy2DRange(dstAlloc, dstXoff, dstYoff, 1506 dstMip, dstFace, width, height, 1507 srcAlloc, srcXoff, srcYoff, 1508 srcMip, srcFace); 1509} 1510 1511void __attribute__((overloadable)) rsForEach(::rs_script script, 1512 ::rs_allocation in, 1513 ::rs_allocation out, 1514 const void *usr, 1515 const rs_script_call *call) { 1516 return SC_ForEach_SAAUS(script, in, out, usr, (RsScriptCall*)call); 1517} 1518 1519void __attribute__((overloadable)) rsForEach(::rs_script script, 1520 ::rs_allocation in, 1521 ::rs_allocation out) { 1522 return SC_ForEach_SAA(script, in, out); 1523} 1524 1525void __attribute__((overloadable)) rsForEach(::rs_script script, 1526 ::rs_allocation in, 1527 ::rs_allocation out, 1528 const void *usr, 1529 uint32_t usrLen) { 1530 return SC_ForEach_SAAUL(script, in, out, usr, usrLen); 1531} 1532 1533void __attribute__((overloadable)) rsForEach(::rs_script script, 1534 ::rs_allocation in, 1535 ::rs_allocation out, 1536 const void *usr, 1537 uint32_t usrLen, 1538 const rs_script_call *call) { 1539 return SC_ForEach_SAAULS(script, in, out, usr, usrLen, (RsScriptCall*)call); 1540} 1541 1542int rsTime(int *timer) { 1543 return SC_Time(timer); 1544} 1545 1546rs_tm* rsLocaltime(rs_tm* local, const int *timer) { 1547 return (rs_tm*)(SC_LocalTime((tm*)local, (long*)timer)); 1548} 1549 1550int64_t rsUptimeMillis() { 1551 Context *rsc = RsdCpuReference::getTlsContext(); 1552 return rsrUptimeMillis(rsc); 1553} 1554 1555int64_t rsUptimeNanos() { 1556 return SC_UptimeNanos(); 1557} 1558 1559float rsGetDt() { 1560 return SC_GetDt(); 1561} 1562 1563uint32_t rsSendToClient(int cmdID) { 1564 return SC_ToClient(cmdID); 1565} 1566 1567uint32_t rsSendToClient(int cmdID, const void *data, uint32_t len) { 1568 return SC_ToClient2(cmdID, data, len); 1569} 1570 1571uint32_t rsSendToClientBlocking(int cmdID) { 1572 return SC_ToClientBlocking(cmdID); 1573} 1574 1575uint32_t rsSendToClientBlocking(int cmdID, const void *data, uint32_t len) { 1576 return SC_ToClientBlocking2(cmdID, data, len); 1577} 1578 1579static void SC_debugF(const char *s, float f) { 1580 ALOGD("%s %f, 0x%08x", s, f, *((int *) (&f))); 1581} 1582static void SC_debugFv2(const char *s, float f1, float f2) { 1583 ALOGD("%s {%f, %f}", s, f1, f2); 1584} 1585static void SC_debugFv3(const char *s, float f1, float f2, float f3) { 1586 ALOGD("%s {%f, %f, %f}", s, f1, f2, f3); 1587} 1588static void SC_debugFv4(const char *s, float f1, float f2, float f3, float f4) { 1589 ALOGD("%s {%f, %f, %f, %f}", s, f1, f2, f3, f4); 1590} 1591static void SC_debugF2(const char *s, float2 f) { 1592 ALOGD("%s {%f, %f}", s, f.x, f.y); 1593} 1594static void SC_debugF3(const char *s, float3 f) { 1595 ALOGD("%s {%f, %f, %f}", s, f.x, f.y, f.z); 1596} 1597static void SC_debugF4(const char *s, float4 f) { 1598 ALOGD("%s {%f, %f, %f, %f}", s, f.x, f.y, f.z, f.w); 1599} 1600static void SC_debugD(const char *s, double d) { 1601 ALOGD("%s %f, 0x%08llx", s, d, *((long long *) (&d))); 1602} 1603static void SC_debugFM4v4(const char *s, const float *f) { 1604 ALOGD("%s {%f, %f, %f, %f", s, f[0], f[4], f[8], f[12]); 1605 ALOGD("%s %f, %f, %f, %f", s, f[1], f[5], f[9], f[13]); 1606 ALOGD("%s %f, %f, %f, %f", s, f[2], f[6], f[10], f[14]); 1607 ALOGD("%s %f, %f, %f, %f}", s, f[3], f[7], f[11], f[15]); 1608} 1609static void SC_debugFM3v3(const char *s, const float *f) { 1610 ALOGD("%s {%f, %f, %f", s, f[0], f[3], f[6]); 1611 ALOGD("%s %f, %f, %f", s, f[1], f[4], f[7]); 1612 ALOGD("%s %f, %f, %f}",s, f[2], f[5], f[8]); 1613} 1614static void SC_debugFM2v2(const char *s, const float *f) { 1615 ALOGD("%s {%f, %f", s, f[0], f[2]); 1616 ALOGD("%s %f, %f}",s, f[1], f[3]); 1617} 1618static void SC_debugI8(const char *s, char c) { 1619 ALOGD("%s %hhd 0x%hhx", s, c, (unsigned char)c); 1620} 1621static void SC_debugC2(const char *s, char2 c) { 1622 ALOGD("%s {%hhd, %hhd} 0x%hhx 0x%hhx", s, c.x, c.y, (unsigned char)c.x, (unsigned char)c.y); 1623} 1624static void SC_debugC3(const char *s, char3 c) { 1625 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); 1626} 1627static void SC_debugC4(const char *s, char4 c) { 1628 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); 1629} 1630static void SC_debugU8(const char *s, unsigned char c) { 1631 ALOGD("%s %hhu 0x%hhx", s, c, c); 1632} 1633static void SC_debugUC2(const char *s, uchar2 c) { 1634 ALOGD("%s {%hhu, %hhu} 0x%hhx 0x%hhx", s, c.x, c.y, c.x, c.y); 1635} 1636static void SC_debugUC3(const char *s, uchar3 c) { 1637 ALOGD("%s {%hhu, %hhu, %hhu} 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.x, c.y, c.z); 1638} 1639static void SC_debugUC4(const char *s, uchar4 c) { 1640 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); 1641} 1642static void SC_debugI16(const char *s, short c) { 1643 ALOGD("%s %hd 0x%hx", s, c, c); 1644} 1645static void SC_debugS2(const char *s, short2 c) { 1646 ALOGD("%s {%hd, %hd} 0x%hx 0x%hx", s, c.x, c.y, c.x, c.y); 1647} 1648static void SC_debugS3(const char *s, short3 c) { 1649 ALOGD("%s {%hd, %hd, %hd} 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z); 1650} 1651static void SC_debugS4(const char *s, short4 c) { 1652 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); 1653} 1654static void SC_debugU16(const char *s, unsigned short c) { 1655 ALOGD("%s %hu 0x%hx", s, c, c); 1656} 1657static void SC_debugUS2(const char *s, ushort2 c) { 1658 ALOGD("%s {%hu, %hu} 0x%hx 0x%hx", s, c.x, c.y, c.x, c.y); 1659} 1660static void SC_debugUS3(const char *s, ushort3 c) { 1661 ALOGD("%s {%hu, %hu, %hu} 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z); 1662} 1663static void SC_debugUS4(const char *s, ushort4 c) { 1664 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); 1665} 1666static void SC_debugI32(const char *s, int32_t i) { 1667 ALOGD("%s %d 0x%x", s, i, i); 1668} 1669static void SC_debugI2(const char *s, int2 i) { 1670 ALOGD("%s {%d, %d} 0x%x 0x%x", s, i.x, i.y, i.x, i.y); 1671} 1672static void SC_debugI3(const char *s, int3 i) { 1673 ALOGD("%s {%d, %d, %d} 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z); 1674} 1675static void SC_debugI4(const char *s, int4 i) { 1676 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); 1677} 1678static void SC_debugU32(const char *s, uint32_t i) { 1679 ALOGD("%s %u 0x%x", s, i, i); 1680} 1681static void SC_debugUI2(const char *s, uint2 i) { 1682 ALOGD("%s {%u, %u} 0x%x 0x%x", s, i.x, i.y, i.x, i.y); 1683} 1684static void SC_debugUI3(const char *s, uint3 i) { 1685 ALOGD("%s {%u, %u, %u} 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z); 1686} 1687static void SC_debugUI4(const char *s, uint4 i) { 1688 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); 1689} 1690static void SC_debugLL64(const char *s, long long ll) { 1691 ALOGD("%s %lld 0x%llx", s, ll, ll); 1692} 1693static void SC_debugL2(const char *s, long2 ll) { 1694 ALOGD("%s {%lld, %lld} 0x%llx 0x%llx", s, ll.x, ll.y, ll.x, ll.y); 1695} 1696static void SC_debugL3(const char *s, long3 ll) { 1697 ALOGD("%s {%lld, %lld, %lld} 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.x, ll.y, ll.z); 1698} 1699static void SC_debugL4(const char *s, long4 ll) { 1700 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); 1701} 1702static void SC_debugULL64(const char *s, unsigned long long ll) { 1703 ALOGD("%s %llu 0x%llx", s, ll, ll); 1704} 1705static void SC_debugUL2(const char *s, ulong2 ll) { 1706 ALOGD("%s {%llu, %llu} 0x%llx 0x%llx", s, ll.x, ll.y, ll.x, ll.y); 1707} 1708static void SC_debugUL3(const char *s, ulong3 ll) { 1709 ALOGD("%s {%llu, %llu, %llu} 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.x, ll.y, ll.z); 1710} 1711static void SC_debugUL4(const char *s, ulong4 ll) { 1712 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); 1713} 1714static void SC_debugP(const char *s, const void *p) { 1715 ALOGD("%s %p", s, p); 1716} 1717 1718// TODO: allocation ops, messaging, time 1719 1720void rsDebug(const char *s, float f) { 1721 SC_debugF(s, f); 1722} 1723 1724void rsDebug(const char *s, float f1, float f2) { 1725 SC_debugFv2(s, f1, f2); 1726} 1727 1728void rsDebug(const char *s, float f1, float f2, float f3) { 1729 SC_debugFv3(s, f1, f2, f3); 1730} 1731 1732void rsDebug(const char *s, float f1, float f2, float f3, float f4) { 1733 SC_debugFv4(s, f1, f2, f3, f4); 1734} 1735 1736void rsDebug(const char *s, const float2 *f) { 1737 SC_debugF2(s, *f); 1738} 1739 1740void rsDebug(const char *s, const float3 *f) { 1741 SC_debugF3(s, *f); 1742} 1743 1744void rsDebug(const char *s, const float4 *f) { 1745 SC_debugF4(s, *f); 1746} 1747 1748void rsDebug(const char *s, double d) { 1749 SC_debugD(s, d); 1750} 1751 1752void rsDebug(const char *s, const rs_matrix4x4 *m) { 1753 SC_debugFM4v4(s, (float *) m); 1754} 1755 1756void rsDebug(const char *s, const rs_matrix3x3 *m) { 1757 SC_debugFM3v3(s, (float *) m); 1758} 1759 1760void rsDebug(const char *s, const rs_matrix2x2 *m) { 1761 SC_debugFM2v2(s, (float *) m); 1762} 1763 1764void rsDebug(const char *s, char c) { 1765 SC_debugI8(s, c); 1766} 1767 1768void rsDebug(const char *s, const char2 *c) { 1769 SC_debugC2(s, *c); 1770} 1771 1772void rsDebug(const char *s, const char3 *c) { 1773 SC_debugC3(s, *c); 1774} 1775 1776void rsDebug(const char *s, const char4 *c) { 1777 SC_debugC4(s, *c); 1778} 1779 1780void rsDebug(const char *s, unsigned char c) { 1781 SC_debugU8(s, c); 1782} 1783 1784void rsDebug(const char *s, const uchar2 *c) { 1785 SC_debugUC2(s, *c); 1786} 1787 1788void rsDebug(const char *s, const uchar3 *c) { 1789 SC_debugUC3(s, *c); 1790} 1791 1792void rsDebug(const char *s, const uchar4 *c) { 1793 SC_debugUC4(s, *c); 1794} 1795 1796void rsDebug(const char *s, short c) { 1797 SC_debugI16(s, c); 1798} 1799 1800void rsDebug(const char *s, const short2 *c) { 1801 SC_debugS2(s, *c); 1802} 1803 1804void rsDebug(const char *s, const short3 *c) { 1805 SC_debugS3(s, *c); 1806} 1807 1808void rsDebug(const char *s, const short4 *c) { 1809 SC_debugS4(s, *c); 1810} 1811 1812void rsDebug(const char *s, unsigned short c) { 1813 SC_debugU16(s, c); 1814} 1815 1816void rsDebug(const char *s, const ushort2 *c) { 1817 SC_debugUS2(s, *c); 1818} 1819 1820void rsDebug(const char *s, const ushort3 *c) { 1821 SC_debugUS3(s, *c); 1822} 1823 1824void rsDebug(const char *s, const ushort4 *c) { 1825 SC_debugUS4(s, *c); 1826} 1827 1828void rsDebug(const char *s, int c) { 1829 SC_debugI32(s, c); 1830} 1831 1832void rsDebug(const char *s, const int2 *c) { 1833 SC_debugI2(s, *c); 1834} 1835 1836void rsDebug(const char *s, const int3 *c) { 1837 SC_debugI3(s, *c); 1838} 1839 1840void rsDebug(const char *s, const int4 *c) { 1841 SC_debugI4(s, *c); 1842} 1843 1844void rsDebug(const char *s, unsigned int c) { 1845 SC_debugU32(s, c); 1846} 1847 1848void rsDebug(const char *s, const uint2 *c) { 1849 SC_debugUI2(s, *c); 1850} 1851 1852void rsDebug(const char *s, const uint3 *c) { 1853 SC_debugUI3(s, *c); 1854} 1855 1856void rsDebug(const char *s, const uint4 *c) { 1857 SC_debugUI4(s, *c); 1858} 1859 1860void rsDebug(const char *s, long c) { 1861 SC_debugLL64(s, c); 1862} 1863 1864void rsDebug(const char *s, long long c) { 1865 SC_debugLL64(s, c); 1866} 1867 1868void rsDebug(const char *s, const long2 *c) { 1869 SC_debugL2(s, *c); 1870} 1871 1872void rsDebug(const char *s, const long3 *c) { 1873 SC_debugL3(s, *c); 1874} 1875 1876void rsDebug(const char *s, const long4 *c) { 1877 SC_debugL4(s, *c); 1878} 1879 1880void rsDebug(const char *s, unsigned long c) { 1881 SC_debugULL64(s, c); 1882} 1883 1884void rsDebug(const char *s, unsigned long long c) { 1885 SC_debugULL64(s, c); 1886} 1887 1888void rsDebug(const char *s, const ulong2 *c) { 1889 SC_debugUL2(s, *c); 1890} 1891 1892void rsDebug(const char *s, const ulong3 *c) { 1893 SC_debugUL3(s, *c); 1894} 1895 1896void rsDebug(const char *s, const ulong4 *c) { 1897 SC_debugUL4(s, *c); 1898} 1899 1900// FIXME: We need to export these function signatures for the compatibility 1901// library. The C++ name mangling that LLVM uses for ext_vector_type requires 1902// different versions for "long" vs. "long long". Note that the called 1903// functions are still using the appropriate 64-bit sizes. 1904typedef long l2 __attribute__((ext_vector_type(2))); 1905typedef long l3 __attribute__((ext_vector_type(3))); 1906typedef long l4 __attribute__((ext_vector_type(4))); 1907typedef unsigned long ul2 __attribute__((ext_vector_type(2))); 1908typedef unsigned long ul3 __attribute__((ext_vector_type(3))); 1909typedef unsigned long ul4 __attribute__((ext_vector_type(4))); 1910 1911void rsDebug(const char *s, const l2 *c) { 1912 SC_debugL2(s, *(const long2 *)c); 1913} 1914 1915void rsDebug(const char *s, const l3 *c) { 1916 SC_debugL3(s, *(const long3 *)c); 1917} 1918 1919void rsDebug(const char *s, const l4 *c) { 1920 SC_debugL4(s, *(const long4 *)c); 1921} 1922 1923void rsDebug(const char *s, const ul2 *c) { 1924 SC_debugUL2(s, *(const ulong2 *)c); 1925} 1926 1927void rsDebug(const char *s, const ul3 *c) { 1928 SC_debugUL3(s, *(const ulong3 *)c); 1929} 1930 1931void rsDebug(const char *s, const ul4 *c) { 1932 SC_debugUL4(s, *(const ulong4 *)c); 1933} 1934 1935void rsDebug(const char *s, const void *p) { 1936 SC_debugP(s, p); 1937} 1938#endif // RS_COMPATIBILITY_LIB 1939 1940extern const RsdCpuReference::CpuSymbol * rsdLookupRuntimeStub(Context * pContext, char const* name) { 1941 ScriptC *s = (ScriptC *)pContext; 1942 const RsdCpuReference::CpuSymbol *syms = gSyms; 1943 const RsdCpuReference::CpuSymbol *sym = nullptr; 1944 1945 if (!sym) { 1946 while (syms->fnPtr) { 1947 if (!strcmp(syms->name, name)) { 1948 return syms; 1949 } 1950 syms++; 1951 } 1952 } 1953 1954 return nullptr; 1955} 1956