blob: 03f911ed3cf42757967172c06946b52e059f1fad [file] [log] [blame]
/*
* 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
};
/**
* 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
};
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:
int16_t x, y;
Short2(int16_t initX, int16_t initY)
: x(initX), y(initY) {}
Short2() : x(0), y(0) {}
};
class Short3 {
public:
int16_t x, y, z;
Short3(int16_t initX, int16_t initY, int16_t initZ)
: x(initX), y(initY), z(initZ) {}
Short3() : x(0), y(0), z(0) {}
};
class Short4 {
public:
int16_t x, y, z, w;
Short4(int16_t initX, int16_t initY, int16_t initZ, int16_t 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) {}
};
/**
* 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);
/**
* 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 Flags for this context.
* @param[in] targetApi Target RS API level.
* @return true on success
*/
bool init(const char * name, uint32_t flags, int targetApi);
/**
* 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);
static void * threadProc(void *);
static bool gInitialized;
static pthread_mutex_t gInitMutex;
pthread_t mMessageThreadId;
pid_t mNativeMessageThreadId;
bool mMessageRun;
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> F16;
sp<const Element> F16_2;
sp<const Element> F16_3;
sp<const Element> F16_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(const sp<const BaseObj>& obj);
protected:
void *mID;
RS* mRS;
const char * mName;
BaseObj(void *id, sp<RS> rs);
void checkValid();
static void * getObjID(const 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(const 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();
#ifndef 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(const 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, const 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,
const 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,
const 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(const sp<RS>& rs, const 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(const sp<RS>& rs, const 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(const sp<RS>& rs, const 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(const sp<RS>& rs, const 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(const sp<RS>& rs, const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const sp<RS> &rs);
/**
* Utility function for returning an Element containing a single half.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> F16(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const sp<RS> &rs);
/**
* Utility function for returning an Element containing a half2.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> F16_2(const sp<RS> &rs);
/**
* Utility function for returning an Element containing a half3.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> F16_3(const sp<RS> &rs);
/**
* Utility function for returning an Element containing a half4.
* @param[in] rs RenderScript context
* @return Element
*/
static sp<const Element> F16_4(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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:
explicit Builder(sp<RS> rs);
~Builder();
void add(const sp<const Element>& e, const char * name, uint32_t arraySize = 1);
sp<const Element> create();
};
protected:
friend class Type;
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(void *id, sp<RS> rs);
explicit 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:
explicit 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(const 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 RS_YUV_YV12 and RS_YUV_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(const sp<RS>& rs, const 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, const sp<const Allocation>& in, const sp<const Allocation>& out,
const void *v, size_t) const;
void bindAllocation(const sp<Allocation>& va, uint32_t slot) const;
void setVar(uint32_t index, const void *, size_t len) const;
void setVar(uint32_t index, const 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(const 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(const sp<RS>& rs, const sp<const Element>& e);
/**
* Launch the intrinsic.
* @param[in] ain input Allocation
* @param[in] aout output Allocation
*/
void forEach(const sp<Allocation>& ain, const 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(const sp<Allocation>& lut);
};
/**
* Intrinsic kernel provides high performance RenderScript APIs to BLAS.
*
* The BLAS (Basic Linear Algebra Subprograms) are routines that provide standard
* building blocks for performing basic vector and matrix operations.
*
* For detailed description of BLAS, please refer to http://www.netlib.org/blas/
*
**/
class ScriptIntrinsicBLAS : public ScriptIntrinsic {
private:
ScriptIntrinsicBLAS(sp<RS> rs, sp<const Element> e);
public:
/**
* Create an intrinsic to access BLAS subroutines.
*
* @param rs The RenderScript context
* @return ScriptIntrinsicBLAS
*/
static sp<ScriptIntrinsicBLAS> create(const sp<RS>& rs);
/**
* SGEMV performs one of the matrix-vector operations
* y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/db/d58/sgemv_8f.html
*
* @param TransA The type of transpose applied to matrix A.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void SGEMV(RsBlasTranspose TransA,
float alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
float beta, const sp<Allocation>& Y, int incY);
/**
* DGEMV performs one of the matrix-vector operations
* y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/dc/da8/dgemv_8f.html
*
* @param TransA The type of transpose applied to matrix A.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void DGEMV(RsBlasTranspose TransA,
double alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
double beta, const sp<Allocation>& Y, int incY);
/**
* CGEMV performs one of the matrix-vector operations
* y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d4/d8a/cgemv_8f.html
*
* @param TransA The type of transpose applied to matrix A.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void CGEMV(RsBlasTranspose TransA,
Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
Float2 beta, const sp<Allocation>& Y, int incY);
/**
* ZGEMV performs one of the matrix-vector operations
* y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/db/d40/zgemv_8f.html
*
* @param TransA The type of transpose applied to matrix A.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void ZGEMV(RsBlasTranspose TransA,
Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
Double2 beta, const sp<Allocation>& Y, int incY);
/**
* SGBMV performs one of the matrix-vector operations
* y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d6/d46/sgbmv_8f.html
*
* Note: For a M*N matrix, the input Allocation should also be of size M*N (dimY = M, dimX = N),
* but only the region M*(KL+KU+1) will be referenced. The following subroutine can is an
* example showing how to convert the original matrix 'a' to row-based band matrix 'b'.
* for i in range(0, m):
* for j in range(max(0, i-kl), min(i+ku+1, n)):
* b[i, j-i+kl] = a[i, j]
*
* @param TransA The type of transpose applied to matrix A.
* @param KL The number of sub-diagonals of the matrix A.
* @param KU The number of super-diagonals of the matrix A.
* @param alpha The scalar alpha.
* @param A The input allocation contains the band matrix A, supported elements type: {Element#F32}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void SGBMV(RsBlasTranspose TransA,
int KL, int KU, float alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
float beta, const sp<Allocation>& Y, int incY);
/**
* DGBMV performs one of the matrix-vector operations
* y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d2/d3f/dgbmv_8f.html
*
* Note: For a M*N matrix, the input Allocation should also be of size M*N (dimY = M, dimX = N),
* but only the region M*(KL+KU+1) will be referenced. The following subroutine can is an
* example showing how to convert the original matrix 'a' to row-based band matrix 'b'.
* for i in range(0, m):
* for j in range(max(0, i-kl), min(i+ku+1, n)):
* b[i, j-i+kl] = a[i, j]
*
* @param TransA The type of transpose applied to matrix A.
* @param KL The number of sub-diagonals of the matrix A.
* @param KU The number of super-diagonals of the matrix A.
* @param alpha The scalar alpha.
* @param A The input allocation contains the band matrix A, supported elements type: {Element#F64}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void DGBMV(RsBlasTranspose TransA,
int KL, int KU, double alpha, const sp<Allocation>& A, const sp<Allocation>& X,
int incX, double beta, const sp<Allocation>& Y, int incY);
/**
* CGBMV performs one of the matrix-vector operations
* y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d0/d75/cgbmv_8f.html
*
* Note: For a M*N matrix, the input Allocation should also be of size M*N (dimY = M, dimX = N),
* but only the region M*(KL+KU+1) will be referenced. The following subroutine can is an
* example showing how to convert the original matrix 'a' to row-based band matrix 'b'.
* for i in range(0, m):
* for j in range(max(0, i-kl), min(i+ku+1, n)):
* b[i, j-i+kl] = a[i, j]
*
* @param TransA The type of transpose applied to matrix A.
* @param KL The number of sub-diagonals of the matrix A.
* @param KU The number of super-diagonals of the matrix A.
* @param alpha The scalar alpha.
* @param A The input allocation contains the band matrix A, supported elements type: {Element#F32_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void CGBMV(RsBlasTranspose TransA,
int KL, int KU, Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
int incX, Float2 beta, const sp<Allocation>& Y, int incY);
/**
* ZGBMV performs one of the matrix-vector operations
* y := alpha*A*x + beta*y or y := alpha*A**T*x + beta*y or y := alpha*A**H*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d9/d46/zgbmv_8f.html
*
* Note: For a M*N matrix, the input Allocation should also be of size M*N (dimY = M, dimX = N),
* but only the region M*(KL+KU+1) will be referenced. The following subroutine can is an
* example showing how to convert the original matrix 'a' to row-based band matrix 'b'.
* for i in range(0, m):
* for j in range(max(0, i-kl), min(i+ku+1, n)):
* b[i, j-i+kl] = a[i, j]
*
* @param TransA The type of transpose applied to matrix A.
* @param KL The number of sub-diagonals of the matrix A.
* @param KU The number of super-diagonals of the matrix A.
* @param alpha The scalar alpha.
* @param A The input allocation contains the band matrix A, supported elements type: {Element#F64_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void ZGBMV(RsBlasTranspose TransA,
int KL, int KU, Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
Double2 beta, const sp<Allocation>& Y, int incY);
/**
* STRMV performs one of the matrix-vector operations
* x := A*x or x := A**T*x
*
* Details: http://www.netlib.org/lapack/explore-html/de/d45/strmv_8f.html
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void STRMV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* DTRMV performs one of the matrix-vector operations
* x := A*x or x := A**T*x
*
* Details: http://www.netlib.org/lapack/explore-html/dc/d7e/dtrmv_8f.html
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void DTRMV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* CTRMV performs one of the matrix-vector operations
* x := A*x or x := A**T*x or x := A**H*x
*
* Details: http://www.netlib.org/lapack/explore-html/df/d78/ctrmv_8f.html
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void CTRMV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* ZTRMV performs one of the matrix-vector operations
* x := A*x or x := A**T*x or x := A**H*x
*
* Details: http://www.netlib.org/lapack/explore-html/d0/dd1/ztrmv_8f.html
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void ZTRMV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* STBMV performs one of the matrix-vector operations
* x := A*x or x := A**T*x
*
* Details: http://www.netlib.org/lapack/explore-html/d6/d7d/stbmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
* but only the region N*(K+1) will be referenced. The following subroutine can is an
* example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
* for i in range(0, n):
* for j in range(i, min(i+k+1, n)):
* b[i, j-i] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param K The number of off-diagonals of the matrix A
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void STBMV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* DTBMV performs one of the matrix-vector operations
* x := A*x or x := A**T*x
*
* Details: http://www.netlib.org/lapack/explore-html/df/d29/dtbmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
* but only the region N*(K+1) will be referenced. The following subroutine can is an
* example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
* for i in range(0, n):
* for j in range(i, min(i+k+1, n)):
* b[i, j-i] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param K The number of off-diagonals of the matrix A
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void DTBMV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* CTBMV performs one of the matrix-vector operations
* x := A*x or x := A**T*x or x := A**H*x
*
* Details: http://www.netlib.org/lapack/explore-html/d3/dcd/ctbmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
* but only the region N*(K+1) will be referenced. The following subroutine can is an
* example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
* for i in range(0, n):
* for j in range(i, min(i+k+1, n)):
* b[i, j-i] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param K The number of off-diagonals of the matrix A
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void CTBMV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* ZTBMV performs one of the matrix-vector operations
* x := A*x or x := A**T*x or x := A**H*x
*
* Details: http://www.netlib.org/lapack/explore-html/d3/d39/ztbmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
* but only the region N*(K+1) will be referenced. The following subroutine can is an
* example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
* for i in range(0, n):
* for j in range(i, min(i+k+1, n)):
* b[i, j-i] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param K The number of off-diagonals of the matrix A
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void ZTBMV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* STPMV performs one of the matrix-vector operations
* x := A*x or x := A**T*x
*
* Details: http://www.netlib.org/lapack/explore-html/db/db1/stpmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F32}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void STPMV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
/**
* DTPMV performs one of the matrix-vector operations
* x := A*x or x := A**T*x
*
* Details: http://www.netlib.org/lapack/explore-html/dc/dcd/dtpmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F64}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void DTPMV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
/**
* CTPMV performs one of the matrix-vector operations
* x := A*x or x := A**T*x or x := A**H*x
*
* Details: http://www.netlib.org/lapack/explore-html/d4/dbb/ctpmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F32_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void CTPMV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
/**
* ZTPMV performs one of the matrix-vector operations
* x := A*x or x := A**T*x or x := A**H*x
*
* Details: http://www.netlib.org/lapack/explore-html/d2/d9e/ztpmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F64_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void ZTPMV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
/**
* STRSV solves one of the systems of equations
* A*x = b or A**T*x = b
*
* Details: http://www.netlib.org/lapack/explore-html/d0/d2a/strsv_8f.html
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void STRSV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* DTRSV solves one of the systems of equations
* A*x = b or A**T*x = b
*
* Details: http://www.netlib.org/lapack/explore-html/d6/d96/dtrsv_8f.html
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void DTRSV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* CTRSV solves one of the systems of equations
* A*x = b or A**T*x = b or A**H*x = b
*
* Details: http://www.netlib.org/lapack/explore-html/d4/dc8/ctrsv_8f.html
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void CTRSV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* ZTRSV solves one of the systems of equations
* A*x = b or A**T*x = b or A**H*x = b
*
* Details: http://www.netlib.org/lapack/explore-html/d1/d2f/ztrsv_8f.html
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void ZTRSV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* STBSV solves one of the systems of equations
* A*x = b or A**T*x = b
*
* Details: http://www.netlib.org/lapack/explore-html/d0/d1f/stbsv_8f.html
*
* Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
* but only the region N*(K+1) will be referenced. The following subroutine can is an
* example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
* for i in range(0, n):
* for j in range(i, min(i+k+1, n)):
* b[i, j-i] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param K The number of off-diagonals of the matrix A
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void STBSV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* DTBSV solves one of the systems of equations
* A*x = b or A**T*x = b
*
* Details: http://www.netlib.org/lapack/explore-html/d4/dcf/dtbsv_8f.html
*
* Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
* but only the region N*(K+1) will be referenced. The following subroutine can is an
* example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
* for i in range(0, n):
* for j in range(i, min(i+k+1, n)):
* b[i, j-i] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param K The number of off-diagonals of the matrix A
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void DTBSV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* CTBSV solves one of the systems of equations
* A*x = b or A**T*x = b or A**H*x = b
*
* Details: http://www.netlib.org/lapack/explore-html/d9/d5f/ctbsv_8f.html
*
* Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
* but only the region N*(K+1) will be referenced. The following subroutine can is an
* example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
* for i in range(0, n):
* for j in range(i, min(i+k+1, n)):
* b[i, j-i] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param K The number of off-diagonals of the matrix A
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void CTBSV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* ZTBSV solves one of the systems of equations
* A*x = b or A**T*x = b or A**H*x = b
*
* Details: http://www.netlib.org/lapack/explore-html/d4/d5a/ztbsv_8f.html
*
* Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
* but only the region N*(K+1) will be referenced. The following subroutine can is an
* example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
* for i in range(0, n):
* for j in range(i, min(i+k+1, n)):
* b[i, j-i] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param K The number of off-diagonals of the matrix A
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void ZTBSV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
/**
* STPSV solves one of the systems of equations
* A*x = b or A**T*x = b
*
* Details: http://www.netlib.org/lapack/explore-html/d0/d7c/stpsv_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F32}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void STPSV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
/**
* DTPSV solves one of the systems of equations
* A*x = b or A**T*x = b
*
* Details: http://www.netlib.org/lapack/explore-html/d9/d84/dtpsv_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F64}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void DTPSV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
/**
* CTPSV solves one of the systems of equations
* A*x = b or A**T*x = b or A**H*x = b
*
* Details: http://www.netlib.org/lapack/explore-html/d8/d56/ctpsv_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F32_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void CTPSV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
/**
* ZTPSV solves one of the systems of equations
* A*x = b or A**T*x = b or A**H*x = b
*
* Details: http://www.netlib.org/lapack/explore-html/da/d57/ztpsv_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the matrix is an upper or lower triangular matrix.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F64_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
*/
void ZTPSV(RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
/**
* SSYMV performs the matrix-vector operation
* y := alpha*A*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d2/d94/ssymv_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void SSYMV(RsBlasUplo Uplo, float alpha, const sp<Allocation>& A, const sp<Allocation>& X,
int incX, float beta, const sp<Allocation>& Y, int incY);
/**
* SSBMV performs the matrix-vector operation
* y := alpha*A*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d3/da1/ssbmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
* but only the region N*(K+1) will be referenced. The following subroutine can is an
* example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
* for i in range(0, n):
* for j in range(i, min(i+k+1, n)):
* b[i, j-i] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part of the band matrix A is being supplied.
* @param K The number of off-diagonals of the matrix A
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void SSBMV(RsBlasUplo Uplo, int K, float alpha, const sp<Allocation>& A, const sp<Allocation>& X,
int incX, float beta, const sp<Allocation>& Y, int incY);
/**
* SSPMV performs the matrix-vector operation
* y := alpha*A*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d8/d68/sspmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part of the matrix A is supplied in packed form.
* @param alpha The scalar alpha.
* @param Ap The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void SSPMV(RsBlasUplo Uplo, float alpha, const sp<Allocation>& Ap, const sp<Allocation>& X,
int incX, float beta, const sp<Allocation>& Y, int incY);
/**
* SGER performs the rank 1 operation
* A := alpha*x*y**T + A
*
* Details: http://www.netlib.org/lapack/explore-html/db/d5c/sger_8f.html
*
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
*/
void SGER(float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
/**
* SSYR performs the rank 1 operation
* A := alpha*x*x**T + A
*
* Details: http://www.netlib.org/lapack/explore-html/d6/dac/ssyr_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
*/
void SSYR(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& A);
/**
* SSPR performs the rank 1 operation
* A := alpha*x*x**T + A
*
* Details: http://www.netlib.org/lapack/explore-html/d2/d9b/sspr_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part is to be supplied in the packed form.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Ap The input allocation contains matrix A, supported elements type: {Element#F32}.
*/
void SSPR(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Ap);
/**
* SSYR2 performs the symmetric rank 2 operation
* A := alpha*x*y**T + alpha*y*x**T + A
*
* Details: http://www.netlib.org/lapack/explore-html/db/d99/ssyr2_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
*/
void SSYR2(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX,
const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
/**
* SSPR2 performs the symmetric rank 2 operation
* A := alpha*x*y**T + alpha*y*x**T + A
*
* Details: http://www.netlib.org/lapack/explore-html/db/d3e/sspr2_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part is to be supplied in the packed form.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F32}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param Ap The input allocation contains matrix A, supported elements type: {Element#F32}.
*/
void SSPR2(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX,
const sp<Allocation>& Y, int incY, const sp<Allocation>& Ap);
/**
* DSYMV performs the matrix-vector operation
* y := alpha*A*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d8/dbe/dsymv_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void DSYMV(RsBlasUplo Uplo, double alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
double beta, const sp<Allocation>& Y, int incY);
/**
* DSBMV performs the matrix-vector operation
* y := alpha*A*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d8/d1e/dsbmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
* but only the region N*(K+1) will be referenced. The following subroutine can is an
* example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
* for i in range(0, n):
* for j in range(i, min(i+k+1, n)):
* b[i, j-i] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part of the band matrix A is being supplied.
* @param K The number of off-diagonals of the matrix A
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void DSBMV(RsBlasUplo Uplo, int K, double alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
double beta, const sp<Allocation>& Y, int incY);
/**
* DSPMV performs the matrix-vector operation
* y := alpha*A*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d4/d85/dspmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part of the matrix A is supplied in packed form.
* @param alpha The scalar alpha.
* @param Ap The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void DSPMV(RsBlasUplo Uplo, double alpha, const sp<Allocation>& Ap, const sp<Allocation>& X, int incX,
double beta, const sp<Allocation>& Y, int incY);
/**
* DGER performs the rank 1 operation
* A := alpha*x*y**T + A
*
* Details: http://www.netlib.org/lapack/explore-html/dc/da8/dger_8f.html
*
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
*/
void DGER(double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
/**
* DSYR performs the rank 1 operation
* A := alpha*x*x**T + A
*
* Details: http://www.netlib.org/lapack/explore-html/d3/d60/dsyr_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
*/
void DSYR(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& A);
/**
* DSPR performs the rank 1 operation
* A := alpha*x*x**T + A
*
* Details: http://www.netlib.org/lapack/explore-html/dd/dba/dspr_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part is to be supplied in the packed form.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Ap The input allocation contains matrix A, supported elements type: {Element#F64}.
*/
void DSPR(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Ap);
/**
* DSYR2 performs the symmetric rank 2 operation
* A := alpha*x*y**T + alpha*y*x**T + A
*
* Details: http://www.netlib.org/lapack/explore-html/de/d41/dsyr2_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
*/
void DSYR2(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX,
const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
/**
* DSPR2 performs the symmetric rank 2 operation
* A := alpha*x*y**T + alpha*y*x**T + A
*
* Details: http://www.netlib.org/lapack/explore-html/dd/d9e/dspr2_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part is to be supplied in the packed form.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F64}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param Ap The input allocation contains matrix A, supported elements type: {Element#F64}.
*/
void DSPR2(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX,
const sp<Allocation>& Y, int incY, const sp<Allocation>& Ap);
/**
* CHEMV performs the matrix-vector operation
* y := alpha*A*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d7/d51/chemv_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void CHEMV(RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
int incX, Float2 beta, const sp<Allocation>& Y, int incY);
/**
* CHBMV performs the matrix-vector operation
* y := alpha*A*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/db/dc2/chbmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
* but only the region N*(K+1) will be referenced. The following subroutine can is an
* example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
* for i in range(0, n):
* for j in range(i, min(i+k+1, n)):
* b[i, j-i] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part of the band matrix A is being supplied.
* @param K The number of off-diagonals of the matrix A
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void CHBMV(RsBlasUplo Uplo, int K, Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
int incX, Float2 beta, const sp<Allocation>& Y, int incY);
/**
* CHPMV performs the matrix-vector operation
* y := alpha*A*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d2/d06/chpmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part of the matrix A is supplied in packed form.
* @param alpha The scalar alpha.
* @param Ap The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void CHPMV(RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& Ap, const sp<Allocation>& X,
int incX, Float2 beta, const sp<Allocation>& Y, int incY);
/**
* CGERU performs the rank 1 operation
* A := alpha*x*y**T + A
*
* Details: http://www.netlib.org/lapack/explore-html/db/d5f/cgeru_8f.html
*
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
*/
void CGERU(Float2 alpha, const sp<Allocation>& X, int incX,
const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
/**
* CGERC performs the rank 1 operation
* A := alpha*x*y**H + A
*
* Details: http://www.netlib.org/lapack/explore-html/dd/d84/cgerc_8f.html
*
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
*/
void CGERC(Float2 alpha, const sp<Allocation>& X, int incX,
const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
/**
* CHER performs the rank 1 operation
* A := alpha*x*x**H + A
*
* Details: http://www.netlib.org/lapack/explore-html/d3/d6d/cher_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
*/
void CHER(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& A);
/**
* CHPR performs the rank 1 operation
* A := alpha*x*x**H + A
*
* Details: http://www.netlib.org/lapack/explore-html/db/dcd/chpr_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part is to be supplied in the packed form.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Ap The input allocation contains matrix A, supported elements type: {Element#F32_2}.
*/
void CHPR(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Ap);
/**
* CHER2 performs the symmetric rank 2 operation
* A := alpha*x*y**H + alpha*y*x**H + A
*
* Details: http://www.netlib.org/lapack/explore-html/db/d87/cher2_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
*/
void CHER2(RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& X, int incX,
const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
/**
* CHPR2 performs the symmetric rank 2 operation
* A := alpha*x*y**H + alpha*y*x**H + A
*
* Details: http://www.netlib.org/lapack/explore-html/d6/d44/chpr2_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part is to be supplied in the packed form.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param Ap The input allocation contains matrix A, supported elements type: {Element#F32_2}.
*/
void CHPR2(RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& X, int incX,
const sp<Allocation>& Y, int incY, const sp<Allocation>& Ap);
/**
* ZHEMV performs the matrix-vector operation
* y := alpha*A*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d0/ddd/zhemv_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void ZHEMV(RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
int incX, Double2 beta, const sp<Allocation>& Y, int incY);
/**
* ZHBMV performs the matrix-vector operation
* y := alpha*A*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d3/d1a/zhbmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
* but only the region N*(K+1) will be referenced. The following subroutine can is an
* example showing how to convert a UPPER trianglar matrix 'a' to row-based band matrix 'b'.
* for i in range(0, n):
* for j in range(i, min(i+k+1, n)):
* b[i, j-i] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part of the band matrix A is being supplied.
* @param K The number of off-diagonals of the matrix A
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void ZHBMV(RsBlasUplo Uplo, int K, Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
int incX, Double2 beta, const sp<Allocation>& Y, int incY);
/**
* ZHPMV performs the matrix-vector operation
* y := alpha*A*x + beta*y
*
* Details: http://www.netlib.org/lapack/explore-html/d0/d60/zhpmv_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part of the matrix A is supplied in packed form.
* @param alpha The scalar alpha.
* @param Ap The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param beta The scalar beta.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
*/
void ZHPMV(RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& Ap, const sp<Allocation>& X,
int incX, Double2 beta, const sp<Allocation>& Y, int incY);
/**
* ZGERU performs the rank 1 operation
* A := alpha*x*y**T + A
*
* Details: http://www.netlib.org/lapack/explore-html/d7/d12/zgeru_8f.html
*
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
*/
void ZGERU(Double2 alpha, const sp<Allocation>& X, int incX,
const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
/**
* ZGERC performs the rank 1 operation
* A := alpha*x*y**H + A
*
* Details: http://www.netlib.org/lapack/explore-html/d3/dad/zgerc_8f.html
*
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
*/
void ZGERC(Double2 alpha, const sp<Allocation>& X, int incX,
const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
/**
* ZHER performs the rank 1 operation
* A := alpha*x*x**H + A
*
* Details: http://www.netlib.org/lapack/explore-html/de/d0e/zher_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
*/
void ZHER(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& A);
/**
* ZHPR performs the rank 1 operation
* A := alpha*x*x**H + A
*
* Details: http://www.netlib.org/lapack/explore-html/de/de1/zhpr_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part is to be supplied in the packed form.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Ap The input allocation contains matrix A, supported elements type: {Element#F64_2}.
*/
void ZHPR(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Ap);
/**
* ZHER2 performs the symmetric rank 2 operation
* A := alpha*x*y**H + alpha*y*x**H + A
*
* Details: http://www.netlib.org/lapack/explore-html/da/d8a/zher2_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
*/
void ZHER2(RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& X, int incX,
const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
/**
* ZHPR2 performs the symmetric rank 2 operation
* A := alpha*x*y**H + alpha*y*x**H + A
*
* Details: http://www.netlib.org/lapack/explore-html/d5/d52/zhpr2_8f.html
*
* Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
* The following subroutine can is an example showing how to convert a UPPER trianglar matrix
* 'a' to packed matrix 'b'.
* k = 0
* for i in range(0, n):
* for j in range(i, n):
* b[k++] = a[i, j]
*
* @param Uplo Specifies whether the upper or lower triangular part is to be supplied in the packed form.
* @param alpha The scalar alpha.
* @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
* @param incX The increment for the elements of vector x, must be larger than zero.
* @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
* @param incY The increment for the elements of vector y, must be larger than zero.
* @param Ap The input allocation contains matrix A, supported elements type: {Element#F64_2}.
*/
void ZHPR2(RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& X, int incX,
const sp<Allocation>& Y, int incY, const sp<Allocation>& Ap);
/**
* SGEMM performs one of the matrix-matrix operations
* C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T
*
* Details: http://www.netlib.org/lapack/explore-html/d4/de2/sgemm_8f.html
*
* @param TransA The type of transpose applied to matrix A.
* @param TransB The type of transpose applied to matrix B.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F32}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F32}.
*/
void SGEMM(RsBlasTranspose TransA, RsBlasTranspose TransB, float alpha, const sp<Allocation>& A,
const sp<Allocation>& B, float beta, const sp<Allocation>& C);
/**
* DGEMM performs one of the matrix-matrix operations
* C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T
*
* Details: http://www.netlib.org/lapack/explore-html/d7/d2b/dgemm_8f.html
*
* @param TransA The type of transpose applied to matrix A.
* @param TransB The type of transpose applied to matrix B.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F64}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F64}.
*/
void DGEMM(RsBlasTranspose TransA, RsBlasTranspose TransB, double alpha, const sp<Allocation>& A,
const sp<Allocation>& B, double beta, const sp<Allocation>& C);
/**
* CGEMM performs one of the matrix-matrix operations
* C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T or op(X) = X**H
*
* Details: http://www.netlib.org/lapack/explore-html/d6/d5b/cgemm_8f.html
*
* @param TransA The type of transpose applied to matrix A.
* @param TransB The type of transpose applied to matrix B.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
*/
void CGEMM(RsBlasTranspose TransA, RsBlasTranspose TransB, Float2 alpha, const sp<Allocation>& A,
const sp<Allocation>& B, Float2 beta, const sp<Allocation>& C);
/**
* ZGEMM performs one of the matrix-matrix operations
* C := alpha*op(A)*op(B) + beta*C where op(X) is one of op(X) = X or op(X) = X**T or op(X) = X**H
*
* Details: http://www.netlib.org/lapack/explore-html/d7/d76/zgemm_8f.html
*
* @param TransA The type of transpose applied to matrix A.
* @param TransB The type of transpose applied to matrix B.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
*/
void ZGEMM(RsBlasTranspose TransA, RsBlasTranspose TransB, Double2 alpha, const sp<Allocation>& A,
const sp<Allocation>& B, Double2 beta, const sp<Allocation>& C);
/**
* SSYMM performs one of the matrix-matrix operations
* C := alpha*A*B + beta*C or C := alpha*B*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/d7/d42/ssymm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F32}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F32}.
*/
void SSYMM(RsBlasSide Side, RsBlasUplo Uplo, float alpha, const sp<Allocation>& A,
const sp<Allocation>& B, float beta, const sp<Allocation>& C);
/**
* DSYMM performs one of the matrix-matrix operations
* C := alpha*A*B + beta*C or C := alpha*B*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/d8/db0/dsymm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F64}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F64}.
*/
void DSYMM(RsBlasSide Side, RsBlasUplo Uplo, double alpha, const sp<Allocation>& A,
const sp<Allocation>& B, double beta, const sp<Allocation>& C);
/**
* CSYMM performs one of the matrix-matrix operations
* C := alpha*A*B + beta*C or C := alpha*B*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/db/d59/csymm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
*/
void CSYMM(RsBlasSide Side, RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& A,
const sp<Allocation>& B, Float2 beta, const sp<Allocation>& C);
/**
* ZSYMM performs one of the matrix-matrix operations
* C := alpha*A*B + beta*C or C := alpha*B*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/df/d51/zsymm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
*/
void ZSYMM(RsBlasSide Side, RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& A,
const sp<Allocation>& B, Double2 beta, const sp<Allocation>& C);
/**
* SSYRK performs one of the symmetric rank k operations
* C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/d0/d40/ssyrk_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part of C is to be referenced.
* @param Trans The type of transpose applied to the operation.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F32}.
*/
void SSYRK(RsBlasUplo Uplo, RsBlasTranspose Trans, float alpha,
const sp<Allocation>& A, float beta, const sp<Allocation>& C);
/**
* DSYRK performs one of the symmetric rank k operations
* C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/dc/d05/dsyrk_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part of C is to be referenced.
* @param Trans The type of transpose applied to the operation.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F64}.
*/
void DSYRK(RsBlasUplo Uplo, RsBlasTranspose Trans, double alpha,
const sp<Allocation>& A, double beta, const sp<Allocation>& C);
/**
* CSYRK performs one of the symmetric rank k operations
* C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/d3/d6a/csyrk_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part of C is to be referenced.
* @param Trans The type of transpose applied to the operation.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
*/
void CSYRK(RsBlasUplo Uplo, RsBlasTranspose Trans, Float2 alpha,
const sp<Allocation>& A, Float2 beta, const sp<Allocation>& C);
/**
* ZSYRK performs one of the symmetric rank k operations
* C := alpha*A*A**T + beta*C or C := alpha*A**T*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/de/d54/zsyrk_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part of C is to be referenced.
* @param Trans The type of transpose applied to the operation.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
*/
void ZSYRK(RsBlasUplo Uplo, RsBlasTranspose Trans, Double2 alpha,
const sp<Allocation>& A, Double2 beta, const sp<Allocation>& C);
/**
* SSYR2K performs one of the symmetric rank 2k operations
* C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/df/d3d/ssyr2k_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part of C is to be referenced.
* @param Trans The type of transpose applied to the operation.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F32}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F32}.
*/
void SSYR2K(RsBlasUplo Uplo, RsBlasTranspose Trans, float alpha,
const sp<Allocation>& A, const sp<Allocation>& B, float beta, const sp<Allocation>& C);
/**
* DSYR2K performs one of the symmetric rank 2k operations
* C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/d1/dec/dsyr2k_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part of C is to be referenced.
* @param Trans The type of transpose applied to the operation.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F64}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F64}.
*/
void DSYR2K(RsBlasUplo Uplo, RsBlasTranspose Trans, double alpha,
const sp<Allocation>& A, const sp<Allocation>& B, double beta, const sp<Allocation>& C);
/**
* CSYR2K performs one of the symmetric rank 2k operations
* C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/de/d7e/csyr2k_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part of C is to be referenced.
* @param Trans The type of transpose applied to the operation.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
*/
void CSYR2K(RsBlasUplo Uplo, RsBlasTranspose Trans, Float2 alpha,
const sp<Allocation>& A, const sp<Allocation>& B, Float2 beta, const sp<Allocation>& C);
/**
* ZSYR2K performs one of the symmetric rank 2k operations
* C := alpha*A*B**T + alpha*B*A**T + beta*C or C := alpha*A**T*B + alpha*B**T*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/df/d20/zsyr2k_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part of C is to be referenced.
* @param Trans The type of transpose applied to the operation.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
*/
void ZSYR2K(RsBlasUplo Uplo, RsBlasTranspose Trans, Double2 alpha,
const sp<Allocation>& A, const sp<Allocation>& B, Double2 beta, const sp<Allocation>& C);
/**
* STRMM performs one of the matrix-matrix operations
* B := alpha*op(A)*B or B := alpha*B*op(A)
* op(A) is one of op(A) = A or op(A) = A**T
*
* Details: http://www.netlib.org/lapack/explore-html/df/d01/strmm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether matrix A is upper or lower triangular.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F32}.
*/
void STRMM(RsBlasSide Side, RsBlasUplo Uplo, RsBlasTranspose TransA,
RsBlasDiag Diag, float alpha, const sp<Allocation>& A, const sp<Allocation>& B);
/**
* DTRMM performs one of the matrix-matrix operations
* B := alpha*op(A)*B or B := alpha*B*op(A)
* op(A) is one of op(A) = A or op(A) = A**T
*
* Details: http://www.netlib.org/lapack/explore-html/dd/d19/dtrmm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether matrix A is upper or lower triangular.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F64}.
*/
void DTRMM(RsBlasSide Side, RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
double alpha, const sp<Allocation>& A, const sp<Allocation>& B);
/**
* CTRMM performs one of the matrix-matrix operations
* B := alpha*op(A)*B or B := alpha*B*op(A)
* op(A) is one of op(A) = A or op(A) = A**T or op(A) = A**H
*
* Details: http://www.netlib.org/lapack/explore-html/d4/d9b/ctrmm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether matrix A is upper or lower triangular.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
*/
void CTRMM(RsBlasSide Side, RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& B);
/**
* ZTRMM performs one of the matrix-matrix operations
* B := alpha*op(A)*B or B := alpha*B*op(A)
* op(A) is one of op(A) = A or op(A) = A**T or op(A) = A**H
*
* Details: http://www.netlib.org/lapack/explore-html/d8/de1/ztrmm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether matrix A is upper or lower triangular.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
*/
void ZTRMM(RsBlasSide Side, RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& B);
/**
* STRSM solves one of the matrix equations
* op(A)*X := alpha*B or X*op(A) := alpha*B
* op(A) is one of op(A) = A or op(A) = A**T
*
* Details: http://www.netlib.org/lapack/explore-html/d2/d8b/strsm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether matrix A is upper or lower triangular.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F32}.
*/
void STRSM(RsBlasSide Side, RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
float alpha, const sp<Allocation>& A, const sp<Allocation>& B);
/**
* DTRSM solves one of the matrix equations
* op(A)*X := alpha*B or X*op(A) := alpha*B
* op(A) is one of op(A) = A or op(A) = A**T
*
* Details: http://www.netlib.org/lapack/explore-html/de/da7/dtrsm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether matrix A is upper or lower triangular.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F64}.
*/
void DTRSM(RsBlasSide Side, RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
double alpha, const sp<Allocation>& A, const sp<Allocation>& B);
/**
* CTRSM solves one of the matrix equations
* op(A)*X := alpha*B or X*op(A) := alpha*B
* op(A) is one of op(A) = A or op(A) = A**T or op(A) = A**H
*
* Details: http://www.netlib.org/lapack/explore-html/de/d30/ctrsm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether matrix A is upper or lower triangular.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
*/
void CTRSM(RsBlasSide Side, RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& B);
/**
* ZTRSM solves one of the matrix equations
* op(A)*X := alpha*B or X*op(A) := alpha*B
* op(A) is one of op(A) = A or op(A) = A**T or op(A) = A**H
*
* Details: http://www.netlib.org/lapack/explore-html/d1/d39/ztrsm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether matrix A is upper or lower triangular.
* @param TransA The type of transpose applied to matrix A.
* @param Diag Specifies whether or not A is unit triangular.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
*/
void ZTRSM(RsBlasSide Side, RsBlasUplo Uplo, RsBlasTranspose TransA, RsBlasDiag Diag,
Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& B);
/**
* CHEMM performs one of the matrix-matrix operations
* C := alpha*A*B + beta*C or C := alpha*B*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/d3/d66/chemm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
*/
void CHEMM(RsBlasSide Side, RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& A,
const sp<Allocation>& B, Float2 beta, const sp<Allocation>& C);
/**
* ZHEMM performs one of the matrix-matrix operations
* C := alpha*A*B + beta*C or C := alpha*B*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/d6/d3e/zhemm_8f.html
*
* @param Side Specifies whether the symmetric matrix A appears on the left or right.
* @param Uplo Specifies whether the upper or lower triangular part is to be referenced.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
*/
void ZHEMM(RsBlasSide Side, RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& A,
const sp<Allocation>& B, Double2 beta, const sp<Allocation>& C);
/**
* CHERK performs one of the hermitian rank k operations
* C := alpha*A*A**H + beta*C or C := alpha*A**H*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/d8/d52/cherk_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part of C is to be referenced.
* @param Trans The type of transpose applied to the operation.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
*/
void CHERK(RsBlasUplo Uplo, RsBlasTranspose Trans, float alpha, const sp<Allocation>& A,
float beta, const sp<Allocation>& C);
/**
* ZHERK performs one of the hermitian rank k operations
* C := alpha*A*A**H + beta*C or C := alpha*A**H*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/d1/db1/zherk_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part of C is to be referenced.
* @param Trans The type of transpose applied to the operation.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
*/
void ZHERK(RsBlasUplo Uplo, RsBlasTranspose Trans, double alpha, const sp<Allocation>& A,
double beta, const sp<Allocation>& C);
/**
* CHER2K performs one of the hermitian rank 2k operations
* C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C or C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/d1/d82/cher2k_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part of C is to be referenced.
* @param Trans The type of transpose applied to the operation.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
*/
void CHER2K(RsBlasUplo Uplo, RsBlasTranspose Trans, Float2 alpha, const sp<Allocation>& A,
const sp<Allocation>& B, float beta, const sp<Allocation>& C);
/**
* ZHER2K performs one of the hermitian rank 2k operations
* C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C or C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C
*
* Details: http://www.netlib.org/lapack/explore-html/d7/dfa/zher2k_8f.html
*
* @param Uplo Specifies whether the upper or lower triangular part of C is to be referenced.
* @param Trans The type of transpose applied to the operation.
* @param alpha The scalar alpha.
* @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
* @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
* @param beta The scalar beta.
* @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
*/
void ZHER2K(RsBlasUplo Uplo, RsBlasTranspose Trans, Double2 alpha, const sp<Allocation>& A,
const sp<Allocation>& B, double beta, const sp<Allocation>& C);
/**
* 8-bit GEMM-like operation for neural networks: C = A * Transpose(B)
* Calculations are done in 1.10.21 fixed-point format for the final output,
* just before there's a shift down to drop the fractional parts. The output
* values are gated to 0 to 255 to fit in a byte, but the 10-bit format
* gives some headroom to avoid wrapping around on small overflows.
*
* @param A The input allocation contains matrix A, supported elements type: {Element#U8}.
* @param a_offset The offset for all values in matrix A, e.g A[i,j] = A[i,j] - a_offset. Value should be from 0 to 255.
* @param B The input allocation contains matrix B, supported elements type: {Element#U8}.
* @param b_offset The offset for all values in matrix B, e.g B[i,j] = B[i,j] - b_offset. Value should be from 0 to 255.
* @param C The input allocation contains matrix C, supported elements type: {Element#U8}.
* @param c_offset The offset for all values in matrix C.
* @param c_mult The multiplier for all values in matrix C, e.g C[i,j] = (C[i,j] + c_offset) * c_mult.
**/
void BNNM(const sp<Allocation>& A, int a_offset, const sp<Allocation>& B, int b_offset, const sp<Allocation>& C,
int c_offset, int c_mult);
};
/**
* 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(const sp<RS>& rs, const sp<const Element>& e);
/**
* sets dst = {0, 0, 0, 0}
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachClear(const sp<Allocation>& in, const sp<Allocation>& out);
/**
* Sets dst = src
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachSrc(const sp<Allocation>& in, const sp<Allocation>& out);
/**
* Sets dst = dst (NOP)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachDst(const sp<Allocation>& in, const sp<Allocation>& out);
/**
* Sets dst = src + dst * (1.0 - src.a)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachSrcOver(const sp<Allocation>& in, const sp<Allocation>& out);
/**
* Sets dst = dst + src * (1.0 - dst.a)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachDstOver(const sp<Allocation>& in, const sp<Allocation>& out);
/**
* Sets dst = src * dst.a
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachSrcIn(const sp<Allocation>& in, const sp<Allocation>& out);
/**
* Sets dst = dst * src.a
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachDstIn(const sp<Allocation>& in, const sp<Allocation>& out);
/**
* Sets dst = src * (1.0 - dst.a)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachSrcOut(const sp<Allocation>& in, const sp<Allocation>& out);
/**
* Sets dst = dst * (1.0 - src.a)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachDstOut(const sp<Allocation>& in, const 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(const sp<Allocation>& in, const 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(const sp<Allocation>& in, const 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(const sp<Allocation>& in, const sp<Allocation>& out);
/**
* Sets dst = src * dst
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachMultiply(const sp<Allocation>& in, const sp<Allocation>& out);
/**
* Sets dst = min(src + dst, 1.0)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachAdd(const sp<Allocation>& in, const sp<Allocation>& out);
/**
* Sets dst = max(dst - src, 0.0)
* @param[in] in input Allocation
* @param[in] out output Allocation
*/
void forEachSubtract(const sp<Allocation>& in, const 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(const sp<RS>& rs, const sp<const Element>& e);
/**
* Sets the input of the blur.
* @param[in] in input Allocation
*/
void setInput(const sp<Allocation>& in);
/**
* Runs the intrinsic.
* @param[in] output Allocation
*/
void forEach(const 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(const 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(const sp<Allocation>& in, const 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(const sp<RS>& rs, const sp<const Element>& e);
/**
* Sets input for intrinsic.
* @param[in] in input Allocation
*/
void setInput(const sp<Allocation>& in);
/**
* Launches the intrinsic.
* @param[in] out output Allocation
*/
void forEach(const 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(const sp<RS>& rs, const sp<const Element>& e);
/**
* Sets input for intrinsic.
* @param[in] in input Allocation
*/
void setInput(const sp<Allocation>& in);
/**
* Launches the intrinsic.
* @param[in] out output Allocation
*/
void forEach(const 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(const sp<RS>& rs, const sp<const Element>& e);
/**
* Set the output of the histogram. 32 bit integer types are
* supported.
*
* @param[in] aout The output allocation
*/
void setOutput(const 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(const 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(const 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(const sp<RS>& rs, const 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(const sp<Allocation>& ain, const 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(const 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(const sp<Allocation>& aout);
/**
* Set the input of the resize.
* @param[in] lut new lookup table
*/
void setInput(const 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(const sp<RS>& rs, const sp<const Element>& e);
/**
* Set the input YUV allocation.
*
* @param[in] ain The input allocation.
*/
void setInput(const sp<Allocation>& in);
/**
* Convert the image to RGB.
*
* @param[in] aout Output allocation. Must match creation element
* type.
*/
void forEach(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const sp<RS> &rs);
};
} // namespace RSC
} // namespace android
#endif