How to retrieve a struct from Renderscript kernel

Question

I have a problem. I would like to retrieve a struct from a renderscript kernel. What I wanted was that I would get an input a struct element... I would modify it and then return it modified. But there is no such a way in the reflected layer. I tryied to manually deserialize the data from the buffer but I am not even able to copy the buffer to a ByteBuffer because the Allocation has validation in the copyTo on a type so I have no idea what am I supposed to do...

Answer 1

RenderScript supports custom elements. To create one, declare a custom typedef struct like the following one, inside a RS script:

typedef struct MyElement {

    int x;
    int y;
    bool simpleBool;

} MyElement_t;

After the build process, a ScriptField_MyElement Java class will appear, mirroring the RS struct. You will be able to use this class to create a custom Allocation that uses your own Element:

// Declares a new Allocation, based upon the custom struct Element
Element myElement = ScriptField_MyElement.createElement(mRS);
Allocation myElementsAllocation = Allocation.createSized(mRS, myElement, 5);

// Or

Allocation myElementsAllocation = ScriptField_MyElement.create1D(mRS, sizeX).getAllocation();

You can find an example of this process inside the CustomElementExample sample project. Also, inside the SurfaceRenderExample sample project you can see how a custom element can be used to model a mathematical structure (in this case a particle, falling with some acceleration).

Inside RenderScript scripts:

• To get a custom element from an allocation:

  MyElement_t el = * (MyElement_t *) rsGetElementAt(aIn, index);
  

• To change a custom element member:

  el.x = 10;
  

• To set a custom element in an allocation:

  rsSetElementAt(myAlloc, (void *)&el);
  

Reference: RenderScript: parallel computing on Android, the easy way

Edit:

For now, there is no direct way to copy a custom struct element to the Java side.

The CustomStructElementCopyToJava sample project provides an example of the process.

Short explanation of the example

Note: the following process is EXPERIMENTAL and not performant at all! If you plan to heavily use this process, please use the Android NDK to access the allocation. Also, in future versions of the Android SDK, this code may break because it relies on Java reflection; some normally hidden methods can change without any notice in the Android SDK.

Let's assume using the following custom struct element:

typedef struct Point {
    int x;
    int y;
} Point_t;

When looking at the generated code of the struct (which can be seen, in Android Studio, by pressing CTRL+B while focusing on a ScriptField_Point element on the Java side), the following elements can be seen:

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();
    }

You can map the contents of the custom struct in a hacky way:

1) Define the destination byte array:

    byte destinationArray[] = new byte[allocationGrayPointOrdered.getBytesSize()];

2) Use Java reflection to access the hidden Allocation.copyTo method:

private static Method getCopyToWithoutValidationMethod(){
    // private void copyTo(Object array, Element.DataType dt, int arrayLen)
    Method allocationHiddenCopyToMethod = null;
    try {
        allocationHiddenCopyToMethod = Allocation.class.getDeclaredMethod("copyTo", Object.class, Element.DataType.class, int.class);
        allocationHiddenCopyToMethod.setAccessible(true);
    } catch (NoSuchMethodException e) {
        throw new RuntimeException("Could not find allocationHiddenCopyToMethod");
    }

    return allocationHiddenCopyToMethod;
}

3) Perform the copy:

// Gets reflected method
Method copyToWithoutValidationMethod = getCopyToWithoutValidationMethod();

// Tries to copy contents
try {
    copyToWithoutValidationMethod.invoke(allocationGrayPointOrdered, destinationArray, 
                                                Element.DataType.UNSIGNED_8, destinationArray.length);
} catch (IllegalAccessException e) {
    throw new RuntimeException(e);
} catch (InvocationTargetException e) {
    throw new RuntimeException(e);
}

4) Once the array is filled with source data, it is then possible to map its content to a human-readable struct.

// Defines the destination array
ScriptField_Point.Item mappedItems[][] = new ScriptField_Point.Item[sizeX][sizeY];

// Wraps array contents
ByteBuffer byteBuffer = ByteBuffer.wrap(destinationArray);
// Sets byte order to be Android-like
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);

// Iterates on every column and row
for (int x = 0; x < sizeX; x++) {
    for (int y = 0; y < sizeY; y++) {

        // Allocates a new item
        ScriptField_Point.Item currentItem = new ScriptField_Point.Item();

        // Calculate the offset in the source array
        int currentOffset = (x + y * sizeX) * ScriptField_Point.Item.sizeof;

        // Gets data from the byte array
        currentItem.x = byteBuffer.getInt(currentOffset);
        currentItem.y = byteBuffer.getInt(currentOffset + 4);

        mappedItems[x][y] = currentItem;
    }
}

For the complete explanation, please refer to the book.