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