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