Home | History | Annotate | Download | only in cpp 
      1 /*
      2  * Copyright (C) 2012 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #define LOG_TAG "libRS_cpp"
     18 
     19 #include <utils/Log.h>
     20 #include <malloc.h>
     21 #include <string.h>
     22 
     23 #include "RenderScript.h"
     24 #include "Element.h"
     25 
     26 using namespace android;
     27 using namespace renderscriptCpp;
     28 
     29 sp<const Element> Element::getSubElement(uint32_t index) {
     30     if (!mVisibleElementMap.size()) {
     31         mRS->throwError("Element contains no sub-elements");
     32     }
     33     if (index >= mVisibleElementMap.size()) {
     34         mRS->throwError("Illegal sub-element index");
     35     }
     36     return mElements[mVisibleElementMap[index]];
     37 }
     38 
     39 const char * Element::getSubElementName(uint32_t index) {
     40     if (!mVisibleElementMap.size()) {
     41         mRS->throwError("Element contains no sub-elements");
     42     }
     43     if (index >= mVisibleElementMap.size()) {
     44         mRS->throwError("Illegal sub-element index");
     45     }
     46     return mElementNames[mVisibleElementMap[index]];
     47 }
     48 
     49 size_t Element::getSubElementArraySize(uint32_t index) {
     50     if (!mVisibleElementMap.size()) {
     51         mRS->throwError("Element contains no sub-elements");
     52     }
     53     if (index >= mVisibleElementMap.size()) {
     54         mRS->throwError("Illegal sub-element index");
     55     }
     56     return mArraySizes[mVisibleElementMap[index]];
     57 }
     58 
     59 uint32_t Element::getSubElementOffsetBytes(uint32_t index) {
     60     if (mVisibleElementMap.size()) {
     61         mRS->throwError("Element contains no sub-elements");
     62     }
     63     if (index >= mVisibleElementMap.size()) {
     64         mRS->throwError("Illegal sub-element index");
     65     }
     66     return mOffsetInBytes[mVisibleElementMap[index]];
     67 }
     68 
     69 
     70 #define CREATE_USER(N, T) sp<const Element> Element::N(RenderScript *rs) { \
     71     return createUser(rs, RS_TYPE_##T); \
     72 }
     73 CREATE_USER(BOOLEAN, BOOLEAN);
     74 CREATE_USER(U8, UNSIGNED_8);
     75 CREATE_USER(I8, SIGNED_8);
     76 CREATE_USER(U16, UNSIGNED_16);
     77 CREATE_USER(I16, SIGNED_16);
     78 CREATE_USER(U32, UNSIGNED_32);
     79 CREATE_USER(I32, SIGNED_32);
     80 CREATE_USER(U64, UNSIGNED_64);
     81 CREATE_USER(I64, SIGNED_64);
     82 CREATE_USER(F32, FLOAT_32);
     83 CREATE_USER(F64, FLOAT_64);
     84 CREATE_USER(ELEMENT, ELEMENT);
     85 CREATE_USER(TYPE, TYPE);
     86 CREATE_USER(ALLOCATION, ALLOCATION);
     87 CREATE_USER(SAMPLER, SAMPLER);
     88 CREATE_USER(SCRIPT, SCRIPT);
     89 CREATE_USER(MESH, MESH);
     90 CREATE_USER(PROGRAM_FRAGMENT, PROGRAM_FRAGMENT);
     91 CREATE_USER(PROGRAM_VERTEX, PROGRAM_VERTEX);
     92 CREATE_USER(PROGRAM_RASTER, PROGRAM_RASTER);
     93 CREATE_USER(PROGRAM_STORE, PROGRAM_STORE);
     94 CREATE_USER(MATRIX_4X4, MATRIX_4X4);
     95 CREATE_USER(MATRIX_3X3, MATRIX_3X3);
     96 CREATE_USER(MATRIX_2X2, MATRIX_2X2);
     97 
     98 #define CREATE_PIXEL(N, T, K) sp<const Element> Element::N(RenderScript *rs) { \
     99     return createPixel(rs, RS_TYPE_##T, RS_KIND_##K); \
    100 }
    101 CREATE_PIXEL(A_8, UNSIGNED_8, PIXEL_A);
    102 CREATE_PIXEL(RGB_565, UNSIGNED_5_6_5, PIXEL_RGB);
    103 CREATE_PIXEL(RGB_888, UNSIGNED_8, PIXEL_RGB);
    104 CREATE_PIXEL(RGBA_4444, UNSIGNED_4_4_4_4, PIXEL_RGBA);
    105 CREATE_PIXEL(RGBA_8888, UNSIGNED_8, PIXEL_RGBA);
    106 
    107 #define CREATE_VECTOR(N, T) sp<const Element> Element::N##_2(RenderScript *rs) { \
    108     return createVector(rs, RS_TYPE_##T, 2); \
    109 } \
    110 sp<const Element> Element::N##_3(RenderScript *rs) { \
    111     return createVector(rs, RS_TYPE_##T, 3); \
    112 } \
    113 sp<const Element> Element::N##_4(RenderScript *rs) { \
    114     return createVector(rs, RS_TYPE_##T, 4); \
    115 }
    116 CREATE_VECTOR(U8, UNSIGNED_8);
    117 CREATE_VECTOR(I8, SIGNED_8);
    118 CREATE_VECTOR(U16, UNSIGNED_16);
    119 CREATE_VECTOR(I16, SIGNED_16);
    120 CREATE_VECTOR(U32, UNSIGNED_32);
    121 CREATE_VECTOR(I32, SIGNED_32);
    122 CREATE_VECTOR(U64, UNSIGNED_64);
    123 CREATE_VECTOR(I64, SIGNED_64);
    124 CREATE_VECTOR(F32, FLOAT_32);
    125 CREATE_VECTOR(F64, FLOAT_64);
    126 
    127 
    128 void Element::updateVisibleSubElements() {
    129     if (!mElements.size()) {
    130         return;
    131     }
    132     mVisibleElementMap.clear();
    133 
    134     int noPaddingFieldCount = 0;
    135     size_t fieldCount = mElementNames.size();
    136     // Find out how many elements are not padding
    137     for (size_t ct = 0; ct < fieldCount; ct ++) {
    138         if (mElementNames[ct].string()[0] != '#') {
    139             noPaddingFieldCount ++;
    140         }
    141     }
    142 
    143     // Make a map that points us at non-padding elements
    144     for (size_t ct = 0; ct < fieldCount; ct ++) {
    145         if (mElementNames[ct].string()[0] != '#') {
    146             mVisibleElementMap.push((uint32_t)ct);
    147         }
    148     }
    149 }
    150 
    151 Element::Element(void *id, RenderScript *rs,
    152                  android::Vector<sp</*const*/ Element> > &elements,
    153                  android::Vector<android::String8> &elementNames,
    154                  android::Vector<uint32_t> &arraySizes) : BaseObj(id, rs) {
    155     mSizeBytes = 0;
    156     mVectorSize = 1;
    157     mElements = elements;
    158     mArraySizes = arraySizes;
    159     mElementNames = elementNames;
    160 
    161     mType = RS_TYPE_NONE;
    162     mKind = RS_KIND_USER;
    163 
    164     for (size_t ct = 0; ct < mElements.size(); ct++ ) {
    165         mOffsetInBytes.push(mSizeBytes);
    166         mSizeBytes += mElements[ct]->mSizeBytes * mArraySizes[ct];
    167     }
    168     updateVisibleSubElements();
    169 }
    170 
    171 
    172 static uint32_t GetSizeInBytesForType(RsDataType dt) {
    173     switch(dt) {
    174     case RS_TYPE_NONE:
    175         return 0;
    176     case RS_TYPE_SIGNED_8:
    177     case RS_TYPE_UNSIGNED_8:
    178     case RS_TYPE_BOOLEAN:
    179         return 1;
    180 
    181     case RS_TYPE_FLOAT_16:
    182     case RS_TYPE_SIGNED_16:
    183     case RS_TYPE_UNSIGNED_16:
    184     case RS_TYPE_UNSIGNED_5_6_5:
    185     case RS_TYPE_UNSIGNED_5_5_5_1:
    186     case RS_TYPE_UNSIGNED_4_4_4_4:
    187         return 2;
    188 
    189     case RS_TYPE_FLOAT_32:
    190     case RS_TYPE_SIGNED_32:
    191     case RS_TYPE_UNSIGNED_32:
    192         return 4;
    193 
    194     case RS_TYPE_FLOAT_64:
    195     case RS_TYPE_SIGNED_64:
    196     case RS_TYPE_UNSIGNED_64:
    197         return 8;
    198 
    199     case RS_TYPE_MATRIX_4X4:
    200         return 16 * 4;
    201     case RS_TYPE_MATRIX_3X3:
    202         return 9 * 4;
    203     case RS_TYPE_MATRIX_2X2:
    204         return 4 * 4;
    205 
    206     case RS_TYPE_TYPE:
    207     case RS_TYPE_ALLOCATION:
    208     case RS_TYPE_SAMPLER:
    209     case RS_TYPE_SCRIPT:
    210     case RS_TYPE_MESH:
    211     case RS_TYPE_PROGRAM_FRAGMENT:
    212     case RS_TYPE_PROGRAM_VERTEX:
    213     case RS_TYPE_PROGRAM_RASTER:
    214     case RS_TYPE_PROGRAM_STORE:
    215         return 4;
    216 
    217     default:
    218         break;
    219     }
    220 
    221     ALOGE("Missing type %i", dt);
    222     return 0;
    223 }
    224 
    225 Element::Element(void *id, RenderScript *rs,
    226                  RsDataType dt, RsDataKind dk, bool norm, uint32_t size) :
    227     BaseObj(id, rs)
    228 {
    229     uint32_t tsize = GetSizeInBytesForType(dt);
    230     if ((dt != RS_TYPE_UNSIGNED_5_6_5) &&
    231         (dt != RS_TYPE_UNSIGNED_4_4_4_4) &&
    232         (dt != RS_TYPE_UNSIGNED_5_5_5_1)) {
    233         if (size == 3) {
    234             mSizeBytes = tsize * 4;
    235         } else {
    236             mSizeBytes = tsize * size;
    237         }
    238     } else {
    239         mSizeBytes = tsize;
    240     }
    241     mType = dt;
    242     mKind = dk;
    243     mNormalized = norm;
    244     mVectorSize = size;
    245 }
    246 
    247 Element::~Element() {
    248 }
    249 
    250    /*
    251     Element(int id, RenderScript rs) {
    252         super(id, rs);
    253     }
    254     */
    255 
    256 void Element::updateFromNative() {
    257     BaseObj::updateFromNative();
    258 /*
    259     // we will pack mType; mKind; mNormalized; mVectorSize; NumSubElements
    260     int[] dataBuffer = new int[5];
    261     mRS.nElementGetNativeData(getID(), dataBuffer);
    262 
    263     mNormalized = dataBuffer[2] == 1 ? true : false;
    264     mVectorSize = dataBuffer[3];
    265     mSize = 0;
    266     for (DataType dt: DataType.values()) {
    267         if(dt.mID == dataBuffer[0]){
    268             mType = dt;
    269             mSize = mType.mSize * mVectorSize;
    270         }
    271     }
    272     for (DataKind dk: DataKind.values()) {
    273         if(dk.mID == dataBuffer[1]){
    274             mKind = dk;
    275         }
    276     }
    277 
    278     int numSubElements = dataBuffer[4];
    279     if(numSubElements > 0) {
    280         mElements = new Element[numSubElements];
    281         mElementNames = new String[numSubElements];
    282         mArraySizes = new int[numSubElements];
    283         mOffsetInBytes = new int[numSubElements];
    284 
    285         int[] subElementIds = new int[numSubElements];
    286         mRS.nElementGetSubElements(getID(), subElementIds, mElementNames, mArraySizes);
    287         for(int i = 0; i < numSubElements; i ++) {
    288             mElements[i] = new Element(subElementIds[i], mRS);
    289             mElements[i].updateFromNative();
    290             mOffsetInBytes[i] = mSize;
    291             mSize += mElements[i].mSize * mArraySizes[i];
    292         }
    293     }
    294     */
    295     updateVisibleSubElements();
    296 }
    297 
    298 sp<const Element> Element::createUser(RenderScript *rs, RsDataType dt) {
    299     void * id = rsElementCreate(rs->mContext, dt, RS_KIND_USER, false, 1);
    300     return new Element(id, rs, dt, RS_KIND_USER, false, 1);
    301 }
    302 
    303 sp<const Element> Element::createVector(RenderScript *rs, RsDataType dt, uint32_t size) {
    304     if (size < 2 || size > 4) {
    305         rs->throwError("Vector size out of range 2-4.");
    306     }
    307     void *id = rsElementCreate(rs->mContext, dt, RS_KIND_USER, false, size);
    308     return new Element(id, rs, dt, RS_KIND_USER, false, size);
    309 }
    310 
    311 sp<const Element> Element::createPixel(RenderScript *rs, RsDataType dt, RsDataKind dk) {
    312     if (!(dk == RS_KIND_PIXEL_L ||
    313           dk == RS_KIND_PIXEL_A ||
    314           dk == RS_KIND_PIXEL_LA ||
    315           dk == RS_KIND_PIXEL_RGB ||
    316           dk == RS_KIND_PIXEL_RGBA ||
    317           dk == RS_KIND_PIXEL_DEPTH)) {
    318         rs->throwError("Unsupported DataKind");
    319     }
    320     if (!(dt == RS_TYPE_UNSIGNED_8 ||
    321           dt == RS_TYPE_UNSIGNED_16 ||
    322           dt == RS_TYPE_UNSIGNED_5_6_5 ||
    323           dt == RS_TYPE_UNSIGNED_4_4_4_4 ||
    324           dt == RS_TYPE_UNSIGNED_5_5_5_1)) {
    325         rs->throwError("Unsupported DataType");
    326     }
    327     if (dt == RS_TYPE_UNSIGNED_5_6_5 && dk != RS_KIND_PIXEL_RGB) {
    328         rs->throwError("Bad kind and type combo");
    329     }
    330     if (dt == RS_TYPE_UNSIGNED_5_5_5_1 && dk != RS_KIND_PIXEL_RGBA) {
    331         rs->throwError("Bad kind and type combo");
    332     }
    333     if (dt == RS_TYPE_UNSIGNED_4_4_4_4 && dk != RS_KIND_PIXEL_RGBA) {
    334         rs->throwError("Bad kind and type combo");
    335     }
    336     if (dt == RS_TYPE_UNSIGNED_16 && dk != RS_KIND_PIXEL_DEPTH) {
    337         rs->throwError("Bad kind and type combo");
    338     }
    339 
    340     int size = 1;
    341     switch (dk) {
    342     case RS_KIND_PIXEL_LA:
    343         size = 2;
    344         break;
    345     case RS_KIND_PIXEL_RGB:
    346         size = 3;
    347         break;
    348     case RS_KIND_PIXEL_RGBA:
    349         size = 4;
    350         break;
    351     case RS_KIND_PIXEL_DEPTH:
    352         size = 2;
    353         break;
    354     default:
    355         break;
    356     }
    357 
    358     void * id = rsElementCreate(rs->mContext, dt, dk, true, size);
    359     return new Element(id, rs, dt, dk, true, size);
    360 }
    361 
    362 bool Element::isCompatible(sp<const Element>e) {
    363     // Try strict BaseObj equality to start with.
    364     if (this == e.get()) {
    365         return true;
    366     }
    367 
    368     // Ignore mKind because it is allowed to be different (user vs. pixel).
    369     // We also ignore mNormalized because it can be different. The mType
    370     // field must be non-null since we require name equivalence for
    371     // user-created Elements.
    372     return ((mSizeBytes == e->mSizeBytes) &&
    373             (mType != RS_TYPE_NONE) &&
    374             (mType == e->mType) &&
    375             (mVectorSize == e->mVectorSize));
    376 }
    377 
    378 Element::Builder::Builder(RenderScript *rs) {
    379     mRS = rs;
    380     mSkipPadding = false;
    381 }
    382 
    383 void Element::Builder::add(sp</*const*/ Element>e, android::String8 &name, uint32_t arraySize) {
    384     // Skip padding fields after a vector 3 type.
    385     if (mSkipPadding) {
    386         const char *s1 = "#padding_";
    387         const char *s2 = name;
    388         size_t len = strlen(s1);
    389         if (strlen(s2) >= len) {
    390             if (!memcmp(s1, s2, len)) {
    391                 mSkipPadding = false;
    392                 return;
    393             }
    394         }
    395     }
    396 
    397     if (e->mVectorSize == 3) {
    398         mSkipPadding = true;
    399     } else {
    400         mSkipPadding = false;
    401     }
    402 
    403     mElements.add(e);
    404     mElementNames.add(name);
    405     mArraySizes.add(arraySize);
    406 }
    407 
    408 sp<const Element> Element::Builder::create() {
    409     size_t fieldCount = mElements.size();
    410     const char ** nameArray = (const char **)calloc(fieldCount, sizeof(char *));
    411     const Element ** elementArray = (const Element **)calloc(fieldCount, sizeof(Element *));
    412     size_t* sizeArray = (size_t*)calloc(fieldCount, sizeof(size_t));
    413 
    414     for (size_t ct = 0; ct < fieldCount; ct++) {
    415         nameArray[ct] = mElementNames[ct].string();
    416         elementArray[ct] = mElements[ct].get();
    417         sizeArray[ct] = mElementNames[ct].length();
    418     }
    419 
    420     void *id = rsElementCreate2(mRS->mContext,
    421                                 (RsElement *)elementArray, fieldCount,
    422                                 nameArray, fieldCount * sizeof(size_t),  sizeArray,
    423                                 (const uint32_t *)mArraySizes.array(), fieldCount);
    424 
    425 
    426     free(nameArray);
    427     free(sizeArray);
    428     free(elementArray);
    429     return new Element(id, mRS, mElements, mElementNames, mArraySizes);
    430 }
    431 
    432