| /* |
| * 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); } |
