3 RenderScript****运行时层与反射层
3.1 RenderScript****运行时层
RenderScript运行时层是指.rs代码运行时所在的层级。当对安卓项目进行编译的时候，.rs或者.rsh中编写的代码都会被llvm编译器编译成字节码。当该安卓应用在设备上运行的时候，这些字节码将会被设备上另外一个llvm编译（just-in-time）成机器码。这些机器码是针对该设备进行了优化的，且缓存在设备上，等到下次被应用的时候就不需要重新编译了，以加快速度。虽然RenderScript运行时层很像NDK，但是由于NDK中的C函数只针对CPU设计，与RenderScript还能够在GPU和DSP上运行的目标不同，因此在RenderScript中不能使用NDK中的C函数。
RenderScript运行时库的特性包括：
- 请求内存分配，即其内存是由Android framework层负责分配的。
- 一系列针对标量与向量计算的数学函数
- 提供基本数据到向量/矩阵或者数据到时间的转换函数
- 预定义的一系列二维、三维、四维向量类型
- Log功能，rsDebug函数
3.2 ****反射层
反射层由安卓编译工具基于开发者编写的.rs/.rsh文件自动生成的，反射层的作用就是给Android framework层提供对RenderScript运行时层操作的Java接口，包括内存分配、计算任务启动、数据交互等。
每一个.rs文件都会被映射成继承于ScriptC的类：ScriptC_RenderScript_filename，该类被生成在gen目录下与.rs文件相同的包下。该类就是.rs文件的Java版本。该类主要包含.rs中的如下内容：
- 非静态函数。.rs中的非kernel函数不能有返回值，因为RenderScript系统被设计成异步执行。当你从安卓层调用RenderScript函数的时候，这个调用被放在队列中，然后当轮到该调用的时候再执行。这样的话可以使RenderScript避免被经常打断以提升性能。如果想在RenderScript代码（.rs）中给安卓层返回值，则可以使用rsSendToClient()
- 非静态全局变量。而且会对这些变量生成get/set方法（const变量则不会生成set方法），且如果在RenderScript中对这些变量进行了初始化，那么在反射层也会进行相同的初始化。
- 全局指针。指针会被映射到.rs对应的类中。可以声明一个指针指向struct或者其他任何RenderScript支持的类型的指针。因为不容许在.rs中给指针分配内存，对于每个指针，都会生成一个对应的get方法以及bind_pointer_name，这个函数用于把在安卓VM中分配的内存绑定到RenderScript运行时。
- 定义的struct。Struct也是定义在.rs文件中，无论是单独定义struct还是和其他RenderScript代码放在一起，都会给每个单独的struct生成一个ScriptField_struct_name.java的类文件，你可以通过它来给一个或者多个该struct实例分配内存。但是注意：只有当你定义的struct在RenderScript代码中被用到了才会生成对应的类文件，若是没有使用的话则不会生成。在struct中不能含有指针或者数列。
Struct****映射的详细解释
反射层生成的Struct主要包括：
- 构造函数：ScriptField_struct_name(RenderScript rs, int count)，这个构造函数用来分配count数量的struct内存
- 构造函数：ScriptField_struct_name(RenderScript rs, int count, int usages)不仅通过count指定要分配的struct数量，并且通过usages指定这些内存被分配在哪个区域。主要有：
- USAGE_SCRIPT：指定在脚本内存区分配内存，这也是默认的内存分配区
- USAGE_GRAPHICS_TEXTURE: 在GPU的纹理内存区分配，API对其描述是："The Allocation will be used as a texture source by one or more graphics programs."，所以如果么有打算需要绘制这些图片就不要在TEXTURE分配了。
- USAGE_GRAPHICS_VERTEX：在GPU的顶点内存区分配，API对其描述是："The Allocation will be used as a graphics mesh. This was deprecated in API level 16."，已经在API16废弃。
- USAGE_GRAPHICS_CONSTANTS：在GPU的常量内存区分配。常量内存区被多个应用共同使用。API中对其描述是：“The Allocation will be used as the source of shader constants by one or more programs. This was deprecated in API level 16.”，同样也是在API16中就已经废弃。
可以使用或操作符来指定在多个内存区分配该内存，这样做表示向RenderScript表明：我想在多个内存区来访问该数据。
综上，能用的或者建议使用的就只有SCRIPT和TEXTURE两个，只需要记住：后面一个当你有使用GL绘制你分配的Allocation的时候才用即可。
- 一个Item内部类，通过该内部类你可以创建该结构的实例，这对于如果需要在安卓层中使用结构实例就非常有用。可以使用set(Item i, int index, boolean copyNow)方法来把某个Item实例插入到已经分配好的内存的指定位置。
- 结构中的每个字段都会有一个对应的set/get方法，且这些方法中都有一个index参数来指定要设置/读取内存区的哪个对象。每一个set方法都有一个copyNow参数来说明是否立即同步该内存到RenderScript运行时。通过调用copyAll方法可以同步所有还没有同步的内存。
- 创建该结构在内存中的描述Element，通过该Element可以分配由一个或者多个该结构对应的Element组成的内存。
- resize()函数。就像C中的realloc()一样，可以扩展之前分配的内存，并保持之前创建的对象的值。
- copyAll()用来同步在framework层设置的值到RenderScript运行时层。当调用set方法时，如果给copyNow设置的false，则将会在调用copyNow时同步到RenderScript运行时层。
代码举例：
.rs文件，文件名：script.rs
#pragma version(1)
#pragma rs java_package_name(com.example.renderscripttest)
#pragma rs_fp_relaxed
uint32_t width;
uint32_t height;
rs_allocation inBitmap;
rs_allocation rgbBitmap;
rs_allocation yuvBitmap;
//multipliers to convert a RGB colors to black and white
const static float3 gMonoMult = {0.299f, 0.587f, 0.114f};
typedef struct Point_2D{
int x;
int y;
}Point;
static Point *spPoint;
static Point sPoint;
Point point;
Point *pPoint;
//google sample
void root(const uchar4 *v_in, uchar4 *v_out) {
//unpack a color to a float4
float4 f4 = rsUnpackColor8888(*v_in);
//take the dot product of the color and the multiplier
float3 mono = dot(f4.rgb, gMonoMult);
//repack the float to a color
*v_out = rsPackColorTo8888(mono);
}
void __attribute((kernel)) setPoint(const uint2 in, uint32_t x, uint32_t y){
rsDebug("lyh", point.x);
point.x = 9; //struct is used
point.y = 12;
rsSendToClient(0, &point, 1);
rsDebug("willhua", point.x);
}
uchar4 __attribute__((kernel)) halveBitmap(uchar4 in){
uchar4 out = in;
out.r = in.r / 2;
out.r = in.r / 2;
out.r = in.r / 2;
return out;
}
uchar4 __attribute__((kernel)) averageBitmap(uchar4 in, uint32_t x, uint32_t y){
uchar4 out = in;
uchar4 left = in;
uchar4 top = in;
uchar4 right = in;
uchar4 bottom = in;
if(x - 1 > -1){ //access other element
left = rsGetElementAt_uchar4(inBitmap, x - 1, y);
}
if(y - 1 > -1){
top = rsGetElementAt_uchar4(inBitmap, x , y - 1);
}
if(x + 1 < width){
right = rsGetElementAt_uchar4(inBitmap, x + 1, y);
}
if(y + 1 < height){
bottom = rsGetElementAt_uchar4(inBitmap, x, y + 1);
}
out.r = (left.r + top.r + right.r + bottom.r) / 4;
out.g = (left.g + top.g + right.g + bottom.g) / 4;
out.b = (left.b + top.b + right.b + bottom.b) / 4;
return out;
}
反射层生成的ScriptC子类：
/*
* Copyright (C) 2011-2014 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.
*/
/*
* This file is auto-generated. DO NOT MODIFY!
* The source Renderscript file: G:\\Files\\EclipseWorkSpace\\RenderScriptTest\\src\\com\\example\\renderscripttest\\script.rs
*/
package com.example.renderscripttest;
import android.support.v8.renderscript.*;
import android.content.res.Resources;
/**
* @hide
*/
public class ScriptC_script extends ScriptC {
private static final String __rs_resource_name = "script";
// Constructor
public ScriptC_script(RenderScript rs) {
this(rs,
rs.getApplicationContext().getResources(),
rs.getApplicationContext().getResources().getIdentifier(
__rs_resource_name, "raw",
rs.getApplicationContext().getPackageName()));
}
public ScriptC_script(RenderScript rs, Resources resources, int id) {
super(rs, resources, id);
__U32 = Element.U32(rs);
__ALLOCATION = Element.ALLOCATION(rs);
__ScriptField_Point_2D = ScriptField_Point_2D.createElement(rs);
__U8_4 = Element.U8_4(rs);
__U32_2 = Element.U32_2(rs);
}
private Element __ALLOCATION;
private Element __ScriptField_Point_2D;
private Element __U32;
private Element __U32_2;
private Element __U8_4;
private FieldPacker __rs_fp_ALLOCATION;
private FieldPacker __rs_fp_ScriptField_Point_2D;
private FieldPacker __rs_fp_U32;
private final static int mExportVarIdx_width = 0;
private long mExportVar_width;
public synchronized void set_width(long v) {
if (__rs_fp_U32!= null) {
__rs_fp_U32.reset();
} else {
__rs_fp_U32 = new FieldPacker(4);
}
__rs_fp_U32.addU32(v);
setVar(mExportVarIdx_width, __rs_fp_U32);
mExportVar_width = v;
}
public long get_width() {
return mExportVar_width;
}
public Script.FieldID getFieldID_width() {
return createFieldID(mExportVarIdx_width, null);
}
private final static int mExportVarIdx_height = 1;
private long mExportVar_height;
public synchronized void set_height(long v) {
if (__rs_fp_U32!= null) {
__rs_fp_U32.reset();
} else {
__rs_fp_U32 = new FieldPacker(4);
}
__rs_fp_U32.addU32(v);
setVar(mExportVarIdx_height, __rs_fp_U32);
mExportVar_height = v;
}
public long get_height() {
return mExportVar_height;
}
public Script.FieldID getFieldID_height() {
return createFieldID(mExportVarIdx_height, null);
}
private final static int mExportVarIdx_inBitmap = 2;
private Allocation mExportVar_inBitmap;
public synchronized void set_inBitmap(Allocation v) {
setVar(mExportVarIdx_inBitmap, v);
mExportVar_inBitmap = v;
}
public Allocation get_inBitmap() {
return mExportVar_inBitmap;
}
public Script.FieldID getFieldID_inBitmap() {
return createFieldID(mExportVarIdx_inBitmap, null);
}
private final static int mExportVarIdx_rgbBitmap = 3;
private Allocation mExportVar_rgbBitmap;
public synchronized void set_rgbBitmap(Allocation v) {
setVar(mExportVarIdx_rgbBitmap, v);
mExportVar_rgbBitmap = v;
}
public Allocation get_rgbBitmap() {
return mExportVar_rgbBitmap;
}
public Script.FieldID getFieldID_rgbBitmap() {
return createFieldID(mExportVarIdx_rgbBitmap, null);
}
private final static int mExportVarIdx_yuvBitmap = 4;
private Allocation mExportVar_yuvBitmap;
public synchronized void set_yuvBitmap(Allocation v) {
setVar(mExportVarIdx_yuvBitmap, v);
mExportVar_yuvBitmap = v;
}
public Allocation get_yuvBitmap() {
return mExportVar_yuvBitmap;
}
public Script.FieldID getFieldID_yuvBitmap() {
return createFieldID(mExportVarIdx_yuvBitmap, null);
}
private final static int mExportVarIdx_point = 5;
private ScriptField_Point_2D.Item mExportVar_point;
public synchronized void set_point(ScriptField_Point_2D.Item v) {
mExportVar_point = v;
FieldPacker fp = new FieldPacker(8);
fp.addI32(v.x);
fp.addI32(v.y);
int []__dimArr = new int[1];
__dimArr[0] = 1;
setVar(mExportVarIdx_point, fp, __ScriptField_Point_2D, __dimArr);
}
public ScriptField_Point_2D.Item get_point() {
return mExportVar_point;
}
public Script.FieldID getFieldID_point() {
return createFieldID(mExportVarIdx_point, null);
}
private final static int mExportVarIdx_pPoint = 6;
private ScriptField_Point_2D mExportVar_pPoint;
public void bind_pPoint(ScriptField_Point_2D v) {
mExportVar_pPoint = v;
if (v == null) bindAllocation(null, mExportVarIdx_pPoint);
else bindAllocation(v.getAllocation(), mExportVarIdx_pPoint);
}
public ScriptField_Point_2D get_pPoint() {
return mExportVar_pPoint;
}
private final static int mExportForEachIdx_root = 0;
public Script.KernelID getKernelID_root() {
return createKernelID(mExportForEachIdx_root, 3, null, null);
}
public void forEach_root(Allocation ain, Allocation aout) {
forEach_root(ain, aout, null);
}
public void forEach_root(Allocation ain, Allocation aout, Script.LaunchOptions sc) {
// check ain
if (!ain.getType().getElement().isCompatible(__U8_4)) {
throw new RSRuntimeException("Type mismatch with U8_4!");
}
// check aout
if (!aout.getType().getElement().isCompatible(__U8_4)) {
throw new RSRuntimeException("Type mismatch with U8_4!");
}
Type t0, t1; // Verify dimensions
t0 = ain.getType();
t1 = aout.getType();
if ((t0.getCount() != t1.getCount()) ||
(t0.getX() != t1.getX()) ||
(t0.getY() != t1.getY()) ||
(t0.getZ() != t1.getZ()) ||
(t0.hasFaces() != t1.hasFaces()) ||
(t0.hasMipmaps() != t1.hasMipmaps())) {
throw new RSRuntimeException("Dimension mismatch between parameters ain and aout!");
}
forEach(mExportForEachIdx_root, ain, aout, null, sc);
}
private final static int mExportForEachIdx_setPoint = 1;
public Script.KernelID getKernelID_setPoint() {
return createKernelID(mExportForEachIdx_setPoint, 57, null, null);
}
public void forEach_setPoint(Allocation ain) {
forEach_setPoint(ain, null);
}
public void forEach_setPoint(Allocation ain, Script.LaunchOptions sc) {
// check ain
if (!ain.getType().getElement().isCompatible(__U32_2)) {
throw new RSRuntimeException("Type mismatch with U32_2!");
}
forEach(mExportForEachIdx_setPoint, ain, null, null, sc);
}
private final static int mExportForEachIdx_halveBitmap = 2;
public Script.KernelID getKernelID_halveBitmap() {
return createKernelID(mExportForEachIdx_halveBitmap, 35, null, null);
}
public void forEach_halveBitmap(Allocation ain, Allocation aout) {
forEach_halveBitmap(ain, aout, null);
}
public void forEach_halveBitmap(Allocation ain, Allocation aout, Script.LaunchOptions sc) {
// check ain
if (!ain.getType().getElement().isCompatible(__U8_4)) {
throw new RSRuntimeException("Type mismatch with U8_4!");
}
// check aout
if (!aout.getType().getElement().isCompatible(__U8_4)) {
throw new RSRuntimeException("Type mismatch with U8_4!");
}
Type t0, t1; // Verify dimensions
t0 = ain.getType();
t1 = aout.getType();
if ((t0.getCount() != t1.getCount()) ||
(t0.getX() != t1.getX()) ||
(t0.getY() != t1.getY()) ||
(t0.getZ() != t1.getZ()) ||
(t0.hasFaces() != t1.hasFaces()) ||
(t0.hasMipmaps() != t1.hasMipmaps())) {
throw new RSRuntimeException("Dimension mismatch between parameters ain and aout!");
}
forEach(mExportForEachIdx_halveBitmap, ain, aout, null, sc);
}
private final static int mExportForEachIdx_averageBitmap = 3;
public Script.KernelID getKernelID_averageBitmap() {
return createKernelID(mExportForEachIdx_averageBitmap, 59, null, null);
}
public void forEach_averageBitmap(Allocation ain, Allocation aout) {
forEach_averageBitmap(ain, aout, null);
}
public void forEach_averageBitmap(Allocation ain, Allocation aout, Script.LaunchOptions sc) {
// check ain
if (!ain.getType().getElement().isCompatible(__U8_4)) {
throw new RSRuntimeException("Type mismatch with U8_4!");
}
// check aout
if (!aout.getType().getElement().isCompatible(__U8_4)) {
throw new RSRuntimeException("Type mismatch with U8_4!");
}
Type t0, t1; // Verify dimensions
t0 = ain.getType();
t1 = aout.getType();
if ((t0.getCount() != t1.getCount()) ||
(t0.getX() != t1.getX()) ||
(t0.getY() != t1.getY()) ||
(t0.getZ() != t1.getZ()) ||
(t0.hasFaces() != t1.hasFaces()) ||
(t0.hasMipmaps() != t1.hasMipmaps())) {
throw new RSRuntimeException("Dimension mismatch between parameters ain and aout!");
}
forEach(mExportForEachIdx_averageBitmap, ain, aout, null, sc);
}
}
反射层生成的struct，Point_2D, 对应的类：
/*
* Copyright (C) 2011-2014 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.
*/
/*
* This file is auto-generated. DO NOT MODIFY!
* The source Renderscript file: G:\\Files\\EclipseWorkSpace\\RenderScriptTest\\src\\com\\example\\renderscripttest\\script.rs
*/
package com.example.renderscripttest;
import android.support.v8.renderscript.*;
import android.content.res.Resources;
/**
* @hide
*/
public class ScriptField_Point_2D extends android.support.v8.renderscript.Script.FieldBase {
static public class Item {
public static final int sizeof = 8;
int x;
int y;
Item() {
}
}
private Item mItemArray[];
private FieldPacker mIOBuffer;
private static java.lang.ref.WeakReference mElementCache = new java.lang.ref.WeakReference(null);
public static Element createElement(RenderScript rs) {
Element.Builder eb = new Element.Builder(rs);
eb.add(Element.I32(rs), "x");
eb.add(Element.I32(rs), "y");
return eb.create();
}
private ScriptField_Point_2D(RenderScript rs) {
mItemArray = null;
mIOBuffer = null;
mElement = createElement(rs);
}
public ScriptField_Point_2D(RenderScript rs, int count) {
mItemArray = null;
mIOBuffer = null;
mElement = createElement(rs);
init(rs, count);
}
public ScriptField_Point_2D(RenderScript rs, int count, int usages) {
mItemArray = null;
mIOBuffer = null;
mElement = createElement(rs);
init(rs, count, usages);
}
public static ScriptField_Point_2D create1D(RenderScript rs, int dimX, int usages) {
ScriptField_Point_2D obj = new ScriptField_Point_2D(rs);
obj.mAllocation = Allocation.createSized(rs, obj.mElement, dimX, usages);
return obj;
}
public static ScriptField_Point_2D create1D(RenderScript rs, int dimX) {
return create1D(rs, dimX, Allocation.USAGE_SCRIPT);
}
public static ScriptField_Point_2D create2D(RenderScript rs, int dimX, int dimY) {
return create2D(rs, dimX, dimY, Allocation.USAGE_SCRIPT);
}
public static ScriptField_Point_2D create2D(RenderScript rs, int dimX, int dimY, int usages) {
ScriptField_Point_2D obj = new ScriptField_Point_2D(rs);
Type.Builder b = new Type.Builder(rs, obj.mElement);
b.setX(dimX);
b.setY(dimY);
Type t = b.create();
obj.mAllocation = Allocation.createTyped(rs, t, usages);
return obj;
}
public static Type.Builder createTypeBuilder(RenderScript rs) {
Element e = createElement(rs);
return new Type.Builder(rs, e);
}
public static ScriptField_Point_2D createCustom(RenderScript rs, Type.Builder tb, int usages) {
ScriptField_Point_2D obj = new ScriptField_Point_2D(rs);
Type t = tb.create();
if (t.getElement() != obj.mElement) {
throw new RSIllegalArgumentException("Type.Builder did not match expected element type.");
}
obj.mAllocation = Allocation.createTyped(rs, t, usages);
return obj;
}
private void copyToArrayLocal(Item i, FieldPacker fp) {
fp.addI32(i.x);
fp.addI32(i.y);
}
private void copyToArray(Item i, int index) {
if (mIOBuffer == null) mIOBuffer = new FieldPacker(mElement.getBytesSize() * getType().getX()/* count */);
mIOBuffer.reset(index * mElement.getBytesSize());
copyToArrayLocal(i, mIOBuffer);
}
public synchronized void set(Item i, int index, boolean copyNow) {
if (mItemArray == null) mItemArray = new Item[getType().getX() /* count */];
mItemArray[index] = i;
if (copyNow) {
copyToArray(i, index);
FieldPacker fp = new FieldPacker(mElement.getBytesSize());
copyToArrayLocal(i, fp);
mAllocation.setFromFieldPacker(index, fp);
}
}
public synchronized Item get(int index) {
if (mItemArray == null) return null;
return mItemArray[index];
}
public synchronized void set_x(int index, int v, boolean copyNow) {
if (mIOBuffer == null) mIOBuffer = new FieldPacker(mElement.getBytesSize() * getType().getX()/* count */);
if (mItemArray == null) mItemArray = new Item[getType().getX() /* count */];
if (mItemArray[index] == null) mItemArray[index] = new Item();
mItemArray[index].x = v;
if (copyNow) {
mIOBuffer.reset(index * mElement.getBytesSize());
mIOBuffer.addI32(v);
FieldPacker fp = new FieldPacker(4);
fp.addI32(v);
mAllocation.setFromFieldPacker(index, 0, fp);
}
}
public synchronized void set_y(int index, int v, boolean copyNow) {
if (mIOBuffer == null) mIOBuffer = new FieldPacker(mElement.getBytesSize() * getType().getX()/* count */);
if (mItemArray == null) mItemArray = new Item[getType().getX() /* count */];
if (mItemArray[index] == null) mItemArray[index] = new Item();
mItemArray[index].y = v;
if (copyNow) {
mIOBuffer.reset(index * mElement.getBytesSize() + 4);
mIOBuffer.addI32(v);
FieldPacker fp = new FieldPacker(4);
fp.addI32(v);
mAllocation.setFromFieldPacker(index, 1, fp);
}
}
public synchronized int get_x(int index) {
if (mItemArray == null) return 0;
return mItemArray[index].x;
}
public synchronized int get_y(int index) {
if (mItemArray == null) return 0;
return mItemArray[index].y;
}
public synchronized void copyAll() {
for (int ct = 0; ct < mItemArray.length; ct++) copyToArray(mItemArray[ct], ct);
mAllocation.setFromFieldPacker(0, mIOBuffer);
}
}
4 ****内存
我们已经知道，应用自身运行在安卓VM中，而RenderScript部分代码则运行在本地，且其内存是由上层的应用分配的。
4.1 ****内存分配****API
内存API主要包含三个类：Element，Type与Allocation。他们三者对应的关系能用malloc函数的使用来很好的说明，例如：
int *array = (int *)malloc(sizeof(int) * 10);
malloc函数的参数可以分成两个部分：第一个就是sizeof(int)，该过程指定每个内存单元需要多个内存；第二个就是10，该过程指定需要分配多个这样的内存单元。对应的内存分配APIs就是Element类，表示的是一个内存单元，就像一个float或者一个struct所表示的内存。而Type表示的就是“10”部分，就像一个Element序列一样。Allocation则用来执行由Type所描述的内存分配，且最终代表分配得到的内存。
大部分情况下都不需要直接使用这些API，因为系统在自动生成反射层的时候已经做好了封装，需要做的就是调用对应类的构造函数并把分配的内存绑定到RenderScript而已。但是比如当你加载一张图片到RenderScript层或者给一个指针分配内存时，就需要应用到这些API。
4.2 ****静态内存
4.2.1 ****静态内存的分配
这里的静态内存指的是在RenderScript中声明的非静态的全局变量（静态的或者局部的变量就无法在Android framework层访问，也就不讨论），他们在编译时就分配了内存，在RenderScript代码中可以直接使用它们而不需要在Android Framework层给他们分配内存。在Android Framework层也可以通过反射层生成的函数来访问他们。如果这些变量在RenderScript中被初始化，那么他们也将在Android Framework层中被进行同样的初始化。
注意：如果在RenderScript中使用到了RenderScript中预定义了的一些含有指针的结构体，比如rs_program_fragment和rs_allocation，那么就需要先在Android Framework层构造一个该结构对应类的实例，然后调用set方法把内存绑定到RenderScript运行时，而不能直接在RenderScript层操作。但是这个对于用户自定义的包含指针的结果无效，因为根本就无法自定义包含指针的结构。
4.2.2 ****静态内存的读写
在RenderScript层对静态分配的内存的写操作是单向的。当你在RenderScript层修改了某个变量的值，出于性能方面的考虑，这个变化不会反应给安卓层。在安卓层调用get方法获得的是安卓层最后一次通过set方法设置的值，除非通过rsSendToClient()等手段，否则安卓层是永远获取不到RenderScript对静态分配的内存的修改的。但是，当安卓层修改了某个变量的值后，该值的变化随后就会自动同步到RenderScript层。
下面是读写示例。假如在rsfile.rs中定义了全局变量point:
typedef struct Point {
int x;
int y;
} Point_t;
Point_t point;
那么在RenderScript中可以如下直接给变量赋值：
point.x = 1;
point.y = 1;
在Android framework层中可以这样修改该变量的值，且修改的值会通知到RenderScript层：
ScriptC_rsfile mScript;
...
Item i = new ScriptField_Point.Item();
i.x = 1;
i.y = 1;
mScript.set_point(i);
在RenderScript中读取变量的值：
rsDebug("Printing out a Point", point.x, point.y);
在Android framework中读取变量的值。再一次强调：读取到的永远是Android framework层最后一次调用set方法给该变量赋的值，而如果在Android framework层没有用set方法给变量赋过值的话，那么读取的将是null，下面代码也会报空指针错误
Log.i("TAGNAME", "Printing out a Point: " + mScript.get_point().x + " " + mScript.get_point().y);
System.out.println(point.get_x() + " " + point.get_y());
4.3 ****动态内存
4.3.1 ****动态内存的分配
对于动态内存，比如指针，就必须在Android Framework层中给它分配内存。需要两个过程：分配内存与绑定内存。这样做的好处在于：安卓VM能够完全掌握RenderScript内存的分配与回收。
无论在Android Framework层还是RenderScript中，都可以通过该指针来访问分配的内存。
为了给RenderScript动态分配内存，最常见的做法是调用Script.FieldBase的构造函数，当然好也可以手动创建Allocation来实现，为了简单起见，应该使用Script.FieldBase.当获取分配的内存对象后，就可以通过反射层的bind方法把该内存绑定到RenderScript。下面代码是两种实现方式的例子：
private RenderScript myRenderScript;
private ScriptC_example mScript;
private Resources resources;
public void init(RenderScript rs, Resources res) {
myRenderScript = rs;
resources = res;
//使用反射层生成的类分配内存
ScriptField_Point touchPoints = new ScriptField_Point(myRenderScript, 2);
//自己使用API分配内存
intPointer = Allocation.createSized(myRenderScript, Element.I32(myRenderScript), 2);
mScript = new ScriptC_example(myRenderScript, resources, R.raw.example);
//绑定内存
mScript.bind_touchPoints(touchPoints);
mScript.bind_intPointer(intPointer);
...
}
4.3.2 ****动态内存的读写
对于动态内存，在Android framework层可以通过反射层的set/get方法来读/写内存，在RenderScript中也可以像往常一样读/写，且任意一方的写操作都会通知到另外一方。
下面是示例。假设在rsfile.rs定义了如下全局指针:
typedef struct Point {
int x;
int y;
} Point_t;
Point_t *point;
只要你已经在Android framework层给分配了内存，那么就可以像往常一样使用它，且任何的修改都会通知到Android framework层。
point[index].x = 1;
point[index].y = 1;
在Android framework 层通过反射层提供的方法读写:
ScriptField_Point p = new ScriptField_Point(mRS, 1);
Item i = new ScriptField_Point.Item();
i.x=100;
i.y = 100;
p.set(i, 0, true);
mScript.bind_point(p);
points.get_x(0); //read x and y from index 0
points.get_x(0);
内存只需要绑定一次就可以了，不需要每次修改值的时候再次绑定
5 ****基本应用场景
5.1 RenderScript****层回调Android framework****层
前面我们提到过，RenderScript中的invokable不能有返回值，以及对于静态内存，RenderScript层对其修改不会通知到Android framework层。对于这两种情况，配套使用RSMessageHandler和rsSendToClient是很好的解决方案。对于二者的关系，从命名就可以看出一二，RSMessageHandler相当于常用的handleMessage函数，而rsSendToClient则相当于Handler.sendMessage，只是RSMessageHandler运行在Android framework层，而rsSendToClient运行在RenderScript层。
RenderScript.RSMessageHandler它implements Runnable，在使用过程中只需要重写run函数即可。其有三个重要的字段：
- mData：int[],对应rsSendToClient中的data，表示从RenderScript发送过来的数据的地址
- mID:消息标志，对应rsSendToClient中的cmdID,类似使用Handler发送Message时的what
- mLength：对应rsSendToClient时的len，mData中数据的个数
使用范例：
- 在RenderScript（.rs文件）中调用回调函数rsSendToClicent，reSendToClient函数有四个： rsSendToClient (int cmdID) rsSendToClient (int cmdID, const void *data, uint len) rsSendToClientBlocking (int cmdID) rsSendToClientBlocking (int cmdID, const void *data, uint len)，其中cmdID即相当于message中的what参数。
- 在安卓层中，设定RenderScript中消息的Handler。即继承RenderScript.RSMessageHandler写一个类RSHandler，重写其中的run函数。在RenderScript.RSMessageHandler中有一个mID参数，即若与reSendToClient中的cmdID相等则表示是该reSendToClient发送过来的消息。
mRenderScript.setMessageHandler(new RSMessageHandler(){
@Override
public void run(){
switch (mID) {
case type:
//do something
break;
default:
break;
}
}
});
注意：run函数不是运行在主线程，所以在run函数中不能直接做操作主界面UI的操作。
5.2 ****在****RenderScript kernel****中访问更多的元素
我们提到过，对于一个kernel，最多只能有一个输入Allocation，假如需要在kernel中访问更多的Allocation，那怎么办呢？
在kernel中，仅容许对当前元素进行操作，即当前坐标（x，y）表示的元素，如果想访问其他元素，则需要定义一个全局的输入allocation，然后使用rsGetElementAt_type()来获取其他元素，比如：下面的averageBitmap就访问了全局变量inBitmap的数据:
rs_allocation inBitmap;
uchar4 __attribute__((kernel)) averageBitmap(uchar4 in, uint32_t x, uint32_t y){
uchar4 out = in;
uchar4 left = in;
uchar4 top = in;
uchar4 right = in;
uchar4 bottom = in;
if(x - 1 > -1){ //access other element
left = rsGetElementAt_uchar4(inBitmap, x - 1, y);
}
if(y - 1 > -1){
top = rsGetElementAt_uchar4(inBitmap, x , y - 1);
}
if(x + 1 < width){
right = rsGetElementAt_uchar4(inBitmap, x + 1, y);
}
if(y + 1 < height){
bottom = rsGetElementAt_uchar4(inBitmap, x, y + 1);
}
out.r = (left.r + top.r + right.r + bottom.r) / 4;
out.g = (left.g + top.g + right.g + bottom.g) / 4;
out.b = (left.b + top.b + right.b + bottom.b) / 4;
return out;
}
转自：https://www.cnblogs.com/willhua/p/5782293.html