drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add Kernel, Method, and field IDs

Browse Source 
bug 7182873

Change-Id: I066a359bb04027e9376dac088560f042c496b10e
This commit is contained in:
Jason Sams
2012-09-18 12:32:10 -07:00
parent 21dfd7c5fe
commit 08a81583c1
11 changed files with 615 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
api/current.txt
View File

@ -20003,6 +20003,8 @@ package android.renderscript {
public class Script extends android.renderscript.BaseObj {
method public void bindAllocation(android.renderscript.Allocation, int);
method protected android.renderscript.Script.FieldID createFieldID(int, android.renderscript.Element);
method protected android.renderscript.Script.KernelID createKernelID(int, int, android.renderscript.Element, android.renderscript.Element);
method protected void forEach(int, android.renderscript.Allocation, android.renderscript.Allocation, android.renderscript.FieldPacker);
method protected void invoke(int);
method protected void invoke(int, android.renderscript.FieldPacker);
@ -20032,17 +20034,39 @@ package android.renderscript {
field protected android.renderscript.Element mElement;
}
public static final class Script.FieldID extends android.renderscript.BaseObj {
}
public static final class Script.KernelID extends android.renderscript.BaseObj {
}
public class ScriptC extends android.renderscript.Script {
ctor protected ScriptC(int, android.renderscript.RenderScript);
ctor protected ScriptC(android.renderscript.RenderScript, android.content.res.Resources, int);
}
public final class ScriptGroup extends android.renderscript.BaseObj {
method public void execute();
method public void setInput(android.renderscript.Script.KernelID, android.renderscript.Allocation);
method public void setOutput(android.renderscript.Script.KernelID, android.renderscript.Allocation);
}
public static final class ScriptGroup.Builder {
ctor public ScriptGroup.Builder(android.renderscript.RenderScript);
method public android.renderscript.ScriptGroup.Builder addConnection(android.renderscript.Type, android.renderscript.Script.KernelID, android.renderscript.Script.FieldID);
method public android.renderscript.ScriptGroup.Builder addConnection(android.renderscript.Type, android.renderscript.Script.KernelID, android.renderscript.Script.KernelID);
method public android.renderscript.ScriptGroup.Builder addKernel(android.renderscript.Script.KernelID);
method public android.renderscript.ScriptGroup create();
}
public abstract class ScriptIntrinsic extends android.renderscript.Script {
}
public final class ScriptIntrinsicBlur extends android.renderscript.ScriptIntrinsic {
method public static android.renderscript.ScriptIntrinsicBlur create(android.renderscript.RenderScript, android.renderscript.Element);
method public void forEach(android.renderscript.Allocation);
method public android.renderscript.Script.FieldID getFieldID_Input();
method public android.renderscript.Script.KernelID getKernelID();
method public void setInput(android.renderscript.Allocation);
method public void setRadius(float);
}
@ -20050,6 +20074,7 @@ package android.renderscript {
public final class ScriptIntrinsicColorMatrix extends android.renderscript.ScriptIntrinsic {
method public static android.renderscript.ScriptIntrinsicColorMatrix create(android.renderscript.RenderScript, android.renderscript.Element);
method public void forEach(android.renderscript.Allocation, android.renderscript.Allocation);
method public android.renderscript.Script.KernelID getKernelID();
method public void setColorMatrix(android.renderscript.Matrix4f);
method public void setColorMatrix(android.renderscript.Matrix3f);
method public void setGreyscale();
@ -20060,6 +20085,8 @@ package android.renderscript {
public final class ScriptIntrinsicConvolve3x3 extends android.renderscript.ScriptIntrinsic {
method public static android.renderscript.ScriptIntrinsicConvolve3x3 create(android.renderscript.RenderScript, android.renderscript.Element);
method public void forEach(android.renderscript.Allocation);
method public android.renderscript.Script.FieldID getFieldID_Input();
method public android.renderscript.Script.KernelID getKernelID();
method public void setCoefficients(float[]);
method public void setInput(android.renderscript.Allocation);
}
@ -20067,6 +20094,8 @@ package android.renderscript {
public final class ScriptIntrinsicConvolve5x5 extends android.renderscript.ScriptIntrinsic {
method public static android.renderscript.ScriptIntrinsicConvolve5x5 create(android.renderscript.RenderScript, android.renderscript.Element);
method public void forEach(android.renderscript.Allocation);
method public android.renderscript.Script.FieldID getFieldID_Input();
method public android.renderscript.Script.KernelID getKernelID();
method public void setCoefficients(float[]);
method public void setInput(android.renderscript.Allocation);
}
@ -20074,6 +20103,7 @@ package android.renderscript {
public final class ScriptIntrinsicLUT extends android.renderscript.ScriptIntrinsic {
method public static android.renderscript.ScriptIntrinsicLUT create(android.renderscript.RenderScript, android.renderscript.Element);
method public void forEach(android.renderscript.Allocation, android.renderscript.Allocation);
method public android.renderscript.Script.KernelID getKernelID();
method public void setAlpha(int, int);
method public void setBlue(int, int);
method public void setGreen(int, int);

36
graphics/java/android/renderscript/RenderScript.java
View File

@ -567,6 +567,42 @@ public class RenderScript {
return rsnScriptIntrinsicCreate(mContext, id, eid);
}
native int rsnScriptKernelIDCreate(int con, int sid, int slot, int sig);
synchronized int nScriptKernelIDCreate(int sid, int slot, int sig) {
validate();
return rsnScriptKernelIDCreate(mContext, sid, slot, sig);
}
native int rsnScriptFieldIDCreate(int con, int sid, int slot);
synchronized int nScriptFieldIDCreate(int sid, int slot) {
validate();
return rsnScriptFieldIDCreate(mContext, sid, slot);
}
native int rsnScriptGroupCreate(int con, int[] kernels, int[] src, int[] dstk, int[] dstf, int[] types);
synchronized int nScriptGroupCreate(int[] kernels, int[] src, int[] dstk, int[] dstf, int[] types) {
validate();
return rsnScriptGroupCreate(mContext, kernels, src, dstk, dstf, types);
}
native void rsnScriptGroupSetInput(int con, int group, int kernel, int alloc);
synchronized void nScriptGroupSetInput(int group, int kernel, int alloc) {
validate();
rsnScriptGroupSetInput(mContext, group, kernel, alloc);
}
native void rsnScriptGroupSetOutput(int con, int group, int kernel, int alloc);
synchronized void nScriptGroupSetOutput(int group, int kernel, int alloc) {
validate();
rsnScriptGroupSetOutput(mContext, group, kernel, alloc);
}
native void rsnScriptGroupExecute(int con, int group);
synchronized void nScriptGroupExecute(int group) {
validate();
rsnScriptGroupExecute(mContext, group);
}
native int rsnSamplerCreate(int con, int magFilter, int minFilter,
int wrapS, int wrapT, int wrapR, float aniso);
synchronized int nSamplerCreate(int magFilter, int minFilter,

95
graphics/java/android/renderscript/Script.java
View File

@ -16,10 +16,105 @@
package android.renderscript;
import android.util.SparseArray;
/**
*
**/
public class Script extends BaseObj {
/**
* KernelID is an identifier for a Script + root function pair. It is used
* as an identifier for ScriptGroup creation.
*
* This class should not be directly created. Instead use the method in the
* reflected or intrinsic code "getKernelID_funcname()".
*
*/
public static final class KernelID extends BaseObj {
Script mScript;
int mSlot;
int mSig;
KernelID(int id, RenderScript rs, Script s, int slot, int sig) {
super(id, rs);
mScript = s;
mSlot = slot;
mSig = sig;
}
}
private final SparseArray<KernelID> mKIDs = new SparseArray<KernelID>();
/**
* Only to be used by generated reflected classes.
*
*
* @param slot
* @param sig
* @param ein
* @param eout
*
* @return KernelID
*/
protected KernelID createKernelID(int slot, int sig, Element ein, Element eout) {
KernelID k = mKIDs.get(slot);
if (k != null) {
return k;
}
int id = mRS.nScriptKernelIDCreate(getID(mRS), slot, sig);
if (id == 0) {
throw new RSDriverException("Failed to create KernelID");
}
k = new KernelID(id, mRS, this, slot, sig);
mKIDs.put(slot, k);
return k;
}
/**
* FieldID is an identifier for a Script + exported field pair. It is used
* as an identifier for ScriptGroup creation.
*
* This class should not be directly created. Instead use the method in the
* reflected or intrinsic code "getFieldID_funcname()".
*
*/
public static final class FieldID extends BaseObj {
Script mScript;
int mSlot;
FieldID(int id, RenderScript rs, Script s, int slot) {
super(id, rs);
mScript = s;
mSlot = slot;
}
}
private final SparseArray<FieldID> mFIDs = new SparseArray();
/**
* Only to be used by generated reflected classes.
*
* @param slot
* @param e
*
* @return FieldID
*/
protected FieldID createFieldID(int slot, Element e) {
FieldID f = mFIDs.get(slot);
if (f != null) {
return f;
}
int id = mRS.nScriptFieldIDCreate(getID(mRS), slot);
if (id == 0) {
throw new RSDriverException("Failed to create FieldID");
}
f = new FieldID(id, mRS, this, slot);
mFIDs.put(slot, f);
return f;
}
/**
* Only intended for use by generated reflected code.
*

565
graphics/java/android/renderscript/ScriptGroup.java
View File

@ -17,67 +17,60 @@
package android.renderscript;
import java.lang.reflect.Method;
import java.util.ArrayList;
/**
* @hide
* ScriptGroup creates a groups of scripts which are executed
* together based upon upon one execution call as if they were
* all part of a single script. The scripts may be connected
* internally or to an external allocation. For the internal
* connections the intermediate results are not observable after
* the execution of the script.
* <p>
* The external connections are grouped into inputs and outputs.
* All outputs are produced by a script kernel and placed into a
* user supplied allocation. Inputs are similar but supply the
* input of a kernal. Inputs bounds to a script are set directly
* upon the script.
*
**/
public class ScriptGroup extends BaseObj {
Node mNodes[];
Connection mConnections[];
Node mFirstNode;
public final class ScriptGroup extends BaseObj {
IO mOutputs[];
IO mInputs[];
static class IO {
Script mScript;
Script.KernelID mKID;
Allocation mAllocation;
String mName;
IO(Script s) {
mScript = s;
}
IO(Script s, String n) {
mScript = s;
mName = n;
IO(Script.KernelID s) {
mKID = s;
}
}
static class Connection {
Node mTo[];
String mToName[];
Node mFrom;
Type mAllocationType;
Allocation mInternalAllocation;
Connection(Node out, Type t) {
mFrom = out;
static class ConnectLine {
ConnectLine(Type t, Script.KernelID from, Script.KernelID to) {
mFrom = from;
mToK = to;
mAllocationType = t;
}
void addTo(Node n, String name) {
if (mTo == null) {
mTo = new Node[1];
mToName = new String[1];
} else {
Node nt[] = new Node[mTo.length + 1];
String ns[] = new String[mTo.length + 1];
System.arraycopy(mTo, 0, nt, 0, mTo.length);
System.arraycopy(mToName, 0, ns, 0, mTo.length);
mTo = nt;
mToName = ns;
}
mTo[mTo.length - 1] = n;
mToName[mTo.length - 1] = name;
ConnectLine(Type t, Script.KernelID from, Script.FieldID to) {
mFrom = from;
mToF = to;
mAllocationType = t;
}
Script.FieldID mToF;
Script.KernelID mToK;
Script.KernelID mFrom;
Type mAllocationType;
}
static class Node {
Script mScript;
Connection mInput[] = new Connection[8];
Connection mOutput[] = new Connection[1];
int mInputCount;
int mOutputCount;
int mDepth;
ArrayList<Script.KernelID> mKernels = new ArrayList<Script.KernelID>();
ArrayList<ConnectLine> mInputs = new ArrayList<ConnectLine>();
ArrayList<ConnectLine> mOutputs = new ArrayList<ConnectLine>();
boolean mSeen;
Node mNext;
@ -85,24 +78,6 @@ public class ScriptGroup extends BaseObj {
Node(Script s) {
mScript = s;
}
void addInput(Connection c) {
if (mInput.length <= mInputCount) {
Connection[] nc = new Connection[mInput.length + 8];
System.arraycopy(mInput, 0, nc, 0, mInputCount);
mInput = nc;
}
mInput[mInputCount++] = c;
}
void addOutput(Connection c) {
if (mOutput.length <= mOutputCount) {
Connection[] nc = new Connection[mOutput.length + 8];
System.arraycopy(mOutput, 0, nc, 0, mOutputCount);
mOutput = nc;
}
mOutput[mOutputCount++] = c;
}
}
@ -110,276 +85,326 @@ public class ScriptGroup extends BaseObj {
super(id, rs);
}
void init(int nodeCount, int connectionCount) {
mNodes = new Node[nodeCount];
mConnections = new Connection[connectionCount];
android.util.Log.v("RSR", "init" + nodeCount + ", " + connectionCount);
// Count outputs and create array.
Node n = mFirstNode;
int outputCount = 0;
int inputCount = 0;
int connectionIndex = 0;
int nodeNum = 0;
while (n != null) {
mNodes[nodeNum++] = n;
// Look for unattached kernel inputs
boolean hasInput = false;
for (int ct=0; ct < n.mInput.length; ct++) {
if (n.mInput[ct] != null) {
if (n.mInput[ct].mToName == null) {
hasInput = true;
}
}
}
if (!hasInput) {
if (mInputs == null) {
mInputs = new IO[1];
}
if (mInputs.length <= inputCount) {
IO t[] = new IO[mInputs.length + 1];
System.arraycopy(mInputs, 0, t, 0, mInputs.length);
mInputs = t;
}
mInputs[inputCount++] = new IO(n.mScript);
}
// Look for unattached kernel outputs
boolean hasOutput = false;
for (int ct=0; ct < n.mOutput.length; ct++) {
if (n.mOutput[ct] != null) {
hasOutput = true;
}
}
if (!hasOutput) {
if (mOutputs == null) {
mOutputs = new IO[1];
}
if (mOutputs.length <= outputCount) {
IO t[] = new IO[mOutputs.length + 1];
System.arraycopy(mOutputs, 0, t, 0, mOutputs.length);
mOutputs = t;
}
mOutputs[outputCount++] = new IO(n.mScript);
}
// Make allocations for internal connections
// Since script outputs are unique, use those to avoid duplicates.
for (int ct=0; ct < n.mOutput.length; ct++) {
android.util.Log.v("RSR", "init out2 " + n.mOutput[ct]);
if (n.mOutput[ct] != null) {
Connection t = n.mOutput[ct];
mConnections[connectionIndex++] = t;
t.mInternalAllocation = Allocation.createTyped(mRS, t.mAllocationType);
}
}
n = n.mNext;
}
}
public void setInput(Script s, Allocation a) {
/**
* Sets an input of the ScriptGroup. This specifies an
* Allocation to be used for the kernels which require a kernel
* input and that input is provided external to the group.
*
* @param s The ID of the kernel where the allocation should be
* connected.
* @param a The allocation to connect.
*/
public void setInput(Script.KernelID s, Allocation a) {
for (int ct=0; ct < mInputs.length; ct++) {
if (mInputs[ct].mScript == s) {
if (mInputs[ct].mKID == s) {
mInputs[ct].mAllocation = a;
mRS.nScriptGroupSetInput(getID(mRS), s.getID(mRS), mRS.safeID(a));
return;
}
}
throw new RSIllegalArgumentException("Script not found");
}
public void setOutput(Script s, Allocation a) {
/**
* Sets an output of the ScriptGroup. This specifies an
* Allocation to be used for the kernels which require a kernel
* output and that output is provided external to the group.
*
* @param s The ID of the kernel where the allocation should be
* connected.
* @param a The allocation to connect.
*/
public void setOutput(Script.KernelID s, Allocation a) {
for (int ct=0; ct < mOutputs.length; ct++) {
if (mOutputs[ct].mScript == s) {
if (mOutputs[ct].mKID == s) {
mOutputs[ct].mAllocation = a;
mRS.nScriptGroupSetOutput(getID(mRS), s.getID(mRS), mRS.safeID(a));
return;
}
}
throw new RSIllegalArgumentException("Script not found");
}
/**
* Execute the ScriptGroup. This will run all the kernels in
* the script. The state of the connecting lines will not be
* observable after this operation.
*/
public void execute() {
android.util.Log.v("RSR", "execute");
boolean more = true;
int depth = 0;
while (more) {
more = false;
for (int ct=0; ct < mNodes.length; ct++) {
if (mNodes[ct].mDepth == depth) {
more = true;
Allocation kernelIn = null;
for (int ct2=0; ct2 < mNodes[ct].mInputCount; ct2++) {
android.util.Log.v("RSR", " kin " + ct2 + ", to " + mNodes[ct].mInput[ct2].mTo[0] + ", name " + mNodes[ct].mInput[ct2].mToName[0]);
if (mNodes[ct].mInput[ct2].mToName[0] == null) {
kernelIn = mNodes[ct].mInput[ct2].mInternalAllocation;
break;
}
}
Allocation kernelOut= null;
for (int ct2=0; ct2 < mNodes[ct].mOutputCount; ct2++) {
android.util.Log.v("RSR", " kout " + ct2 + ", from " + mNodes[ct].mOutput[ct2].mFrom);
if (mNodes[ct].mOutput[ct2].mFrom != null) {
kernelOut = mNodes[ct].mOutput[ct2].mInternalAllocation;
break;
}
}
if (kernelOut == null) {
for (int ct2=0; ct2 < mOutputs.length; ct2++) {
if (mOutputs[ct2].mScript == mNodes[ct].mScript) {
kernelOut = mOutputs[ct2].mAllocation;
break;
}
}
}
android.util.Log.v("RSR", "execute calling " + mNodes[ct] + ", with " + kernelIn);
if (kernelIn != null) {
try {
Method m = mNodes[ct].mScript.getClass().getMethod("forEach_root",
new Class[] { Allocation.class, Allocation.class });
m.invoke(mNodes[ct].mScript, new Object[] {kernelIn, kernelOut} );
} catch (Throwable t) {
android.util.Log.e("RSR", "execute error " + t);
}
} else {
try {
Method m = mNodes[ct].mScript.getClass().getMethod("forEach_root",
new Class[] { Allocation.class });
m.invoke(mNodes[ct].mScript, new Object[] {kernelOut} );
} catch (Throwable t) {
android.util.Log.e("RSR", "execute error " + t);
}
}
}
}
depth ++;
}
mRS.nScriptGroupExecute(getID(mRS));
}
public static class Builder {
RenderScript mRS;
Node mFirstNode;
int mConnectionCount = 0;
int mNodeCount = 0;
/**
* Create a ScriptGroup. There are two steps to creating a
* ScriptGoup.
* <p>
* First all the Kernels to be used by the group should be
* added. Once this is done the kernels should be connected.
* Kernels cannot be added once a connection has been made.
* <p>
* Second, add connections. There are two forms of connections.
* Kernel to Kernel and Kernel to Field. Kernel to Kernel is
* higher performance and should be used where possible. The
* line of connections cannot form a loop. If a loop is detected
* an exception is thrown.
* <p>
* Once all the connections are made a call to create will
* return the ScriptGroup object.
*
*/
public static final class Builder {
private RenderScript mRS;
private ArrayList<Node> mNodes = new ArrayList<Node>();
private ArrayList<ConnectLine> mLines = new ArrayList<ConnectLine>();
private int mKernelCount;
/**
* Create a builder for generating a ScriptGroup.
*
*
* @param rs The Renderscript context.
*/
public Builder(RenderScript rs) {
mRS = rs;
}
private void validateRecurse(Node n, int depth) {
n.mSeen = true;
if (depth > n.mDepth) {
n.mDepth = depth;
}
android.util.Log.v("RSR", " validateRecurse outputCount " + n.mOutputCount);
for (int ct=0; ct < n.mOutputCount; ct++) {
for (int ct2=0; ct2 < n.mOutput[ct].mTo.length; ct2++) {
if (n.mOutput[ct].mTo[ct2].mSeen) {
//android.util.Log.v("RSR", " validateRecurse outputCount " + n.mOutputs.size());
for (int ct=0; ct < n.mOutputs.size(); ct++) {
final ConnectLine cl = n.mOutputs.get(ct);
if (cl.mToK != null) {
Node tn = findNode(cl.mToK.mScript);
if (tn.mSeen) {
throw new RSInvalidStateException("Loops in group not allowed.");
}
validateRecurse(n.mOutput[ct].mTo[ct2], depth + 1);
validateRecurse(tn, depth + 1);
}
if (cl.mToF != null) {
Node tn = findNode(cl.mToF.mScript);
if (tn.mSeen) {
throw new RSInvalidStateException("Loops in group not allowed.");
}
validateRecurse(tn, depth + 1);
}
}
}
private void validate() {
android.util.Log.v("RSR", "validate");
Node n = mFirstNode;
while (n != null) {
n.mSeen = false;
n.mDepth = 0;
n = n.mNext;
}
//android.util.Log.v("RSR", "validate");
n = mFirstNode;
while (n != null) {
android.util.Log.v("RSR", "validate n= " + n);
if ((n.mSeen == false) && (n.mInputCount == 0)) {
android.util.Log.v("RSR", " recursing " + n);
for (int ct=0; ct < mNodes.size(); ct++) {
for (int ct2=0; ct2 < mNodes.size(); ct2++) {
mNodes.get(ct2).mSeen = false;
}
Node n = mNodes.get(ct);
if (n.mInputs.size() == 0) {
validateRecurse(n, 0);
}
n = n.mNext;
}
}
private Node findScript(Script s) {
Node n = mFirstNode;
while (n != null) {
if (n.mScript == s) {
return n;
private Node findNode(Script s) {
for (int ct=0; ct < mNodes.size(); ct++) {
if (s == mNodes.get(ct).mScript) {
return mNodes.get(ct);
}
n = n.mNext;
}
return null;
}
private void addNode(Node n) {
n.mNext = mFirstNode;
mFirstNode = n;
}
public Builder addConnection(Type t, Script output, Script input, String inputName) {
android.util.Log.v("RSR", "addConnection " + t +", " + output + ", " + input);
// Look for existing output
Node nout = findScript(output);
Connection c;
if (nout == null) {
// Make new node
android.util.Log.v("RSR", "addConnection new output node");
nout = new Node(output);
mNodeCount++;
c = new Connection(nout, t);
mConnectionCount++;
nout.addOutput(c);
addNode(nout);
} else {
// Add to existing node
android.util.Log.v("RSR", "addConnection reuse output node");
if (nout.mOutput[0] != null) {
if (nout.mOutput[0].mFrom.mScript != output) {
throw new RSInvalidStateException("Changed output of existing node");
}
if (nout.mOutput[0].mAllocationType != t) {
throw new RSInvalidStateException("Changed output type of existing node");
private Node findNode(Script.KernelID k) {
for (int ct=0; ct < mNodes.size(); ct++) {
Node n = mNodes.get(ct);
for (int ct2=0; ct2 < n.mKernels.size(); ct2++) {
if (k == n.mKernels.get(ct2)) {
return n;
}
}
c = nout.mOutput[0];
}
// At this point we should have a connection attached to a script ouput.
return null;
}
// Find input
Node nin = findScript(input);
if (nin == null) {
android.util.Log.v("RSR", "addConnection new input node");
nin = new Node(input);
mNodeCount++;
addNode(nin);
/**
* Adds a Kernel to the group.
*
*
* @param k The kernel to add.
*
* @return Builder Returns this.
*/
public Builder addKernel(Script.KernelID k) {
if (mLines.size() != 0) {
throw new RSInvalidStateException(
"Kernels may not be added once connections exist.");
}
c.addTo(nin, inputName);
nin.addInput(c);
//android.util.Log.v("RSR", "addKernel 1 k=" + k);
if (findNode(k) != null) {
return this;
}
//android.util.Log.v("RSR", "addKernel 2 ");
mKernelCount++;
Node n = findNode(k.mScript);
if (n == null) {
//android.util.Log.v("RSR", "addKernel 3 ");
n = new Node(k.mScript);
mNodes.add(n);
}
n.mKernels.add(k);
return this;
}
/**
* Adds a connection to the group.
*
*
* @param t The type of the connection. This is used to
* determine the kernel launch sizes on the source side
* of this connection.
* @param from The source for the connection.
* @param to The destination of the connection.
*
* @return Builder Returns this
*/
public Builder addConnection(Type t, Script.KernelID from, Script.FieldID to) {
//android.util.Log.v("RSR", "addConnection " + t +", " + from + ", " + to);
Node nf = findNode(from);
if (nf == null) {
throw new RSInvalidStateException("From kernel not found.");
}
Node nt = findNode(to.mScript);
if (nt == null) {
throw new RSInvalidStateException("To script not found.");
}
ConnectLine cl = new ConnectLine(t, from, to);
mLines.add(new ConnectLine(t, from, to));
nf.mOutputs.add(cl);
nt.mInputs.add(cl);
validate();
return this;
}
/**
* Adds a connection to the group.
*
*
* @param t The type of the connection. This is used to
* determine the kernel launch sizes for both sides of
* this connection.
* @param from The source for the connection.
* @param to The destination of the connection.
*
* @return Builder Returns this
*/
public Builder addConnection(Type t, Script.KernelID from, Script.KernelID to) {
//android.util.Log.v("RSR", "addConnection " + t +", " + from + ", " + to);
Node nf = findNode(from);
if (nf == null) {
throw new RSInvalidStateException("From kernel not found.");
}
Node nt = findNode(to);
if (nt == null) {
throw new RSInvalidStateException("To script not found.");
}
ConnectLine cl = new ConnectLine(t, from, to);
mLines.add(new ConnectLine(t, from, to));
nf.mOutputs.add(cl);
nt.mInputs.add(cl);
validate();
return this;
}
/**
* Creates the Script group.
*
*
* @return ScriptGroup The new ScriptGroup
*/
public ScriptGroup create() {
ScriptGroup sg = new ScriptGroup(0, mRS);
sg.mFirstNode = mFirstNode;
mFirstNode = null;
ArrayList<IO> inputs = new ArrayList<IO>();
ArrayList<IO> outputs = new ArrayList<IO>();
android.util.Log.v("RSR", "create nodes= " + mNodeCount + ", Connections= " + mConnectionCount);
int[] kernels = new int[mKernelCount];
int idx = 0;
for (int ct=0; ct < mNodes.size(); ct++) {
Node n = mNodes.get(ct);
for (int ct2=0; ct2 < n.mKernels.size(); ct2++) {
final Script.KernelID kid = n.mKernels.get(ct2);
kernels[idx++] = kid.getID(mRS);
boolean hasInput = false;
boolean hasOutput = false;
for (int ct3=0; ct3 < n.mInputs.size(); ct3++) {
if (n.mInputs.get(ct3).mToK == kid) {
hasInput = true;
}
}
for (int ct3=0; ct3 < n.mOutputs.size(); ct3++) {
if (n.mOutputs.get(ct3).mFrom == kid) {
hasOutput = true;
}
}
if (!hasInput) {
inputs.add(new IO(kid));
}
if (!hasOutput) {
outputs.add(new IO(kid));
}
}
}
if (idx != mKernelCount) {
throw new RSRuntimeException("Count mismatch, should not happen.");
}
int[] src = new int[mLines.size()];
int[] dstk = new int[mLines.size()];
int[] dstf = new int[mLines.size()];
int[] types = new int[mLines.size()];
for (int ct=0; ct < mLines.size(); ct++) {
ConnectLine cl = mLines.get(ct);
src[ct] = cl.mFrom.getID(mRS);
if (cl.mToK != null) {
dstk[ct] = cl.mToK.getID(mRS);
}
if (cl.mToF != null) {
dstf[ct] = cl.mToF.getID(mRS);
}
types[ct] = cl.mAllocationType.getID(mRS);
}
int id = mRS.nScriptGroupCreate(kernels, src, dstk, dstf, types);
if (id == 0) {
throw new RSRuntimeException("Object creation error, should not happen.");
}
ScriptGroup sg = new ScriptGroup(id, mRS);
sg.mOutputs = new IO[outputs.size()];
for (int ct=0; ct < outputs.size(); ct++) {
sg.mOutputs[ct] = outputs.get(ct);
}
sg.mInputs = new IO[inputs.size()];
for (int ct=0; ct < inputs.size(); ct++) {
sg.mInputs[ct] = inputs.get(ct);
}
sg.init(mNodeCount, mConnectionCount);
return sg;
}

17
graphics/java/android/renderscript/ScriptIntrinsicBlur.java
View File

@ -91,5 +91,22 @@ public final class ScriptIntrinsicBlur extends ScriptIntrinsic {
forEach(0, null, aout, null);
}
/**
* Get a KernelID for this intrinsic kernel.
*
* @return Script.KernelID The KernelID object.
*/
public Script.KernelID getKernelID() {
return createKernelID(0, 2, null, null);
}
/**
* Get a FieldID for the input field of this intrinsic.
*
* @return Script.FieldID The FieldID object.
*/
public Script.FieldID getFieldID_Input() {
return createFieldID(1, null);
}
}

9
graphics/java/android/renderscript/ScriptIntrinsicColorMatrix.java
View File

@ -154,5 +154,14 @@ public final class ScriptIntrinsicColorMatrix extends ScriptIntrinsic {
forEach(0, ain, aout, null);
}
/**
* Get a KernelID for this intrinsic kernel.
*
* @return Script.KernelID The KernelID object.
*/
public Script.KernelID getKernelID() {
return createKernelID(0, 3, null, null);
}
}

18
graphics/java/android/renderscript/ScriptIntrinsicConvolve3x3.java
View File

@ -103,5 +103,23 @@ public final class ScriptIntrinsicConvolve3x3 extends ScriptIntrinsic {
forEach(0, null, aout, null);
}
/**
* Get a KernelID for this intrinsic kernel.
*
* @return Script.KernelID The KernelID object.
*/
public Script.KernelID getKernelID() {
return createKernelID(0, 2, null, null);
}
/**
* Get a FieldID for the input field of this intrinsic.
*
* @return Script.FieldID The FieldID object.
*/
public Script.FieldID getFieldID_Input() {
return createFieldID(1, null);
}
}

17
graphics/java/android/renderscript/ScriptIntrinsicConvolve5x5.java
View File

@ -98,5 +98,22 @@ public final class ScriptIntrinsicConvolve5x5 extends ScriptIntrinsic {
forEach(0, null, aout, null);
}
/**
* Get a KernelID for this intrinsic kernel.
*
* @return Script.KernelID The KernelID object.
*/
public Script.KernelID getKernelID() {
return createKernelID(0, 2, null, null);
}
/**
* Get a FieldID for the input field of this intrinsic.
*
* @return Script.FieldID The FieldID object.
*/
public Script.FieldID getFieldID_Input() {
return createFieldID(1, null);
}
}

8
graphics/java/android/renderscript/ScriptIntrinsicLUT.java
View File

@ -134,5 +134,13 @@ public final class ScriptIntrinsicLUT extends ScriptIntrinsic {
forEach(0, ain, aout, null);
}
/**
* Get a KernelID for this intrinsic kernel.
*
* @return Script.KernelID The KernelID object.
*/
public Script.KernelID getKernelID() {
return createKernelID(0, 3, null, null);
}
}

75
graphics/jni/android_renderscript_RenderScript.cpp
View File

@ -1078,6 +1078,75 @@ nScriptIntrinsicCreate(JNIEnv *_env, jobject _this, RsContext con, jint id, jint
return (jint)rsScriptIntrinsicCreate(con, id, (RsElement)eid);
}
static jint
nScriptKernelIDCreate(JNIEnv *_env, jobject _this, RsContext con, jint sid, jint slot, jint sig)
{
LOG_API("nScriptKernelIDCreate, con(%p) script(%p), slot(%i), sig(%i)", con, (void *)sid, slot, sig);
return (jint)rsScriptKernelIDCreate(con, (RsScript)sid, slot, sig);
}
static jint
nScriptFieldIDCreate(JNIEnv *_env, jobject _this, RsContext con, jint sid, jint slot)
{
LOG_API("nScriptFieldIDCreate, con(%p) script(%p), slot(%i)", con, (void *)sid, slot);
return (jint)rsScriptFieldIDCreate(con, (RsScript)sid, slot);
}
static jint
nScriptGroupCreate(JNIEnv *_env, jobject _this, RsContext con, jintArray _kernels, jintArray _src,
jintArray _dstk, jintArray _dstf, jintArray _types)
{
LOG_API("nScriptGroupCreate, con(%p)", con);
jint kernelsLen = _env->GetArrayLength(_kernels) * sizeof(int);
jint *kernelsPtr = _env->GetIntArrayElements(_kernels, NULL);
jint srcLen = _env->GetArrayLength(_src) * sizeof(int);
jint *srcPtr = _env->GetIntArrayElements(_src, NULL);
jint dstkLen = _env->GetArrayLength(_dstk) * sizeof(int);
jint *dstkPtr = _env->GetIntArrayElements(_dstk, NULL);
jint dstfLen = _env->GetArrayLength(_dstf) * sizeof(int);
jint *dstfPtr = _env->GetIntArrayElements(_dstf, NULL);
jint typesLen = _env->GetArrayLength(_types) * sizeof(int);
jint *typesPtr = _env->GetIntArrayElements(_types, NULL);
int id = (int)rsScriptGroupCreate(con,
(RsScriptKernelID *)kernelsPtr, kernelsLen,
(RsScriptKernelID *)srcPtr, srcLen,
(RsScriptKernelID *)dstkPtr, dstkLen,
(RsScriptFieldID *)dstfPtr, dstfLen,
(RsType *)typesPtr, typesLen);
_env->ReleaseIntArrayElements(_kernels, kernelsPtr, 0);
_env->ReleaseIntArrayElements(_src, srcPtr, 0);
_env->ReleaseIntArrayElements(_dstk, dstkPtr, 0);
_env->ReleaseIntArrayElements(_dstf, dstfPtr, 0);
_env->ReleaseIntArrayElements(_types, typesPtr, 0);
return id;
}
static void
nScriptGroupSetInput(JNIEnv *_env, jobject _this, RsContext con, jint gid, jint kid, jint alloc)
{
LOG_API("nScriptGroupSetInput, con(%p) group(%p), kernelId(%p), alloc(%p)", con,
(void *)gid, (void *)kid, (void *)alloc);
rsScriptGroupSetInput(con, (RsScriptGroup)gid, (RsScriptKernelID)kid, (RsAllocation)alloc);
}
static void
nScriptGroupSetOutput(JNIEnv *_env, jobject _this, RsContext con, jint gid, jint kid, jint alloc)
{
LOG_API("nScriptGroupSetOutput, con(%p) group(%p), kernelId(%p), alloc(%p)", con,
(void *)gid, (void *)kid, (void *)alloc);
rsScriptGroupSetOutput(con, (RsScriptGroup)gid, (RsScriptKernelID)kid, (RsAllocation)alloc);
}
static void
nScriptGroupExecute(JNIEnv *_env, jobject _this, RsContext con, jint gid)
{
LOG_API("nScriptGroupSetOutput, con(%p) group(%p)", con, (void *)gid);
rsScriptGroupExecute(con, (RsScriptGroup)gid);
}
// ---------------------------------------------------------------------------
static jint
@ -1420,6 +1489,12 @@ static JNINativeMethod methods[] = {
{"rsnScriptCCreate", "(ILjava/lang/String;Ljava/lang/String;[BI)I", (void*)nScriptCCreate },
{"rsnScriptIntrinsicCreate", "(III)I", (void*)nScriptIntrinsicCreate },
{"rsnScriptKernelIDCreate", "(IIII)I", (void*)nScriptKernelIDCreate },
{"rsnScriptFieldIDCreate", "(III)I", (void*)nScriptFieldIDCreate },
{"rsnScriptGroupCreate", "(I[I[I[I[I[I)I", (void*)nScriptGroupCreate },
{"rsnScriptGroupSetInput", "(IIII)V", (void*)nScriptGroupSetInput },
{"rsnScriptGroupSetOutput", "(IIII)V", (void*)nScriptGroupSetOutput },
{"rsnScriptGroupExecute", "(II)V", (void*)nScriptGroupExecute },
{"rsnProgramStoreCreate", "(IZZZZZZIII)I", (void*)nProgramStoreCreate },

31
tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/GroupTest.java
View File

@ -21,16 +21,16 @@ import java.lang.Math;
import android.renderscript.Allocation;
import android.renderscript.Element;
import android.renderscript.RenderScript;
import android.renderscript.Script;
import android.renderscript.ScriptC;
import android.renderscript.ScriptIntrinsicConvolve3x3;
import android.renderscript.ScriptIntrinsicColorMatrix;
import android.renderscript.Type;
import android.renderscript.Matrix4f;
import android.renderscript.ScriptGroup;
import android.util.Log;
public class GroupTest extends TestBase {
private ScriptC_convolve3x3 mConvolve;
private ScriptC_colormatrix mMatrix;
private ScriptIntrinsicConvolve3x3 mConvolve;
private ScriptIntrinsicColorMatrix mMatrix;
private Allocation mScratchPixelsAllocation1;
private ScriptGroup mGroup;
@ -48,20 +48,20 @@ public class GroupTest extends TestBase {
mWidth = mInPixelsAllocation.getType().getX();
mHeight = mInPixelsAllocation.getType().getY();
mConvolve = new ScriptC_convolve3x3(mRS, res, R.raw.convolve3x3);
mMatrix = new ScriptC_colormatrix(mRS, res, R.raw.colormatrix);
mConvolve = ScriptIntrinsicConvolve3x3.create(mRS, Element.U8_4(mRS));
mMatrix = ScriptIntrinsicColorMatrix.create(mRS, Element.U8_4(mRS));
float f[] = new float[9];
f[0] = 0.f; f[1] = -1.f; f[2] = 0.f;
f[3] = -1.f; f[4] = 5.f; f[5] = -1.f;
f[6] = 0.f; f[7] = -1.f; f[8] = 0.f;
mConvolve.set_gCoeffs(f);
mConvolve.setCoefficients(f);
Matrix4f m = new Matrix4f();
m.set(1, 0, 0.2f);
m.set(1, 1, 0.9f);
m.set(1, 2, 0.2f);
mMatrix.invoke_setMatrix(m);
mMatrix.setColorMatrix(m);
Type.Builder tb = new Type.Builder(mRS, Element.U8_4(mRS));
tb.setX(mWidth);
@ -70,24 +70,23 @@ public class GroupTest extends TestBase {
if (mUseNative) {
ScriptGroup.Builder b = new ScriptGroup.Builder(mRS);
b.addConnection(connect, mConvolve, mMatrix, null);
b.addKernel(mConvolve.getKernelID());
b.addKernel(mMatrix.getKernelID());
b.addConnection(connect, mConvolve.getKernelID(), mMatrix.getKernelID());
mGroup = b.create();
} else {
mScratchPixelsAllocation1 = Allocation.createTyped(mRS, connect);
}
}
public void runTest() {
mConvolve.set_gIn(mInPixelsAllocation);
mConvolve.set_gWidth(mWidth);
mConvolve.set_gHeight(mHeight);
mConvolve.setInput(mInPixelsAllocation);
if (mUseNative) {
mGroup.setOutput(mMatrix, mOutPixelsAllocation);
mGroup.setOutput(mMatrix.getKernelID(), mOutPixelsAllocation);
mGroup.execute();
} else {
mConvolve.forEach_root(mScratchPixelsAllocation1);
mMatrix.forEach_root(mScratchPixelsAllocation1, mOutPixelsAllocation);
mConvolve.forEach(mScratchPixelsAllocation1);
mMatrix.forEach(mScratchPixelsAllocation1, mOutPixelsAllocation);
}
}