Merge "Add docs to C++ API." into klp-dev
diff --git a/cpp/Element.cpp b/cpp/Element.cpp
index db7df64..d3fb29a 100644
--- a/cpp/Element.cpp
+++ b/cpp/Element.cpp
@@ -95,11 +95,6 @@
CREATE_USER(ALLOCATION, ALLOCATION);
CREATE_USER(SAMPLER, SAMPLER);
CREATE_USER(SCRIPT, SCRIPT);
-CREATE_USER(MESH, MESH);
-CREATE_USER(PROGRAM_FRAGMENT, PROGRAM_FRAGMENT);
-CREATE_USER(PROGRAM_VERTEX, PROGRAM_VERTEX);
-CREATE_USER(PROGRAM_RASTER, PROGRAM_RASTER);
-CREATE_USER(PROGRAM_STORE, PROGRAM_STORE);
CREATE_USER(MATRIX_4X4, MATRIX_4X4);
CREATE_USER(MATRIX_3X3, MATRIX_3X3);
CREATE_USER(MATRIX_2X2, MATRIX_2X2);
diff --git a/cpp/RenderScript.cpp b/cpp/RenderScript.cpp
index 3be195f..30d530e 100644
--- a/cpp/RenderScript.cpp
+++ b/cpp/RenderScript.cpp
@@ -401,6 +401,8 @@
return true;
}
+// this will only open API 19+ libRS
+// because that's when we changed libRS to extern "C" entry points
static bool loadSO(const char* filename) {
void* handle = dlopen(filename, RTLD_LAZY | RTLD_LOCAL);
if (handle == NULL) {
diff --git a/cpp/RenderScript.h b/cpp/RenderScript.h
index 1fe7b87..7bd99f8 100644
--- a/cpp/RenderScript.h
+++ b/cpp/RenderScript.h
@@ -14,6 +14,17 @@
* limitations under the License.
*/
+ /*! \mainpage notitle
+ *
+ * RenderScript is a high-performance runtime that provides
+ * compute operations at the native level. RenderScript code is compiled on devices
+ * at runtime to allow platform-independence as well.
+ * This reference documentation describes the RenderScript runtime APIs, which you
+ * can utilize to write RenderScript code in C99. The RenderScript compute header
+ * files are automatically included for you.
+ *
+ */
+
#ifndef ANDROID_RENDERSCRIPT_H
#define ANDROID_RENDERSCRIPT_H
diff --git a/cpp/ScriptIntrinsics.cpp b/cpp/ScriptIntrinsics.cpp
index e7cdde5..c5013b6 100644
--- a/cpp/ScriptIntrinsics.cpp
+++ b/cpp/ScriptIntrinsics.cpp
@@ -78,7 +78,7 @@
: ScriptIntrinsic(rs, RS_SCRIPT_INTRINSIC_ID_BLEND, e) {
}
-void ScriptIntrinsicBlend::blendClear(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachClear(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -86,7 +86,7 @@
Script::forEach(0, in, out, NULL, 0);
}
-void ScriptIntrinsicBlend::blendSrc(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachSrc(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -94,7 +94,7 @@
Script::forEach(1, in, out, NULL, 0);
}
-void ScriptIntrinsicBlend::blendDst(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachDst(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -102,7 +102,7 @@
Script::forEach(2, in, out, NULL, 0);
}
-void ScriptIntrinsicBlend::blendSrcOver(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachSrcOver(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -110,7 +110,7 @@
Script::forEach(3, in, out, NULL, 0);
}
-void ScriptIntrinsicBlend::blendDstOver(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachDstOver(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -118,7 +118,7 @@
Script::forEach(4, in, out, NULL, 0);
}
-void ScriptIntrinsicBlend::blendSrcIn(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachSrcIn(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -126,7 +126,7 @@
Script::forEach(5, in, out, NULL, 0);
}
-void ScriptIntrinsicBlend::blendDstIn(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachDstIn(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -134,7 +134,7 @@
Script::forEach(6, in, out, NULL, 0);
}
-void ScriptIntrinsicBlend::blendSrcOut(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachSrcOut(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -142,7 +142,7 @@
Script::forEach(7, in, out, NULL, 0);
}
-void ScriptIntrinsicBlend::blendDstOut(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachDstOut(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -150,7 +150,7 @@
Script::forEach(8, in, out, NULL, 0);
}
-void ScriptIntrinsicBlend::blendSrcAtop(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachSrcAtop(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -158,7 +158,7 @@
Script::forEach(9, in, out, NULL, 0);
}
-void ScriptIntrinsicBlend::blendDstAtop(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachDstAtop(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -166,7 +166,7 @@
Script::forEach(10, in, out, NULL, 0);
}
-void ScriptIntrinsicBlend::blendXor(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachXor(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -175,7 +175,7 @@
}
// Numbering jumps here
-void ScriptIntrinsicBlend::blendMultiply(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachMultiply(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -184,7 +184,7 @@
}
// Numbering jumps here
-void ScriptIntrinsicBlend::blendAdd(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachAdd(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
@@ -192,7 +192,7 @@
Script::forEach(34, in, out, NULL, 0);
}
-void ScriptIntrinsicBlend::blendSubtract(sp<Allocation> in, sp<Allocation> out) {
+void ScriptIntrinsicBlend::forEachSubtract(sp<Allocation> in, sp<Allocation> out) {
if (in->getType()->getElement()->isCompatible(mElement) == false ||
out->getType()->getElement()->isCompatible(mElement) == false) {
mRS->throwError(RS_ERROR_INVALID_ELEMENT, "Invalid element in blend");
diff --git a/cpp/rsCppStructs.h b/cpp/rsCppStructs.h
index 60341c2..1efd128 100644
--- a/cpp/rsCppStructs.h
+++ b/cpp/rsCppStructs.h
@@ -24,8 +24,10 @@
#include <vector>
#include <string>
-// Every row in an RS allocation is guaranteed to be aligned by this amount
-// Every row in a user-backed allocation must be aligned by this amount
+/**
+ * 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
namespace android {
@@ -43,50 +45,102 @@
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,
- RS_ERROR_INVALID_PARAMETER = 1,
- RS_ERROR_RUNTIME_ERROR = 2,
- RS_ERROR_INVALID_ELEMENT = 3,
+ 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,
- RS_YUV_YV12 = 1,
- RS_YUV_NV21 = 2,
+ 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,
- RS_INIT_LOW_LATENCY = 2,
+ 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.
RS_INIT_MAX = 4
};
-
+ /**
+ * 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] flags Optional flags for this context.
+ * @return true on success
+ */
bool init(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; }
- void throwError(RSError error, const char *errMsg);
+ /**
+ * Returns current status for the context.
+ *
+ * @return current error
+ */
RSError getError();
- RsContext getContext() { return mContext; }
-
+ /**
+ * 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:
@@ -194,6 +248,9 @@
friend class Element;
};
+ /**
+ * Base class for all RenderScript objects. Not for direct use by developers.
+ */
class BaseObj : public android::RSC::LightRefBase<BaseObj> {
public:
void * getID() const;
@@ -213,7 +270,21 @@
};
-
+ /**
+ * 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;
@@ -254,58 +325,230 @@
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;
}
+ /**
+ * 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);
void ioSendOutput();
void ioGetInput();
+ /**
+ * 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);
+ /**
+ * 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] mips 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 mips, 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] mips 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 mips, 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);
@@ -313,103 +556,479 @@
};
+ /**
+ * 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 mVisibleElementMap.size();
}
+ /**
+ * 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);
- static sp<const Element> MESH(sp<RS> rs);
- static sp<const Element> PROGRAM_FRAGMENT(sp<RS> rs);
- static sp<const Element> PROGRAM_VERTEX(sp<RS> rs);
- static sp<const Element> PROGRAM_RASTER(sp<RS> rs);
- static sp<const Element> PROGRAM_STORE(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:
sp<RS> mRS;
@@ -544,7 +1163,23 @@
}
};
-
+/**
+ * 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;
@@ -565,42 +1200,87 @@
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 {
@@ -628,6 +1308,9 @@
};
+/**
+ * The parent class for all executable Scripts. This should not be used by applications.
+ */
class Script : public BaseObj {
private:
@@ -685,6 +1368,9 @@
};
};
+/**
+ * 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,
@@ -694,6 +1380,10 @@
};
+/**
+ * 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;
@@ -701,93 +1391,373 @@
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);
- void blendClear(sp<Allocation> in, sp<Allocation> out);
- void blendSrc(sp<Allocation> in, sp<Allocation> out);
- void blendDst(sp<Allocation> in, sp<Allocation> out);
- void blendSrcOver(sp<Allocation> in, sp<Allocation> out);
- void blendDstOver(sp<Allocation> in, sp<Allocation> out);
- void blendSrcIn(sp<Allocation> in, sp<Allocation> out);
- void blendDstIn(sp<Allocation> in, sp<Allocation> out);
- void blendSrcOut(sp<Allocation> in, sp<Allocation> out);
- void blendDstOut(sp<Allocation> in, sp<Allocation> out);
- void blendSrcAtop(sp<Allocation> in, sp<Allocation> out);
- void blendDstAtop(sp<Allocation> in, sp<Allocation> out);
- void blendXor(sp<Allocation> in, sp<Allocation> out);
- void blendMultiply(sp<Allocation> in, sp<Allocation> out);
- void blendAdd(sp<Allocation> in, sp<Allocation> out);
- void blendSubtract(sp<Allocation> in, sp<Allocation> out);
+ /**
+ * 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);
+ /**
+ * 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;
@@ -797,26 +1767,105 @@
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 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);
@@ -828,22 +1877,118 @@
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
+ */
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
+ */
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
+ */
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
+ */
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
+ */
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
+ */
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
+ */
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
+ */
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
+ */
sp<const Sampler> MIRRORED_REPEAT_LINEAR_MIP_LINEAR(sp<RS> rs);
};
