/*
* Copyright (C) 2011-2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <time.h>
#include "rsContext.h"
#include "rsElement.h"
#include "rsMatrix2x2.h"
#include "rsMatrix3x3.h"
#include "rsMatrix4x4.h"
#include "rsRuntime.h"
#include "rsScriptC.h"
#include "rsType.h"
#include "rsovAllocation.h"
#include "rsovCore.h"
#include "rsovScript.h"
using namespace android;
using namespace android::renderscript;
typedef __fp16 half;
typedef half half2 __attribute__((ext_vector_type(2)));
typedef half half3 __attribute__((ext_vector_type(3)));
typedef half half4 __attribute__((ext_vector_type(4)));
typedef float float2 __attribute__((ext_vector_type(2)));
typedef float float3 __attribute__((ext_vector_type(3)));
typedef float float4 __attribute__((ext_vector_type(4)));
typedef double double2 __attribute__((ext_vector_type(2)));
typedef double double3 __attribute__((ext_vector_type(3)));
typedef double double4 __attribute__((ext_vector_type(4)));
typedef char char2 __attribute__((ext_vector_type(2)));
typedef char char3 __attribute__((ext_vector_type(3)));
typedef char char4 __attribute__((ext_vector_type(4)));
typedef unsigned char uchar2 __attribute__((ext_vector_type(2)));
typedef unsigned char uchar3 __attribute__((ext_vector_type(3)));
typedef unsigned char uchar4 __attribute__((ext_vector_type(4)));
typedef int16_t short2 __attribute__((ext_vector_type(2)));
typedef int16_t short3 __attribute__((ext_vector_type(3)));
typedef int16_t short4 __attribute__((ext_vector_type(4)));
typedef uint16_t ushort2 __attribute__((ext_vector_type(2)));
typedef uint16_t ushort3 __attribute__((ext_vector_type(3)));
typedef uint16_t ushort4 __attribute__((ext_vector_type(4)));
typedef int32_t int2 __attribute__((ext_vector_type(2)));
typedef int32_t int3 __attribute__((ext_vector_type(3)));
typedef int32_t int4 __attribute__((ext_vector_type(4)));
typedef uint32_t uint2 __attribute__((ext_vector_type(2)));
typedef uint32_t uint3 __attribute__((ext_vector_type(3)));
typedef uint32_t uint4 __attribute__((ext_vector_type(4)));
typedef int64_t long2 __attribute__((ext_vector_type(2)));
typedef int64_t long3 __attribute__((ext_vector_type(3)));
typedef int64_t long4 __attribute__((ext_vector_type(4)));
typedef uint64_t ulong2 __attribute__((ext_vector_type(2)));
typedef uint64_t ulong3 __attribute__((ext_vector_type(3)));
typedef uint64_t ulong4 __attribute__((ext_vector_type(4)));
typedef uint8_t uchar;
typedef uint16_t ushort;
typedef uint32_t uint;
typedef uint64_t ulong;
// Add NOLINT to suppress wrong warnings from clang-tidy.
#ifndef __LP64__
#define OPAQUETYPE(t) \
typedef struct { \
const int *const p; \
} __attribute__((packed, aligned(4))) t; /*NOLINT*/
#else
#define OPAQUETYPE(t) \
typedef struct { \
const void *p; \
const void *unused1; \
const void *unused2; \
const void *unused3; \
} t; /*NOLINT*/
#endif
OPAQUETYPE(rs_element)
OPAQUETYPE(rs_type)
OPAQUETYPE(rs_allocation)
OPAQUETYPE(rs_sampler)
OPAQUETYPE(rs_script)
OPAQUETYPE(rs_script_call)
OPAQUETYPE(rs_program_fragment);
OPAQUETYPE(rs_program_store);
OPAQUETYPE(rs_program_vertex);
OPAQUETYPE(rs_program_raster);
OPAQUETYPE(rs_mesh);
OPAQUETYPE(rs_font);
#undef OPAQUETYPE
typedef enum {
// Empty to avoid conflicting definitions with RsAllocationCubemapFace
} rs_allocation_cubemap_face;
typedef enum {
// Empty to avoid conflicting definitions with RsYuvFormat
} rs_yuv_format;
typedef enum {
// Empty to avoid conflicting definitions with RsAllocationMipmapControl
} rs_allocation_mipmap_control;
typedef struct { unsigned int val; } rs_allocation_usage_type;
typedef struct {
int tm_sec; ///< seconds
int tm_min; ///< minutes
int tm_hour; ///< hours
int tm_mday; ///< day of the month
int tm_mon; ///< month
int tm_year; ///< year
int tm_wday; ///< day of the week
int tm_yday; ///< day of the year
int tm_isdst; ///< daylight savings time
} rs_tm;
// Some RS functions are not threadsafe but can be called from an invoke
// function. Instead of summarily marking scripts that call these functions as
// not-threadable we detect calls to them in the driver and sends a fatal error
// message.
static bool failIfInKernel(Context *rsc, const char *funcName) {
RSoVHal *dc = (RSoVHal *)rsc->mHal.drv;
RsdCpuReference *impl = (RsdCpuReference *)dc->mCpuRef;
if (impl->getInKernel()) {
char buf[256];
snprintf(buf, sizeof(buf),
"Error: Call to unsupported function %s "
"in kernel",
funcName);
rsc->setError(RS_ERROR_FATAL_DRIVER, buf);
return true;
}
return false;
}
//////////////////////////////////////////////////////////////////////////////
// Allocation routines
//////////////////////////////////////////////////////////////////////////////
#if defined(__i386__) || (defined(__mips__) && __mips == 32)
// i386 and MIPS32 have different struct return passing to ARM; emulate with a
// pointer
const Allocation *rsGetAllocation(const void *ptr) {
Context *rsc = RsdCpuReference::getTlsContext();
const Script *sc = RsdCpuReference::getTlsScript();
Allocation *alloc = rsovScriptGetAllocationForPointer(rsc, sc, ptr);
android::renderscript::rs_allocation obj = {0};
alloc->callUpdateCacheObject(rsc, &obj);
return (Allocation *)obj.p;
}
#else
const android::renderscript::rs_allocation rsGetAllocation(const void *ptr) {
Context *rsc = RsdCpuReference::getTlsContext();
const Script *sc = RsdCpuReference::getTlsScript();
Allocation *alloc = rsovScriptGetAllocationForPointer(rsc, sc, ptr);
#ifndef __LP64__ // ARMv7
android::renderscript::rs_allocation obj = {0};
#else // AArch64/x86_64/MIPS64
android::renderscript::rs_allocation obj = {0, 0, 0, 0};
#endif
alloc->callUpdateCacheObject(rsc, &obj);
return obj;
}
#endif
void __attribute__((overloadable)) rsAllocationIoSend(::rs_allocation a) {
Context *rsc = RsdCpuReference::getTlsContext();
if (failIfInKernel(rsc, "rsAllocationIoSend")) return;
rsrAllocationIoSend(rsc, (Allocation *)a.p);
}
void __attribute__((overloadable)) rsAllocationIoReceive(::rs_allocation a) {
Context *rsc = RsdCpuReference::getTlsContext();
if (failIfInKernel(rsc, "rsAllocationIoReceive")) return;
rsrAllocationIoReceive(rsc, (Allocation *)a.p);
}
void __attribute__((overloadable))
rsAllocationCopy1DRange(::rs_allocation dstAlloc, uint32_t dstOff,
uint32_t dstMip, uint32_t count,
::rs_allocation srcAlloc, uint32_t srcOff,
uint32_t srcMip) {
Context *rsc = RsdCpuReference::getTlsContext();
if (failIfInKernel(rsc, "rsAllocationCopy1DRange")) return;
rsrAllocationCopy1DRange(rsc, (Allocation *)dstAlloc.p, dstOff, dstMip, count,
(Allocation *)srcAlloc.p, srcOff, srcMip);
}
void __attribute__((overloadable))
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) {
Context *rsc = RsdCpuReference::getTlsContext();
if (failIfInKernel(rsc, "rsAllocationCopy2DRange")) return;
rsrAllocationCopy2DRange(
rsc, (Allocation *)dstAlloc.p, dstXoff, dstYoff, dstMip, dstFace, width,
height, (Allocation *)srcAlloc.p, srcXoff, srcYoff, srcMip, srcFace);
}
static android::renderscript::rs_element CreateElement(RsDataType dt,
RsDataKind dk,
bool isNormalized,
uint32_t vecSize) {
Context *rsc = RsdCpuReference::getTlsContext();
// No need for validation here. The rsCreateElement overload below is not
// exposed to the Script. The Element-creation APIs call this function in a
// consistent manner and rsComponent.cpp asserts on any inconsistency.
Element *element =
(Element *)rsrElementCreate(rsc, dt, dk, isNormalized, vecSize);
android::renderscript::rs_element obj = {};
if (element == nullptr) return obj;
element->callUpdateCacheObject(rsc, &obj);
// Any new rsObject created from inside a script should have the usrRefCount
// initialized to 0 and the sysRefCount initialized to 1.
element->incSysRef();
element->decUserRef();
return obj;
}
static android::renderscript::rs_type CreateType(RsElement element,
uint32_t dimX, uint32_t dimY,
uint32_t dimZ, bool mipmaps,
bool faces,
uint32_t yuv_format) {
Context *rsc = RsdCpuReference::getTlsContext();
android::renderscript::rs_type obj = {};
if (element == nullptr) {
ALOGE("rs_type creation error: Invalid element");
return obj;
}
// validate yuv_format
RsYuvFormat yuv = (RsYuvFormat)yuv_format;
if (yuv != RS_YUV_NONE && yuv != RS_YUV_YV12 && yuv != RS_YUV_NV21 &&
yuv != RS_YUV_420_888) {
ALOGE("rs_type creation error: Invalid yuv_format %d\n", yuv_format);
return obj;
}
// validate consistency of shape parameters
if (dimZ > 0) {
if (dimX < 1 || dimY < 1) {
ALOGE(
"rs_type creation error: Both X and Y dimension required "
"when Z is present.");
return obj;
}
if (mipmaps) {
ALOGE("rs_type creation error: mipmap control requires 2D types");
return obj;
}
if (faces) {
ALOGE("rs_type creation error: Cube maps require 2D types");
return obj;
}
}
if (dimY > 0 && dimX < 1) {
ALOGE(
"rs_type creation error: X dimension required when Y is "
"present.");
return obj;
}
if (mipmaps && dimY < 1) {
ALOGE("rs_type creation error: mipmap control require 2D Types.");
return obj;
}
if (faces && dimY < 1) {
ALOGE("rs_type creation error: Cube maps require 2D Types.");
return obj;
}
if (yuv_format != RS_YUV_NONE) {
if (dimZ != 0 || dimY == 0 || faces || mipmaps) {
ALOGE("rs_type creation error: YUV only supports basic 2D.");
return obj;
}
}
Type *type = (Type *)rsrTypeCreate(rsc, element, dimX, dimY, dimZ, mipmaps,
faces, yuv_format);
if (type == nullptr) return obj;
type->callUpdateCacheObject(rsc, &obj);
// Any new rsObject created from inside a script should have the usrRefCount
// initialized to 0 and the sysRefCount initialized to 1.
type->incSysRef();
type->decUserRef();
return obj;
}
static android::renderscript::rs_allocation CreateAllocation(
RsType type, RsAllocationMipmapControl mipmaps, uint32_t usages,
void *ptr) {
Context *rsc = RsdCpuReference::getTlsContext();
android::renderscript::rs_allocation obj = {};
if (type == nullptr) {
ALOGE("rs_allocation creation error: Invalid type");
return obj;
}
uint32_t validUsages =
RS_ALLOCATION_USAGE_SCRIPT | RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE;
if (usages & ~validUsages) {
ALOGE("rs_allocation creation error: Invalid usage flag");
return obj;
}
Allocation *alloc = (Allocation *)rsrAllocationCreateTyped(
rsc, type, mipmaps, usages, (uintptr_t)ptr);
if (alloc == nullptr) return obj;
alloc->callUpdateCacheObject(rsc, &obj);
// Any new rsObject created from inside a script should have the usrRefCount
// initialized to 0 and the sysRefCount initialized to 1.
alloc->incSysRef();
alloc->decUserRef();
return obj;
}
// Define rsCreateElement, rsCreateType and rsCreateAllocation entry points
// differently for 32-bit x86 and Mips. The definitions for ARM32 and all
// 64-bit architectures is further below.
#if defined(__i386__) || (defined(__mips__) && __mips == 32)
// The calling convention for the driver on 32-bit x86 and Mips returns
// rs_element etc. as a stack-return parameter. The Script uses ARM32 calling
// conventions that return the structs in a register. To match this convention,
// emulate the return value using a pointer.
Element *rsCreateElement(int32_t dt, int32_t dk, bool isNormalized,
uint32_t vecSize) {
android::renderscript::rs_element obj =
CreateElement((RsDataType)dt, (RsDataKind)dk, isNormalized, vecSize);
return (Element *)obj.p;
}
Type *rsCreateType(::rs_element element, uint32_t dimX, uint32_t dimY,
uint32_t dimZ, bool mipmaps, bool faces,
rs_yuv_format yuv_format) {
android::renderscript::rs_type obj =
CreateType((RsElement)element.p, dimX, dimY, dimZ, mipmaps, faces,
(RsYuvFormat)yuv_format);
return (Type *)obj.p;
}
Allocation *rsCreateAllocation(::rs_type type,
rs_allocation_mipmap_control mipmaps,
uint32_t usages, void *ptr) {
android::renderscript::rs_allocation obj;
obj = CreateAllocation((RsType)type.p, (RsAllocationMipmapControl)mipmaps,
usages, ptr);
return (Allocation *)obj.p;
}
#else
android::renderscript::rs_element rsCreateElement(int32_t dt, int32_t dk,
bool isNormalized,
uint32_t vecSize) {
return CreateElement((RsDataType)dt, (RsDataKind)dk, isNormalized, vecSize);
}
android::renderscript::rs_type rsCreateType(::rs_element element, uint32_t dimX,
uint32_t dimY, uint32_t dimZ,
bool mipmaps, bool faces,
rs_yuv_format yuv_format) {
return CreateType((RsElement)element.p, dimX, dimY, dimZ, mipmaps, faces,
yuv_format);
}
android::renderscript::rs_allocation rsCreateAllocation(
::rs_type type, rs_allocation_mipmap_control mipmaps, uint32_t usages,
void *ptr) {
return CreateAllocation((RsType)type.p, (RsAllocationMipmapControl)mipmaps,
usages, ptr);
}
#endif
//////////////////////////////////////////////////////////////////////////////
// Object routines
//////////////////////////////////////////////////////////////////////////////
// Add NOLINT to suppress wrong warnings from clang-tidy.
#define IS_CLEAR_SET_OBJ(t) \
bool rsIsObject(t src) { return src.p != nullptr; } \
void __attribute__((overloadable)) rsClearObject(t *dst) { /*NOLINT*/ \
rsrClearObject(reinterpret_cast<rs_object_base *>(dst)); \
} \
void __attribute__((overloadable)) rsSetObject(t *dst, t src) { /*NOLINT*/ \
Context *rsc = RsdCpuReference::getTlsContext(); \
rsrSetObject(rsc, reinterpret_cast<rs_object_base *>(dst), \
(ObjectBase *)src.p); \
}
IS_CLEAR_SET_OBJ(::rs_element)
IS_CLEAR_SET_OBJ(::rs_type)
IS_CLEAR_SET_OBJ(::rs_allocation)
IS_CLEAR_SET_OBJ(::rs_sampler)
IS_CLEAR_SET_OBJ(::rs_script)
IS_CLEAR_SET_OBJ(::rs_mesh)
IS_CLEAR_SET_OBJ(::rs_program_fragment)
IS_CLEAR_SET_OBJ(::rs_program_vertex)
IS_CLEAR_SET_OBJ(::rs_program_raster)
IS_CLEAR_SET_OBJ(::rs_program_store)
IS_CLEAR_SET_OBJ(::rs_font)
#undef IS_CLEAR_SET_OBJ
//////////////////////////////////////////////////////////////////////////////
// Element routines
//////////////////////////////////////////////////////////////////////////////
static void *ElementAt(Allocation *a, RsDataType dt, uint32_t vecSize,
uint32_t x, uint32_t y, uint32_t z) {
Context *rsc = RsdCpuReference::getTlsContext();
const Type *t = a->getType();
const Element *e = t->getElement();
char buf[256];
if (x && (x >= t->getLODDimX(0))) {
snprintf(buf, sizeof(buf), "Out range ElementAt X %i of %i", x,
t->getLODDimX(0));
rsc->setError(RS_ERROR_FATAL_DEBUG, buf);
return nullptr;
}
if (y && (y >= t->getLODDimY(0))) {
snprintf(buf, sizeof(buf), "Out range ElementAt Y %i of %i", y,
t->getLODDimY(0));
rsc->setError(RS_ERROR_FATAL_DEBUG, buf);
return nullptr;
}
if (z && (z >= t->getLODDimZ(0))) {
snprintf(buf, sizeof(buf), "Out range ElementAt Z %i of %i", z,
t->getLODDimZ(0));
rsc->setError(RS_ERROR_FATAL_DEBUG, buf);
return nullptr;
}
if (vecSize > 0) {
if (vecSize != e->getVectorSize()) {
snprintf(buf, sizeof(buf), "Vector size mismatch for ElementAt %i of %i",
vecSize, e->getVectorSize());
rsc->setError(RS_ERROR_FATAL_DEBUG, buf);
return nullptr;
}
if (dt != e->getType()) {
snprintf(buf, sizeof(buf), "Data type mismatch for ElementAt %i of %i",
dt, e->getType());
rsc->setError(RS_ERROR_FATAL_DEBUG, buf);
return nullptr;
}
}
uint8_t *p = (uint8_t *)a->mHal.drvState.lod[0].mallocPtr;
const uint32_t eSize = e->getSizeBytes();
const uint32_t stride = a->mHal.drvState.lod[0].stride;
const uint32_t dimY = a->mHal.drvState.lod[0].dimY;
return &p[(x * eSize) + (y * stride) + (z * stride * dimY)];
}
void rsSetElementAt(::rs_allocation a, const void *ptr, uint32_t x, uint32_t y,
uint32_t z) {
const Type *t = const_cast<Allocation *>((Allocation *)a.p)->getType();
const Element *e = t->getElement();
void *tmp = ElementAt((Allocation *)a.p, RS_TYPE_UNSIGNED_8, 0, x, y, z);
if (tmp != nullptr) memcpy(tmp, ptr, e->getSizeBytes());
}
void rsSetElementAt(::rs_allocation a, const void *ptr, uint32_t x,
uint32_t y) {
rsSetElementAt(a, ptr, x, y, 0);
}
void rsSetElementAt(::rs_allocation a, const void *ptr, uint32_t x) {
rsSetElementAt(a, ptr, x, 0, 0);
}
const void *rsGetElementAt(::rs_allocation a, uint32_t x, uint32_t y,
uint32_t z) {
return ElementAt((Allocation *)a.p, RS_TYPE_UNSIGNED_8, 0, x, y, z);
}
const void *rsGetElementAt(::rs_allocation a, uint32_t x, uint32_t y) {
return rsGetElementAt(a, x, y, 0);
}
const void *rsGetElementAt(::rs_allocation a, uint32_t x) {
return rsGetElementAt(a, x, 0, 0);
}
// Add NOLINT to suppress wrong warnings from clang-tidy.
#define ELEMENT_AT(T, DT, VS) \
void rsSetElementAt_##T(::rs_allocation a, const T *val, uint32_t x, \
uint32_t y, uint32_t z) { \
void *r = ElementAt((Allocation *)a.p, DT, VS, x, y, z); \
if (r != nullptr) \
((T *)r)[0] = *val; \
else \
ALOGE("Error from %s", __PRETTY_FUNCTION__); \
} \
void rsSetElementAt_##T(::rs_allocation a, const T *val, uint32_t x, \
uint32_t y) { \
rsSetElementAt_##T(a, val, x, y, 0); \
} \
void rsSetElementAt_##T(::rs_allocation a, const T *val, uint32_t x) { \
rsSetElementAt_##T(a, val, x, 0, 0); \
} \
void rsGetElementAt_##T(::rs_allocation a, T *val, uint32_t x, uint32_t y, \
uint32_t z) { /*NOLINT*/ \
void *r = ElementAt((Allocation *)a.p, DT, VS, x, y, z); \
if (r != nullptr) \
*val = ((T *)r)[0]; \
else \
ALOGE("Error from %s", __PRETTY_FUNCTION__); \
} \
void rsGetElementAt_##T(::rs_allocation a, T *val, uint32_t x, \
uint32_t y) { /*NOLINT*/ \
rsGetElementAt_##T(a, val, x, y, 0); \
} \
void rsGetElementAt_##T(::rs_allocation a, T *val, uint32_t x) { /*NOLINT*/ \
rsGetElementAt_##T(a, val, x, 0, 0); \
}
ELEMENT_AT(char, RS_TYPE_SIGNED_8, 1)
ELEMENT_AT(char2, RS_TYPE_SIGNED_8, 2)
ELEMENT_AT(char3, RS_TYPE_SIGNED_8, 3)
ELEMENT_AT(char4, RS_TYPE_SIGNED_8, 4)
ELEMENT_AT(uchar, RS_TYPE_UNSIGNED_8, 1)
ELEMENT_AT(uchar2, RS_TYPE_UNSIGNED_8, 2)
ELEMENT_AT(uchar3, RS_TYPE_UNSIGNED_8, 3)
ELEMENT_AT(uchar4, RS_TYPE_UNSIGNED_8, 4)
ELEMENT_AT(short, RS_TYPE_SIGNED_16, 1)
ELEMENT_AT(short2, RS_TYPE_SIGNED_16, 2)
ELEMENT_AT(short3, RS_TYPE_SIGNED_16, 3)
ELEMENT_AT(short4, RS_TYPE_SIGNED_16, 4)
ELEMENT_AT(ushort, RS_TYPE_UNSIGNED_16, 1)
ELEMENT_AT(ushort2, RS_TYPE_UNSIGNED_16, 2)
ELEMENT_AT(ushort3, RS_TYPE_UNSIGNED_16, 3)
ELEMENT_AT(ushort4, RS_TYPE_UNSIGNED_16, 4)
ELEMENT_AT(int, RS_TYPE_SIGNED_32, 1)
ELEMENT_AT(int2, RS_TYPE_SIGNED_32, 2)
ELEMENT_AT(int3, RS_TYPE_SIGNED_32, 3)
ELEMENT_AT(int4, RS_TYPE_SIGNED_32, 4)
ELEMENT_AT(uint, RS_TYPE_UNSIGNED_32, 1)
ELEMENT_AT(uint2, RS_TYPE_UNSIGNED_32, 2)
ELEMENT_AT(uint3, RS_TYPE_UNSIGNED_32, 3)
ELEMENT_AT(uint4, RS_TYPE_UNSIGNED_32, 4)
ELEMENT_AT(long, RS_TYPE_SIGNED_64, 1)
ELEMENT_AT(long2, RS_TYPE_SIGNED_64, 2)
ELEMENT_AT(long3, RS_TYPE_SIGNED_64, 3)
ELEMENT_AT(long4, RS_TYPE_SIGNED_64, 4)
ELEMENT_AT(ulong, RS_TYPE_UNSIGNED_64, 1)
ELEMENT_AT(ulong2, RS_TYPE_UNSIGNED_64, 2)
ELEMENT_AT(ulong3, RS_TYPE_UNSIGNED_64, 3)
ELEMENT_AT(ulong4, RS_TYPE_UNSIGNED_64, 4)
ELEMENT_AT(half, RS_TYPE_FLOAT_16, 1)
ELEMENT_AT(half2, RS_TYPE_FLOAT_16, 2)
ELEMENT_AT(half3, RS_TYPE_FLOAT_16, 3)
ELEMENT_AT(half4, RS_TYPE_FLOAT_16, 4)
ELEMENT_AT(float, RS_TYPE_FLOAT_32, 1)
ELEMENT_AT(float2, RS_TYPE_FLOAT_32, 2)
ELEMENT_AT(float3, RS_TYPE_FLOAT_32, 3)
ELEMENT_AT(float4, RS_TYPE_FLOAT_32, 4)
ELEMENT_AT(double, RS_TYPE_FLOAT_64, 1)
ELEMENT_AT(double2, RS_TYPE_FLOAT_64, 2)
ELEMENT_AT(double3, RS_TYPE_FLOAT_64, 3)
ELEMENT_AT(double4, RS_TYPE_FLOAT_64, 4)
#undef ELEMENT_AT
#ifndef __LP64__
/*
* We miss some symbols for rs{Get,Set}Element_long,ulong variants because 64
* bit integer values are 'long' in RS-land but might be 'long long' in the
* driver. Define native_long* and native_ulong* types to be vectors of
* 'long' as seen by the driver and define overloaded versions of
* rsSetElementAt_* and rsGetElementAt_*. This should get us the correct
* mangled names in the driver.
*/
typedef long native_long2 __attribute__((ext_vector_type(2)));
typedef long native_long3 __attribute__((ext_vector_type(3)));
typedef long native_long4 __attribute__((ext_vector_type(4)));
typedef unsigned long native_ulong2 __attribute__((ext_vector_type(2)));
typedef unsigned long native_ulong3 __attribute__((ext_vector_type(3)));
typedef unsigned long native_ulong4 __attribute__((ext_vector_type(4)));
// Add NOLINT to suppress wrong warnings from clang-tidy.
#define ELEMENT_AT_OVERLOADS(T, U) \
void rsSetElementAt_##T(::rs_allocation a, const U *val, uint32_t x, \
uint32_t y, uint32_t z) { \
rsSetElementAt_##T(a, (T *)val, x, y, z); \
} \
void rsSetElementAt_##T(::rs_allocation a, const U *val, uint32_t x, \
uint32_t y) { \
rsSetElementAt_##T(a, (T *)val, x, y, 0); \
} \
void rsSetElementAt_##T(::rs_allocation a, const U *val, uint32_t x) { \
rsSetElementAt_##T(a, (T *)val, x, 0, 0); \
} \
void rsGetElementAt_##T(::rs_allocation a, U *val, uint32_t x, uint32_t y, \
uint32_t z) { /*NOLINT*/ \
rsGetElementAt_##T(a, (T *)val, x, y, z); \
} \
void rsGetElementAt_##T(::rs_allocation a, U *val, uint32_t x, \
uint32_t y) { /*NOLINT*/ \
rsGetElementAt_##T(a, (T *)val, x, y, 0); \
} \
void rsGetElementAt_##T(::rs_allocation a, U *val, uint32_t x) { /*NOLINT*/ \
rsGetElementAt_##T(a, (T *)val, x, 0, 0); \
}
ELEMENT_AT_OVERLOADS(long2, native_long2)
ELEMENT_AT_OVERLOADS(long3, native_long3)
ELEMENT_AT_OVERLOADS(long4, native_long4)
ELEMENT_AT_OVERLOADS(ulong, unsigned long)
ELEMENT_AT_OVERLOADS(ulong2, native_ulong2)
ELEMENT_AT_OVERLOADS(ulong3, native_ulong3)
ELEMENT_AT_OVERLOADS(ulong4, native_ulong4)
// We also need variants of rs{Get,Set}ElementAt_long that take 'long long *' as
// we might have this overloaded variant in old APKs.
ELEMENT_AT_OVERLOADS(long, long long)
#undef ELEMENT_AT_OVERLOADS
#endif
//////////////////////////////////////////////////////////////////////////////
// ForEach routines
//////////////////////////////////////////////////////////////////////////////
void rsForEachInternal(int slot, rs_script_call *options, int hasOutput,
int numInputs, ::rs_allocation *allocs) {
Context *rsc = RsdCpuReference::getTlsContext();
Script *s = const_cast<Script *>(RsdCpuReference::getTlsScript());
if (numInputs > RS_KERNEL_MAX_ARGUMENTS) {
rsc->setError(RS_ERROR_BAD_SCRIPT,
"rsForEachInternal: too many inputs to a kernel.");
return;
}
Allocation *inputs[RS_KERNEL_MAX_ARGUMENTS];
for (int i = 0; i < numInputs; i++) {
inputs[i] = (Allocation *)allocs[i].p;
}
Allocation *out = hasOutput ? (Allocation *)allocs[numInputs].p : nullptr;
rsrForEach(rsc, s, slot, numInputs, numInputs > 0 ? inputs : nullptr, out,
nullptr, 0, (RsScriptCall *)options);
}
void __attribute__((overloadable))
rsForEach(::rs_script script, ::rs_allocation in, ::rs_allocation out,
const void *usr, const rs_script_call *call) {
Context *rsc = RsdCpuReference::getTlsContext();
rsrForEach(rsc, (Script *)script.p, 0, 1, (Allocation **)&in.p,
(Allocation *)out.p, usr, 0, (RsScriptCall *)call);
}
void __attribute__((overloadable))
rsForEach(::rs_script script, ::rs_allocation in, ::rs_allocation out,
const void *usr) {
Context *rsc = RsdCpuReference::getTlsContext();
rsrForEach(rsc, (Script *)script.p, 0, 1, (Allocation **)&in.p,
(Allocation *)out.p, usr, 0, nullptr);
}
void __attribute__((overloadable))
rsForEach(::rs_script script, ::rs_allocation in, ::rs_allocation out) {
Context *rsc = RsdCpuReference::getTlsContext();
rsrForEach(rsc, (Script *)script.p, 0, 1, (Allocation **)&in.p,
(Allocation *)out.p, nullptr, 0, nullptr);
}
// These functions are only supported in 32-bit.
#ifndef __LP64__
void __attribute__((overloadable))
rsForEach(::rs_script script, ::rs_allocation in, ::rs_allocation out,
const void *usr, uint32_t usrLen) {
Context *rsc = RsdCpuReference::getTlsContext();
rsrForEach(rsc, (Script *)script.p, 0, 1, (Allocation **)&in.p,
(Allocation *)out.p, usr, usrLen, nullptr);
}
void __attribute__((overloadable))
rsForEach(::rs_script script, ::rs_allocation in, ::rs_allocation out,
const void *usr, uint32_t usrLen, const rs_script_call *call) {
Context *rsc = RsdCpuReference::getTlsContext();
rsrForEach(rsc, (Script *)script.p, 0, 1, (Allocation **)&in.p,
(Allocation *)out.p, usr, usrLen, (RsScriptCall *)call);
}
#endif
//////////////////////////////////////////////////////////////////////////////
// Message routines
//////////////////////////////////////////////////////////////////////////////
uint32_t rsSendToClient(int cmdID) {
Context *rsc = RsdCpuReference::getTlsContext();
return rsrToClient(rsc, cmdID, (const void *)nullptr, 0);
}
uint32_t rsSendToClient(int cmdID, const void *data, uint32_t len) {
Context *rsc = RsdCpuReference::getTlsContext();
return rsrToClient(rsc, cmdID, data, len);
}
uint32_t rsSendToClientBlocking(int cmdID) {
Context *rsc = RsdCpuReference::getTlsContext();
return rsrToClientBlocking(rsc, cmdID, (const void *)nullptr, 0);
}
uint32_t rsSendToClientBlocking(int cmdID, const void *data, uint32_t len) {
Context *rsc = RsdCpuReference::getTlsContext();
return rsrToClientBlocking(rsc, cmdID, data, len);
}
//////////////////////////////////////////////////////////////////////////////
// Time routines
//////////////////////////////////////////////////////////////////////////////
// time_t is int in 32-bit RenderScript. time_t is long in bionic. rsTime and
// rsLocaltime are set to explicitly take 'const int *' so we generate the
// correct mangled names.
#ifndef __LP64__
int rsTime(int *timer) {
#else
time_t rsTime(time_t *timer) {
#endif
Context *rsc = RsdCpuReference::getTlsContext();
return rsrTime(rsc, (time_t *)timer);
}
#ifndef __LP64__
rs_tm *rsLocaltime(rs_tm *local, const int *timer) {
#else
rs_tm *rsLocaltime(rs_tm *local, const time_t *timer) {
#endif
Context *rsc = RsdCpuReference::getTlsContext();
return (rs_tm *)rsrLocalTime(rsc, (tm *)local, (time_t *)timer);
}
int64_t rsUptimeMillis() {
Context *rsc = RsdCpuReference::getTlsContext();
return rsrUptimeMillis(rsc);
}
int64_t rsUptimeNanos() {
Context *rsc = RsdCpuReference::getTlsContext();
return rsrUptimeNanos(rsc);
}
float rsGetDt() {
Context *rsc = RsdCpuReference::getTlsContext();
const Script *sc = RsdCpuReference::getTlsScript();
return rsrGetDt(rsc, sc);
}
//////////////////////////////////////////////////////////////////////////////
// Debug routines
//////////////////////////////////////////////////////////////////////////////
void rsDebug(const char *s, float f) {
ALOGD("%s %f, 0x%08x", s, f, *((int *)(&f)));
}
void rsDebug(const char *s, float f1, float f2) {
ALOGD("%s {%f, %f}", s, f1, f2);
}
void rsDebug(const char *s, float f1, float f2, float f3) {
ALOGD("%s {%f, %f, %f}", s, f1, f2, f3);
}
void rsDebug(const char *s, float f1, float f2, float f3, float f4) {
ALOGD("%s {%f, %f, %f, %f}", s, f1, f2, f3, f4);
}
void rsDebug(const char *s, const float2 *f2) {
float2 f = *f2;
ALOGD("%s {%f, %f}", s, f.x, f.y);
}
void rsDebug(const char *s, const float3 *f3) {
float3 f = *f3;
ALOGD("%s {%f, %f, %f}", s, f.x, f.y, f.z);
}
void rsDebug(const char *s, const float4 *f4) {
float4 f = *f4;
ALOGD("%s {%f, %f, %f, %f}", s, f.x, f.y, f.z, f.w);
}
// Accept a half value converted to float. This eliminates the need in the
// driver to properly support the half datatype (either by adding compiler flags
// for half or link against compiler_rt).
void rsDebug(const char *s, float f, ushort us) {
ALOGD("%s {%f} {0x%hx}", s, f, us);
}
void rsDebug(const char *s, const float2 *f2, const ushort2 *us2) {
float2 f = *f2;
ushort2 us = *us2;
ALOGD("%s {%f %f} {0x%hx 0x%hx}", s, f.x, f.y, us.x, us.y);
}
void rsDebug(const char *s, const float3 *f3, const ushort3 *us3) {
float3 f = *f3;
ushort3 us = *us3;
ALOGD("%s {%f %f %f} {0x%hx 0x%hx 0x%hx}", s, f.x, f.y, f.z, us.x, us.y,
us.z);
}
void rsDebug(const char *s, const float4 *f4, const ushort4 *us4) {
float4 f = *f4;
ushort4 us = *us4;
ALOGD("%s {%f %f %f %f} {0x%hx 0x%hx 0x%hx 0x%hx}", s, f.x, f.y, f.z, f.w,
us.x, us.y, us.z, us.w);
}
void rsDebug(const char *s, double d) {
ALOGD("%s %f, 0x%08llx", s, d, *((long long *)(&d)));
}
void rsDebug(const char *s, const double2 *d2) {
double2 d = *d2;
ALOGD("%s {%f, %f}", s, d.x, d.y);
}
void rsDebug(const char *s, const double3 *d3) {
double3 d = *d3;
ALOGD("%s {%f, %f, %f}", s, d.x, d.y, d.z);
}
void rsDebug(const char *s, const double4 *d4) {
double4 d = *d4;
ALOGD("%s {%f, %f, %f, %f}", s, d.x, d.y, d.z, d.w);
}
void rsDebug(const char *s, const rs_matrix4x4 *m) {
float *f = (float *)m;
ALOGD("%s {%f, %f, %f, %f", s, f[0], f[4], f[8], f[12]);
ALOGD("%s %f, %f, %f, %f", s, f[1], f[5], f[9], f[13]);
ALOGD("%s %f, %f, %f, %f", s, f[2], f[6], f[10], f[14]);
ALOGD("%s %f, %f, %f, %f}", s, f[3], f[7], f[11], f[15]);
}
void rsDebug(const char *s, const rs_matrix3x3 *m) {
float *f = (float *)m;
ALOGD("%s {%f, %f, %f", s, f[0], f[3], f[6]);
ALOGD("%s %f, %f, %f", s, f[1], f[4], f[7]);
ALOGD("%s %f, %f, %f}", s, f[2], f[5], f[8]);
}
void rsDebug(const char *s, const rs_matrix2x2 *m) {
float *f = (float *)m;
ALOGD("%s {%f, %f", s, f[0], f[2]);
ALOGD("%s %f, %f}", s, f[1], f[3]);
}
void rsDebug(const char *s, char c) {
ALOGD("%s %hhd 0x%hhx", s, c, (unsigned char)c);
}
void rsDebug(const char *s, const char2 *c2) {
char2 c = *c2;
ALOGD("%s {%hhd, %hhd} 0x%hhx 0x%hhx", s, c.x, c.y, (unsigned char)c.x,
(unsigned char)c.y);
}
void rsDebug(const char *s, const char3 *c3) {
char3 c = *c3;
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);
}
void rsDebug(const char *s, const char4 *c4) {
char4 c = *c4;
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);
}
void rsDebug(const char *s, unsigned char c) {
ALOGD("%s %hhu 0x%hhx", s, c, c);
}
void rsDebug(const char *s, const uchar2 *c2) {
uchar2 c = *c2;
ALOGD("%s {%hhu, %hhu} 0x%hhx 0x%hhx", s, c.x, c.y, c.x, c.y);
}
void rsDebug(const char *s, const uchar3 *c3) {
uchar3 c = *c3;
ALOGD("%s {%hhu, %hhu, %hhu} 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.x,
c.y, c.z);
}
void rsDebug(const char *s, const uchar4 *c4) {
uchar4 c = *c4;
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);
}
void rsDebug(const char *s, short c) { ALOGD("%s %hd 0x%hx", s, c, c); }
void rsDebug(const char *s, const short2 *c2) {
short2 c = *c2;
ALOGD("%s {%hd, %hd} 0x%hx 0x%hx", s, c.x, c.y, c.x, c.y);
}
void rsDebug(const char *s, const short3 *c3) {
short3 c = *c3;
ALOGD("%s {%hd, %hd, %hd} 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y,
c.z);
}
void rsDebug(const char *s, const short4 *c4) {
short4 c = *c4;
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);
}
void rsDebug(const char *s, unsigned short c) {
ALOGD("%s %hu 0x%hx", s, c, c);
}
void rsDebug(const char *s, const ushort2 *c2) {
ushort2 c = *c2;
ALOGD("%s {%hu, %hu} 0x%hx 0x%hx", s, c.x, c.y, c.x, c.y);
}
void rsDebug(const char *s, const ushort3 *c3) {
ushort3 c = *c3;
ALOGD("%s {%hu, %hu, %hu} 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y,
c.z);
}
void rsDebug(const char *s, const ushort4 *c4) {
ushort4 c = *c4;
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);
}
void rsDebug(const char *s, int i) { ALOGD("%s %d 0x%x", s, i, i); }
void rsDebug(const char *s, const int2 *i2) {
int2 i = *i2;
ALOGD("%s {%d, %d} 0x%x 0x%x", s, i.x, i.y, i.x, i.y);
}
void rsDebug(const char *s, const int3 *i3) {
int3 i = *i3;
ALOGD("%s {%d, %d, %d} 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z);
}
void rsDebug(const char *s, const int4 *i4) {
int4 i = *i4;
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);
}
void rsDebug(const char *s, unsigned int i) { ALOGD("%s %u 0x%x", s, i, i); }
void rsDebug(const char *s, const uint2 *i2) {
uint2 i = *i2;
ALOGD("%s {%u, %u} 0x%x 0x%x", s, i.x, i.y, i.x, i.y);
}
void rsDebug(const char *s, const uint3 *i3) {
uint3 i = *i3;
ALOGD("%s {%u, %u, %u} 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z);
}
void rsDebug(const char *s, const uint4 *i4) {
uint4 i = *i4;
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);
}
template <typename T>
static inline long long LL(const T &x) {
return static_cast<long long>(x);
}
template <typename T>
static inline unsigned long long LLu(const T &x) {
return static_cast<unsigned long long>(x);
}
void rsDebug(const char *s, long l) {
ALOGD("%s %lld 0x%llx", s, LL(l), LL(l));
}
void rsDebug(const char *s, long long ll) {
ALOGD("%s %lld 0x%llx", s, LL(ll), LL(ll));
}
void rsDebug(const char *s, const long2 *c) {
long2 ll = *c;
ALOGD("%s {%lld, %lld} 0x%llx 0x%llx", s, LL(ll.x), LL(ll.y), LL(ll.x),
LL(ll.y));
}
void rsDebug(const char *s, const long3 *c) {
long3 ll = *c;
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));
}
void rsDebug(const char *s, const long4 *c) {
long4 ll = *c;
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));
}
void rsDebug(const char *s, unsigned long l) {
unsigned long long ll = l;
ALOGD("%s %llu 0x%llx", s, ll, ll);
}
void rsDebug(const char *s, unsigned long long ll) {
ALOGD("%s %llu 0x%llx", s, ll, ll);
}
void rsDebug(const char *s, const ulong2 *c) {
ulong2 ll = *c;
ALOGD("%s {%llu, %llu} 0x%llx 0x%llx", s, LLu(ll.x), LLu(ll.y), LLu(ll.x),
LLu(ll.y));
}
void rsDebug(const char *s, const ulong3 *c) {
ulong3 ll = *c;
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));
}
void rsDebug(const char *s, const ulong4 *c) {
ulong4 ll = *c;
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));
}
// FIXME: We need to export these function signatures for the compatibility
// library. The C++ name mangling that LLVM uses for ext_vector_type requires
// different versions for "long" vs. "long long". Note that the called
// functions are still using the appropriate 64-bit sizes.
#ifndef __LP64__
typedef long l2 __attribute__((ext_vector_type(2)));
typedef long l3 __attribute__((ext_vector_type(3)));
typedef long l4 __attribute__((ext_vector_type(4)));
typedef unsigned long ul2 __attribute__((ext_vector_type(2)));
typedef unsigned long ul3 __attribute__((ext_vector_type(3)));
typedef unsigned long ul4 __attribute__((ext_vector_type(4)));
void rsDebug(const char *s, const l2 *c) {
long2 ll = *(const long2 *)c;
ALOGD("%s {%lld, %lld} 0x%llx 0x%llx", s, LL(ll.x), LL(ll.y), LL(ll.x),
LL(ll.y));
}
void rsDebug(const char *s, const l3 *c) {
long3 ll = *(const long3 *)c;
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));
}
void rsDebug(const char *s, const l4 *c) {
long4 ll = *(const long4 *)c;
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));
}
void rsDebug(const char *s, const ul2 *c) {
ulong2 ll = *(const ulong2 *)c;
ALOGD("%s {%llu, %llu} 0x%llx 0x%llx", s, LLu(ll.x), LLu(ll.y), LLu(ll.x),
LLu(ll.y));
}
void rsDebug(const char *s, const ul3 *c) {
ulong3 ll = *(const ulong3 *)c;
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));
}
void rsDebug(const char *s, const ul4 *c) {
ulong4 ll = *(const ulong4 *)c;
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));
}
#endif
void rsDebug(const char *s, const long2 ll) {
ALOGD("%s {%lld, %lld} 0x%llx 0x%llx", s, LL(ll.x), LL(ll.y), LL(ll.x),
LL(ll.y));
}
void rsDebug(const char *s, const long3 ll) {
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));
}
void rsDebug(const char *s, const long4 ll) {
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));
}
void rsDebug(const char *s, const ulong2 ll) {
ALOGD("%s {%llu, %llu} 0x%llx 0x%llx", s, LLu(ll.x), LLu(ll.y), LLu(ll.x),
LLu(ll.y));
}
void rsDebug(const char *s, const ulong3 ll) {
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));
}
void rsDebug(const char *s, const ulong4 ll) {
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));
}
void rsDebug(const char *s, const void *p) { ALOGD("%s %p", s, p); }