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