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