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 android::RSC::Element; 24 25 android::RSC::sp<const Element> Element::getSubElement(uint32_t index) { 26 if (!mVisibleElementMapSize) { 27 mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Element contains no sub-elements"); 28 return nullptr; 29 } 30 if (index >= mVisibleElementMapSize) { 31 mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Illegal sub-element index"); 32 return nullptr; 33 } 34 return mElements[mVisibleElementMap[index]]; 35 } 36 37 const char * Element::getSubElementName(uint32_t index) { 38 if (!mVisibleElementMapSize) { 39 mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Element contains no sub-elements"); 40 return nullptr; 41 } 42 if (index >= mVisibleElementMapSize) { 43 mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Illegal sub-element index"); 44 return nullptr; 45 } 46 return mElementNames[mVisibleElementMap[index]]; 47 } 48 49 size_t Element::getSubElementArraySize(uint32_t index) { 50 if (!mVisibleElementMapSize) { 51 mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Element contains no sub-elements"); 52 return 0; 53 } 54 if (index >= mVisibleElementMapSize) { 55 mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Illegal sub-element index"); 56 return 0; 57 } 58 return mArraySizes[mVisibleElementMap[index]]; 59 } 60 61 uint32_t Element::getSubElementOffsetBytes(uint32_t index) { 62 if (!mVisibleElementMapSize) { 63 mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Element contains no sub-elements"); 64 return 0; 65 } 66 if (index >= mVisibleElementMapSize) { 67 mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Illegal sub-element index"); 68 return 0; 69 } 70 return mOffsetInBytes[mVisibleElementMap[index]]; 71 } 72 73 74 #define CREATE_USER(N, T) android::RSC::sp<const Element> Element::N(const android::RSC::sp<RS>& rs) { \ 75 if (rs->mElements.N == nullptr) { \ 76 rs->mElements.N = (createUser(rs, RS_TYPE_##T)); \ 77 } \ 78 return rs->mElements.N; \ 79 } 80 81 CREATE_USER(BOOLEAN, BOOLEAN); 82 CREATE_USER(U8, UNSIGNED_8); 83 CREATE_USER(I8, SIGNED_8); 84 CREATE_USER(U16, UNSIGNED_16); 85 CREATE_USER(I16, SIGNED_16); 86 CREATE_USER(U32, UNSIGNED_32); 87 CREATE_USER(I32, SIGNED_32); 88 CREATE_USER(U64, UNSIGNED_64); 89 CREATE_USER(I64, SIGNED_64); 90 CREATE_USER(F16, FLOAT_16); 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(const android::RSC::sp<RS> &rs) { \ 103 if (rs->mElements.N == nullptr) { \ 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(const android::RSC::sp<RS> &rs) { \ 118 if (rs->mElements.N##_2 == nullptr) { \ 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(const android::RSC::sp<RS> &rs) { \ 124 if (rs->mElements.N##_3 == nullptr) { \ 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(const android::RSC::sp<RS> &rs) { \ 130 if (rs->mElements.N##_4 == nullptr) { \ 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(F16, FLOAT_16); 144 CREATE_VECTOR(F32, FLOAT_32); 145 CREATE_VECTOR(F64, FLOAT_64); 146 147 148 void Element::updateVisibleSubElements() { 149 if (!mElementsCount) { 150 return; 151 } 152 if (mVisibleElementMapSize) { 153 free(mVisibleElementMap); 154 mVisibleElementMapSize = 0; 155 } 156 mVisibleElementMap = (uint32_t*)calloc(mElementsCount, sizeof(uint32_t)); 157 158 int noPaddingFieldCount = 0; 159 size_t fieldCount = mElementsCount; 160 // Find out how many elements are not padding. 161 for (size_t ct = 0; ct < fieldCount; ct ++) { 162 if (mElementNames[ct][0] != '#') { 163 noPaddingFieldCount ++; 164 } 165 } 166 167 // Make a map that points us at non-padding elements. 168 size_t i = 0; 169 for (size_t ct = 0; ct < fieldCount; ct ++) { 170 if (mElementNames[ct][0] != '#') { 171 mVisibleElementMap[i++] = (uint32_t)ct; 172 } 173 } 174 mVisibleElementMapSize = i; 175 } 176 177 Element::Element(void *id, android::RSC::sp<RS> rs, 178 android::RSC::sp<const Element> * elements, 179 size_t elementCount, 180 const char ** elementNames, 181 size_t * elementNameLengths, 182 uint32_t * arraySizes) : BaseObj(id, rs) { 183 mSizeBytes = 0; 184 mVectorSize = 1; 185 mElementsCount = elementCount; 186 mVisibleElementMap = nullptr; 187 mVisibleElementMapSize = 0; 188 189 mElements = (android::RSC::sp<const Element> *)calloc(mElementsCount, sizeof(android::RSC::sp<const Element>)); 190 mElementNames = (char **)calloc(mElementsCount, sizeof(char *)); 191 mElementNameLengths = (size_t*)calloc(mElementsCount, sizeof(size_t)); 192 mArraySizes = (uint32_t*)calloc(mElementsCount, sizeof(uint32_t)); 193 mOffsetInBytes = (uint32_t*)calloc(mElementsCount, sizeof(uint32_t)); 194 195 memcpy(mElements, elements, mElementsCount * sizeof(android::RSC::sp<Element>)); 196 memcpy(mArraySizes, arraySizes, mElementsCount * sizeof(uint32_t)); 197 198 // Copy strings (char array). 199 memcpy(mElementNameLengths, elementNameLengths, mElementsCount * sizeof(size_t)); 200 for (size_t ct = 0; ct < mElementsCount; ct++ ) { 201 size_t elemNameLen = mElementNameLengths[ct]; 202 mElementNames[ct] = (char *)calloc(elemNameLen, sizeof(char)); 203 memcpy(mElementNames[ct], elementNames[ct], elemNameLen); 204 } 205 206 mType = RS_TYPE_NONE; 207 mKind = RS_KIND_USER; 208 209 for (size_t ct = 0; ct < mElementsCount; ct++ ) { 210 mOffsetInBytes[ct] = mSizeBytes; 211 mSizeBytes += mElements[ct]->mSizeBytes * mArraySizes[ct]; 212 } 213 updateVisibleSubElements(); 214 } 215 216 Element::Element(void *id, android::RSC::sp<RS> rs) : 217 BaseObj(id, rs) { 218 } 219 220 static uint32_t GetSizeInBytesForType(RsDataType dt) { 221 switch(dt) { 222 case RS_TYPE_NONE: 223 return 0; 224 case RS_TYPE_SIGNED_8: 225 case RS_TYPE_UNSIGNED_8: 226 case RS_TYPE_BOOLEAN: 227 return 1; 228 229 case RS_TYPE_FLOAT_16: 230 case RS_TYPE_SIGNED_16: 231 case RS_TYPE_UNSIGNED_16: 232 case RS_TYPE_UNSIGNED_5_6_5: 233 case RS_TYPE_UNSIGNED_5_5_5_1: 234 case RS_TYPE_UNSIGNED_4_4_4_4: 235 return 2; 236 237 case RS_TYPE_FLOAT_32: 238 case RS_TYPE_SIGNED_32: 239 case RS_TYPE_UNSIGNED_32: 240 return 4; 241 242 case RS_TYPE_FLOAT_64: 243 case RS_TYPE_SIGNED_64: 244 case RS_TYPE_UNSIGNED_64: 245 return 8; 246 247 case RS_TYPE_MATRIX_4X4: 248 return 16 * 4; 249 case RS_TYPE_MATRIX_3X3: 250 return 9 * 4; 251 case RS_TYPE_MATRIX_2X2: 252 return 4 * 4; 253 254 case RS_TYPE_TYPE: 255 case RS_TYPE_ALLOCATION: 256 case RS_TYPE_SAMPLER: 257 case RS_TYPE_SCRIPT: 258 case RS_TYPE_MESH: 259 case RS_TYPE_PROGRAM_FRAGMENT: 260 case RS_TYPE_PROGRAM_VERTEX: 261 case RS_TYPE_PROGRAM_RASTER: 262 case RS_TYPE_PROGRAM_STORE: 263 return 4; 264 265 default: 266 break; 267 } 268 269 ALOGE("Missing type %i", dt); 270 return 0; 271 } 272 273 Element::Element(void *id, android::RSC::sp<RS> rs, 274 RsDataType dt, RsDataKind dk, bool norm, uint32_t size) : 275 BaseObj(id, rs) 276 { 277 uint32_t tsize = GetSizeInBytesForType(dt); 278 if ((dt != RS_TYPE_UNSIGNED_5_6_5) && 279 (dt != RS_TYPE_UNSIGNED_4_4_4_4) && 280 (dt != RS_TYPE_UNSIGNED_5_5_5_1)) { 281 if (size == 3) { 282 mSizeBytes = tsize * 4; 283 } else { 284 mSizeBytes = tsize * size; 285 } 286 } else { 287 mSizeBytes = tsize; 288 } 289 mType = dt; 290 mKind = dk; 291 mNormalized = norm; 292 mVectorSize = size; 293 mElementsCount = 0; 294 mVisibleElementMap = 0; 295 } 296 297 Element::~Element() { 298 if (mElementsCount) { 299 free(mElements); 300 for (size_t ct = 0; ct < mElementsCount; ct++ ) { 301 free(mElementNames[ct]); 302 } 303 free(mElementNames); 304 free(mElementNameLengths); 305 free(mArraySizes); 306 free(mOffsetInBytes); 307 } 308 if (mVisibleElementMapSize) { 309 free(mVisibleElementMap); 310 } 311 } 312 313 void Element::updateFromNative() { 314 BaseObj::updateFromNative(); 315 updateVisibleSubElements(); 316 } 317 318 android::RSC::sp<const Element> Element::createUser(const android::RSC::sp<RS>& rs, RsDataType dt) { 319 void * id = RS::dispatch->ElementCreate(rs->getContext(), dt, RS_KIND_USER, false, 1); 320 return new Element(id, rs, dt, RS_KIND_USER, false, 1); 321 } 322 323 android::RSC::sp<const Element> Element::createVector(const android::RSC::sp<RS>& rs, RsDataType dt, uint32_t size) { 324 if (size < 2 || size > 4) { 325 rs->throwError(RS_ERROR_INVALID_PARAMETER, "Vector size out of range 2-4."); 326 return nullptr; 327 } 328 void *id = RS::dispatch->ElementCreate(rs->getContext(), dt, RS_KIND_USER, false, size); 329 return new Element(id, rs, dt, RS_KIND_USER, false, size); 330 } 331 332 android::RSC::sp<const Element> Element::createPixel(const android::RSC::sp<RS>& rs, RsDataType dt, RsDataKind dk) { 333 if (!(dk == RS_KIND_PIXEL_L || 334 dk == RS_KIND_PIXEL_A || 335 dk == RS_KIND_PIXEL_LA || 336 dk == RS_KIND_PIXEL_RGB || 337 dk == RS_KIND_PIXEL_RGBA || 338 dk == RS_KIND_PIXEL_DEPTH || 339 dk == RS_KIND_PIXEL_YUV)) { 340 rs->throwError(RS_ERROR_INVALID_PARAMETER, "Unsupported DataKind"); 341 return nullptr; 342 } 343 if (!(dt == RS_TYPE_UNSIGNED_8 || 344 dt == RS_TYPE_UNSIGNED_16 || 345 dt == RS_TYPE_UNSIGNED_5_6_5 || 346 dt == RS_TYPE_UNSIGNED_4_4_4_4 || 347 dt == RS_TYPE_UNSIGNED_5_5_5_1)) { 348 rs->throwError(RS_ERROR_INVALID_PARAMETER, "Unsupported DataType"); 349 return nullptr; 350 } 351 if (dt == RS_TYPE_UNSIGNED_5_6_5 && dk != RS_KIND_PIXEL_RGB) { 352 rs->throwError(RS_ERROR_INVALID_PARAMETER, "Bad kind and type combo"); 353 return nullptr; 354 } 355 if (dt == RS_TYPE_UNSIGNED_5_5_5_1 && dk != RS_KIND_PIXEL_RGBA) { 356 rs->throwError(RS_ERROR_INVALID_PARAMETER, "Bad kind and type combo"); 357 return nullptr; 358 } 359 if (dt == RS_TYPE_UNSIGNED_4_4_4_4 && dk != RS_KIND_PIXEL_RGBA) { 360 rs->throwError(RS_ERROR_INVALID_PARAMETER, "Bad kind and type combo"); 361 return nullptr; 362 } 363 if (dt == RS_TYPE_UNSIGNED_16 && dk != RS_KIND_PIXEL_DEPTH) { 364 rs->throwError(RS_ERROR_INVALID_PARAMETER, "Bad kind and type combo"); 365 return nullptr; 366 } 367 368 int size = 1; 369 switch (dk) { 370 case RS_KIND_PIXEL_LA: 371 size = 2; 372 break; 373 case RS_KIND_PIXEL_RGB: 374 size = 3; 375 break; 376 case RS_KIND_PIXEL_RGBA: 377 size = 4; 378 break; 379 case RS_KIND_PIXEL_DEPTH: 380 size = 2; 381 break; 382 default: 383 break; 384 } 385 386 void * id = RS::dispatch->ElementCreate(rs->getContext(), dt, dk, true, size); 387 return new Element(id, rs, dt, dk, true, size); 388 } 389 390 bool Element::isCompatible(const android::RSC::sp<const Element>&e) const { 391 // Try strict BaseObj equality to start with. 392 if (this == e.get()) { 393 return true; 394 } 395 396 /* 397 * Ignore mKind because it is allowed to be different (user vs. pixel). 398 * We also ignore mNormalized because it can be different. The mType 399 * field must be non-null since we require name equivalence for 400 * user-created Elements. 401 */ 402 return ((mSizeBytes == e->mSizeBytes) && 403 (mType != RS_TYPE_NONE) && 404 (mType == e->mType) && 405 (mVectorSize == e->mVectorSize)); 406 } 407 408 Element::Builder::Builder(android::RSC::sp<RS> rs) { 409 mRS = rs.get(); 410 mSkipPadding = false; 411 mElementsVecSize = 8; 412 mElementsCount = 0; 413 // Initialize space. 414 mElements = (android::RSC::sp<const Element> *)calloc(mElementsVecSize, sizeof(android::RSC::sp<const Element>)); 415 mElementNames = (char **)calloc(mElementsVecSize, sizeof(char *)); 416 mElementNameLengths = (size_t*)calloc(mElementsVecSize, sizeof(size_t)); 417 mArraySizes = (uint32_t*)calloc(mElementsVecSize, sizeof(uint32_t)); 418 } 419 420 Element::Builder::~Builder() { 421 // Free allocated space. 422 free(mElements); 423 for (size_t ct = 0; ct < mElementsCount; ct++ ) { 424 free(mElementNames[ct]); 425 } 426 free(mElementNameLengths); 427 free(mElementNames); 428 free(mArraySizes); 429 } 430 431 void Element::Builder::add(const android::RSC::sp<const Element>&e, const char * name, uint32_t arraySize) { 432 // Skip padding fields after a vector 3 type. 433 if (mSkipPadding) { 434 const char *s1 = "#padding_"; 435 const char *s2 = name; 436 size_t len = strlen(s1); 437 if (strlen(s2) >= len) { 438 if (!memcmp(s1, s2, len)) { 439 mSkipPadding = false; 440 return; 441 } 442 } 443 } 444 445 if (e->mVectorSize == 3) { 446 mSkipPadding = true; 447 } else { 448 mSkipPadding = false; 449 } 450 451 if (mElementsCount >= mElementsVecSize) { 452 // If pre-allocated space is full, allocate a larger one. 453 mElementsVecSize += 8; 454 455 android::RSC::sp<const Element> * newElements = (android::RSC::sp<const Element> *)calloc(mElementsVecSize, sizeof(android::RSC::sp<const Element>)); 456 char ** newElementNames = (char **)calloc(mElementsVecSize, sizeof(char *)); 457 size_t * newElementNameLengths = (size_t*)calloc(mElementsVecSize, sizeof(size_t)); 458 uint32_t * newArraySizes = (uint32_t*)calloc(mElementsVecSize, sizeof(uint32_t)); 459 460 memcpy(newElements, mElements, mElementsCount * sizeof(android::RSC::sp<Element>)); 461 memcpy(newElementNames, mElementNames, mElementsCount * sizeof(char *)); 462 memcpy(newElementNameLengths, mElementNameLengths, mElementsCount * sizeof(size_t)); 463 memcpy(newArraySizes, mArraySizes, mElementsCount * sizeof(uint32_t)); 464 465 // Free the old arrays. 466 free(mElements); 467 free(mElementNames); 468 free(mArraySizes); 469 free(mElementNameLengths); 470 471 mElements = newElements; 472 mElementNames = newElementNames; 473 mArraySizes = newArraySizes; 474 mElementNameLengths = newElementNameLengths; 475 } 476 mElements[mElementsCount] = e; 477 mArraySizes[mElementsCount] = arraySize; 478 479 size_t nameLen = strlen(name); 480 mElementNameLengths[mElementsCount] = nameLen + 1; 481 mElementNames[mElementsCount] = (char *)calloc(nameLen + 1, sizeof(char)); 482 memcpy(mElementNames[mElementsCount], name, nameLen); 483 mElementNames[mElementsCount][nameLen] = 0; 484 485 mElementsCount++; 486 } 487 488 android::RSC::sp<const Element> Element::Builder::create() { 489 size_t fieldCount = mElementsCount; 490 void ** elementArray = (void **)calloc(fieldCount, sizeof(void *)); 491 492 for (size_t ct = 0; ct < fieldCount; ct++) { 493 elementArray[ct] = mElements[ct]->getID(); 494 } 495 496 void *id = RS::dispatch->ElementCreate2(mRS->getContext(), 497 (RsElement *)elementArray, fieldCount, 498 (const char **)mElementNames, fieldCount, mElementNameLengths, 499 mArraySizes, fieldCount); 500 free(elementArray); 501 return new Element(id, mRS, mElements, mElementsCount, (const char **)mElementNames, mElementNameLengths, mArraySizes); 502 } 503
