| /* | |
| * 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. | |
| */ | |
| package android.renderscript; | |
| import android.compat.annotation.UnsupportedAppUsage; | |
| /** | |
| * <p>An Element represents one item within an {@link | |
| * android.renderscript.Allocation}. An Element is roughly equivalent to a C | |
| * type in a RenderScript kernel. Elements may be basic or complex. Some basic | |
| * elements are</p> <ul> <li>A single float value (equivalent to a float in a | |
| * kernel)</li> <li>A four-element float vector (equivalent to a float4 in a | |
| * kernel)</li> <li>An unsigned 32-bit integer (equivalent to an unsigned int in | |
| * a kernel)</li> <li>A single signed 8-bit integer (equivalent to a char in a | |
| * kernel)</li> </ul> <p>A complex element is roughly equivalent to a C struct | |
| * and contains a number of basic or complex Elements. From Java code, a complex | |
| * element contains a list of sub-elements and names that represents a | |
| * particular data structure. Structs used in RS scripts are available to Java | |
| * code by using the {@code ScriptField_structname} class that is reflected from | |
| * a particular script.</p> | |
| * | |
| * <p>Basic Elements are comprised of a {@link | |
| * android.renderscript.Element.DataType} and a {@link | |
| * android.renderscript.Element.DataKind}. The DataType encodes C type | |
| * information of an Element, while the DataKind encodes how that Element should | |
| * be interpreted by a {@link android.renderscript.Sampler}. Note that {@link | |
| * android.renderscript.Allocation} objects with DataKind {@link | |
| * android.renderscript.Element.DataKind#USER} cannot be used as input for a | |
| * {@link android.renderscript.Sampler}. In general, {@link | |
| * android.renderscript.Allocation} objects that are intended for use with a | |
| * {@link android.renderscript.Sampler} should use bitmap-derived Elements such | |
| * as {@link android.renderscript.Element#RGBA_8888} or {@link | |
| * android.renderscript#Element.A_8}.</p> | |
| * | |
| * <div class="special reference"> | |
| * <h3>Developer Guides</h3> | |
| * <p>For more information about creating an application that uses RenderScript, read the | |
| * <a href="{@docRoot}guide/topics/renderscript/index.html">RenderScript</a> developer guide.</p> | |
| * </div> | |
| * | |
| * @deprecated Renderscript has been deprecated in API level 31. Please refer to the <a | |
| * href="https://developer.android.com/guide/topics/renderscript/migration-guide">migration | |
| * guide</a> for the proposed alternatives. | |
| **/ | |
| @Deprecated | |
| public class Element extends BaseObj { | |
| int mSize; | |
| Element[] mElements; | |
| String[] mElementNames; | |
| int[] mArraySizes; | |
| int[] mOffsetInBytes; | |
| int[] mVisibleElementMap; | |
| DataType mType; | |
| DataKind mKind; | |
| boolean mNormalized; | |
| int mVectorSize; | |
| private void updateVisibleSubElements() { | |
| if (mElements == null) { | |
| return; | |
| } | |
| int noPaddingFieldCount = 0; | |
| int fieldCount = mElementNames.length; | |
| // Find out how many elements are not padding | |
| for (int ct = 0; ct < fieldCount; ct ++) { | |
| if (mElementNames[ct].charAt(0) != '#') { | |
| noPaddingFieldCount ++; | |
| } | |
| } | |
| mVisibleElementMap = new int[noPaddingFieldCount]; | |
| // Make a map that points us at non-padding elements | |
| for (int ct = 0, ctNoPadding = 0; ct < fieldCount; ct ++) { | |
| if (mElementNames[ct].charAt(0) != '#') { | |
| mVisibleElementMap[ctNoPadding ++] = ct; | |
| } | |
| } | |
| } | |
| /** | |
| * @return element size in bytes | |
| */ | |
| public int getBytesSize() {return mSize;} | |
| /** | |
| * Returns the number of vector components. 2 for float2, 4 for | |
| * float4, etc. | |
| * @return element vector size | |
| */ | |
| public int getVectorSize() {return mVectorSize;} | |
| /** | |
| * DataType represents the basic type information for a basic element. The | |
| * naming convention follows. For numeric types it is FLOAT, | |
| * SIGNED, or UNSIGNED followed by the _BITS where BITS is the | |
| * size of the data. BOOLEAN is a true / false (1,0) | |
| * represented in an 8 bit container. The UNSIGNED variants | |
| * with multiple bit definitions are for packed graphical data | |
| * formats and represent vectors with per vector member sizes | |
| * which are treated as a single unit for packing and alignment | |
| * purposes. | |
| * | |
| * MATRIX the three matrix types contain FLOAT_32 elements and are treated | |
| * as 32 bits for alignment purposes. | |
| * | |
| * RS_* objects: opaque handles with implementation dependent | |
| * sizes. | |
| */ | |
| public enum DataType { | |
| NONE (0, 0), | |
| FLOAT_16 (1, 2), | |
| FLOAT_32 (2, 4), | |
| FLOAT_64 (3, 8), | |
| SIGNED_8 (4, 1), | |
| SIGNED_16 (5, 2), | |
| SIGNED_32 (6, 4), | |
| SIGNED_64 (7, 8), | |
| UNSIGNED_8 (8, 1), | |
| UNSIGNED_16 (9, 2), | |
| UNSIGNED_32 (10, 4), | |
| UNSIGNED_64 (11, 8), | |
| BOOLEAN(12, 1), | |
| UNSIGNED_5_6_5 (13, 2), | |
| UNSIGNED_5_5_5_1 (14, 2), | |
| UNSIGNED_4_4_4_4 (15, 2), | |
| MATRIX_4X4 (16, 64), | |
| MATRIX_3X3 (17, 36), | |
| MATRIX_2X2 (18, 16), | |
| RS_ELEMENT (1000), | |
| RS_TYPE (1001), | |
| RS_ALLOCATION (1002), | |
| RS_SAMPLER (1003), | |
| RS_SCRIPT (1004), | |
| RS_MESH (1005), | |
| RS_PROGRAM_FRAGMENT (1006), | |
| RS_PROGRAM_VERTEX (1007), | |
| RS_PROGRAM_RASTER (1008), | |
| RS_PROGRAM_STORE (1009), | |
| RS_FONT (1010); | |
| int mID; | |
| int mSize; | |
| DataType(int id, int size) { | |
| mID = id; | |
| mSize = size; | |
| } | |
| DataType(int id) { | |
| mID = id; | |
| mSize = 4; | |
| if (RenderScript.sPointerSize == 8) { | |
| mSize = 32; | |
| } | |
| } | |
| } | |
| /** | |
| * The special interpretation of the data if required. This is primarly | |
| * useful for graphical data. USER indicates no special interpretation is | |
| * expected. PIXEL is used in conjunction with the standard data types for | |
| * representing texture formats. | |
| */ | |
| public enum DataKind { | |
| USER (0), | |
| PIXEL_L (7), | |
| PIXEL_A (8), | |
| PIXEL_LA (9), | |
| PIXEL_RGB (10), | |
| PIXEL_RGBA (11), | |
| PIXEL_DEPTH (12), | |
| PIXEL_YUV(13); | |
| int mID; | |
| DataKind(int id) { | |
| mID = id; | |
| } | |
| } | |
| /** | |
| * Return if a element is too complex for use as a data source for a Mesh or | |
| * a Program. | |
| * | |
| * @return boolean | |
| */ | |
| public boolean isComplex() { | |
| if (mElements == null) { | |
| return false; | |
| } | |
| for (int ct=0; ct < mElements.length; ct++) { | |
| if (mElements[ct].mElements != null) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| /** | |
| * 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 in this element | |
| */ | |
| public int getSubElementCount() { | |
| if (mVisibleElementMap == null) { | |
| return 0; | |
| } | |
| return mVisibleElementMap.length; | |
| } | |
| /** | |
| * For complex elements, this function will return the | |
| * sub-element at index | |
| * @param index index of the sub-element to return | |
| * @return sub-element in this element at given index | |
| */ | |
| public Element getSubElement(int index) { | |
| if (mVisibleElementMap == null) { | |
| throw new RSIllegalArgumentException("Element contains no sub-elements"); | |
| } | |
| if (index < 0 || index >= mVisibleElementMap.length) { | |
| throw new RSIllegalArgumentException("Illegal sub-element index"); | |
| } | |
| return mElements[mVisibleElementMap[index]]; | |
| } | |
| /** | |
| * For complex elements, this function will return the | |
| * sub-element name at index | |
| * @param index index of the sub-element | |
| * @return sub-element in this element at given index | |
| */ | |
| public String getSubElementName(int index) { | |
| if (mVisibleElementMap == null) { | |
| throw new RSIllegalArgumentException("Element contains no sub-elements"); | |
| } | |
| if (index < 0 || index >= mVisibleElementMap.length) { | |
| throw new RSIllegalArgumentException("Illegal sub-element index"); | |
| } | |
| return mElementNames[mVisibleElementMap[index]]; | |
| } | |
| /** | |
| * For complex elements, some sub-elements could be statically | |
| * sized arrays. This function will return the array size for | |
| * sub-element at index | |
| * @param index index of the sub-element | |
| * @return array size of sub-element in this element at given index | |
| */ | |
| public int getSubElementArraySize(int index) { | |
| if (mVisibleElementMap == null) { | |
| throw new RSIllegalArgumentException("Element contains no sub-elements"); | |
| } | |
| if (index < 0 || index >= mVisibleElementMap.length) { | |
| throw new RSIllegalArgumentException("Illegal sub-element index"); | |
| } | |
| return mArraySizes[mVisibleElementMap[index]]; | |
| } | |
| /** | |
| * This function specifies the location of a sub-element within | |
| * the element | |
| * @param index index of the sub-element | |
| * @return offset in bytes of sub-element in this element at given index | |
| */ | |
| public int getSubElementOffsetBytes(int index) { | |
| if (mVisibleElementMap == null) { | |
| throw new RSIllegalArgumentException("Element contains no sub-elements"); | |
| } | |
| if (index < 0 || index >= mVisibleElementMap.length) { | |
| throw new RSIllegalArgumentException("Illegal sub-element index"); | |
| } | |
| return mOffsetInBytes[mVisibleElementMap[index]]; | |
| } | |
| /** | |
| * @return element data type | |
| */ | |
| public DataType getDataType() { | |
| return mType; | |
| } | |
| /** | |
| * @return element data kind | |
| */ | |
| public DataKind getDataKind() { | |
| return mKind; | |
| } | |
| /** | |
| * Utility function for returning an Element containing a single Boolean. | |
| * | |
| * @param rs Context to which the element will belong. | |
| * | |
| * @return Element | |
| */ | |
| public static Element BOOLEAN(RenderScript rs) { | |
| if (rs.mElement_BOOLEAN == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_BOOLEAN == null) { | |
| rs.mElement_BOOLEAN = createUser(rs, DataType.BOOLEAN); | |
| } | |
| } | |
| } | |
| return rs.mElement_BOOLEAN; | |
| } | |
| /** | |
| * Utility function for returning an Element containing a single UNSIGNED_8. | |
| * | |
| * @param rs Context to which the element will belong. | |
| * | |
| * @return Element | |
| */ | |
| public static Element U8(RenderScript rs) { | |
| if (rs.mElement_U8 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_U8 == null) { | |
| rs.mElement_U8 = createUser(rs, DataType.UNSIGNED_8); | |
| } | |
| } | |
| } | |
| return rs.mElement_U8; | |
| } | |
| /** | |
| * Utility function for returning an Element containing a single SIGNED_8. | |
| * | |
| * @param rs Context to which the element will belong. | |
| * | |
| * @return Element | |
| */ | |
| public static Element I8(RenderScript rs) { | |
| if (rs.mElement_I8 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_I8 == null) { | |
| rs.mElement_I8 = createUser(rs, DataType.SIGNED_8); | |
| } | |
| } | |
| } | |
| return rs.mElement_I8; | |
| } | |
| public static Element U16(RenderScript rs) { | |
| if (rs.mElement_U16 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_U16 == null) { | |
| rs.mElement_U16 = createUser(rs, DataType.UNSIGNED_16); | |
| } | |
| } | |
| } | |
| return rs.mElement_U16; | |
| } | |
| public static Element I16(RenderScript rs) { | |
| if (rs.mElement_I16 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_I16 == null) { | |
| rs.mElement_I16 = createUser(rs, DataType.SIGNED_16); | |
| } | |
| } | |
| } | |
| return rs.mElement_I16; | |
| } | |
| public static Element U32(RenderScript rs) { | |
| if (rs.mElement_U32 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_U32 == null) { | |
| rs.mElement_U32 = createUser(rs, DataType.UNSIGNED_32); | |
| } | |
| } | |
| } | |
| return rs.mElement_U32; | |
| } | |
| public static Element I32(RenderScript rs) { | |
| if (rs.mElement_I32 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_I32 == null) { | |
| rs.mElement_I32 = createUser(rs, DataType.SIGNED_32); | |
| } | |
| } | |
| } | |
| return rs.mElement_I32; | |
| } | |
| public static Element U64(RenderScript rs) { | |
| if (rs.mElement_U64 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_U64 == null) { | |
| rs.mElement_U64 = createUser(rs, DataType.UNSIGNED_64); | |
| } | |
| } | |
| } | |
| return rs.mElement_U64; | |
| } | |
| public static Element I64(RenderScript rs) { | |
| if (rs.mElement_I64 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_I64 == null) { | |
| rs.mElement_I64 = createUser(rs, DataType.SIGNED_64); | |
| } | |
| } | |
| } | |
| return rs.mElement_I64; | |
| } | |
| public static Element F16(RenderScript rs) { | |
| if (rs.mElement_F16 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_F16 == null) { | |
| rs.mElement_F16 = createUser(rs, DataType.FLOAT_16); | |
| } | |
| } | |
| } | |
| return rs.mElement_F16; | |
| } | |
| public static Element F32(RenderScript rs) { | |
| if (rs.mElement_F32 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_F32 == null) { | |
| rs.mElement_F32 = createUser(rs, DataType.FLOAT_32); | |
| } | |
| } | |
| } | |
| return rs.mElement_F32; | |
| } | |
| public static Element F64(RenderScript rs) { | |
| if (rs.mElement_F64 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_F64 == null) { | |
| rs.mElement_F64 = createUser(rs, DataType.FLOAT_64); | |
| } | |
| } | |
| } | |
| return rs.mElement_F64; | |
| } | |
| public static Element ELEMENT(RenderScript rs) { | |
| if (rs.mElement_ELEMENT == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_ELEMENT == null) { | |
| rs.mElement_ELEMENT = createUser(rs, DataType.RS_ELEMENT); | |
| } | |
| } | |
| } | |
| return rs.mElement_ELEMENT; | |
| } | |
| public static Element TYPE(RenderScript rs) { | |
| if (rs.mElement_TYPE == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_TYPE == null) { | |
| rs.mElement_TYPE = createUser(rs, DataType.RS_TYPE); | |
| } | |
| } | |
| } | |
| return rs.mElement_TYPE; | |
| } | |
| public static Element ALLOCATION(RenderScript rs) { | |
| if (rs.mElement_ALLOCATION == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_ALLOCATION == null) { | |
| rs.mElement_ALLOCATION = createUser(rs, DataType.RS_ALLOCATION); | |
| } | |
| } | |
| } | |
| return rs.mElement_ALLOCATION; | |
| } | |
| public static Element SAMPLER(RenderScript rs) { | |
| if (rs.mElement_SAMPLER == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_SAMPLER == null) { | |
| rs.mElement_SAMPLER = createUser(rs, DataType.RS_SAMPLER); | |
| } | |
| } | |
| } | |
| return rs.mElement_SAMPLER; | |
| } | |
| public static Element SCRIPT(RenderScript rs) { | |
| if (rs.mElement_SCRIPT == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_SCRIPT == null) { | |
| rs.mElement_SCRIPT = createUser(rs, DataType.RS_SCRIPT); | |
| } | |
| } | |
| } | |
| return rs.mElement_SCRIPT; | |
| } | |
| public static Element MESH(RenderScript rs) { | |
| if (rs.mElement_MESH == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_MESH == null) { | |
| rs.mElement_MESH = createUser(rs, DataType.RS_MESH); | |
| } | |
| } | |
| } | |
| return rs.mElement_MESH; | |
| } | |
| public static Element PROGRAM_FRAGMENT(RenderScript rs) { | |
| if (rs.mElement_PROGRAM_FRAGMENT == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_PROGRAM_FRAGMENT == null) { | |
| rs.mElement_PROGRAM_FRAGMENT = createUser(rs, DataType.RS_PROGRAM_FRAGMENT); | |
| } | |
| } | |
| } | |
| return rs.mElement_PROGRAM_FRAGMENT; | |
| } | |
| public static Element PROGRAM_VERTEX(RenderScript rs) { | |
| if (rs.mElement_PROGRAM_VERTEX == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_PROGRAM_VERTEX == null) { | |
| rs.mElement_PROGRAM_VERTEX = createUser(rs, DataType.RS_PROGRAM_VERTEX); | |
| } | |
| } | |
| } | |
| return rs.mElement_PROGRAM_VERTEX; | |
| } | |
| public static Element PROGRAM_RASTER(RenderScript rs) { | |
| if (rs.mElement_PROGRAM_RASTER == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_PROGRAM_RASTER == null) { | |
| rs.mElement_PROGRAM_RASTER = createUser(rs, DataType.RS_PROGRAM_RASTER); | |
| } | |
| } | |
| } | |
| return rs.mElement_PROGRAM_RASTER; | |
| } | |
| public static Element PROGRAM_STORE(RenderScript rs) { | |
| if (rs.mElement_PROGRAM_STORE == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_PROGRAM_STORE == null) { | |
| rs.mElement_PROGRAM_STORE = createUser(rs, DataType.RS_PROGRAM_STORE); | |
| } | |
| } | |
| } | |
| return rs.mElement_PROGRAM_STORE; | |
| } | |
| public static Element FONT(RenderScript rs) { | |
| if (rs.mElement_FONT == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_FONT == null) { | |
| rs.mElement_FONT = createUser(rs, DataType.RS_FONT); | |
| } | |
| } | |
| } | |
| return rs.mElement_FONT; | |
| } | |
| public static Element A_8(RenderScript rs) { | |
| if (rs.mElement_A_8 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_A_8 == null) { | |
| rs.mElement_A_8 = createPixel(rs, DataType.UNSIGNED_8, DataKind.PIXEL_A); | |
| } | |
| } | |
| } | |
| return rs.mElement_A_8; | |
| } | |
| public static Element RGB_565(RenderScript rs) { | |
| if (rs.mElement_RGB_565 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_RGB_565 == null) { | |
| rs.mElement_RGB_565 = createPixel(rs, DataType.UNSIGNED_5_6_5, DataKind.PIXEL_RGB); | |
| } | |
| } | |
| } | |
| return rs.mElement_RGB_565; | |
| } | |
| public static Element RGB_888(RenderScript rs) { | |
| if (rs.mElement_RGB_888 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_RGB_888 == null) { | |
| rs.mElement_RGB_888 = createPixel(rs, DataType.UNSIGNED_8, DataKind.PIXEL_RGB); | |
| } | |
| } | |
| } | |
| return rs.mElement_RGB_888; | |
| } | |
| public static Element RGBA_5551(RenderScript rs) { | |
| if (rs.mElement_RGBA_5551 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_RGBA_5551 == null) { | |
| rs.mElement_RGBA_5551 = createPixel(rs, DataType.UNSIGNED_5_5_5_1, DataKind.PIXEL_RGBA); | |
| } | |
| } | |
| } | |
| return rs.mElement_RGBA_5551; | |
| } | |
| public static Element RGBA_4444(RenderScript rs) { | |
| if (rs.mElement_RGBA_4444 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_RGBA_4444 == null) { | |
| rs.mElement_RGBA_4444 = createPixel(rs, DataType.UNSIGNED_4_4_4_4, DataKind.PIXEL_RGBA); | |
| } | |
| } | |
| } | |
| return rs.mElement_RGBA_4444; | |
| } | |
| public static Element RGBA_8888(RenderScript rs) { | |
| if (rs.mElement_RGBA_8888 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_RGBA_8888 == null) { | |
| rs.mElement_RGBA_8888 = createPixel(rs, DataType.UNSIGNED_8, DataKind.PIXEL_RGBA); | |
| } | |
| } | |
| } | |
| return rs.mElement_RGBA_8888; | |
| } | |
| public static Element F16_2(RenderScript rs) { | |
| if (rs.mElement_HALF_2 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_HALF_2 == null) { | |
| rs.mElement_HALF_2 = createVector(rs, DataType.FLOAT_16, 2); | |
| } | |
| } | |
| } | |
| return rs.mElement_HALF_2; | |
| } | |
| public static Element F16_3(RenderScript rs) { | |
| if (rs.mElement_HALF_3 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_HALF_3 == null) { | |
| rs.mElement_HALF_3 = createVector(rs, DataType.FLOAT_16, 3); | |
| } | |
| } | |
| } | |
| return rs.mElement_HALF_3; | |
| } | |
| public static Element F16_4(RenderScript rs) { | |
| if (rs.mElement_HALF_4 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_HALF_4 == null) { | |
| rs.mElement_HALF_4 = createVector(rs, DataType.FLOAT_16, 4); | |
| } | |
| } | |
| } | |
| return rs.mElement_HALF_4; | |
| } | |
| public static Element F32_2(RenderScript rs) { | |
| if (rs.mElement_FLOAT_2 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_FLOAT_2 == null) { | |
| rs.mElement_FLOAT_2 = createVector(rs, DataType.FLOAT_32, 2); | |
| } | |
| } | |
| } | |
| return rs.mElement_FLOAT_2; | |
| } | |
| public static Element F32_3(RenderScript rs) { | |
| if (rs.mElement_FLOAT_3 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_FLOAT_3 == null) { | |
| rs.mElement_FLOAT_3 = createVector(rs, DataType.FLOAT_32, 3); | |
| } | |
| } | |
| } | |
| return rs.mElement_FLOAT_3; | |
| } | |
| public static Element F32_4(RenderScript rs) { | |
| if (rs.mElement_FLOAT_4 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_FLOAT_4 == null) { | |
| rs.mElement_FLOAT_4 = createVector(rs, DataType.FLOAT_32, 4); | |
| } | |
| } | |
| } | |
| return rs.mElement_FLOAT_4; | |
| } | |
| public static Element F64_2(RenderScript rs) { | |
| if (rs.mElement_DOUBLE_2 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_DOUBLE_2 == null) { | |
| rs.mElement_DOUBLE_2 = createVector(rs, DataType.FLOAT_64, 2); | |
| } | |
| } | |
| } | |
| return rs.mElement_DOUBLE_2; | |
| } | |
| public static Element F64_3(RenderScript rs) { | |
| if (rs.mElement_DOUBLE_3 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_DOUBLE_3 == null) { | |
| rs.mElement_DOUBLE_3 = createVector(rs, DataType.FLOAT_64, 3); | |
| } | |
| } | |
| } | |
| return rs.mElement_DOUBLE_3; | |
| } | |
| public static Element F64_4(RenderScript rs) { | |
| if (rs.mElement_DOUBLE_4 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_DOUBLE_4 == null) { | |
| rs.mElement_DOUBLE_4 = createVector(rs, DataType.FLOAT_64, 4); | |
| } | |
| } | |
| } | |
| return rs.mElement_DOUBLE_4; | |
| } | |
| public static Element U8_2(RenderScript rs) { | |
| if (rs.mElement_UCHAR_2 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_UCHAR_2 == null) { | |
| rs.mElement_UCHAR_2 = createVector(rs, DataType.UNSIGNED_8, 2); | |
| } | |
| } | |
| } | |
| return rs.mElement_UCHAR_2; | |
| } | |
| public static Element U8_3(RenderScript rs) { | |
| if (rs.mElement_UCHAR_3 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_UCHAR_3 == null) { | |
| rs.mElement_UCHAR_3 = createVector(rs, DataType.UNSIGNED_8, 3); | |
| } | |
| } | |
| } | |
| return rs.mElement_UCHAR_3; | |
| } | |
| public static Element U8_4(RenderScript rs) { | |
| if (rs.mElement_UCHAR_4 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_UCHAR_4 == null) { | |
| rs.mElement_UCHAR_4 = createVector(rs, DataType.UNSIGNED_8, 4); | |
| } | |
| } | |
| } | |
| return rs.mElement_UCHAR_4; | |
| } | |
| public static Element I8_2(RenderScript rs) { | |
| if (rs.mElement_CHAR_2 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_CHAR_2 == null) { | |
| rs.mElement_CHAR_2 = createVector(rs, DataType.SIGNED_8, 2); | |
| } | |
| } | |
| } | |
| return rs.mElement_CHAR_2; | |
| } | |
| public static Element I8_3(RenderScript rs) { | |
| if (rs.mElement_CHAR_3 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_CHAR_3 == null) { | |
| rs.mElement_CHAR_3 = createVector(rs, DataType.SIGNED_8, 3); | |
| } | |
| } | |
| } | |
| return rs.mElement_CHAR_3; | |
| } | |
| public static Element I8_4(RenderScript rs) { | |
| if (rs.mElement_CHAR_4 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_CHAR_4 == null) { | |
| rs.mElement_CHAR_4 = createVector(rs, DataType.SIGNED_8, 4); | |
| } | |
| } | |
| } | |
| return rs.mElement_CHAR_4; | |
| } | |
| public static Element U16_2(RenderScript rs) { | |
| if (rs.mElement_USHORT_2 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_USHORT_2 == null) { | |
| rs.mElement_USHORT_2 = createVector(rs, DataType.UNSIGNED_16, 2); | |
| } | |
| } | |
| } | |
| return rs.mElement_USHORT_2; | |
| } | |
| public static Element U16_3(RenderScript rs) { | |
| if (rs.mElement_USHORT_3 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_USHORT_3 == null) { | |
| rs.mElement_USHORT_3 = createVector(rs, DataType.UNSIGNED_16, 3); | |
| } | |
| } | |
| } | |
| return rs.mElement_USHORT_3; | |
| } | |
| public static Element U16_4(RenderScript rs) { | |
| if (rs.mElement_USHORT_4 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_USHORT_4 == null) { | |
| rs.mElement_USHORT_4 = createVector(rs, DataType.UNSIGNED_16, 4); | |
| } | |
| } | |
| } | |
| return rs.mElement_USHORT_4; | |
| } | |
| public static Element I16_2(RenderScript rs) { | |
| if (rs.mElement_SHORT_2 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_SHORT_2 == null) { | |
| rs.mElement_SHORT_2 = createVector(rs, DataType.SIGNED_16, 2); | |
| } | |
| } | |
| } | |
| return rs.mElement_SHORT_2; | |
| } | |
| public static Element I16_3(RenderScript rs) { | |
| if (rs.mElement_SHORT_3 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_SHORT_3 == null) { | |
| rs.mElement_SHORT_3 = createVector(rs, DataType.SIGNED_16, 3); | |
| } | |
| } | |
| } | |
| return rs.mElement_SHORT_3; | |
| } | |
| public static Element I16_4(RenderScript rs) { | |
| if (rs.mElement_SHORT_4 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_SHORT_4 == null) { | |
| rs.mElement_SHORT_4 = createVector(rs, DataType.SIGNED_16, 4); | |
| } | |
| } | |
| } | |
| return rs.mElement_SHORT_4; | |
| } | |
| public static Element U32_2(RenderScript rs) { | |
| if (rs.mElement_UINT_2 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_UINT_2 == null) { | |
| rs.mElement_UINT_2 = createVector(rs, DataType.UNSIGNED_32, 2); | |
| } | |
| } | |
| } | |
| return rs.mElement_UINT_2; | |
| } | |
| public static Element U32_3(RenderScript rs) { | |
| if (rs.mElement_UINT_3 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_UINT_3 == null) { | |
| rs.mElement_UINT_3 = createVector(rs, DataType.UNSIGNED_32, 3); | |
| } | |
| } | |
| } | |
| return rs.mElement_UINT_3; | |
| } | |
| public static Element U32_4(RenderScript rs) { | |
| if (rs.mElement_UINT_4 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_UINT_4 == null) { | |
| rs.mElement_UINT_4 = createVector(rs, DataType.UNSIGNED_32, 4); | |
| } | |
| } | |
| } | |
| return rs.mElement_UINT_4; | |
| } | |
| public static Element I32_2(RenderScript rs) { | |
| if (rs.mElement_INT_2 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_INT_2 == null) { | |
| rs.mElement_INT_2 = createVector(rs, DataType.SIGNED_32, 2); | |
| } | |
| } | |
| } | |
| return rs.mElement_INT_2; | |
| } | |
| public static Element I32_3(RenderScript rs) { | |
| if (rs.mElement_INT_3 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_INT_3 == null) { | |
| rs.mElement_INT_3 = createVector(rs, DataType.SIGNED_32, 3); | |
| } | |
| } | |
| } | |
| return rs.mElement_INT_3; | |
| } | |
| public static Element I32_4(RenderScript rs) { | |
| if (rs.mElement_INT_4 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_INT_4 == null) { | |
| rs.mElement_INT_4 = createVector(rs, DataType.SIGNED_32, 4); | |
| } | |
| } | |
| } | |
| return rs.mElement_INT_4; | |
| } | |
| public static Element U64_2(RenderScript rs) { | |
| if (rs.mElement_ULONG_2 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_ULONG_2 == null) { | |
| rs.mElement_ULONG_2 = createVector(rs, DataType.UNSIGNED_64, 2); | |
| } | |
| } | |
| } | |
| return rs.mElement_ULONG_2; | |
| } | |
| public static Element U64_3(RenderScript rs) { | |
| if (rs.mElement_ULONG_3 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_ULONG_3 == null) { | |
| rs.mElement_ULONG_3 = createVector(rs, DataType.UNSIGNED_64, 3); | |
| } | |
| } | |
| } | |
| return rs.mElement_ULONG_3; | |
| } | |
| public static Element U64_4(RenderScript rs) { | |
| if (rs.mElement_ULONG_4 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_ULONG_4 == null) { | |
| rs.mElement_ULONG_4 = createVector(rs, DataType.UNSIGNED_64, 4); | |
| } | |
| } | |
| } | |
| return rs.mElement_ULONG_4; | |
| } | |
| public static Element I64_2(RenderScript rs) { | |
| if (rs.mElement_LONG_2 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_LONG_2 == null) { | |
| rs.mElement_LONG_2 = createVector(rs, DataType.SIGNED_64, 2); | |
| } | |
| } | |
| } | |
| return rs.mElement_LONG_2; | |
| } | |
| public static Element I64_3(RenderScript rs) { | |
| if (rs.mElement_LONG_3 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_LONG_3 == null) { | |
| rs.mElement_LONG_3 = createVector(rs, DataType.SIGNED_64, 3); | |
| } | |
| } | |
| } | |
| return rs.mElement_LONG_3; | |
| } | |
| public static Element I64_4(RenderScript rs) { | |
| if (rs.mElement_LONG_4 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_LONG_4 == null) { | |
| rs.mElement_LONG_4 = createVector(rs, DataType.SIGNED_64, 4); | |
| } | |
| } | |
| } | |
| return rs.mElement_LONG_4; | |
| } | |
| public static Element YUV(RenderScript rs) { | |
| if (rs.mElement_YUV == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_YUV == null) { | |
| rs.mElement_YUV = createPixel(rs, DataType.UNSIGNED_8, DataKind.PIXEL_YUV); | |
| } | |
| } | |
| } | |
| return rs.mElement_YUV; | |
| } | |
| public static Element MATRIX_4X4(RenderScript rs) { | |
| if (rs.mElement_MATRIX_4X4 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_MATRIX_4X4 == null) { | |
| rs.mElement_MATRIX_4X4 = createUser(rs, DataType.MATRIX_4X4); | |
| } | |
| } | |
| } | |
| return rs.mElement_MATRIX_4X4; | |
| } | |
| /** @deprecated use MATRIX_4X4 | |
| */ | |
| public static Element MATRIX4X4(RenderScript rs) { | |
| return MATRIX_4X4(rs); | |
| } | |
| public static Element MATRIX_3X3(RenderScript rs) { | |
| if (rs.mElement_MATRIX_3X3 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_MATRIX_3X3 == null) { | |
| rs.mElement_MATRIX_3X3 = createUser(rs, DataType.MATRIX_3X3); | |
| } | |
| } | |
| } | |
| return rs.mElement_MATRIX_3X3; | |
| } | |
| public static Element MATRIX_2X2(RenderScript rs) { | |
| if (rs.mElement_MATRIX_2X2 == null) { | |
| synchronized (rs) { | |
| if (rs.mElement_MATRIX_2X2 == null) { | |
| rs.mElement_MATRIX_2X2 = createUser(rs, DataType.MATRIX_2X2); | |
| } | |
| } | |
| } | |
| return rs.mElement_MATRIX_2X2; | |
| } | |
| Element(long id, RenderScript rs, Element[] e, String[] n, int[] as) { | |
| super(id, rs); | |
| mSize = 0; | |
| mVectorSize = 1; | |
| mElements = e; | |
| mElementNames = n; | |
| mArraySizes = as; | |
| mType = DataType.NONE; | |
| mKind = DataKind.USER; | |
| mOffsetInBytes = new int[mElements.length]; | |
| for (int ct = 0; ct < mElements.length; ct++ ) { | |
| mOffsetInBytes[ct] = mSize; | |
| mSize += mElements[ct].mSize * mArraySizes[ct]; | |
| } | |
| updateVisibleSubElements(); | |
| } | |
| Element(long id, RenderScript rs, DataType dt, DataKind dk, boolean norm, int size) { | |
| super(id, rs); | |
| if ((dt != DataType.UNSIGNED_5_6_5) && | |
| (dt != DataType.UNSIGNED_4_4_4_4) && | |
| (dt != DataType.UNSIGNED_5_5_5_1)) { | |
| if (size == 3) { | |
| mSize = dt.mSize * 4; | |
| } else { | |
| mSize = dt.mSize * size; | |
| } | |
| } else { | |
| mSize = dt.mSize; | |
| } | |
| mType = dt; | |
| mKind = dk; | |
| mNormalized = norm; | |
| mVectorSize = size; | |
| } | |
| Element(long id, RenderScript rs) { | |
| super(id, rs); | |
| } | |
| @Override | |
| void updateFromNative() { | |
| super.updateFromNative(); | |
| // we will pack mType; mKind; mNormalized; mVectorSize; NumSubElements | |
| int[] dataBuffer = new int[5]; | |
| mRS.nElementGetNativeData(getID(mRS), dataBuffer); | |
| mNormalized = dataBuffer[2] == 1 ? true : false; | |
| mVectorSize = dataBuffer[3]; | |
| mSize = 0; | |
| for (DataType dt: DataType.values()) { | |
| if(dt.mID == dataBuffer[0]){ | |
| mType = dt; | |
| mSize = mType.mSize * mVectorSize; | |
| } | |
| } | |
| for (DataKind dk: DataKind.values()) { | |
| if(dk.mID == dataBuffer[1]){ | |
| mKind = dk; | |
| } | |
| } | |
| int numSubElements = dataBuffer[4]; | |
| if(numSubElements > 0) { | |
| mElements = new Element[numSubElements]; | |
| mElementNames = new String[numSubElements]; | |
| mArraySizes = new int[numSubElements]; | |
| mOffsetInBytes = new int[numSubElements]; | |
| long[] subElementIds = new long[numSubElements]; | |
| mRS.nElementGetSubElements(getID(mRS), subElementIds, mElementNames, mArraySizes); | |
| for(int i = 0; i < numSubElements; i ++) { | |
| mElements[i] = new Element(subElementIds[i], mRS); | |
| mElements[i].updateFromNative(); | |
| mOffsetInBytes[i] = mSize; | |
| mSize += mElements[i].mSize * mArraySizes[i]; | |
| } | |
| } | |
| updateVisibleSubElements(); | |
| } | |
| /** | |
| * Create a custom Element of the specified DataType. The DataKind will be | |
| * set to USER and the vector size to 1 indicating non-vector. | |
| * | |
| * @param rs The context associated with the new Element. | |
| * @param dt The DataType for the new element. | |
| * @return Element | |
| */ | |
| @UnsupportedAppUsage | |
| static Element createUser(RenderScript rs, DataType dt) { | |
| DataKind dk = DataKind.USER; | |
| boolean norm = false; | |
| int vecSize = 1; | |
| long id = rs.nElementCreate(dt.mID, dk.mID, norm, vecSize); | |
| return new Element(id, rs, dt, dk, norm, vecSize); | |
| } | |
| /** | |
| * Create a custom vector element of the specified DataType and vector size. | |
| * DataKind will be set to USER. Only primitive types (FLOAT_32, FLOAT_64, | |
| * SIGNED_8, SIGNED_16, SIGNED_32, SIGNED_64, UNSIGNED_8, UNSIGNED_16, | |
| * UNSIGNED_32, UNSIGNED_64, BOOLEAN) are supported. | |
| * | |
| * @param rs The context associated with the new Element. | |
| * @param dt The DataType for the new Element. | |
| * @param size Vector size for the new Element. Range 2-4 inclusive | |
| * supported. | |
| * | |
| * @return Element | |
| */ | |
| public static Element createVector(RenderScript rs, DataType dt, int size) { | |
| if (size < 2 || size > 4) { | |
| throw new RSIllegalArgumentException("Vector size out of range 2-4."); | |
| } | |
| switch (dt) { | |
| // Support only primitive integer/float/boolean types as vectors. | |
| case FLOAT_16: | |
| case FLOAT_32: | |
| case FLOAT_64: | |
| case SIGNED_8: | |
| case SIGNED_16: | |
| case SIGNED_32: | |
| case SIGNED_64: | |
| case UNSIGNED_8: | |
| case UNSIGNED_16: | |
| case UNSIGNED_32: | |
| case UNSIGNED_64: | |
| case BOOLEAN: { | |
| DataKind dk = DataKind.USER; | |
| boolean norm = false; | |
| long id = rs.nElementCreate(dt.mID, dk.mID, norm, size); | |
| return new Element(id, rs, dt, dk, norm, size); | |
| } | |
| default: { | |
| throw new RSIllegalArgumentException("Cannot create vector of " + | |
| "non-primitive type."); | |
| } | |
| } | |
| } | |
| /** | |
| * Create a new pixel Element type. A matching DataType and DataKind must | |
| * be provided. The DataType and DataKind must contain the same number of | |
| * components. Vector size will be set to 1. | |
| * | |
| * @param rs The context associated with the new Element. | |
| * @param dt The DataType for the new element. | |
| * @param dk The DataKind to specify the mapping of each component in the | |
| * DataType. | |
| * | |
| * @return Element | |
| */ | |
| public static Element createPixel(RenderScript rs, DataType dt, DataKind dk) { | |
| if (!(dk == DataKind.PIXEL_L || | |
| dk == DataKind.PIXEL_A || | |
| dk == DataKind.PIXEL_LA || | |
| dk == DataKind.PIXEL_RGB || | |
| dk == DataKind.PIXEL_RGBA || | |
| dk == DataKind.PIXEL_DEPTH || | |
| dk == DataKind.PIXEL_YUV)) { | |
| throw new RSIllegalArgumentException("Unsupported DataKind"); | |
| } | |
| if (!(dt == DataType.UNSIGNED_8 || | |
| dt == DataType.UNSIGNED_16 || | |
| dt == DataType.UNSIGNED_5_6_5 || | |
| dt == DataType.UNSIGNED_4_4_4_4 || | |
| dt == DataType.UNSIGNED_5_5_5_1)) { | |
| throw new RSIllegalArgumentException("Unsupported DataType"); | |
| } | |
| if (dt == DataType.UNSIGNED_5_6_5 && dk != DataKind.PIXEL_RGB) { | |
| throw new RSIllegalArgumentException("Bad kind and type combo"); | |
| } | |
| if (dt == DataType.UNSIGNED_5_5_5_1 && dk != DataKind.PIXEL_RGBA) { | |
| throw new RSIllegalArgumentException("Bad kind and type combo"); | |
| } | |
| if (dt == DataType.UNSIGNED_4_4_4_4 && dk != DataKind.PIXEL_RGBA) { | |
| throw new RSIllegalArgumentException("Bad kind and type combo"); | |
| } | |
| if (dt == DataType.UNSIGNED_16 && | |
| dk != DataKind.PIXEL_DEPTH) { | |
| throw new RSIllegalArgumentException("Bad kind and type combo"); | |
| } | |
| int size = 1; | |
| switch (dk) { | |
| case PIXEL_LA: | |
| size = 2; | |
| break; | |
| case PIXEL_RGB: | |
| size = 3; | |
| break; | |
| case PIXEL_RGBA: | |
| size = 4; | |
| break; | |
| case PIXEL_DEPTH: | |
| size = 2; | |
| break; | |
| } | |
| boolean norm = true; | |
| long id = rs.nElementCreate(dt.mID, dk.mID, norm, size); | |
| return new Element(id, rs, dt, dk, norm, size); | |
| } | |
| /** | |
| * Check if the current Element is compatible with another Element. | |
| * Primitive Elements are compatible if they share the same underlying | |
| * size and type (i.e. U8 is compatible with A_8). User-defined Elements | |
| * must be equal in order to be compatible. This requires strict name | |
| * equivalence for all sub-Elements (in addition to structural equivalence). | |
| * | |
| * @param e The Element to check compatibility with. | |
| * | |
| * @return boolean true if the Elements are compatible, otherwise false. | |
| */ | |
| public boolean isCompatible(Element e) { | |
| // Try strict BaseObj equality to start with. | |
| if (this.equals(e)) { | |
| return true; | |
| } | |
| // Ignore mKind because it is allowed to be different (user vs. pixel). | |
| // We also ignore mNormalized because it can be different. The mType | |
| // field must not be NONE since we require name equivalence for | |
| // all user-created Elements. | |
| return ((mSize == e.mSize) && | |
| (mType != DataType.NONE) && | |
| (mType == e.mType) && | |
| (mVectorSize == e.mVectorSize)); | |
| } | |
| /** | |
| * 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. | |
| * | |
| */ | |
| public static class Builder { | |
| RenderScript mRS; | |
| Element[] mElements; | |
| String[] mElementNames; | |
| int[] mArraySizes; | |
| int mCount; | |
| int mSkipPadding; | |
| /** | |
| * Create a builder object. | |
| * | |
| * @param rs | |
| */ | |
| public Builder(RenderScript rs) { | |
| mRS = rs; | |
| mCount = 0; | |
| mElements = new Element[8]; | |
| mElementNames = new String[8]; | |
| mArraySizes = new int[8]; | |
| } | |
| /** | |
| * Add an array of elements to this element. | |
| * | |
| * @param element | |
| * @param name | |
| * @param arraySize | |
| */ | |
| public Builder add(Element element, String name, int arraySize) { | |
| if (arraySize < 1) { | |
| throw new RSIllegalArgumentException("Array size cannot be less than 1."); | |
| } | |
| // Skip padding fields after a vector 3 type. | |
| if (mSkipPadding != 0) { | |
| if (name.startsWith("#padding_")) { | |
| mSkipPadding = 0; | |
| return this; | |
| } | |
| } | |
| if (element.mVectorSize == 3) { | |
| mSkipPadding = 1; | |
| } else { | |
| mSkipPadding = 0; | |
| } | |
| if(mCount == mElements.length) { | |
| Element[] e = new Element[mCount + 8]; | |
| String[] s = new String[mCount + 8]; | |
| int[] as = new int[mCount + 8]; | |
| System.arraycopy(mElements, 0, e, 0, mCount); | |
| System.arraycopy(mElementNames, 0, s, 0, mCount); | |
| System.arraycopy(mArraySizes, 0, as, 0, mCount); | |
| mElements = e; | |
| mElementNames = s; | |
| mArraySizes = as; | |
| } | |
| mElements[mCount] = element; | |
| mElementNames[mCount] = name; | |
| mArraySizes[mCount] = arraySize; | |
| mCount++; | |
| return this; | |
| } | |
| /** | |
| * Add a single element to this Element. | |
| * | |
| * @param element | |
| * @param name | |
| */ | |
| public Builder add(Element element, String name) { | |
| return add(element, name, 1); | |
| } | |
| /** | |
| * Create the element from this builder. | |
| * | |
| * | |
| * @return Element | |
| */ | |
| public Element create() { | |
| mRS.validate(); | |
| Element[] ein = new Element[mCount]; | |
| String[] sin = new String[mCount]; | |
| int[] asin = new int[mCount]; | |
| java.lang.System.arraycopy(mElements, 0, ein, 0, mCount); | |
| java.lang.System.arraycopy(mElementNames, 0, sin, 0, mCount); | |
| java.lang.System.arraycopy(mArraySizes, 0, asin, 0, mCount); | |
| long[] ids = new long[ein.length]; | |
| for (int ct = 0; ct < ein.length; ct++ ) { | |
| ids[ct] = ein[ct].getID(mRS); | |
| } | |
| long id = mRS.nElementCreate2(ids, sin, asin); | |
| return new Element(id, mRS, ein, sin, asin); | |
| } | |
| } | |
| } | |