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