/*
* Copyright (C) 2013 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.
*/
#ifndef ANDROID_RSCPPSTRUCTS_H
#define ANDROID_RSCPPSTRUCTS_H
#include "rsDefines.h"
#include "util/RefBase.h"
#include <pthread.h>
/**
* Every row in an RS allocation is guaranteed to be aligned by this amount, and
* every row in a user-backed allocation must be aligned by this amount.
*/
#define RS_CPU_ALLOCATION_ALIGNMENT 16
struct dispatchTable;
namespace android {
class Surface;
namespace RSC {
typedef void (*ErrorHandlerFunc_t)(uint32_t errorNum, const char *errorText);
typedef void (*MessageHandlerFunc_t)(uint32_t msgNum, const void *msgData, size_t msgLen);
class RS;
class BaseObj;
class Element;
class Type;
class Allocation;
class Script;
class ScriptC;
class Sampler;
/**
* Possible error codes used by RenderScript. Once a status other than RS_SUCCESS
* is returned, the RenderScript context is considered dead and cannot perform any
* additional work.
*/
enum RSError {
RS_SUCCESS = 0, ///< No error
RS_ERROR_INVALID_PARAMETER = 1, ///< An invalid parameter was passed to a function
RS_ERROR_RUNTIME_ERROR = 2, ///< The RenderScript driver returned an error; this is
///< often indicative of a kernel that crashed
RS_ERROR_INVALID_ELEMENT = 3, ///< An invalid Element was passed to a function
RS_ERROR_MAX = 9999
};
/**
* YUV formats supported by the RenderScript API.
*/
enum RSYuvFormat {
RS_YUV_NONE = 0, ///< No YUV data
RS_YUV_YV12 = 1, ///< YUV data in YV12 format
RS_YUV_NV21 = 2, ///< YUV data in NV21 format
RS_YUV_MAX = 3
};
/**
* Flags that can control RenderScript behavior on a per-context level.
*/
enum RSInitFlags {
RS_INIT_SYNCHRONOUS = 1, ///< All RenderScript calls will be synchronous. May reduce latency.
RS_INIT_LOW_LATENCY = 2, ///< Prefer low latency devices over potentially higher throughput devices.
// Bitflag 4 is reserved for the context flag low power
RS_INIT_WAIT_FOR_ATTACH = 8, ///< Kernel execution will hold to give time for a debugger to be attached
RS_INIT_MAX = 16
};
/**
* The RenderScript context. This class controls initialization, resource management, and teardown.
*/
class RS : public android::RSC::LightRefBase<RS> {
public:
RS();
virtual ~RS();
/**
* Initializes a RenderScript context. A context must be initialized before it can be used.
* @param[in] name Directory name to be used by this context. This should be equivalent to
* Context.getCacheDir().
* @param[in] flags Optional flags for this context.
* @return true on success
*/
bool init(const char * name, uint32_t flags = 0);
/**
* Sets the error handler function for this context. This error handler is
* called whenever an error is set.
*
* @param[in] func Error handler function
*/
void setErrorHandler(ErrorHandlerFunc_t func);
/**
* Returns the current error handler function for this context.
*
* @return pointer to current error handler function or NULL if not set
*/
ErrorHandlerFunc_t getErrorHandler() { return mErrorFunc; }
/**
* Sets the message handler function for this context. This message handler
* is called whenever a message is sent from a RenderScript kernel.
*
* @param[in] func Message handler function
*/
void setMessageHandler(MessageHandlerFunc_t func);
/**
* Returns the current message handler function for this context.
*
* @return pointer to current message handler function or NULL if not set
*/
MessageHandlerFunc_t getMessageHandler() { return mMessageFunc; }
/**
* Returns current status for the context.
*
* @return current error
*/
RSError getError();
/**
* Waits for any currently running asynchronous operations to finish. This
* should only be used for performance testing and timing.
*/
void finish();
RsContext getContext() { return mContext; }
void throwError(RSError error, const char *errMsg);
static dispatchTable* dispatch;
private:
static bool usingNative;
static bool initDispatch(int targetApi);
bool init(const char * name, int targetApi, uint32_t flags);
static void * threadProc(void *);
static bool gInitialized;
static pthread_mutex_t gInitMutex;
pthread_t mMessageThreadId;
pid_t mNativeMessageThreadId;
bool mMessageRun;
RsDevice mDev;
RsContext mContext;
RSError mCurrentError;
ErrorHandlerFunc_t mErrorFunc;
MessageHandlerFunc_t mMessageFunc;
bool mInit;
char mCacheDir[PATH_MAX+1];
uint32_t mCacheDirLen;
struct {
sp<const Element> U8;
sp<const Element> U8_2;
sp<const Element> U8_3;
sp<const Element> U8_4;
sp<const Element> I8;
sp<const Element> I8_2;
sp<const Element> I8_3;
sp<const Element> I8_4;
sp<const Element> U16;
sp<const Element> U16_2;
sp<const Element> U16_3;
sp<const Element> U16_4;
sp<const Element> I16;
sp<const Element> I16_2;
sp<const Element> I16_3;
sp<const Element> I16_4;
sp<const Element> U32;
sp<const Element> U32_2;
sp<const Element> U32_3;
sp<const Element> U32_4;
sp<const Element> I32;
sp<const Element> I32_2;
sp<const Element> I32_3;
sp<const Element> I32_4;
sp<const Element> U64;
sp<const Element> U64_2;
sp<const Element> U64_3;
sp<const Element> U64_4;
sp<const Element> I64;
sp<const Element> I64_2;
sp<const Element> I64_3;
sp<const Element> I64_4;
sp<const Element> F32;
sp<const Element> F32_2;
sp<const Element> F32_3;
sp<const Element> F32_4;
sp<const Element> F64;
sp<const Element> F64_2;
sp<const Element> F64_3;
sp<const Element> F64_4;
sp<const Element> BOOLEAN;
sp<const Element> ELEMENT;
sp<const Element> TYPE;
sp<const Element> ALLOCATION;
sp<const Element> SAMPLER;
sp<const Element> SCRIPT;
sp<const Element> MESH;
sp<const Element> PROGRAM_FRAGMENT;
sp<const Element> PROGRAM_VERTEX;
sp<const Element> PROGRAM_RASTER;
sp<const Element> PROGRAM_STORE;
sp<const Element> A_8;
sp<const Element> RGB_565;
sp<const Element> RGB_888;
sp<const Element> RGBA_5551;
sp<const Element> RGBA_4444;
sp<const Element> RGBA_8888;
sp<const Element> YUV;
sp<const Element> MATRIX_4X4;
sp<const Element> MATRIX_3X3;
sp<const Element> MATRIX_2X2;
} mElements;
struct {
sp<const Sampler> CLAMP_NEAREST;
sp<const Sampler> CLAMP_LINEAR;
sp<const Sampler> CLAMP_LINEAR_MIP_LINEAR;
sp<const Sampler> WRAP_NEAREST;
sp<const Sampler> WRAP_LINEAR;
sp<const Sampler> WRAP_LINEAR_MIP_LINEAR;
sp<const Sampler> MIRRORED_REPEAT_NEAREST;
sp<const Sampler> MIRRORED_REPEAT_LINEAR;
sp<const Sampler> MIRRORED_REPEAT_LINEAR_MIP_LINEAR;
} mSamplers;
friend class Sampler;
friend class Element;
friend class ScriptC;
};
/**
* Base class for all RenderScript objects. Not for direct use by developers.
*/
class BaseObj : public android::RSC::LightRefBase<BaseObj> {
public:
void * getID() const;
virtual ~BaseObj();
virtual void updateFromNative();
virtual bool equals(sp<const BaseObj> obj);
protected:
void *mID;
RS* mRS;
const char * mName;
BaseObj(void *id, sp<RS> rs);
void checkValid();
static void * getObjID(sp<const BaseObj> o);
};
/**
* This class provides the primary method through which data is passed to and
* from RenderScript kernels. An Allocation provides the backing store for a
* given Type.
*
* An Allocation also contains a set of usage flags that denote how the
* Allocation could be used. For example, an Allocation may have usage flags
* specifying that it can be used from a script as well as input to a
* Sampler. A developer must synchronize across these different usages using
* syncAll(int) in order to ensure that different users of the Allocation have
* a consistent view of memory. For example, in the case where an Allocation is
* used as the output of one kernel and as Sampler input in a later kernel, a
* developer must call syncAll(RS_ALLOCATION_USAGE_SCRIPT) prior to launching the
* second kernel to ensure correctness.
*/
class Allocation : public BaseObj {
protected:
sp<const Type> mType;
uint32_t mUsage;
sp<Allocation> mAdaptedAllocation;
bool mConstrainedLOD;
bool mConstrainedFace;
bool mConstrainedY;
bool mConstrainedZ;
bool mReadAllowed;
bool mWriteAllowed;
bool mAutoPadding;
uint32_t mSelectedY;
uint32_t mSelectedZ;
uint32_t mSelectedLOD;
RsAllocationCubemapFace mSelectedFace;
uint32_t mCurrentDimX;
uint32_t mCurrentDimY;
uint32_t mCurrentDimZ;
uint32_t mCurrentCount;
void * getIDSafe() const;
void updateCacheInfo(sp<const Type> t);
Allocation(void *id, sp<RS> rs, sp<const Type> t, uint32_t usage);
void validateIsInt64();
void validateIsInt32();
void validateIsInt16();
void validateIsInt8();
void validateIsFloat32();
void validateIsFloat64();
void validateIsObject();
virtual void updateFromNative();
void validate2DRange(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h);
void validate3DRange(uint32_t xoff, uint32_t yoff, uint32_t zoff,
uint32_t w, uint32_t h, uint32_t d);
public:
/**
* Return Type for the allocation.
* @return pointer to underlying Type
*/
sp<const Type> getType() const {
return mType;
}
/**
* Enable/Disable AutoPadding for Vec3 elements.
*
* @param useAutoPadding True: enable AutoPadding; flase: disable AutoPadding
*
*/
void setAutoPadding(bool useAutoPadding) {
mAutoPadding = useAutoPadding;
}
/**
* Propagate changes from one usage of the Allocation to other usages of the Allocation.
* @param[in] srcLocation source location with changes to propagate elsewhere
*/
void syncAll(RsAllocationUsageType srcLocation);
/**
* Send a buffer to the output stream. The contents of the Allocation will
* be undefined after this operation. This operation is only valid if
* USAGE_IO_OUTPUT is set on the Allocation.
*/
void ioSendOutput();
/**
* Receive the latest input into the Allocation. This operation
* is only valid if USAGE_IO_INPUT is set on the Allocation.
*/
void ioGetInput();
#if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB)
/**
* Returns the handle to a raw buffer that is being managed by the screen
* compositor. This operation is only valid for Allocations with USAGE_IO_INPUT.
* @return Surface associated with allocation
*/
sp<Surface> getSurface();
/**
* Associate a Surface with this Allocation. This
* operation is only valid for Allocations with USAGE_IO_OUTPUT.
* @param[in] s Surface to associate with allocation
*/
void setSurface(sp<Surface> s);
#endif
/**
* Generate a mipmap chain. This is only valid if the Type of the Allocation
* includes mipmaps. This function will generate a complete set of mipmaps
* from the top level LOD and place them into the script memory space. If
* the Allocation is also using other memory spaces, a call to
* syncAll(Allocation.USAGE_SCRIPT) is required.
*/
void generateMipmaps();
/**
* Copy an array into part of this Allocation.
* @param[in] off offset of first Element to be overwritten
* @param[in] count number of Elements to copy
* @param[in] data array from which to copy
*/
void copy1DRangeFrom(uint32_t off, size_t count, const void *data);
/**
* Copy part of an Allocation into part of this Allocation.
* @param[in] off offset of first Element to be overwritten
* @param[in] count number of Elements to copy
* @param[in] data Allocation from which to copy
* @param[in] dataOff offset of first Element in data to copy
*/
void copy1DRangeFrom(uint32_t off, size_t count, sp<const Allocation> data, uint32_t dataOff);
/**
* Copy an array into part of this Allocation.
* @param[in] off offset of first Element to be overwritten
* @param[in] count number of Elements to copy
* @param[in] data array from which to copy
*/
void copy1DRangeTo(uint32_t off, size_t count, void *data);
/**
* Copy entire array to an Allocation.
* @param[in] data array from which to copy
*/
void copy1DFrom(const void* data);
/**
* Copy entire Allocation to an array.
* @param[in] data destination array
*/
void copy1DTo(void* data);
/**
* Copy from an array into a rectangular region in this Allocation. The
* array is assumed to be tightly packed.
* @param[in] xoff X offset of region to update in this Allocation
* @param[in] yoff Y offset of region to update in this Allocation
* @param[in] w Width of region to update
* @param[in] h Height of region to update
* @param[in] data Array from which to copy
*/
void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
const void *data);
/**
* Copy from this Allocation into a rectangular region in an array. The
* array is assumed to be tightly packed.
* @param[in] xoff X offset of region to copy from this Allocation
* @param[in] yoff Y offset of region to copy from this Allocation
* @param[in] w Width of region to update
* @param[in] h Height of region to update
* @param[in] data destination array
*/
void copy2DRangeTo(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
void *data);
/**
* Copy from an Allocation into a rectangular region in this Allocation.
* @param[in] xoff X offset of region to update in this Allocation
* @param[in] yoff Y offset of region to update in this Allocation
* @param[in] w Width of region to update
* @param[in] h Height of region to update
* @param[in] data Allocation from which to copy
* @param[in] dataXoff X offset of region to copy from in data
* @param[in] dataYoff Y offset of region to copy from in data
*/
void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
sp<const Allocation> data, uint32_t dataXoff, uint32_t dataYoff);
/**
* Copy from a strided array into a rectangular region in this Allocation.
* @param[in] xoff X offset of region to update in this Allocation
* @param[in] yoff Y offset of region to update in this Allocation
* @param[in] w Width of region to update
* @param[in] h Height of region to update
* @param[in] data array from which to copy
* @param[in] stride stride of data in bytes
*/
void copy2DStridedFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
const void *data, size_t stride);
/**
* Copy from a strided array into this Allocation.
* @param[in] data array from which to copy
* @param[in] stride stride of data in bytes
*/
void copy2DStridedFrom(const void *data, size_t stride);
/**
* Copy from a rectangular region in this Allocation into a strided array.
* @param[in] xoff X offset of region to update in this Allocation
* @param[in] yoff Y offset of region to update in this Allocation
* @param[in] w Width of region to update
* @param[in] h Height of region to update
* @param[in] data destination array
* @param[in] stride stride of data in bytes
*/
void copy2DStridedTo(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
void *data, size_t stride);
/**
* Copy this Allocation into a strided array.
* @param[in] data destination array
* @param[in] stride stride of data in bytes
*/
void copy2DStridedTo(void *data, size_t stride);
/**
* Copy from an array into a 3D region in this Allocation. The
* array is assumed to be tightly packed.
* @param[in] xoff X offset of region to update in this Allocation
* @param[in] yoff Y offset of region to update in this Allocation
* @param[in] zoff Z offset of region to update in this Allocation
* @param[in] w Width of region to update
* @param[in] h Height of region to update
* @param[in] d Depth of region to update
* @param[in] data Array from which to copy
*/
void copy3DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t w,
uint32_t h, uint32_t d, const void* data);
/**
* Copy from an Allocation into a 3D region in this Allocation.
* @param[in] xoff X offset of region to update in this Allocation
* @param[in] yoff Y offset of region to update in this Allocation
* @param[in] zoff Z offset of region to update in this Allocation
* @param[in] w Width of region to update
* @param[in] h Height of region to update
* @param[in] d Depth of region to update
* @param[in] data Allocation from which to copy
* @param[in] dataXoff X offset of region in data to copy from
* @param[in] dataYoff Y offset of region in data to copy from
* @param[in] dataZoff Z offset of region in data to copy from
*/
void copy3DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t zoff,
uint32_t w, uint32_t h, uint32_t d,
sp<const Allocation> data,
uint32_t dataXoff, uint32_t dataYoff, uint32_t dataZoff);
/**
* Copy a 3D region in this Allocation into an array. The
* array is assumed to be tightly packed.
* @param[in] xoff X offset of region to update in this Allocation
* @param[in] yoff Y offset of region to update in this Allocation
* @param[in] zoff Z offset of region to update in this Allocation
* @param[in] w Width of region to update
* @param[in] h Height of region to update
* @param[in] d Depth of region to update
* @param[in] data Array from which to copy
*/
void copy3DRangeTo(uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t w,
uint32_t h, uint32_t d, void* data);
/**
* Creates an Allocation for use by scripts with a given Type.
* @param[in] rs Context to which the Allocation will belong
* @param[in] type Type of the Allocation
* @param[in] mipmaps desired mipmap behavior for the Allocation
* @param[in] usage usage for the Allocation
* @return new Allocation
*/
static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type,
RsAllocationMipmapControl mipmaps, uint32_t usage);
/**
* Creates an Allocation for use by scripts with a given Type and a backing pointer. For use
* with RS_ALLOCATION_USAGE_SHARED.
* @param[in] rs Context to which the Allocation will belong
* @param[in] type Type of the Allocation
* @param[in] mipmaps desired mipmap behavior for the Allocation
* @param[in] usage usage for the Allocation
* @param[in] pointer existing backing store to use for this Allocation if possible
* @return new Allocation
*/
static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type,
RsAllocationMipmapControl mipmaps, uint32_t usage, void * pointer);
/**
* Creates an Allocation for use by scripts with a given Type with no mipmaps.
* @param[in] rs Context to which the Allocation will belong
* @param[in] type Type of the Allocation
* @param[in] usage usage for the Allocation
* @return new Allocation
*/
static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type,
uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
/**
* Creates an Allocation with a specified number of given elements.
* @param[in] rs Context to which the Allocation will belong
* @param[in] e Element used in the Allocation
* @param[in] count Number of elements of the Allocation
* @param[in] usage usage for the Allocation
* @return new Allocation
*/
static sp<Allocation> createSized(sp<RS> rs, sp<const Element> e, size_t count,
uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
/**
* Creates a 2D Allocation with a specified number of given elements.
* @param[in] rs Context to which the Allocation will belong
* @param[in] e Element used in the Allocation
* @param[in] x Width in Elements of the Allocation
* @param[in] y Height of the Allocation
* @param[in] usage usage for the Allocation
* @return new Allocation
*/
static sp<Allocation> createSized2D(sp<RS> rs, sp<const Element> e,
size_t x, size_t y,
uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
/**
* Get the backing pointer for a USAGE_SHARED allocation.
* @param[in] stride optional parameter. when non-NULL, will contain
* stride in bytes of a 2D Allocation
* @return pointer to data
*/
void * getPointer(size_t *stride = NULL);
};
/**
* An Element represents one item within an Allocation. An Element is roughly
* equivalent to a C type in a RenderScript kernel. Elements may be basic
* or complex. Some basic elements are:
* - A single float value (equivalent to a float in a kernel)
* - A four-element float vector (equivalent to a float4 in a kernel)
* - An unsigned 32-bit integer (equivalent to an unsigned int in a kernel)
* - A single signed 8-bit integer (equivalent to a char in a kernel)
* Basic Elements are comprised of a Element.DataType and a
* Element.DataKind. The DataType encodes C type information of an Element,
* while the DataKind encodes how that Element should be interpreted by a
* Sampler. Note that Allocation objects with DataKind USER cannot be used as
* input for a Sampler. In general, Allocation objects that are intended for
* use with a Sampler should use bitmap-derived Elements such as
* Element::RGBA_8888.
*/
class Element : public BaseObj {
public:
bool isComplex();
/**
* Elements could be simple, such as an int or a float, or a structure with
* multiple sub-elements, such as a collection of floats, float2,
* float4. This function returns zero for simple elements or the number of
* sub-elements otherwise.
* @return number of sub-elements
*/
size_t getSubElementCount() {
return mVisibleElementMapSize;
}
/**
* For complex Elements, this returns the sub-element at a given index.
* @param[in] index index of sub-element
* @return sub-element
*/
sp<const Element> getSubElement(uint32_t index);
/**
* For complex Elements, this returns the name of the sub-element at a given
* index.
* @param[in] index index of sub-element
* @return name of sub-element
*/
const char * getSubElementName(uint32_t index);
/**
* For complex Elements, this returns the size of the sub-element at a given
* index.
* @param[in] index index of sub-element
* @return size of sub-element
*/
size_t getSubElementArraySize(uint32_t index);
/**
* Returns the location of a sub-element within a complex Element.
* @param[in] index index of sub-element
* @return offset in bytes
*/
uint32_t getSubElementOffsetBytes(uint32_t index);
/**
* Returns the data type used for the Element.
* @return data type
*/
RsDataType getDataType() const {
return mType;
}
/**
* Returns the data kind used for the Element.
* @return data kind
*/
RsDataKind getDataKind() const {
return mKind;
}
/**
* Returns the size in bytes of the Element.
* @return size in bytes
*/
size_t getSizeBytes() const {
return mSizeBytes;
}
/**
* Returns the number of vector components for this Element.
* @return number of vector components
*/
uint32_t getVectorSize() const {
return mVectorSize;
}
/**
* Utility function for returning an Element containing a single bool.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> BOOLEAN(sp<RS> rs);
/**
* Utility function for returning an Element containing a single unsigned char.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U8(sp<RS> rs);
/**
* Utility function for returning an Element containing a single signed char.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I8(sp<RS> rs);
/**
* Utility function for returning an Element containing a single unsigned short.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U16(sp<RS> rs);
/**
* Utility function for returning an Element containing a single signed short.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I16(sp<RS> rs);
/**
* Utility function for returning an Element containing a single unsigned int.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U32(sp<RS> rs);
/**
* Utility function for returning an Element containing a single signed int.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I32(sp<RS> rs);
/**
* Utility function for returning an Element containing a single unsigned long long.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U64(sp<RS> rs);
/**
* Utility function for returning an Element containing a single signed long long.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I64(sp<RS> rs);
/**
* Utility function for returning an Element containing a single float.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> F32(sp<RS> rs);
/**
* Utility function for returning an Element containing a single double.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> F64(sp<RS> rs);
/**
* Utility function for returning an Element containing a single Element.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> ELEMENT(sp<RS> rs);
/**
* Utility function for returning an Element containing a single Type.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> TYPE(sp<RS> rs);
/**
* Utility function for returning an Element containing a single Allocation.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> ALLOCATION(sp<RS> rs);
/**
* Utility function for returning an Element containing a single Sampler.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> SAMPLER(sp<RS> rs);
/**
* Utility function for returning an Element containing a single Script.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> SCRIPT(sp<RS> rs);
/**
* Utility function for returning an Element containing an ALPHA_8 pixel.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> A_8(sp<RS> rs);
/**
* Utility function for returning an Element containing an RGB_565 pixel.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> RGB_565(sp<RS> rs);
/**
* Utility function for returning an Element containing an RGB_888 pixel.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> RGB_888(sp<RS> rs);
/**
* Utility function for returning an Element containing an RGBA_5551 pixel.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> RGBA_5551(sp<RS> rs);
/**
* Utility function for returning an Element containing an RGBA_4444 pixel.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> RGBA_4444(sp<RS> rs);
/**
* Utility function for returning an Element containing an RGBA_8888 pixel.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> RGBA_8888(sp<RS> rs);
/**
* Utility function for returning an Element containing a float2.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> F32_2(sp<RS> rs);
/**
* Utility function for returning an Element containing a float3.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> F32_3(sp<RS> rs);
/**
* Utility function for returning an Element containing a float4.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> F32_4(sp<RS> rs);
/**
* Utility function for returning an Element containing a double2.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> F64_2(sp<RS> rs);
/**
* Utility function for returning an Element containing a double3.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> F64_3(sp<RS> rs);
/**
* Utility function for returning an Element containing a double4.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> F64_4(sp<RS> rs);
/**
* Utility function for returning an Element containing a uchar2.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U8_2(sp<RS> rs);
/**
* Utility function for returning an Element containing a uchar3.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U8_3(sp<RS> rs);
/**
* Utility function for returning an Element containing a uchar4.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U8_4(sp<RS> rs);
/**
* Utility function for returning an Element containing a char2.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I8_2(sp<RS> rs);
/**
* Utility function for returning an Element containing a char3.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I8_3(sp<RS> rs);
/**
* Utility function for returning an Element containing a char4.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I8_4(sp<RS> rs);
/**
* Utility function for returning an Element containing a ushort2.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U16_2(sp<RS> rs);
/**
* Utility function for returning an Element containing a ushort3.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U16_3(sp<RS> rs);
/**
* Utility function for returning an Element containing a ushort4.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U16_4(sp<RS> rs);
/**
* Utility function for returning an Element containing a short2.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I16_2(sp<RS> rs);
/**
* Utility function for returning an Element containing a short3.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I16_3(sp<RS> rs);
/**
* Utility function for returning an Element containing a short4.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I16_4(sp<RS> rs);
/**
* Utility function for returning an Element containing a uint2.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U32_2(sp<RS> rs);
/**
* Utility function for returning an Element containing a uint3.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U32_3(sp<RS> rs);
/**
* Utility function for returning an Element containing a uint4.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U32_4(sp<RS> rs);
/**
* Utility function for returning an Element containing an int2.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I32_2(sp<RS> rs);
/**
* Utility function for returning an Element containing an int3.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I32_3(sp<RS> rs);
/**
* Utility function for returning an Element containing an int4.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I32_4(sp<RS> rs);
/**
* Utility function for returning an Element containing a ulong2.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U64_2(sp<RS> rs);
/**
* Utility function for returning an Element containing a ulong3.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U64_3(sp<RS> rs);
/**
* Utility function for returning an Element containing a ulong4.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> U64_4(sp<RS> rs);
/**
* Utility function for returning an Element containing a long2.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I64_2(sp<RS> rs);
/**
* Utility function for returning an Element containing a long3.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I64_3(sp<RS> rs);
/**
* Utility function for returning an Element containing a long4.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> I64_4(sp<RS> rs);
/**
* Utility function for returning an Element containing a YUV pixel.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> YUV(sp<RS> rs);
/**
* Utility function for returning an Element containing an rs_matrix_4x4.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> MATRIX_4X4(sp<RS> rs);
/**
* Utility function for returning an Element containing an rs_matrix_3x3.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> MATRIX_3X3(sp<RS> rs);
/**
* Utility function for returning an Element containing an rs_matrix_2x2.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> MATRIX_2X2(sp<RS> rs);
void updateFromNative();
/**
* Create an Element with a given DataType.
* @param[in] rs RenderScript context
* @param[in] dt data type
* @return Element
*/
static sp<const Element> createUser(sp<RS> rs, RsDataType dt);
/**
* Create a vector Element with the given DataType
* @param[in] rs RenderScript
* @param[in] dt DataType
* @param[in] size vector size
* @return Element
*/
static sp<const Element> createVector(sp<RS> rs, RsDataType dt, uint32_t size);
/**
* Create an Element with a given DataType and DataKind.
* @param[in] rs RenderScript context
* @param[in] dt DataType
* @param[in] dk DataKind
* @return Element
*/
static sp<const Element> createPixel(sp<RS> rs, RsDataType dt, RsDataKind dk);
/**
* Returns true if the Element can interoperate with this Element.
* @param[in] e Element to compare
* @return true if Elements can interoperate
*/
bool isCompatible(sp<const Element>e) const;
/**
* Builder class for producing complex elements with matching field and name
* pairs. The builder starts empty. The order in which elements are added is
* retained for the layout in memory.
*/
class Builder {
private:
RS* mRS;
size_t mElementsCount;
size_t mElementsVecSize;
sp<const Element> * mElements;
char ** mElementNames;
size_t * mElementNameLengths;
uint32_t * mArraySizes;
bool mSkipPadding;
public:
Builder(sp<RS> rs);
~Builder();
void add(sp<const Element> e, const char * name, uint32_t arraySize = 1);
sp<const Element> create();
};
protected:
Element(void *id, sp<RS> rs,
sp<const Element> * elements,
size_t elementCount,
const char ** elementNames,
size_t * elementNameLengths,
uint32_t * arraySizes);
Element(void *id, sp<RS> rs, RsDataType dt, RsDataKind dk, bool norm, uint32_t size);
Element(sp<RS> rs);
virtual ~Element();
private:
void updateVisibleSubElements();
size_t mElementsCount;
size_t mVisibleElementMapSize;
sp<const Element> * mElements;
char ** mElementNames;
size_t * mElementNameLengths;
uint32_t * mArraySizes;
uint32_t * mVisibleElementMap;
uint32_t * mOffsetInBytes;
RsDataType mType;
RsDataKind mKind;
bool mNormalized;
size_t mSizeBytes;
size_t mVectorSize;
};
class FieldPacker {
protected:
unsigned char* mData;
size_t mPos;
size_t mLen;
public:
FieldPacker(size_t len)
: mPos(0), mLen(len) {
mData = new unsigned char[len];
}
virtual ~FieldPacker() {
delete [] mData;
}
void align(size_t v) {
if ((v & (v - 1)) != 0) {
// ALOGE("Non-power-of-two alignment: %zu", v);
return;
}
while ((mPos & (v - 1)) != 0) {
mData[mPos++] = 0;
}
}
void reset() {
mPos = 0;
}
void reset(size_t i) {
if (i >= mLen) {
// ALOGE("Out of bounds: i (%zu) >= len (%zu)", i, mLen);
return;
}
mPos = i;
}
void skip(size_t i) {
size_t res = mPos + i;
if (res > mLen) {
// ALOGE("Exceeded buffer length: i (%zu) > len (%zu)", i, mLen);
return;
}
mPos = res;
}
void* getData() const {
return mData;
}
size_t getLength() const {
return mLen;
}
template <typename T>
void add(T t) {
align(sizeof(t));
if (mPos + sizeof(t) <= mLen) {
memcpy(&mData[mPos], &t, sizeof(t));
mPos += sizeof(t);
}
}
/*
void add(rs_matrix4x4 m) {
for (size_t i = 0; i < 16; i++) {
add(m.m[i]);
}
}
void add(rs_matrix3x3 m) {
for (size_t i = 0; i < 9; i++) {
add(m.m[i]);
}
}
void add(rs_matrix2x2 m) {
for (size_t i = 0; i < 4; i++) {
add(m.m[i]);
}
}
*/
void add(sp<BaseObj> obj) {
if (obj != NULL) {
add((uint32_t) (uintptr_t) obj->getID());
} else {
add((uint32_t) 0);
}
}
};
/**
* A Type describes the Element and dimensions used for an Allocation or a
* parallel operation.
*
* A Type always includes an Element and an X dimension. A Type may be
* multidimensional, up to three dimensions. A nonzero value in the Y or Z
* dimensions indicates that the dimension is present. Note that a Type with
* only a given X dimension and a Type with the same X dimension but Y = 1 are
* not equivalent.
*
* A Type also supports inclusion of level of detail (LOD) or cube map
* faces. LOD and cube map faces are booleans to indicate present or not
* present.
*
* A Type also supports YUV format information to support an Allocation in a YUV
* format. The YUV formats supported are YV12 and NV21.
*/
class Type : public BaseObj {
protected:
friend class Allocation;
uint32_t mDimX;
uint32_t mDimY;
uint32_t mDimZ;
RSYuvFormat mYuvFormat;
bool mDimMipmaps;
bool mDimFaces;
size_t mElementCount;
sp<const Element> mElement;
Type(void *id, sp<RS> rs);
void calcElementCount();
virtual void updateFromNative();
public:
/**
* Returns the YUV format.
* @return YUV format of the Allocation
*/
RSYuvFormat getYuvFormat() const {
return mYuvFormat;
}
/**
* Returns the Element of the Allocation.
* @return YUV format of the Allocation
*/
sp<const Element> getElement() const {
return mElement;
}
/**
* Returns the X dimension of the Allocation.
* @return X dimension of the allocation
*/
uint32_t getX() const {
return mDimX;
}
/**
* Returns the Y dimension of the Allocation.
* @return Y dimension of the allocation
*/
uint32_t getY() const {
return mDimY;
}
/**
* Returns the Z dimension of the Allocation.
* @return Z dimension of the allocation
*/
uint32_t getZ() const {
return mDimZ;
}
/**
* Returns true if the Allocation has mipmaps.
* @return true if the Allocation has mipmaps
*/
bool hasMipmaps() const {
return mDimMipmaps;
}
/**
* Returns true if the Allocation is a cube map
* @return true if the Allocation is a cube map
*/
bool hasFaces() const {
return mDimFaces;
}
/**
* Returns number of accessible Elements in the Allocation
* @return number of accessible Elements in the Allocation
*/
size_t getCount() const {
return mElementCount;
}
/**
* Returns size in bytes of all Elements in the Allocation
* @return size in bytes of all Elements in the Allocation
*/
size_t getSizeBytes() const {
return mElementCount * mElement->getSizeBytes();
}
/**
* Creates a new Type with the given Element and dimensions.
* @param[in] rs RenderScript context
* @param[in] e Element
* @param[in] dimX X dimension
* @param[in] dimY Y dimension
* @param[in] dimZ Z dimension
* @return new Type
*/
static sp<const Type> create(sp<RS> rs, sp<const Element> e, uint32_t dimX, uint32_t dimY, uint32_t dimZ);
class Builder {
protected:
RS* mRS;
uint32_t mDimX;
uint32_t mDimY;
uint32_t mDimZ;
RSYuvFormat mYuvFormat;
bool mDimMipmaps;
bool mDimFaces;
sp<const Element> mElement;
public:
Builder(sp<RS> rs, sp<const Element> e);
void setX(uint32_t value);
void setY(uint32_t value);
void setZ(uint32_t value);
void setYuvFormat(RSYuvFormat format);
void setMipmaps(bool value);
void setFaces(bool value);
sp<const Type> create();
};
};
/**
* The parent class for all executable Scripts. This should not be used by applications.
*/
class Script : public BaseObj {
private:
protected:
Script(void *id, sp<RS> rs);
void forEach(uint32_t slot, sp<const Allocation> in, sp<const Allocation> out,
const void *v, size_t) const;
void bindAllocation(sp<Allocation> va, uint32_t slot) const;
void setVar(uint32_t index, const void *, size_t len) const;
void setVar(uint32_t index, sp<const BaseObj> o) const;
void invoke(uint32_t slot, const void *v, size_t len) const;
void invoke(uint32_t slot) const {
invoke(slot, NULL, 0);
}
void setVar(uint32_t index, float v) const {
setVar(index, &v, sizeof(v));
}
void setVar(uint32_t index, double v) const {
setVar(index, &v, sizeof(v));
}
void setVar(uint32_t index, int32_t v) const {
setVar(index, &v, sizeof(v));
}
void setVar(uint32_t index, uint32_t v) const {
setVar(index, &v, sizeof(v));
}
void setVar(uint32_t index, int64_t v) const {
setVar(index, &v, sizeof(v));
}
void setVar(uint32_t index, bool v) const {
setVar(index, &v, sizeof(v));
}
public:
class FieldBase {
protected:
sp<const Element> mElement;
sp<Allocation> mAllocation;
void init(sp<RS> rs, uint32_t dimx, uint32_t usages = 0);
public:
sp<const Element> getElement() {
return mElement;
}
sp<const Type> getType() {
return mAllocation->getType();
}
sp<const Allocation> getAllocation() {
return mAllocation;
}
//void updateAllocation();
};
};
/**
* The parent class for all user-defined scripts. This is intended to be used by auto-generated code only.
*/
class ScriptC : public Script {
protected:
ScriptC(sp<RS> rs,
const void *codeTxt, size_t codeLength,
const char *cachedName, size_t cachedNameLength,
const char *cacheDir, size_t cacheDirLength);
};
/**
* The parent class for all script intrinsics. Intrinsics provide highly optimized implementations of
* basic functions. This is not intended to be used directly.
*/
class ScriptIntrinsic : public Script {
protected:
sp<const Element> mElement;
ScriptIntrinsic(sp<RS> rs, int id, sp<const Element> e);
virtual ~ScriptIntrinsic();
};
/**
* Intrinsic for converting RGB to RGBA by using a 3D lookup table. The incoming
* r,g,b values are use as normalized x,y,z coordinates into a 3D
* allocation. The 8 nearest values are sampled and linearly interpolated. The
* result is placed in the output.
*/
class ScriptIntrinsic3DLUT : public ScriptIntrinsic {
private:
ScriptIntrinsic3DLUT(sp<RS> rs, sp<const Element> e);
public:
/**
* Supported Element types are U8_4. Default lookup table is identity.
* @param[in] rs RenderScript context
* @param[in] e Element
* @return new ScriptIntrinsic
*/
static sp<ScriptIntrinsic3DLUT> create(sp<RS> rs, sp<const Element> e);
/**
* Launch the intrinsic.
* @param[in] ain input Allocation
* @param[in] aout output Allocation
*/
void forEach(sp<Allocation> ain, sp<Allocation> aout);
/**
* Sets the lookup table. The lookup table must use the same Element as the
* intrinsic.
* @param[in] lut new lookup table
*/
void setLUT(sp<Allocation> lut);
};
/**
* Intrinsic kernel for blending two Allocations.
*/
class ScriptIntrinsicBlend : public ScriptIntrinsic {
private:
ScriptIntrinsicBlend(sp<RS> rs, sp<const Element> e);
public:
/**
* Supported Element types are U8_4.
* @param[in] rs RenderScript context
* @param[in] e Element
* @return new ScriptIntrinsicBlend
*/
static sp<ScriptIntrinsicBlend> create(sp<RS> rs, sp<const Element> e);
/**
* sets dst = {0, 0, 0, 0}
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachClear(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst = src
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachSrc(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst = dst (NOP)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachDst(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst = src + dst * (1.0 - src.a)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachSrcOver(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst = dst + src * (1.0 - dst.a)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachDstOver(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst = src * dst.a
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachSrcIn(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst = dst * src.a
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachDstIn(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst = src * (1.0 - dst.a)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachSrcOut(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst = dst * (1.0 - src.a)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachDstOut(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst.rgb = src.rgb * dst.a + (1.0 - src.a) * dst.rgb
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachSrcAtop(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst.rgb = dst.rgb * src.a + (1.0 - dst.a) * src.rgb
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachDstAtop(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst = {src.r ^ dst.r, src.g ^ dst.g, src.b ^ dst.b, src.a ^ dst.a}
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachXor(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst = src * dst
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachMultiply(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst = min(src + dst, 1.0)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachAdd(sp<Allocation> in, sp<Allocation> out);
/**
* Sets dst = max(dst - src, 0.0)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachSubtract(sp<Allocation> in, sp<Allocation> out);
};
/**
* Intrinsic Gausian blur filter. Applies a Gaussian blur of the specified
* radius to all elements of an Allocation.
*/
class ScriptIntrinsicBlur : public ScriptIntrinsic {
private:
ScriptIntrinsicBlur(sp<RS> rs, sp<const Element> e);
public:
/**
* Supported Element types are U8 and U8_4.
* @param[in] rs RenderScript context
* @param[in] e Element
* @return new ScriptIntrinsicBlur
*/
static sp<ScriptIntrinsicBlur> create(sp<RS> rs, sp<const Element> e);
/**
* Sets the input of the blur.
* @param[in] in input Allocation
*/
void setInput(sp<Allocation> in);
/**
* Runs the intrinsic.
* @param[in] output Allocation
*/
void forEach(sp<Allocation> out);
/**
* Sets the radius of the blur. The supported range is 0 < radius <= 25.
* @param[in] radius radius of the blur
*/
void setRadius(float radius);
};
/**
* Intrinsic for applying a color matrix to allocations. This has the
* same effect as loading each element and converting it to a
* F32_N, multiplying the result by the 4x4 color matrix
* as performed by rsMatrixMultiply() and writing it to the output
* after conversion back to U8_N or F32_N.
*/
class ScriptIntrinsicColorMatrix : public ScriptIntrinsic {
private:
ScriptIntrinsicColorMatrix(sp<RS> rs, sp<const Element> e);
public:
/**
* Creates a new intrinsic.
* @param[in] rs RenderScript context
* @return new ScriptIntrinsicColorMatrix
*/
static sp<ScriptIntrinsicColorMatrix> create(sp<RS> rs);
/**
* Applies the color matrix. Supported types are U8 and F32 with
* vector lengths between 1 and 4.
* @param[in] in input Allocation
* @param[out] out output Allocation
*/
void forEach(sp<Allocation> in, sp<Allocation> out);
/**
* Set the value to be added after the color matrix has been
* applied. The default value is {0, 0, 0, 0}.
* @param[in] add float[4] of values
*/
void setAdd(float* add);
/**
* Set the color matrix which will be applied to each cell of the
* image. The alpha channel will be copied.
*
* @param[in] m float[9] of values
*/
void setColorMatrix3(float* m);
/**
* Set the color matrix which will be applied to each cell of the
* image.
*
* @param[in] m float[16] of values
*/
void setColorMatrix4(float* m);
/**
* Set a color matrix to convert from RGB to luminance. The alpha
* channel will be a copy.
*/
void setGreyscale();
/**
* Set the matrix to convert from RGB to YUV with a direct copy of
* the 4th channel.
*/
void setRGBtoYUV();
/**
* Set the matrix to convert from YUV to RGB with a direct copy of
* the 4th channel.
*/
void setYUVtoRGB();
};
/**
* Intrinsic for applying a 3x3 convolve to an allocation.
*/
class ScriptIntrinsicConvolve3x3 : public ScriptIntrinsic {
private:
ScriptIntrinsicConvolve3x3(sp<RS> rs, sp<const Element> e);
public:
/**
* Supported types U8 and F32 with vector lengths between 1 and
* 4. The default convolution kernel is the identity.
* @param[in] rs RenderScript context
* @param[in] e Element
* @return new ScriptIntrinsicConvolve3x3
*/
static sp<ScriptIntrinsicConvolve3x3> create(sp<RS> rs, sp<const Element> e);
/**
* Sets input for intrinsic.
* @param[in] in input Allocation
*/
void setInput(sp<Allocation> in);
/**
* Launches the intrinsic.
* @param[in] out output Allocation
*/
void forEach(sp<Allocation> out);
/**
* Sets convolution kernel.
* @param[in] v float[9] of values
*/
void setCoefficients(float* v);
};
/**
* Intrinsic for applying a 5x5 convolve to an allocation.
*/
class ScriptIntrinsicConvolve5x5 : public ScriptIntrinsic {
private:
ScriptIntrinsicConvolve5x5(sp<RS> rs, sp<const Element> e);
public:
/**
* Supported types U8 and F32 with vector lengths between 1 and
* 4. The default convolution kernel is the identity.
* @param[in] rs RenderScript context
* @param[in] e Element
* @return new ScriptIntrinsicConvolve5x5
*/
static sp<ScriptIntrinsicConvolve5x5> create(sp<RS> rs, sp<const Element> e);
/**
* Sets input for intrinsic.
* @param[in] in input Allocation
*/
void setInput(sp<Allocation> in);
/**
* Launches the intrinsic.
* @param[in] out output Allocation
*/
void forEach(sp<Allocation> out);
/**
* Sets convolution kernel.
* @param[in] v float[25] of values
*/
void setCoefficients(float* v);
};
/**
* Intrinsic for computing a histogram.
*/
class ScriptIntrinsicHistogram : public ScriptIntrinsic {
private:
ScriptIntrinsicHistogram(sp<RS> rs, sp<const Element> e);
sp<Allocation> mOut;
public:
/**
* Create an intrinsic for calculating the histogram of an uchar
* or uchar4 image.
*
* Supported elements types are U8_4, U8_3, U8_2, and U8.
*
* @param[in] rs The RenderScript context
* @param[in] e Element type for inputs
*
* @return ScriptIntrinsicHistogram
*/
static sp<ScriptIntrinsicHistogram> create(sp<RS> rs, sp<const Element> e);
/**
* Set the output of the histogram. 32 bit integer types are
* supported.
*
* @param[in] aout The output allocation
*/
void setOutput(sp<Allocation> aout);
/**
* Set the coefficients used for the dot product calculation. The
* default is {0.299f, 0.587f, 0.114f, 0.f}.
*
* Coefficients must be >= 0 and sum to 1.0 or less.
*
* @param[in] r Red coefficient
* @param[in] g Green coefficient
* @param[in] b Blue coefficient
* @param[in] a Alpha coefficient
*/
void setDotCoefficients(float r, float g, float b, float a);
/**
* Process an input buffer and place the histogram into the output
* allocation. The output allocation may be a narrower vector size
* than the input. In this case the vector size of the output is
* used to determine how many of the input channels are used in
* the computation. This is useful if you have an RGBA input
* buffer but only want the histogram for RGB.
*
* 1D and 2D input allocations are supported.
*
* @param[in] ain The input image
*/
void forEach(sp<Allocation> ain);
/**
* Process an input buffer and place the histogram into the output
* allocation. The dot product of the input channel and the
* coefficients from 'setDotCoefficients' are used to calculate
* the output values.
*
* 1D and 2D input allocations are supported.
*
* @param ain The input image
*/
void forEach_dot(sp<Allocation> ain);
};
/**
* Intrinsic for applying a per-channel lookup table. Each channel of
* the input has an independant lookup table. The tables are 256
* entries in size and can cover the full value range of U8_4.
**/
class ScriptIntrinsicLUT : public ScriptIntrinsic {
private:
sp<Allocation> LUT;
bool mDirty;
unsigned char mCache[1024];
void setTable(unsigned int offset, unsigned char base, unsigned int length, unsigned char* lutValues);
ScriptIntrinsicLUT(sp<RS> rs, sp<const Element> e);
public:
/**
* Supported elements types are U8_4.
*
* The defaults tables are identity.
*
* @param[in] rs The RenderScript context
* @param[in] e Element type for intputs and outputs
*
* @return ScriptIntrinsicLUT
*/
static sp<ScriptIntrinsicLUT> create(sp<RS> rs, sp<const Element> e);
/**
* Invoke the kernel and apply the lookup to each cell of ain and
* copy to aout.
*
* @param[in] ain Input allocation
* @param[in] aout Output allocation
*/
void forEach(sp<Allocation> ain, sp<Allocation> aout);
/**
* Sets entries in LUT for the red channel.
* @param[in] base base of region to update
* @param[in] length length of region to update
* @param[in] lutValues LUT values to use
*/
void setRed(unsigned char base, unsigned int length, unsigned char* lutValues);
/**
* Sets entries in LUT for the green channel.
* @param[in] base base of region to update
* @param[in] length length of region to update
* @param[in] lutValues LUT values to use
*/
void setGreen(unsigned char base, unsigned int length, unsigned char* lutValues);
/**
* Sets entries in LUT for the blue channel.
* @param[in] base base of region to update
* @param[in] length length of region to update
* @param[in] lutValues LUT values to use
*/
void setBlue(unsigned char base, unsigned int length, unsigned char* lutValues);
/**
* Sets entries in LUT for the alpha channel.
* @param[in] base base of region to update
* @param[in] length length of region to update
* @param[in] lutValues LUT values to use
*/
void setAlpha(unsigned char base, unsigned int length, unsigned char* lutValues);
virtual ~ScriptIntrinsicLUT();
};
/**
* Intrinsic for performing a resize of a 2D allocation.
*/
class ScriptIntrinsicResize : public ScriptIntrinsic {
private:
sp<Allocation> mInput;
ScriptIntrinsicResize(sp<RS> rs, sp<const Element> e);
public:
/**
* Supported Element types are U8_4. Default lookup table is identity.
* @param[in] rs RenderScript context
* @param[in] e Element
* @return new ScriptIntrinsic
*/
static sp<ScriptIntrinsicResize> create(sp<RS> rs);
/**
* Resize copy the input allocation to the output specified. The
* Allocation is rescaled if necessary using bi-cubic
* interpolation.
* @param[in] ain input Allocation
* @param[in] aout output Allocation
*/
void forEach_bicubic(sp<Allocation> aout);
/**
* Set the input of the resize.
* @param[in] lut new lookup table
*/
void setInput(sp<Allocation> ain);
};
/**
* Intrinsic for converting an Android YUV buffer to RGB.
*
* The input allocation should be supplied in a supported YUV format
* as a YUV element Allocation. The output is RGBA; the alpha channel
* will be set to 255.
*/
class ScriptIntrinsicYuvToRGB : public ScriptIntrinsic {
private:
ScriptIntrinsicYuvToRGB(sp<RS> rs, sp<const Element> e);
public:
/**
* Create an intrinsic for converting YUV to RGB.
*
* Supported elements types are U8_4.
*
* @param[in] rs The RenderScript context
* @param[in] e Element type for output
*
* @return ScriptIntrinsicYuvToRGB
*/
static sp<ScriptIntrinsicYuvToRGB> create(sp<RS> rs, sp<const Element> e);
/**
* Set the input YUV allocation.
*
* @param[in] ain The input allocation.
*/
void setInput(sp<Allocation> in);
/**
* Convert the image to RGB.
*
* @param[in] aout Output allocation. Must match creation element
* type.
*/
void forEach(sp<Allocation> out);
};
/**
* Sampler object that defines how Allocations can be read as textures
* within a kernel. Samplers are used in conjunction with the rsSample
* runtime function to return values from normalized coordinates.
*
* Any Allocation used with a Sampler must have been created with
* RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE; using a Sampler on an
* Allocation that was not created with
* RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE is undefined.
**/
class Sampler : public BaseObj {
private:
Sampler(sp<RS> rs, void* id);
Sampler(sp<RS> rs, void* id, RsSamplerValue min, RsSamplerValue mag,
RsSamplerValue wrapS, RsSamplerValue wrapT, float anisotropy);
RsSamplerValue mMin;
RsSamplerValue mMag;
RsSamplerValue mWrapS;
RsSamplerValue mWrapT;
float mAniso;
public:
/**
* Creates a non-standard Sampler.
* @param[in] rs RenderScript context
* @param[in] min minification
* @param[in] mag magnification
* @param[in] wrapS S wrapping mode
* @param[in] wrapT T wrapping mode
* @param[in] anisotropy anisotropy setting
*/
static sp<Sampler> create(sp<RS> rs, RsSamplerValue min, RsSamplerValue mag, RsSamplerValue wrapS, RsSamplerValue wrapT, float anisotropy);
/**
* @return minification setting for the sampler
*/
RsSamplerValue getMinification();
/**
* @return magnification setting for the sampler
*/
RsSamplerValue getMagnification();
/**
* @return S wrapping mode for the sampler
*/
RsSamplerValue getWrapS();
/**
* @return T wrapping mode for the sampler
*/
RsSamplerValue getWrapT();
/**
* @return anisotropy setting for the sampler
*/
float getAnisotropy();
/**
* Retrieve a sampler with min and mag set to nearest and wrap modes set to
* clamp.
*
* @param rs Context to which the sampler will belong.
*
* @return Sampler
*/
static sp<const Sampler> CLAMP_NEAREST(sp<RS> rs);
/**
* Retrieve a sampler with min and mag set to linear and wrap modes set to
* clamp.
*
* @param rs Context to which the sampler will belong.
*
* @return Sampler
*/
static sp<const Sampler> CLAMP_LINEAR(sp<RS> rs);
/**
* Retrieve a sampler with mag set to linear, min linear mipmap linear, and
* wrap modes set to clamp.
*
* @param rs Context to which the sampler will belong.
*
* @return Sampler
*/
static sp<const Sampler> CLAMP_LINEAR_MIP_LINEAR(sp<RS> rs);
/**
* Retrieve a sampler with min and mag set to nearest and wrap modes set to
* wrap.
*
* @param rs Context to which the sampler will belong.
*
* @return Sampler
*/
static sp<const Sampler> WRAP_NEAREST(sp<RS> rs);
/**
* Retrieve a sampler with min and mag set to linear and wrap modes set to
* wrap.
*
* @param rs Context to which the sampler will belong.
*
* @return Sampler
*/
static sp<const Sampler> WRAP_LINEAR(sp<RS> rs);
/**
* Retrieve a sampler with mag set to linear, min linear mipmap linear, and
* wrap modes set to wrap.
*
* @param rs Context to which the sampler will belong.
*
* @return Sampler
*/
static sp<const Sampler> WRAP_LINEAR_MIP_LINEAR(sp<RS> rs);
/**
* Retrieve a sampler with min and mag set to nearest and wrap modes set to
* mirrored repeat.
*
* @param rs Context to which the sampler will belong.
*
* @return Sampler
*/
static sp<const Sampler> MIRRORED_REPEAT_NEAREST(sp<RS> rs);
/**
* Retrieve a sampler with min and mag set to linear and wrap modes set to
* mirrored repeat.
*
* @param rs Context to which the sampler will belong.
*
* @return Sampler
*/
static sp<const Sampler> MIRRORED_REPEAT_LINEAR(sp<RS> rs);
/**
* Retrieve a sampler with min and mag set to linear and wrap modes set to
* mirrored repeat.
*
* @param rs Context to which the sampler will belong.
*
* @return Sampler
*/
static sp<const Sampler> MIRRORED_REPEAT_LINEAR_MIP_LINEAR(sp<RS> rs);
};
class Byte2 {
public:
int8_t x, y;
Byte2(int8_t initX, int8_t initY)
: x(initX), y(initY) {}
Byte2() : x(0), y(0) {}
};
class Byte3 {
public:
int8_t x, y, z;
Byte3(int8_t initX, int8_t initY, int8_t initZ)
: x(initX), y(initY), z(initZ) {}
Byte3() : x(0), y(0), z(0) {}
};
class Byte4 {
public:
int8_t x, y, z, w;
Byte4(int8_t initX, int8_t initY, int8_t initZ, int8_t initW)
: x(initX), y(initY), z(initZ), w(initW) {}
Byte4() : x(0), y(0), z(0), w(0) {}
};
class UByte2 {
public:
uint8_t x, y;
UByte2(uint8_t initX, uint8_t initY)
: x(initX), y(initY) {}
UByte2() : x(0), y(0) {}
};
class UByte3 {
public:
uint8_t x, y, z;
UByte3(uint8_t initX, uint8_t initY, uint8_t initZ)
: x(initX), y(initY), z(initZ) {}
UByte3() : x(0), y(0), z(0) {}
};
class UByte4 {
public:
uint8_t x, y, z, w;
UByte4(uint8_t initX, uint8_t initY, uint8_t initZ, uint8_t initW)
: x(initX), y(initY), z(initZ), w(initW) {}
UByte4() : x(0), y(0), z(0), w(0) {}
};
class Short2 {
public:
short x, y;
Short2(short initX, short initY)
: x(initX), y(initY) {}
Short2() : x(0), y(0) {}
};
class Short3 {
public:
short x, y, z;
Short3(short initX, short initY, short initZ)
: x(initX), y(initY), z(initZ) {}
Short3() : x(0), y(0), z(0) {}
};
class Short4 {
public:
short x, y, z, w;
Short4(short initX, short initY, short initZ, short initW)
: x(initX), y(initY), z(initZ), w(initW) {}
Short4() : x(0), y(0), z(0), w(0) {}
};
class UShort2 {
public:
uint16_t x, y;
UShort2(uint16_t initX, uint16_t initY)
: x(initX), y(initY) {}
UShort2() : x(0), y(0) {}
};
class UShort3 {
public:
uint16_t x, y, z;
UShort3(uint16_t initX, uint16_t initY, uint16_t initZ)
: x(initX), y(initY), z(initZ) {}
UShort3() : x(0), y(0), z(0) {}
};
class UShort4 {
public:
uint16_t x, y, z, w;
UShort4(uint16_t initX, uint16_t initY, uint16_t initZ, uint16_t initW)
: x(initX), y(initY), z(initZ), w(initW) {}
UShort4() : x(0), y(0), z(0), w(0) {}
};
class Int2 {
public:
int x, y;
Int2(int initX, int initY)
: x(initX), y(initY) {}
Int2() : x(0), y(0) {}
};
class Int3 {
public:
int x, y, z;
Int3(int initX, int initY, int initZ)
: x(initX), y(initY), z(initZ) {}
Int3() : x(0), y(0), z(0) {}
};
class Int4 {
public:
int x, y, z, w;
Int4(int initX, int initY, int initZ, int initW)
: x(initX), y(initY), z(initZ), w(initW) {}
Int4() : x(0), y(0), z(0), w(0) {}
};
class UInt2 {
public:
uint32_t x, y;
UInt2(uint32_t initX, uint32_t initY)
: x(initX), y(initY) {}
UInt2() : x(0), y(0) {}
};
class UInt3 {
public:
uint32_t x, y, z;
UInt3(uint32_t initX, uint32_t initY, uint32_t initZ)
: x(initX), y(initY), z(initZ) {}
UInt3() : x(0), y(0), z(0) {}
};
class UInt4 {
public:
uint32_t x, y, z, w;
UInt4(uint32_t initX, uint32_t initY, uint32_t initZ, uint32_t initW)
: x(initX), y(initY), z(initZ), w(initW) {}
UInt4() : x(0), y(0), z(0), w(0) {}
};
class Long2 {
public:
int64_t x, y;
Long2(int64_t initX, int64_t initY)
: x(initX), y(initY) {}
Long2() : x(0), y(0) {}
};
class Long3 {
public:
int64_t x, y, z;
Long3(int64_t initX, int64_t initY, int64_t initZ)
: x(initX), y(initY), z(initZ) {}
Long3() : x(0), y(0), z(0) {}
};
class Long4 {
public:
int64_t x, y, z, w;
Long4(int64_t initX, int64_t initY, int64_t initZ, int64_t initW)
: x(initX), y(initY), z(initZ), w(initW) {}
Long4() : x(0), y(0), z(0), w(0) {}
};
class ULong2 {
public:
uint64_t x, y;
ULong2(uint64_t initX, uint64_t initY)
: x(initX), y(initY) {}
ULong2() : x(0), y(0) {}
};
class ULong3 {
public:
uint64_t x, y, z;
ULong3(uint64_t initX, uint64_t initY, uint64_t initZ)
: x(initX), y(initY), z(initZ) {}
ULong3() : x(0), y(0), z(0) {}
};
class ULong4 {
public:
uint64_t x, y, z, w;
ULong4(uint64_t initX, uint64_t initY, uint64_t initZ, uint64_t initW)
: x(initX), y(initY), z(initZ), w(initW) {}
ULong4() : x(0), y(0), z(0), w(0) {}
};
class Float2 {
public:
float x, y;
Float2(float initX, float initY)
: x(initX), y(initY) {}
Float2() : x(0), y(0) {}
};
class Float3 {
public:
float x, y, z;
Float3(float initX, float initY, float initZ)
: x(initX), y(initY), z(initZ) {}
Float3() : x(0.f), y(0.f), z(0.f) {}
};
class Float4 {
public:
float x, y, z, w;
Float4(float initX, float initY, float initZ, float initW)
: x(initX), y(initY), z(initZ), w(initW) {}
Float4() : x(0.f), y(0.f), z(0.f), w(0.f) {}
};
class Double2 {
public:
double x, y;
Double2(double initX, double initY)
: x(initX), y(initY) {}
Double2() : x(0), y(0) {}
};
class Double3 {
public:
double x, y, z;
Double3(double initX, double initY, double initZ)
: x(initX), y(initY), z(initZ) {}
Double3() : x(0), y(0), z(0) {}
};
class Double4 {
public:
double x, y, z, w;
Double4(double initX, double initY, double initZ, double initW)
: x(initX), y(initY), z(initZ), w(initW) {}
Double4() : x(0), y(0), z(0), w(0) {}
};
}
}
#endif