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 "rsElement.h"
19 #include "rsScriptC.h"
20 #include "rsMatrix4x4.h"
21 #include "rsMatrix3x3.h"
22 #include "rsMatrix2x2.h"
23 #include "rsRuntime.h"
24 #include "rsType.h"
25
26 #include "rsdCore.h"
27 #include "rsdBcc.h"
28
29 #include "rsdAllocation.h"
30 #include "rsdShaderCache.h"
31 #include "rsdVertexArray.h"
32
33 #include <time.h>
34
35 #if !defined(RS_VENDOR_LIB) && !defined(RS_COMPATIBILITY_LIB)
36 using android::renderscript::Font;
37 #endif
38
39 using android::renderscript::Allocation;
40 using android::renderscript::Context;
41 using android::renderscript::Element;
42 using android::renderscript::RsdCpuReference;
43 using android::renderscript::Mesh;
44 using android::renderscript::ObjectBase;
45 using android::renderscript::ObjectBaseRef;
46 using android::renderscript::ProgramFragment;
47 using android::renderscript::ProgramRaster;
48 using android::renderscript::ProgramStore;
49 using android::renderscript::ProgramVertex;
50 using android::renderscript::Sampler;
51 using android::renderscript::Script;
52 using android::renderscript::Type;
53 using android::renderscript::rs_object_base;
54
55 typedef __fp16 half;
56 typedef half half2 __attribute__((ext_vector_type(2)));
57 typedef half half3 __attribute__((ext_vector_type(3)));
58 typedef half half4 __attribute__((ext_vector_type(4)));
59
60 typedef float float2 __attribute__((ext_vector_type(2)));
61 typedef float float3 __attribute__((ext_vector_type(3)));
62 typedef float float4 __attribute__((ext_vector_type(4)));
63 typedef double double2 __attribute__((ext_vector_type(2)));
64 typedef double double3 __attribute__((ext_vector_type(3)));
65 typedef double double4 __attribute__((ext_vector_type(4)));
66 typedef char char2 __attribute__((ext_vector_type(2)));
67 typedef char char3 __attribute__((ext_vector_type(3)));
68 typedef char char4 __attribute__((ext_vector_type(4)));
69 typedef unsigned char uchar2 __attribute__((ext_vector_type(2)));
70 typedef unsigned char uchar3 __attribute__((ext_vector_type(3)));
71 typedef unsigned char uchar4 __attribute__((ext_vector_type(4)));
72 typedef int16_t short2 __attribute__((ext_vector_type(2)));
73 typedef int16_t short3 __attribute__((ext_vector_type(3)));
74 typedef int16_t short4 __attribute__((ext_vector_type(4)));
75 typedef uint16_t ushort2 __attribute__((ext_vector_type(2)));
76 typedef uint16_t ushort3 __attribute__((ext_vector_type(3)));
77 typedef uint16_t ushort4 __attribute__((ext_vector_type(4)));
78 typedef int32_t int2 __attribute__((ext_vector_type(2)));
79 typedef int32_t int3 __attribute__((ext_vector_type(3)));
80 typedef int32_t int4 __attribute__((ext_vector_type(4)));
81 typedef uint32_t uint2 __attribute__((ext_vector_type(2)));
82 typedef uint32_t uint3 __attribute__((ext_vector_type(3)));
83 typedef uint32_t uint4 __attribute__((ext_vector_type(4)));
84 typedef int64_t long2 __attribute__((ext_vector_type(2)));
85 typedef int64_t long3 __attribute__((ext_vector_type(3)));
86 typedef int64_t long4 __attribute__((ext_vector_type(4)));
87 typedef uint64_t ulong2 __attribute__((ext_vector_type(2)));
88 typedef uint64_t ulong3 __attribute__((ext_vector_type(3)));
89 typedef uint64_t ulong4 __attribute__((ext_vector_type(4)));
90
91 typedef uint8_t uchar;
92 typedef uint16_t ushort;
93 typedef uint32_t uint;
94 typedef uint64_t ulong;
95
96 // Add NOLINT to suppress wrong warnings from clang-tidy.
97 #ifndef __LP64__
98 #define OPAQUETYPE(t) \
99 typedef struct { const int* const p; } __attribute__((packed, aligned(4))) t; /*NOLINT*/
100 #else
101 #define OPAQUETYPE(t) \
102 typedef struct { const void* p; const void* unused1; const void* unused2; const void* unused3; } t; /*NOLINT*/
103 #endif
104
105 OPAQUETYPE(rs_element)
106 OPAQUETYPE(rs_type)
107 OPAQUETYPE(rs_allocation)
108 OPAQUETYPE(rs_sampler)
109 OPAQUETYPE(rs_script)
110 OPAQUETYPE(rs_script_call)
111
112 OPAQUETYPE(rs_program_fragment);
113 OPAQUETYPE(rs_program_store);
114 OPAQUETYPE(rs_program_vertex);
115 OPAQUETYPE(rs_program_raster);
116 OPAQUETYPE(rs_mesh);
117 OPAQUETYPE(rs_font);
118
119 #undef OPAQUETYPE
120
121 typedef enum {
122 // Empty to avoid conflicting definitions with RsAllocationCubemapFace
123 } rs_allocation_cubemap_face;
124
125 typedef enum {
126 // Empty to avoid conflicting definitions with RsYuvFormat
127 } rs_yuv_format;
128
129 typedef enum {
130 // Empty to avoid conflicting definitions with RsAllocationMipmapControl
131 } rs_allocation_mipmap_control;
132
133 typedef struct { unsigned int val; } rs_allocation_usage_type;
134
135 typedef struct {
136 int tm_sec; ///< seconds
137 int tm_min; ///< minutes
138 int tm_hour; ///< hours
139 int tm_mday; ///< day of the month
140 int tm_mon; ///< month
141 int tm_year; ///< year
142 int tm_wday; ///< day of the week
143 int tm_yday; ///< day of the year
144 int tm_isdst; ///< daylight savings time
145 } rs_tm;
146
147 // Some RS functions are not threadsafe but can be called from an invoke
148 // function. Instead of summarily marking scripts that call these functions as
149 // not-threadable we detect calls to them in the driver and sends a fatal error
150 // message.
failIfInKernel(Context * rsc,const char * funcName)151 static bool failIfInKernel(Context *rsc, const char *funcName) {
152 RsdHal *dc = (RsdHal *)rsc->mHal.drv;
153 RsdCpuReference *impl = (RsdCpuReference *) dc->mCpuRef;
154
155 if (impl->getInKernel()) {
156 char buf[256];
157 snprintf(buf, sizeof(buf), "Error: Call to unsupported function %s "
158 "in kernel", funcName);
159 rsc->setError(RS_ERROR_FATAL_DRIVER, buf);
160 return true;
161 }
162 return false;
163 }
164
165 //////////////////////////////////////////////////////////////////////////////
166 // Allocation routines
167 //////////////////////////////////////////////////////////////////////////////
168 #if defined(__i386__) || (defined(__mips__) && __mips==32)
169 // i386 and MIPS32 have different struct return passing to ARM; emulate with a pointer
rsGetAllocation(const void * ptr)170 const Allocation * rsGetAllocation(const void *ptr) {
171 Context *rsc = RsdCpuReference::getTlsContext();
172 const Script *sc = RsdCpuReference::getTlsScript();
173 Allocation* alloc = rsdScriptGetAllocationForPointer(rsc, sc, ptr);
174 android::renderscript::rs_allocation obj = {0};
175 alloc->callUpdateCacheObject(rsc, &obj);
176 return (Allocation *)obj.p;
177 }
178 #else
rsGetAllocation(const void * ptr)179 const android::renderscript::rs_allocation rsGetAllocation(const void *ptr) {
180 Context *rsc = RsdCpuReference::getTlsContext();
181 const Script *sc = RsdCpuReference::getTlsScript();
182 Allocation* alloc = rsdScriptGetAllocationForPointer(rsc, sc, ptr);
183
184 #ifndef __LP64__ // ARMv7
185 android::renderscript::rs_allocation obj = {0};
186 #else // AArch64/x86_64/MIPS64
187 android::renderscript::rs_allocation obj = {0, 0, 0, 0};
188 #endif
189 alloc->callUpdateCacheObject(rsc, &obj);
190 return obj;
191 }
192 #endif
193
rsAllocationIoSend(::rs_allocation a)194 void __attribute__((overloadable)) rsAllocationIoSend(::rs_allocation a) {
195 Context *rsc = RsdCpuReference::getTlsContext();
196 if (failIfInKernel(rsc, "rsAllocationIoSend"))
197 return;
198 rsrAllocationIoSend(rsc, (Allocation *)a.p);
199 }
200
rsAllocationIoReceive(::rs_allocation a)201 void __attribute__((overloadable)) rsAllocationIoReceive(::rs_allocation a) {
202 Context *rsc = RsdCpuReference::getTlsContext();
203 if (failIfInKernel(rsc, "rsAllocationIoReceive"))
204 return;
205 rsrAllocationIoReceive(rsc, (Allocation *)a.p);
206 }
207
rsAllocationCopy1DRange(::rs_allocation dstAlloc,uint32_t dstOff,uint32_t dstMip,uint32_t count,::rs_allocation srcAlloc,uint32_t srcOff,uint32_t srcMip)208 void __attribute__((overloadable)) rsAllocationCopy1DRange(
209 ::rs_allocation dstAlloc,
210 uint32_t dstOff, uint32_t dstMip, uint32_t count,
211 ::rs_allocation srcAlloc,
212 uint32_t srcOff, uint32_t srcMip) {
213 Context *rsc = RsdCpuReference::getTlsContext();
214 if (failIfInKernel(rsc, "rsAllocationCopy1DRange"))
215 return;
216 rsrAllocationCopy1DRange(rsc, (Allocation *)dstAlloc.p, dstOff, dstMip,
217 count, (Allocation *)srcAlloc.p, srcOff, srcMip);
218 }
219
rsAllocationCopy2DRange(::rs_allocation dstAlloc,uint32_t dstXoff,uint32_t dstYoff,uint32_t dstMip,rs_allocation_cubemap_face dstFace,uint32_t width,uint32_t height,::rs_allocation srcAlloc,uint32_t srcXoff,uint32_t srcYoff,uint32_t srcMip,rs_allocation_cubemap_face srcFace)220 void __attribute__((overloadable)) rsAllocationCopy2DRange(
221 ::rs_allocation dstAlloc,
222 uint32_t dstXoff, uint32_t dstYoff,
223 uint32_t dstMip, rs_allocation_cubemap_face dstFace,
224 uint32_t width, uint32_t height,
225 ::rs_allocation srcAlloc,
226 uint32_t srcXoff, uint32_t srcYoff,
227 uint32_t srcMip, rs_allocation_cubemap_face srcFace) {
228 Context *rsc = RsdCpuReference::getTlsContext();
229 if (failIfInKernel(rsc, "rsAllocationCopy2DRange"))
230 return;
231 rsrAllocationCopy2DRange(rsc, (Allocation *)dstAlloc.p,
232 dstXoff, dstYoff, dstMip, dstFace,
233 width, height, (Allocation *)srcAlloc.p,
234 srcXoff, srcYoff, srcMip, srcFace);
235 }
236
CreateElement(RsDataType dt,RsDataKind dk,bool isNormalized,uint32_t vecSize)237 static android::renderscript::rs_element CreateElement(RsDataType dt,
238 RsDataKind dk,
239 bool isNormalized,
240 uint32_t vecSize) {
241 Context *rsc = RsdCpuReference::getTlsContext();
242
243 // No need for validation here. The rsCreateElement overload below is not
244 // exposed to the Script. The Element-creation APIs call this function in a
245 // consistent manner and rsComponent.cpp asserts on any inconsistency.
246 Element *element = (Element *) rsrElementCreate(rsc, dt, dk, isNormalized,
247 vecSize);
248 android::renderscript::rs_element obj = {};
249 if (element == nullptr)
250 return obj;
251 element->callUpdateCacheObject(rsc, &obj);
252
253 // Any new rsObject created from inside a script should have the usrRefCount
254 // initialized to 0 and the sysRefCount initialized to 1.
255 element->incSysRef();
256 element->decUserRef();
257
258 return obj;
259 }
260
CreateType(RsElement element,uint32_t dimX,uint32_t dimY,uint32_t dimZ,bool mipmaps,bool faces,uint32_t yuv_format)261 static android::renderscript::rs_type CreateType(RsElement element,
262 uint32_t dimX, uint32_t dimY,
263 uint32_t dimZ, bool mipmaps,
264 bool faces,
265 uint32_t yuv_format) {
266
267 Context *rsc = RsdCpuReference::getTlsContext();
268 android::renderscript::rs_type obj = {};
269
270 if (element == nullptr) {
271 ALOGE("rs_type creation error: Invalid element");
272 return obj;
273 }
274
275 // validate yuv_format
276 RsYuvFormat yuv = (RsYuvFormat) yuv_format;
277 if (yuv != RS_YUV_NONE &&
278 yuv != RS_YUV_YV12 &&
279 yuv != RS_YUV_NV21 &&
280 yuv != RS_YUV_420_888) {
281
282 ALOGE("rs_type creation error: Invalid yuv_format %d\n", yuv_format);
283 return obj;
284 }
285
286 // validate consistency of shape parameters
287 if (dimZ > 0) {
288 if (dimX < 1 || dimY < 1) {
289 ALOGE("rs_type creation error: Both X and Y dimension required "
290 "when Z is present.");
291 return obj;
292 }
293 if (mipmaps) {
294 ALOGE("rs_type creation error: mipmap control requires 2D types");
295 return obj;
296 }
297 if (faces) {
298 ALOGE("rs_type creation error: Cube maps require 2D types");
299 return obj;
300 }
301 }
302 if (dimY > 0 && dimX < 1) {
303 ALOGE("rs_type creation error: X dimension required when Y is "
304 "present.");
305 return obj;
306 }
307 if (mipmaps && dimY < 1) {
308 ALOGE("rs_type creation error: mipmap control require 2D Types.");
309 return obj;
310 }
311 if (faces && dimY < 1) {
312 ALOGE("rs_type creation error: Cube maps require 2D Types.");
313 return obj;
314 }
315 if (yuv_format != RS_YUV_NONE) {
316 if (dimZ != 0 || dimY == 0 || faces || mipmaps) {
317 ALOGE("rs_type creation error: YUV only supports basic 2D.");
318 return obj;
319 }
320 }
321
322 Type *type = (Type *) rsrTypeCreate(rsc, element, dimX, dimY, dimZ, mipmaps,
323 faces, yuv_format);
324 if (type == nullptr)
325 return obj;
326 type->callUpdateCacheObject(rsc, &obj);
327
328 // Any new rsObject created from inside a script should have the usrRefCount
329 // initialized to 0 and the sysRefCount initialized to 1.
330 type->incSysRef();
331 type->decUserRef();
332
333 return obj;
334 }
335
CreateAllocation(RsType type,RsAllocationMipmapControl mipmaps,uint32_t usages,void * ptr)336 static android::renderscript::rs_allocation CreateAllocation(
337 RsType type, RsAllocationMipmapControl mipmaps, uint32_t usages,
338 void *ptr) {
339
340 Context *rsc = RsdCpuReference::getTlsContext();
341 android::renderscript::rs_allocation obj = {};
342
343 if (type == nullptr) {
344 ALOGE("rs_allocation creation error: Invalid type");
345 return obj;
346 }
347
348 uint32_t validUsages = RS_ALLOCATION_USAGE_SCRIPT | \
349 RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE;
350 if (usages & ~validUsages) {
351 ALOGE("rs_allocation creation error: Invalid usage flag");
352 return obj;
353 }
354
355 Allocation *alloc = (Allocation *) rsrAllocationCreateTyped(rsc, type,
356 mipmaps, usages,
357 (uintptr_t) ptr);
358 if (alloc == nullptr)
359 return obj;
360 alloc->callUpdateCacheObject(rsc, &obj);
361
362 // Any new rsObject created from inside a script should have the usrRefCount
363 // initialized to 0 and the sysRefCount initialized to 1.
364 alloc->incSysRef();
365 alloc->decUserRef();
366
367 return obj;
368 }
369
370 // Define rsCreateElement, rsCreateType and rsCreateAllocation entry points
371 // differently for 32-bit x86 and Mips. The definitions for ARM32 and all
372 // 64-bit architectures is further below.
373 #if defined(__i386__) || (defined(__mips__) && __mips==32)
374
375 // The calling convention for the driver on 32-bit x86 and Mips returns
376 // rs_element etc. as a stack-return parameter. The Script uses ARM32 calling
377 // conventions that return the structs in a register. To match this convention,
378 // emulate the return value using a pointer.
rsCreateElement(int32_t dt,int32_t dk,bool isNormalized,uint32_t vecSize)379 Element *rsCreateElement(int32_t dt, int32_t dk, bool isNormalized,
380 uint32_t vecSize) {
381
382 android::renderscript::rs_element obj = CreateElement((RsDataType) dt,
383 (RsDataKind) dk,
384 isNormalized,
385 vecSize);
386 return (Element *) obj.p;
387 }
388
rsCreateType(::rs_element element,uint32_t dimX,uint32_t dimY,uint32_t dimZ,bool mipmaps,bool faces,rs_yuv_format yuv_format)389 Type *rsCreateType(::rs_element element, uint32_t dimX, uint32_t dimY,
390 uint32_t dimZ, bool mipmaps, bool faces,
391 rs_yuv_format yuv_format) {
392 android::renderscript::rs_type obj = CreateType((RsElement) element.p, dimX,
393 dimY, dimZ, mipmaps, faces,
394 (RsYuvFormat) yuv_format);
395 return (Type *) obj.p;
396 }
397
rsCreateAllocation(::rs_type type,rs_allocation_mipmap_control mipmaps,uint32_t usages,void * ptr)398 Allocation *rsCreateAllocation(::rs_type type,
399 rs_allocation_mipmap_control mipmaps,
400 uint32_t usages, void *ptr) {
401
402 android::renderscript::rs_allocation obj;
403 obj = CreateAllocation((RsType) type.p, (RsAllocationMipmapControl) mipmaps,
404 usages, ptr);
405 return (Allocation *) obj.p;
406 }
407
408 #else
rsCreateElement(int32_t dt,int32_t dk,bool isNormalized,uint32_t vecSize)409 android::renderscript::rs_element rsCreateElement(int32_t dt, int32_t dk,
410 bool isNormalized,
411 uint32_t vecSize) {
412
413 return CreateElement((RsDataType) dt, (RsDataKind) dk, isNormalized,
414 vecSize);
415 }
416
rsCreateType(::rs_element element,uint32_t dimX,uint32_t dimY,uint32_t dimZ,bool mipmaps,bool faces,rs_yuv_format yuv_format)417 android::renderscript::rs_type rsCreateType(::rs_element element, uint32_t dimX,
418 uint32_t dimY, uint32_t dimZ,
419 bool mipmaps, bool faces,
420 rs_yuv_format yuv_format) {
421 return CreateType((RsElement) element.p, dimX, dimY, dimZ, mipmaps, faces,
422 yuv_format);
423 }
424
rsCreateAllocation(::rs_type type,rs_allocation_mipmap_control mipmaps,uint32_t usages,void * ptr)425 android::renderscript::rs_allocation rsCreateAllocation(
426 ::rs_type type, rs_allocation_mipmap_control mipmaps, uint32_t usages,
427 void *ptr) {
428
429 return CreateAllocation((RsType) type.p,
430 (RsAllocationMipmapControl) mipmaps,
431 usages, ptr);
432 }
433 #endif
434
435 //////////////////////////////////////////////////////////////////////////////
436 // Object routines
437 //////////////////////////////////////////////////////////////////////////////
438 // Add NOLINT to suppress wrong warnings from clang-tidy.
439 #define IS_CLEAR_SET_OBJ(t) \
440 bool rsIsObject(t src) { \
441 return src.p != nullptr; \
442 } \
443 void __attribute__((overloadable)) rsClearObject(t *dst) { /*NOLINT*/ \
444 rsrClearObject(reinterpret_cast<rs_object_base *>(dst)); \
445 } \
446 void __attribute__((overloadable)) rsSetObject(t *dst, t src) { /*NOLINT*/ \
447 Context *rsc = RsdCpuReference::getTlsContext(); \
448 rsrSetObject(rsc, reinterpret_cast<rs_object_base *>(dst), (ObjectBase*)src.p); \
449 }
450
451 IS_CLEAR_SET_OBJ(::rs_element)
IS_CLEAR_SET_OBJ(::rs_type)452 IS_CLEAR_SET_OBJ(::rs_type)
453 IS_CLEAR_SET_OBJ(::rs_allocation)
454 IS_CLEAR_SET_OBJ(::rs_sampler)
455 IS_CLEAR_SET_OBJ(::rs_script)
456
457 IS_CLEAR_SET_OBJ(::rs_mesh)
458 IS_CLEAR_SET_OBJ(::rs_program_fragment)
459 IS_CLEAR_SET_OBJ(::rs_program_vertex)
460 IS_CLEAR_SET_OBJ(::rs_program_raster)
461 IS_CLEAR_SET_OBJ(::rs_program_store)
462 IS_CLEAR_SET_OBJ(::rs_font)
463
464 #undef IS_CLEAR_SET_OBJ
465
466 //////////////////////////////////////////////////////////////////////////////
467 // Element routines
468 //////////////////////////////////////////////////////////////////////////////
469 static void * ElementAt(Allocation *a, RsDataType dt, uint32_t vecSize,
470 uint32_t x, uint32_t y, uint32_t z) {
471 Context *rsc = RsdCpuReference::getTlsContext();
472 const Type *t = a->getType();
473 const Element *e = t->getElement();
474
475 char buf[256];
476 if (x && (x >= t->getLODDimX(0))) {
477 snprintf(buf, sizeof(buf), "Out range ElementAt X %i of %i", x, t->getLODDimX(0));
478 rsc->setError(RS_ERROR_FATAL_DEBUG, buf);
479 return nullptr;
480 }
481
482 if (y && (y >= t->getLODDimY(0))) {
483 snprintf(buf, sizeof(buf), "Out range ElementAt Y %i of %i", y, t->getLODDimY(0));
484 rsc->setError(RS_ERROR_FATAL_DEBUG, buf);
485 return nullptr;
486 }
487
488 if (z && (z >= t->getLODDimZ(0))) {
489 snprintf(buf, sizeof(buf), "Out range ElementAt Z %i of %i", z, t->getLODDimZ(0));
490 rsc->setError(RS_ERROR_FATAL_DEBUG, buf);
491 return nullptr;
492 }
493
494 if (vecSize > 0) {
495 if (vecSize != e->getVectorSize()) {
496 snprintf(buf, sizeof(buf), "Vector size mismatch for ElementAt %i of %i", vecSize, e->getVectorSize());
497 rsc->setError(RS_ERROR_FATAL_DEBUG, buf);
498 return nullptr;
499 }
500
501 if (dt != e->getType()) {
502 snprintf(buf, sizeof(buf), "Data type mismatch for ElementAt %i of %i", dt, e->getType());
503 rsc->setError(RS_ERROR_FATAL_DEBUG, buf);
504 return nullptr;
505 }
506 }
507
508 uint8_t *p = (uint8_t *)a->mHal.drvState.lod[0].mallocPtr;
509 const uint32_t eSize = e->getSizeBytes();
510 const uint32_t stride = a->mHal.drvState.lod[0].stride;
511 const uint32_t dimY = a->mHal.drvState.lod[0].dimY;
512 return &p[(x * eSize) + (y * stride) + (z * stride * dimY)];
513 }
514
rsSetElementAt(::rs_allocation a,const void * ptr,uint32_t x,uint32_t y,uint32_t z)515 void rsSetElementAt(::rs_allocation a, const void *ptr, uint32_t x, uint32_t y, uint32_t z) {
516 const Type *t = const_cast<Allocation*>((Allocation*)a.p)->getType();
517 const Element *e = t->getElement();
518 void *tmp = ElementAt((Allocation *)a.p, RS_TYPE_UNSIGNED_8, 0, x, y, z);
519 if (tmp != nullptr)
520 memcpy(tmp, ptr, e->getSizeBytes());
521 }
522
rsSetElementAt(::rs_allocation a,const void * ptr,uint32_t x,uint32_t y)523 void rsSetElementAt(::rs_allocation a, const void *ptr, uint32_t x, uint32_t y) {
524 rsSetElementAt(a, ptr, x, y, 0);
525 }
526
rsSetElementAt(::rs_allocation a,const void * ptr,uint32_t x)527 void rsSetElementAt(::rs_allocation a, const void *ptr, uint32_t x) {
528 rsSetElementAt(a, ptr, x, 0, 0);
529 }
530
rsGetElementAt(::rs_allocation a,uint32_t x,uint32_t y,uint32_t z)531 const void *rsGetElementAt(::rs_allocation a, uint32_t x, uint32_t y, uint32_t z) {
532 return ElementAt((Allocation *)a.p, RS_TYPE_UNSIGNED_8, 0, x, y, z);
533 }
534
rsGetElementAt(::rs_allocation a,uint32_t x,uint32_t y)535 const void *rsGetElementAt(::rs_allocation a, uint32_t x, uint32_t y) {
536 return rsGetElementAt(a, x, y ,0);
537 }
538
rsGetElementAt(::rs_allocation a,uint32_t x)539 const void *rsGetElementAt(::rs_allocation a, uint32_t x) {
540 return rsGetElementAt(a, x, 0, 0);
541 }
542
543 // Add NOLINT to suppress wrong warnings from clang-tidy.
544 #define ELEMENT_AT(T, DT, VS) \
545 void rsSetElementAt_##T(::rs_allocation a, const T *val, uint32_t x, uint32_t y, uint32_t z) { \
546 void *r = ElementAt((Allocation *)a.p, DT, VS, x, y, z); \
547 if (r != nullptr) ((T *)r)[0] = *val; \
548 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \
549 } \
550 void rsSetElementAt_##T(::rs_allocation a, const T *val, uint32_t x, uint32_t y) { \
551 rsSetElementAt_##T(a, val, x, y, 0); \
552 } \
553 void rsSetElementAt_##T(::rs_allocation a, const T *val, uint32_t x) { \
554 rsSetElementAt_##T(a, val, x, 0, 0); \
555 } \
556 void rsGetElementAt_##T(::rs_allocation a, T *val, uint32_t x, uint32_t y, uint32_t z) { /*NOLINT*/ \
557 void *r = ElementAt((Allocation *)a.p, DT, VS, x, y, z); \
558 if (r != nullptr) *val = ((T *)r)[0]; \
559 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \
560 } \
561 void rsGetElementAt_##T(::rs_allocation a, T *val, uint32_t x, uint32_t y) { /*NOLINT*/ \
562 rsGetElementAt_##T(a, val, x, y, 0); \
563 } \
564 void rsGetElementAt_##T(::rs_allocation a, T *val, uint32_t x) { /*NOLINT*/ \
565 rsGetElementAt_##T(a, val, x, 0, 0); \
566 }
567
568 ELEMENT_AT(char, RS_TYPE_SIGNED_8, 1)
569 ELEMENT_AT(char2, RS_TYPE_SIGNED_8, 2)
570 ELEMENT_AT(char3, RS_TYPE_SIGNED_8, 3)
571 ELEMENT_AT(char4, RS_TYPE_SIGNED_8, 4)
572 ELEMENT_AT(uchar, RS_TYPE_UNSIGNED_8, 1)
573 ELEMENT_AT(uchar2, RS_TYPE_UNSIGNED_8, 2)
574 ELEMENT_AT(uchar3, RS_TYPE_UNSIGNED_8, 3)
575 ELEMENT_AT(uchar4, RS_TYPE_UNSIGNED_8, 4)
576 ELEMENT_AT(short, RS_TYPE_SIGNED_16, 1)
577 ELEMENT_AT(short2, RS_TYPE_SIGNED_16, 2)
578 ELEMENT_AT(short3, RS_TYPE_SIGNED_16, 3)
579 ELEMENT_AT(short4, RS_TYPE_SIGNED_16, 4)
580 ELEMENT_AT(ushort, RS_TYPE_UNSIGNED_16, 1)
581 ELEMENT_AT(ushort2, RS_TYPE_UNSIGNED_16, 2)
582 ELEMENT_AT(ushort3, RS_TYPE_UNSIGNED_16, 3)
583 ELEMENT_AT(ushort4, RS_TYPE_UNSIGNED_16, 4)
584 ELEMENT_AT(int, RS_TYPE_SIGNED_32, 1)
585 ELEMENT_AT(int2, RS_TYPE_SIGNED_32, 2)
586 ELEMENT_AT(int3, RS_TYPE_SIGNED_32, 3)
587 ELEMENT_AT(int4, RS_TYPE_SIGNED_32, 4)
588 ELEMENT_AT(uint, RS_TYPE_UNSIGNED_32, 1)
589 ELEMENT_AT(uint2, RS_TYPE_UNSIGNED_32, 2)
590 ELEMENT_AT(uint3, RS_TYPE_UNSIGNED_32, 3)
591 ELEMENT_AT(uint4, RS_TYPE_UNSIGNED_32, 4)
592 #ifdef __LP64__
593 ELEMENT_AT(long, RS_TYPE_SIGNED_64, 1)
594 #else
595 /* the long versions need special treatment; the long * argument has to be
596 * kept so the signatures match, but the actual accesses have to be done in
597 * int64_t * to be consistent with the script ABI.
598 */
599 void rsSetElementAt_long(::rs_allocation a, const long *val, uint32_t x, uint32_t y, uint32_t z) {
600 void *r = ElementAt((Allocation *)a.p, RS_TYPE_SIGNED_64, 1, x, y, z);
601 if (r != nullptr) ((int64_t *)r)[0] = *((int64_t *)val);
602 else ALOGE("Error from %s", __PRETTY_FUNCTION__);
603 }
604 void rsSetElementAt_long(::rs_allocation a, const long *val, uint32_t x, uint32_t y) {
605 rsSetElementAt_long(a, val, x, y, 0);
606 }
607 void rsSetElementAt_long(::rs_allocation a, const long *val, uint32_t x) {
608 rsSetElementAt_long(a, val, x, 0, 0);
609 }
610 void rsGetElementAt_long(::rs_allocation a, long *val, uint32_t x, uint32_t y, uint32_t z) { /*NOLINT*/
611 void *r = ElementAt((Allocation *)a.p, RS_TYPE_SIGNED_64, 1, x, y, z);
612 if (r != nullptr) *((int64_t*)val) = ((int64_t *)r)[0];
613 else ALOGE("Error from %s", __PRETTY_FUNCTION__);
614 }
615 void rsGetElementAt_long(::rs_allocation a, long *val, uint32_t x, uint32_t y) { /*NOLINT*/
616 rsGetElementAt_long(a, val, x, y, 0);
617 }
618 void rsGetElementAt_long(::rs_allocation a, long *val, uint32_t x) { /*NOLINT*/
619 rsGetElementAt_long(a, val, x, 0, 0);
620 }
621 #endif
622 ELEMENT_AT(long2, RS_TYPE_SIGNED_64, 2)
623 ELEMENT_AT(long3, RS_TYPE_SIGNED_64, 3)
624 ELEMENT_AT(long4, RS_TYPE_SIGNED_64, 4)
625 ELEMENT_AT(ulong, RS_TYPE_UNSIGNED_64, 1)
626 ELEMENT_AT(ulong2, RS_TYPE_UNSIGNED_64, 2)
627 ELEMENT_AT(ulong3, RS_TYPE_UNSIGNED_64, 3)
628 ELEMENT_AT(ulong4, RS_TYPE_UNSIGNED_64, 4)
629 ELEMENT_AT(half, RS_TYPE_FLOAT_16, 1)
630 ELEMENT_AT(half2, RS_TYPE_FLOAT_16, 2)
631 ELEMENT_AT(half3, RS_TYPE_FLOAT_16, 3)
632 ELEMENT_AT(half4, RS_TYPE_FLOAT_16, 4)
633 ELEMENT_AT(float, RS_TYPE_FLOAT_32, 1)
634 ELEMENT_AT(float2, RS_TYPE_FLOAT_32, 2)
635 ELEMENT_AT(float3, RS_TYPE_FLOAT_32, 3)
636 ELEMENT_AT(float4, RS_TYPE_FLOAT_32, 4)
637 ELEMENT_AT(double, RS_TYPE_FLOAT_64, 1)
638 ELEMENT_AT(double2, RS_TYPE_FLOAT_64, 2)
639 ELEMENT_AT(double3, RS_TYPE_FLOAT_64, 3)
640 ELEMENT_AT(double4, RS_TYPE_FLOAT_64, 4)
641
642 #undef ELEMENT_AT
643
644 #ifndef __LP64__
645 /*
646 * We miss some symbols for rs{Get,Set}Element_long,ulong variants because 64
647 * bit integer values are 'long' in RS-land but might be 'long long' in the
648 * driver. Define native_long* and native_ulong* types to be vectors of
649 * 'long' as seen by the driver and define overloaded versions of
650 * rsSetElementAt_* and rsGetElementAt_*. This should get us the correct
651 * mangled names in the driver.
652 */
653
654 typedef long native_long2 __attribute__((ext_vector_type(2)));
655 typedef long native_long3 __attribute__((ext_vector_type(3)));
656 typedef long native_long4 __attribute__((ext_vector_type(4)));
657 typedef unsigned long native_ulong2 __attribute__((ext_vector_type(2)));
658 typedef unsigned long native_ulong3 __attribute__((ext_vector_type(3)));
659 typedef unsigned long native_ulong4 __attribute__((ext_vector_type(4)));
660
661 // Add NOLINT to suppress wrong warnings from clang-tidy.
662 #define ELEMENT_AT_OVERLOADS(T, U) \
663 void rsSetElementAt_##T(::rs_allocation a, const U *val, uint32_t x, uint32_t y, uint32_t z) { \
664 rsSetElementAt_##T(a, (T *) val, x, y, z); \
665 } \
666 void rsSetElementAt_##T(::rs_allocation a, const U *val, uint32_t x, uint32_t y) { \
667 rsSetElementAt_##T(a, (T *) val, x, y, 0); \
668 } \
669 void rsSetElementAt_##T(::rs_allocation a, const U *val, uint32_t x) { \
670 rsSetElementAt_##T(a, (T *) val, x, 0, 0); \
671 } \
672 void rsGetElementAt_##T(::rs_allocation a, U *val, uint32_t x, uint32_t y, uint32_t z) { /*NOLINT*/ \
673 rsGetElementAt_##T(a, (T *) val, x, y, z); \
674 } \
675 void rsGetElementAt_##T(::rs_allocation a, U *val, uint32_t x, uint32_t y) { /*NOLINT*/ \
676 rsGetElementAt_##T(a, (T *) val, x, y, 0); \
677 } \
678 void rsGetElementAt_##T(::rs_allocation a, U *val, uint32_t x) { /*NOLINT*/ \
679 rsGetElementAt_##T(a, (T *) val, x, 0, 0); \
680 } \
681
ELEMENT_AT_OVERLOADS(long2,native_long2)682 ELEMENT_AT_OVERLOADS(long2, native_long2)
683 ELEMENT_AT_OVERLOADS(long3, native_long3)
684 ELEMENT_AT_OVERLOADS(long4, native_long4)
685 ELEMENT_AT_OVERLOADS(ulong, unsigned long)
686 ELEMENT_AT_OVERLOADS(ulong2, native_ulong2)
687 ELEMENT_AT_OVERLOADS(ulong3, native_ulong3)
688 ELEMENT_AT_OVERLOADS(ulong4, native_ulong4)
689
690 // We also need variants of rs{Get,Set}ElementAt_long that take 'long long *' as
691 // we might have this overloaded variant in old APKs.
692 ELEMENT_AT_OVERLOADS(long, long long)
693
694 #undef ELEMENT_AT_OVERLOADS
695 #endif
696
697 //////////////////////////////////////////////////////////////////////////////
698 // ForEach routines
699 //////////////////////////////////////////////////////////////////////////////
700 void rsForEachInternal(int slot,
701 rs_script_call *options,
702 int hasOutput,
703 int numInputs,
704 ::rs_allocation* allocs) {
705 Context *rsc = RsdCpuReference::getTlsContext();
706 Script *s = const_cast<Script*>(RsdCpuReference::getTlsScript());
707 if (numInputs > RS_KERNEL_MAX_ARGUMENTS) {
708 rsc->setError(RS_ERROR_BAD_SCRIPT,
709 "rsForEachInternal: too many inputs to a kernel.");
710 return;
711 }
712 Allocation* inputs[RS_KERNEL_MAX_ARGUMENTS];
713 for (int i = 0; i < numInputs; i++) {
714 inputs[i] = (Allocation*)allocs[i].p;
715 CHECK_OBJ(inputs[i]);
716 inputs[i]->incSysRef();
717 }
718 Allocation* out = nullptr;
719 if (hasOutput) {
720 out = (Allocation*)allocs[numInputs].p;
721 CHECK_OBJ(out);
722 out->incSysRef();
723 }
724 rsrForEach(rsc, s, slot, numInputs, numInputs > 0 ? inputs : nullptr, out,
725 nullptr, 0, (RsScriptCall*)options);
726 for (int i = 0; i < numInputs; i++) {
727 inputs[i]->decSysRef();
728 }
729 if (hasOutput) {
730 out->decSysRef();
731 }
732 }
733
rsForEach(::rs_script script,::rs_allocation in,::rs_allocation out,const void * usr,const rs_script_call * call)734 void __attribute__((overloadable)) rsForEach(::rs_script script,
735 ::rs_allocation in,
736 ::rs_allocation out,
737 const void *usr,
738 const rs_script_call *call) {
739 Context *rsc = RsdCpuReference::getTlsContext();
740 rsrForEach(rsc, (Script *)script.p, 0, 1, (Allocation **)&in.p,
741 (Allocation *)out.p, usr, 0, (RsScriptCall *)call);
742 }
743
rsForEach(::rs_script script,::rs_allocation in,::rs_allocation out,const void * usr)744 void __attribute__((overloadable)) rsForEach(::rs_script script,
745 ::rs_allocation in,
746 ::rs_allocation out,
747 const void *usr) {
748 Context *rsc = RsdCpuReference::getTlsContext();
749 rsrForEach(rsc, (Script *)script.p, 0, 1, (Allocation **)&in.p, (Allocation *)out.p,
750 usr, 0, nullptr);
751 }
752
rsForEach(::rs_script script,::rs_allocation in,::rs_allocation out)753 void __attribute__((overloadable)) rsForEach(::rs_script script,
754 ::rs_allocation in,
755 ::rs_allocation out) {
756 Context *rsc = RsdCpuReference::getTlsContext();
757 rsrForEach(rsc, (Script *)script.p, 0, 1, (Allocation **)&in.p, (Allocation *)out.p,
758 nullptr, 0, nullptr);
759 }
760
761 // These functions are only supported in 32-bit.
762 #ifndef __LP64__
rsForEach(::rs_script script,::rs_allocation in,::rs_allocation out,const void * usr,uint32_t usrLen)763 void __attribute__((overloadable)) rsForEach(::rs_script script,
764 ::rs_allocation in,
765 ::rs_allocation out,
766 const void *usr,
767 uint32_t usrLen) {
768 Context *rsc = RsdCpuReference::getTlsContext();
769 rsrForEach(rsc, (Script *)script.p, 0, 1, (Allocation **)&in.p, (Allocation *)out.p,
770 usr, usrLen, nullptr);
771 }
772
rsForEach(::rs_script script,::rs_allocation in,::rs_allocation out,const void * usr,uint32_t usrLen,const rs_script_call * call)773 void __attribute__((overloadable)) rsForEach(::rs_script script,
774 ::rs_allocation in,
775 ::rs_allocation out,
776 const void *usr,
777 uint32_t usrLen,
778 const rs_script_call *call) {
779 Context *rsc = RsdCpuReference::getTlsContext();
780 rsrForEach(rsc, (Script *)script.p, 0, 1, (Allocation **)&in.p, (Allocation *)out.p,
781 usr, usrLen, (RsScriptCall *)call);
782 }
783 #endif
784
785 //////////////////////////////////////////////////////////////////////////////
786 // Message routines
787 //////////////////////////////////////////////////////////////////////////////
rsSendToClient(int cmdID)788 uint32_t rsSendToClient(int cmdID) {
789 Context *rsc = RsdCpuReference::getTlsContext();
790 return rsrToClient(rsc, cmdID, (const void *)nullptr, 0);
791 }
792
rsSendToClient(int cmdID,const void * data,uint32_t len)793 uint32_t rsSendToClient(int cmdID, const void *data, uint32_t len) {
794 Context *rsc = RsdCpuReference::getTlsContext();
795 return rsrToClient(rsc, cmdID, data, len);
796 }
797
rsSendToClientBlocking(int cmdID)798 uint32_t rsSendToClientBlocking(int cmdID) {
799 Context *rsc = RsdCpuReference::getTlsContext();
800 return rsrToClientBlocking(rsc, cmdID, (const void *)nullptr, 0);
801 }
802
rsSendToClientBlocking(int cmdID,const void * data,uint32_t len)803 uint32_t rsSendToClientBlocking(int cmdID, const void *data, uint32_t len) {
804 Context *rsc = RsdCpuReference::getTlsContext();
805 return rsrToClientBlocking(rsc, cmdID, data, len);
806 }
807
808 //////////////////////////////////////////////////////////////////////////////
809 // Time routines
810 //////////////////////////////////////////////////////////////////////////////
811
812 // time_t is int in 32-bit RenderScript. time_t is long in bionic. rsTime and
813 // rsLocaltime are set to explicitly take 'const int *' so we generate the
814 // correct mangled names.
815 #ifndef __LP64__
rsTime(int * timer)816 int rsTime(int *timer) {
817 #else
818 time_t rsTime(time_t * timer) {
819 #endif
820 Context *rsc = RsdCpuReference::getTlsContext();
821 return rsrTime(rsc, (time_t *)timer);
822 }
823
824 #ifndef __LP64__
825 rs_tm* rsLocaltime(rs_tm* local, const int *timer) {
826 #else
827 rs_tm* rsLocaltime(rs_tm* local, const time_t *timer) {
828 #endif
829 Context *rsc = RsdCpuReference::getTlsContext();
830 return (rs_tm*)rsrLocalTime(rsc, (tm*)local, (time_t *)timer);
831 }
832
833 int64_t rsUptimeMillis() {
834 Context *rsc = RsdCpuReference::getTlsContext();
835 return rsrUptimeMillis(rsc);
836 }
837
838 int64_t rsUptimeNanos() {
839 Context *rsc = RsdCpuReference::getTlsContext();
840 return rsrUptimeNanos(rsc);
841 }
842
843 float rsGetDt() {
844 Context *rsc = RsdCpuReference::getTlsContext();
845 const Script *sc = RsdCpuReference::getTlsScript();
846 return rsrGetDt(rsc, sc);
847 }
848
849 //////////////////////////////////////////////////////////////////////////////
850 // Graphics routines
851 //////////////////////////////////////////////////////////////////////////////
852 #if !defined(RS_VENDOR_LIB) && !defined(RS_COMPATIBILITY_LIB)
853 static void SC_DrawQuadTexCoords(float x1, float y1, float z1, float u1, float v1,
854 float x2, float y2, float z2, float u2, float v2,
855 float x3, float y3, float z3, float u3, float v3,
856 float x4, float y4, float z4, float u4, float v4) {
857 Context *rsc = RsdCpuReference::getTlsContext();
858
859 if (!rsc->setupCheck()) {
860 return;
861 }
862
863 RsdHal *dc = (RsdHal *)rsc->mHal.drv;
864 if (!dc->gl.shaderCache->setup(rsc)) {
865 return;
866 }
867
868 //ALOGE("Quad");
869 //ALOGE("%4.2f, %4.2f, %4.2f", x1, y1, z1);
870 //ALOGE("%4.2f, %4.2f, %4.2f", x2, y2, z2);
871 //ALOGE("%4.2f, %4.2f, %4.2f", x3, y3, z3);
872 //ALOGE("%4.2f, %4.2f, %4.2f", x4, y4, z4);
873
874 float vtx[] = {x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4};
875 const float tex[] = {u1,v1, u2,v2, u3,v3, u4,v4};
876
877 RsdVertexArray::Attrib attribs[2];
878 attribs[0].set(GL_FLOAT, 3, 12, false, (size_t)vtx, "ATTRIB_position");
879 attribs[1].set(GL_FLOAT, 2, 8, false, (size_t)tex, "ATTRIB_texture0");
880
881 RsdVertexArray va(attribs, 2);
882 va.setup(rsc);
883
884 RSD_CALL_GL(glDrawArrays, GL_TRIANGLE_FAN, 0, 4);
885 }
886
887 static void SC_DrawQuad(float x1, float y1, float z1,
888 float x2, float y2, float z2,
889 float x3, float y3, float z3,
890 float x4, float y4, float z4) {
891 SC_DrawQuadTexCoords(x1, y1, z1, 0, 1,
892 x2, y2, z2, 1, 1,
893 x3, y3, z3, 1, 0,
894 x4, y4, z4, 0, 0);
895 }
896
897 static void SC_DrawSpriteScreenspace(float x, float y, float z, float w, float h) {
898 Context *rsc = RsdCpuReference::getTlsContext();
899
900 ObjectBaseRef<const ProgramVertex> tmp(rsc->getProgramVertex());
901 rsc->setProgramVertex(rsc->getDefaultProgramVertex());
902 //rsc->setupCheck();
903
904 //GLint crop[4] = {0, h, w, -h};
905
906 float sh = rsc->getHeight();
907
908 SC_DrawQuad(x, sh - y, z,
909 x+w, sh - y, z,
910 x+w, sh - (y+h), z,
911 x, sh - (y+h), z);
912 rsc->setProgramVertex((ProgramVertex *)tmp.get());
913 }
914
915 void rsAllocationMarkDirty(::rs_allocation a) {
916 Context *rsc = RsdCpuReference::getTlsContext();
917 rsrAllocationSyncAll(rsc, (Allocation *)a.p, RS_ALLOCATION_USAGE_SCRIPT);
918 }
919
920 void rsgAllocationSyncAll(::rs_allocation a) {
921 Context *rsc = RsdCpuReference::getTlsContext();
922 rsrAllocationSyncAll(rsc, (Allocation *)a.p, RS_ALLOCATION_USAGE_SCRIPT);
923 }
924
925 void rsgAllocationSyncAll(::rs_allocation a,
926 unsigned int usage) {
927 Context *rsc = RsdCpuReference::getTlsContext();
928 rsrAllocationSyncAll(rsc, (Allocation *)a.p, (RsAllocationUsageType)usage);
929 }
930
931
932 void rsgAllocationSyncAll(::rs_allocation a,
933 rs_allocation_usage_type source) {
934 Context *rsc = RsdCpuReference::getTlsContext();
935 rsrAllocationSyncAll(rsc, (Allocation *)a.p, (RsAllocationUsageType)source.val);
936 }
937
938 void rsgBindProgramFragment(::rs_program_fragment pf) {
939 Context *rsc = RsdCpuReference::getTlsContext();
940 rsrBindProgramFragment(rsc, (ProgramFragment *)pf.p);
941 }
942
943 void rsgBindProgramStore(::rs_program_store ps) {
944 Context *rsc = RsdCpuReference::getTlsContext();
945 rsrBindProgramStore(rsc, (ProgramStore *)ps.p);
946 }
947
948 void rsgBindProgramVertex(::rs_program_vertex pv) {
949 Context *rsc = RsdCpuReference::getTlsContext();
950 rsrBindProgramVertex(rsc, (ProgramVertex *)pv.p);
951 }
952
953 void rsgBindProgramRaster(::rs_program_raster pr) {
954 Context *rsc = RsdCpuReference::getTlsContext();
955 rsrBindProgramRaster(rsc, (ProgramRaster *)pr.p);
956 }
957
958 void rsgBindSampler(::rs_program_fragment pf,
959 uint32_t slot, ::rs_sampler s) {
960 Context *rsc = RsdCpuReference::getTlsContext();
961 rsrBindSampler(rsc, (ProgramFragment *)pf.p, slot, (Sampler *)s.p);
962 }
963
964 void rsgBindTexture(::rs_program_fragment pf,
965 uint32_t slot, ::rs_allocation a) {
966 Context *rsc = RsdCpuReference::getTlsContext();
967 rsrBindTexture(rsc, (ProgramFragment *)pf.p, slot, (Allocation *)a.p);
968 }
969
970 void rsgBindConstant(::rs_program_fragment pf,
971 uint32_t slot, ::rs_allocation a) {
972 Context *rsc = RsdCpuReference::getTlsContext();
973 rsrBindConstant(rsc, (ProgramFragment *)pf.p, slot, (Allocation *)a.p);
974 }
975
976 void rsgBindConstant(::rs_program_vertex pv,
977 uint32_t slot, ::rs_allocation a) {
978 Context *rsc = RsdCpuReference::getTlsContext();
979 rsrBindConstant(rsc, (ProgramVertex *)pv.p, slot, (Allocation *)a.p);
980 }
981
982 void rsgProgramVertexLoadProjectionMatrix(const rs_matrix4x4 *m) {
983 Context *rsc = RsdCpuReference::getTlsContext();
984 rsrVpLoadProjectionMatrix(rsc, (const rsc_Matrix *)m);
985 }
986
987 void rsgProgramVertexLoadModelMatrix(const rs_matrix4x4 *m) {
988 Context *rsc = RsdCpuReference::getTlsContext();
989 rsrVpLoadModelMatrix(rsc, (const rsc_Matrix *)m);
990 }
991
992 void rsgProgramVertexLoadTextureMatrix(const rs_matrix4x4 *m) {
993 Context *rsc = RsdCpuReference::getTlsContext();
994 rsrVpLoadTextureMatrix(rsc, (const rsc_Matrix *)m);
995 }
996
997 void rsgProgramVertexGetProjectionMatrix(rs_matrix4x4 *m) {
998 Context *rsc = RsdCpuReference::getTlsContext();
999 rsrVpGetProjectionMatrix(rsc, (rsc_Matrix *)m);
1000 }
1001
1002 void rsgProgramFragmentConstantColor(::rs_program_fragment pf,
1003 float r, float g, float b, float a) {
1004 Context *rsc = RsdCpuReference::getTlsContext();
1005 rsrPfConstantColor(rsc, (ProgramFragment *)pf.p, r, g, b, a);
1006 }
1007
1008 uint32_t rsgGetWidth(void) {
1009 Context *rsc = RsdCpuReference::getTlsContext();
1010 return rsrGetWidth(rsc);
1011 }
1012
1013 uint32_t rsgGetHeight(void) {
1014 Context *rsc = RsdCpuReference::getTlsContext();
1015 return rsrGetHeight(rsc);
1016 }
1017
1018 void rsgDrawRect(float x1, float y1, float x2, float y2, float z) {
1019 SC_DrawQuad(x1, y2, z,
1020 x2, y2, z,
1021 x2, y1, z,
1022 x1, y1, z);
1023 }
1024
1025 void rsgDrawQuad(float x1, float y1, float z1,
1026 float x2, float y2, float z2,
1027 float x3, float y3, float z3,
1028 float x4, float y4, float z4) {
1029 SC_DrawQuad(x1, y1, z1,
1030 x2, y2, z2,
1031 x3, y3, z3,
1032 x4, y4, z4);
1033 }
1034
1035 void rsgDrawQuadTexCoords(float x1, float y1, float z1, float u1, float v1,
1036 float x2, float y2, float z2, float u2, float v2,
1037 float x3, float y3, float z3, float u3, float v3,
1038 float x4, float y4, float z4, float u4, float v4) {
1039 SC_DrawQuadTexCoords(x1, y1, z1, u1, v1,
1040 x2, y2, z2, u2, v2,
1041 x3, y3, z3, u3, v3,
1042 x4, y4, z4, u4, v4);
1043 }
1044
1045 void rsgDrawSpriteScreenspace(float x, float y, float z, float w, float h) {
1046 SC_DrawSpriteScreenspace(x, y, z, w, h);
1047 }
1048
1049 void rsgDrawMesh(::rs_mesh ism) {
1050 Context *rsc = RsdCpuReference::getTlsContext();
1051 rsrDrawMesh(rsc, (Mesh *)ism.p);
1052 }
1053
1054 void rsgDrawMesh(::rs_mesh ism, uint primitiveIndex) {
1055 Context *rsc = RsdCpuReference::getTlsContext();
1056 rsrDrawMeshPrimitive(rsc, (Mesh *)ism.p, primitiveIndex);
1057 }
1058
1059 void rsgDrawMesh(::rs_mesh ism, uint primitiveIndex, uint start, uint len) {
1060 Context *rsc = RsdCpuReference::getTlsContext();
1061 rsrDrawMeshPrimitiveRange(rsc, (Mesh *)ism.p, primitiveIndex, start, len);
1062 }
1063
1064 void rsgMeshComputeBoundingBox(::rs_mesh mesh,
1065 float *minX, float *minY, float *minZ,
1066 float *maxX, float *maxY, float *maxZ) {
1067 Context *rsc = RsdCpuReference::getTlsContext();
1068 rsrMeshComputeBoundingBox(rsc, (Mesh *)mesh.p, minX, minY, minZ, maxX, maxY, maxZ);
1069 }
1070
1071 void rsgClearColor(float r, float g, float b, float a) {
1072 Context *rsc = RsdCpuReference::getTlsContext();
1073 rsrPrepareClear(rsc);
1074 rsdGLClearColor(rsc, r, g, b, a);
1075 }
1076
1077 void rsgClearDepth(float value) {
1078 Context *rsc = RsdCpuReference::getTlsContext();
1079 rsrPrepareClear(rsc);
1080 rsdGLClearDepth(rsc, value);
1081 }
1082
1083 void rsgDrawText(const char *text, int x, int y) {
1084 Context *rsc = RsdCpuReference::getTlsContext();
1085 rsrDrawText(rsc, text, x, y);
1086 }
1087
1088 void rsgDrawText(::rs_allocation a, int x, int y) {
1089 Context *rsc = RsdCpuReference::getTlsContext();
1090 rsrDrawTextAlloc(rsc, (Allocation *)a.p, x, y);
1091 }
1092
1093 void rsgMeasureText(const char *text, int *left, int *right,
1094 int *top, int *bottom) {
1095 Context *rsc = RsdCpuReference::getTlsContext();
1096 rsrMeasureText(rsc, text, left, right, top, bottom);
1097 }
1098
1099 void rsgMeasureText(::rs_allocation a, int *left, int *right,
1100 int *top, int *bottom) {
1101 Context *rsc = RsdCpuReference::getTlsContext();
1102 rsrMeasureTextAlloc(rsc, (Allocation *)a.p, left, right, top, bottom);
1103 }
1104
1105 void rsgBindFont(::rs_font font) {
1106 Context *rsc = RsdCpuReference::getTlsContext();
1107 rsrBindFont(rsc, (Font *)font.p);
1108 }
1109
1110 void rsgFontColor(float r, float g, float b, float a) {
1111 Context *rsc = RsdCpuReference::getTlsContext();
1112 rsrFontColor(rsc, r, g, b, a);
1113 }
1114
1115 void rsgBindColorTarget(::rs_allocation a, uint slot) {
1116 Context *rsc = RsdCpuReference::getTlsContext();
1117 rsrBindFrameBufferObjectColorTarget(rsc, (Allocation *)a.p, slot);
1118 }
1119
1120 void rsgBindDepthTarget(::rs_allocation a) {
1121 Context *rsc = RsdCpuReference::getTlsContext();
1122 rsrBindFrameBufferObjectDepthTarget(rsc, (Allocation *)a.p);
1123 }
1124
1125 void rsgClearColorTarget(uint slot) {
1126 Context *rsc = RsdCpuReference::getTlsContext();
1127 rsrClearFrameBufferObjectColorTarget(rsc, slot);
1128 }
1129
1130 void rsgClearDepthTarget(void) {
1131 Context *rsc = RsdCpuReference::getTlsContext();
1132 rsrClearFrameBufferObjectDepthTarget(rsc);
1133 }
1134
1135 void rsgClearAllRenderTargets(void) {
1136 Context *rsc = RsdCpuReference::getTlsContext();
1137 rsrClearFrameBufferObjectTargets(rsc);
1138 }
1139
1140 void color(float r, float g, float b, float a) {
1141 Context *rsc = RsdCpuReference::getTlsContext();
1142 rsrColor(rsc, r, g, b, a);
1143 }
1144
1145 void rsgFinish(void) {
1146 Context *rsc = RsdCpuReference::getTlsContext();
1147 rsdGLFinish(rsc);
1148 }
1149 #endif
1150
1151 //////////////////////////////////////////////////////////////////////////////
1152 // Debug routines
1153 //////////////////////////////////////////////////////////////////////////////
1154 void rsDebug(const char *s, float f) {
1155 ALOGD("%s %f, 0x%08x", s, f, *((int *) (&f)));
1156 }
1157
1158 void rsDebug(const char *s, float f1, float f2) {
1159 ALOGD("%s {%f, %f}", s, f1, f2);
1160 }
1161
1162 void rsDebug(const char *s, float f1, float f2, float f3) {
1163 ALOGD("%s {%f, %f, %f}", s, f1, f2, f3);
1164 }
1165
1166 void rsDebug(const char *s, float f1, float f2, float f3, float f4) {
1167 ALOGD("%s {%f, %f, %f, %f}", s, f1, f2, f3, f4);
1168 }
1169
1170 void rsDebug(const char *s, const float2 *f2) {
1171 float2 f = *f2;
1172 ALOGD("%s {%f, %f}", s, f.x, f.y);
1173 }
1174
1175 void rsDebug(const char *s, const float3 *f3) {
1176 float3 f = *f3;
1177 ALOGD("%s {%f, %f, %f}", s, f.x, f.y, f.z);
1178 }
1179
1180 void rsDebug(const char *s, const float4 *f4) {
1181 float4 f = *f4;
1182 ALOGD("%s {%f, %f, %f, %f}", s, f.x, f.y, f.z, f.w);
1183 }
1184
1185 // Accept a half value converted to float. This eliminates the need in the
1186 // driver to properly support the half datatype (either by adding compiler flags
1187 // for half or link against compiler_rt).
1188 void rsDebug(const char *s, float f, ushort us) {
1189 ALOGD("%s {%f} {0x%hx}", s, f, us);
1190 }
1191
1192 void rsDebug(const char *s, const float2 *f2, const ushort2 *us2) {
1193 float2 f = *f2;
1194 ushort2 us = *us2;
1195 ALOGD("%s {%f %f} {0x%hx 0x%hx}", s, f.x, f.y, us.x, us.y);
1196 }
1197
1198 void rsDebug(const char *s, const float3 *f3, const ushort3 *us3) {
1199 float3 f = *f3;
1200 ushort3 us = *us3;
1201 ALOGD("%s {%f %f %f} {0x%hx 0x%hx 0x%hx}", s, f.x, f.y, f.z, us.x, us.y,
1202 us.z);
1203 }
1204
1205 void rsDebug(const char *s, const float4 *f4, const ushort4 *us4) {
1206 float4 f = *f4;
1207 ushort4 us = *us4;
1208 ALOGD("%s {%f %f %f %f} {0x%hx 0x%hx 0x%hx 0x%hx}", s, f.x, f.y, f.z, f.w,
1209 us.x, us.y, us.z, us.w);
1210 }
1211
1212 void rsDebug(const char *s, double d) {
1213 ALOGD("%s %f, 0x%08llx", s, d, *((long long *) (&d)));
1214 }
1215
1216 void rsDebug(const char *s, const double2 *d2) {
1217 double2 d = *d2;
1218 ALOGD("%s {%f, %f}", s, d.x, d.y);
1219 }
1220
1221 void rsDebug(const char *s, const double3 *d3) {
1222 double3 d = *d3;
1223 ALOGD("%s {%f, %f, %f}", s, d.x, d.y, d.z);
1224 }
1225
1226 void rsDebug(const char *s, const double4 *d4) {
1227 double4 d = *d4;
1228 ALOGD("%s {%f, %f, %f, %f}", s, d.x, d.y, d.z, d.w);
1229 }
1230
1231 void rsDebug(const char *s, const rs_matrix4x4 *m) {
1232 float *f = (float *)m;
1233 ALOGD("%s {%f, %f, %f, %f", s, f[0], f[4], f[8], f[12]);
1234 ALOGD("%s %f, %f, %f, %f", s, f[1], f[5], f[9], f[13]);
1235 ALOGD("%s %f, %f, %f, %f", s, f[2], f[6], f[10], f[14]);
1236 ALOGD("%s %f, %f, %f, %f}", s, f[3], f[7], f[11], f[15]);
1237 }
1238
1239 void rsDebug(const char *s, const rs_matrix3x3 *m) {
1240 float *f = (float *)m;
1241 ALOGD("%s {%f, %f, %f", s, f[0], f[3], f[6]);
1242 ALOGD("%s %f, %f, %f", s, f[1], f[4], f[7]);
1243 ALOGD("%s %f, %f, %f}",s, f[2], f[5], f[8]);
1244 }
1245
1246 void rsDebug(const char *s, const rs_matrix2x2 *m) {
1247 float *f = (float *)m;
1248 ALOGD("%s {%f, %f", s, f[0], f[2]);
1249 ALOGD("%s %f, %f}",s, f[1], f[3]);
1250 }
1251
1252 void rsDebug(const char *s, char c) {
1253 ALOGD("%s %hhd 0x%hhx", s, c, (unsigned char)c);
1254 }
1255
1256 void rsDebug(const char *s, const char2 *c2) {
1257 char2 c = *c2;
1258 ALOGD("%s {%hhd, %hhd} 0x%hhx 0x%hhx", s, c.x, c.y, (unsigned char)c.x, (unsigned char)c.y);
1259 }
1260
1261 void rsDebug(const char *s, const char3 *c3) {
1262 char3 c = *c3;
1263 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);
1264 }
1265
1266 void rsDebug(const char *s, const char4 *c4) {
1267 char4 c = *c4;
1268 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);
1269 }
1270
1271 void rsDebug(const char *s, unsigned char c) {
1272 ALOGD("%s %hhu 0x%hhx", s, c, c);
1273 }
1274
1275 void rsDebug(const char *s, const uchar2 *c2) {
1276 uchar2 c = *c2;
1277 ALOGD("%s {%hhu, %hhu} 0x%hhx 0x%hhx", s, c.x, c.y, c.x, c.y);
1278 }
1279
1280 void rsDebug(const char *s, const uchar3 *c3) {
1281 uchar3 c = *c3;
1282 ALOGD("%s {%hhu, %hhu, %hhu} 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.x, c.y, c.z);
1283 }
1284
1285 void rsDebug(const char *s, const uchar4 *c4) {
1286 uchar4 c = *c4;
1287 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);
1288 }
1289
1290 void rsDebug(const char *s, int16_t c) {
1291 ALOGD("%s %hd 0x%hx", s, c, c);
1292 }
1293
1294 void rsDebug(const char *s, const short2 *c2) {
1295 short2 c = *c2;
1296 ALOGD("%s {%hd, %hd} 0x%hx 0x%hx", s, c.x, c.y, c.x, c.y);
1297 }
1298
1299 void rsDebug(const char *s, const short3 *c3) {
1300 short3 c = *c3;
1301 ALOGD("%s {%hd, %hd, %hd} 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z);
1302 }
1303
1304 void rsDebug(const char *s, const short4 *c4) {
1305 short4 c = *c4;
1306 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);
1307 }
1308
1309 void rsDebug(const char *s, uint16_t c) {
1310 ALOGD("%s %hu 0x%hx", s, c, c);
1311 }
1312
1313 void rsDebug(const char *s, const ushort2 *c2) {
1314 ushort2 c = *c2;
1315 ALOGD("%s {%hu, %hu} 0x%hx 0x%hx", s, c.x, c.y, c.x, c.y);
1316 }
1317
1318 void rsDebug(const char *s, const ushort3 *c3) {
1319 ushort3 c = *c3;
1320 ALOGD("%s {%hu, %hu, %hu} 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z);
1321 }
1322
1323 void rsDebug(const char *s, const ushort4 *c4) {
1324 ushort4 c = *c4;
1325 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);
1326 }
1327
1328 void rsDebug(const char *s, int i) {
1329 ALOGD("%s %d 0x%x", s, i, i);
1330 }
1331
1332 void rsDebug(const char *s, const int2 *i2) {
1333 int2 i = *i2;
1334 ALOGD("%s {%d, %d} 0x%x 0x%x", s, i.x, i.y, i.x, i.y);
1335 }
1336
1337 void rsDebug(const char *s, const int3 *i3) {
1338 int3 i = *i3;
1339 ALOGD("%s {%d, %d, %d} 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z);
1340 }
1341
1342 void rsDebug(const char *s, const int4 *i4) {
1343 int4 i = *i4;
1344 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);
1345 }
1346
1347 void rsDebug(const char *s, unsigned int i) {
1348 ALOGD("%s %u 0x%x", s, i, i);
1349 }
1350
1351 void rsDebug(const char *s, const uint2 *i2) {
1352 uint2 i = *i2;
1353 ALOGD("%s {%u, %u} 0x%x 0x%x", s, i.x, i.y, i.x, i.y);
1354 }
1355
1356 void rsDebug(const char *s, const uint3 *i3) {
1357 uint3 i = *i3;
1358 ALOGD("%s {%u, %u, %u} 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z);
1359 }
1360
1361 void rsDebug(const char *s, const uint4 *i4) {
1362 uint4 i = *i4;
1363 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);
1364 }
1365
1366 template <typename T>
1367 static inline long long LL(const T &x) {
1368 return static_cast<long long>(x);
1369 }
1370
1371 template <typename T>
1372 static inline unsigned long long LLu(const T &x) {
1373 return static_cast<unsigned long long>(x);
1374 }
1375
1376 void rsDebug(const char *s, long l) {
1377 ALOGD("%s %lld 0x%llx", s, LL(l), LL(l));
1378 }
1379
1380 void rsDebug(const char *s, long long ll) {
1381 ALOGD("%s %lld 0x%llx", s, LL(ll), LL(ll));
1382 }
1383
1384 void rsDebug(const char *s, const long2 *c) {
1385 long2 ll = *c;
1386 ALOGD("%s {%lld, %lld} 0x%llx 0x%llx", s, LL(ll.x), LL(ll.y), LL(ll.x), LL(ll.y));
1387 }
1388
1389 void rsDebug(const char *s, const long3 *c) {
1390 long3 ll = *c;
1391 ALOGD("%s {%lld, %lld, %lld} 0x%llx 0x%llx 0x%llx", s, LL(ll.x), LL(ll.y), LL(ll.z), LL(ll.x), LL(ll.y), LL(ll.z));
1392 }
1393
1394 void rsDebug(const char *s, const long4 *c) {
1395 long4 ll = *c;
1396 ALOGD("%s {%lld, %lld, %lld, %lld} 0x%llx 0x%llx 0x%llx 0x%llx", s, LL(ll.x), LL(ll.y), LL(ll.z), LL(ll.w), LL(ll.x), LL(ll.y), LL(ll.z), LL(ll.w));
1397 }
1398
1399 void rsDebug(const char *s, unsigned long l) {
1400 unsigned long long ll = l;
1401 ALOGD("%s %llu 0x%llx", s, ll, ll);
1402 }
1403
1404 void rsDebug(const char *s, unsigned long long ll) {
1405 ALOGD("%s %llu 0x%llx", s, ll, ll);
1406 }
1407
1408 void rsDebug(const char *s, const ulong2 *c) {
1409 ulong2 ll = *c;
1410 ALOGD("%s {%llu, %llu} 0x%llx 0x%llx", s, LLu(ll.x), LLu(ll.y), LLu(ll.x), LLu(ll.y));
1411 }
1412
1413 void rsDebug(const char *s, const ulong3 *c) {
1414 ulong3 ll = *c;
1415 ALOGD("%s {%llu, %llu, %llu} 0x%llx 0x%llx 0x%llx", s, LLu(ll.x), LLu(ll.y), LLu(ll.z), LLu(ll.x), LLu(ll.y), LLu(ll.z));
1416 }
1417
1418 void rsDebug(const char *s, const ulong4 *c) {
1419 ulong4 ll = *c;
1420 ALOGD("%s {%llu, %llu, %llu, %llu} 0x%llx 0x%llx 0x%llx 0x%llx", s, LLu(ll.x), LLu(ll.y), LLu(ll.z), LLu(ll.w), LLu(ll.x), LLu(ll.y), LLu(ll.z), LLu(ll.w));
1421 }
1422
1423 // FIXME: We need to export these function signatures for the compatibility
1424 // library. The C++ name mangling that LLVM uses for ext_vector_type requires
1425 // different versions for "long" vs. "long long". Note that the called
1426 // functions are still using the appropriate 64-bit sizes.
1427
1428 #ifndef __LP64__
1429 typedef long l2 __attribute__((ext_vector_type(2)));
1430 typedef long l3 __attribute__((ext_vector_type(3)));
1431 typedef long l4 __attribute__((ext_vector_type(4)));
1432 typedef unsigned long ul2 __attribute__((ext_vector_type(2)));
1433 typedef unsigned long ul3 __attribute__((ext_vector_type(3)));
1434 typedef unsigned long ul4 __attribute__((ext_vector_type(4)));
1435
1436 void rsDebug(const char *s, const l2 *c) {
1437 long2 ll = *(const long2 *)c;
1438 ALOGD("%s {%lld, %lld} 0x%llx 0x%llx", s, LL(ll.x), LL(ll.y), LL(ll.x), LL(ll.y));
1439 }
1440
1441 void rsDebug(const char *s, const l3 *c) {
1442 long3 ll = *(const long3 *)c;
1443 ALOGD("%s {%lld, %lld, %lld} 0x%llx 0x%llx 0x%llx", s, LL(ll.x), LL(ll.y), LL(ll.z), LL(ll.x), LL(ll.y), LL(ll.z));
1444 }
1445
1446 void rsDebug(const char *s, const l4 *c) {
1447 long4 ll = *(const long4 *)c;
1448 ALOGD("%s {%lld, %lld, %lld, %lld} 0x%llx 0x%llx 0x%llx 0x%llx", s, LL(ll.x), LL(ll.y), LL(ll.z), LL(ll.w), LL(ll.x), LL(ll.y), LL(ll.z), LL(ll.w));
1449 }
1450
1451 void rsDebug(const char *s, const ul2 *c) {
1452 ulong2 ll = *(const ulong2 *)c;
1453 ALOGD("%s {%llu, %llu} 0x%llx 0x%llx", s, LLu(ll.x), LLu(ll.y), LLu(ll.x), LLu(ll.y));
1454 }
1455
1456 void rsDebug(const char *s, const ul3 *c) {
1457 ulong3 ll = *(const ulong3 *)c;
1458 ALOGD("%s {%llu, %llu, %llu} 0x%llx 0x%llx 0x%llx", s, LLu(ll.x), LLu(ll.y), LLu(ll.z), LLu(ll.x), LLu(ll.y), LLu(ll.z));
1459 }
1460
1461 void rsDebug(const char *s, const ul4 *c) {
1462 ulong4 ll = *(const ulong4 *)c;
1463 ALOGD("%s {%llu, %llu, %llu, %llu} 0x%llx 0x%llx 0x%llx 0x%llx", s, LLu(ll.x), LLu(ll.y), LLu(ll.z), LLu(ll.w), LLu(ll.x), LLu(ll.y), LLu(ll.z), LLu(ll.w));
1464 }
1465 #endif
1466
1467 void rsDebug(const char *s, const long2 ll) {
1468 ALOGD("%s {%lld, %lld} 0x%llx 0x%llx", s, LL(ll.x), LL(ll.y), LL(ll.x), LL(ll.y));
1469 }
1470
1471 void rsDebug(const char *s, const long3 ll) {
1472 ALOGD("%s {%lld, %lld, %lld} 0x%llx 0x%llx 0x%llx", s, LL(ll.x), LL(ll.y), LL(ll.z), LL(ll.x), LL(ll.y), LL(ll.z));
1473 }
1474
1475 void rsDebug(const char *s, const long4 ll) {
1476 ALOGD("%s {%lld, %lld, %lld, %lld} 0x%llx 0x%llx 0x%llx 0x%llx", s, LL(ll.x), LL(ll.y), LL(ll.z), LL(ll.w), LL(ll.x), LL(ll.y), LL(ll.z), LL(ll.w));
1477 }
1478
1479 void rsDebug(const char *s, const ulong2 ll) {
1480 ALOGD("%s {%llu, %llu} 0x%llx 0x%llx", s, LLu(ll.x), LLu(ll.y), LLu(ll.x), LLu(ll.y));
1481 }
1482
1483 void rsDebug(const char *s, const ulong3 ll) {
1484 ALOGD("%s {%llu, %llu, %llu} 0x%llx 0x%llx 0x%llx", s, LLu(ll.x), LLu(ll.y), LLu(ll.z), LLu(ll.x), LLu(ll.y), LLu(ll.z));
1485 }
1486
1487 void rsDebug(const char *s, const ulong4 ll) {
1488 ALOGD("%s {%llu, %llu, %llu, %llu} 0x%llx 0x%llx 0x%llx 0x%llx", s, LLu(ll.x), LLu(ll.y), LLu(ll.z), LLu(ll.w), LLu(ll.x), LLu(ll.y), LLu(ll.z), LLu(ll.w));
1489 }
1490
1491 void rsDebug(const char *s, const void *p) {
1492 ALOGD("%s %p", s, p);
1493 }
1494
1495 extern const RsdCpuReference::CpuSymbol * rsdLookupRuntimeStub(Context * pContext, char const* name) {
1496 // TODO: remove
1497 return nullptr;
1498 }
1499