1 /* 2 * Copyright (C) 2009 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 18 #include "rsContext.h" 19 20 using namespace android; 21 using namespace android::renderscript; 22 23 24 Element::Element(Context *rsc) : ObjectBase(rsc) { 25 mBits = 0; 26 mBitsUnpadded = 0; 27 mFields = NULL; 28 mFieldCount = 0; 29 mHasReference = false; 30 memset(&mHal, 0, sizeof(mHal)); 31 } 32 33 Element::~Element() { 34 clear(); 35 } 36 37 void Element::preDestroy() const { 38 for (uint32_t ct = 0; ct < mRSC->mStateElement.mElements.size(); ct++) { 39 if (mRSC->mStateElement.mElements[ct] == this) { 40 mRSC->mStateElement.mElements.removeAt(ct); 41 break; 42 } 43 } 44 } 45 46 void Element::clear() { 47 delete [] mFields; 48 mFields = NULL; 49 mFieldCount = 0; 50 mHasReference = false; 51 52 delete [] mHal.state.fields; 53 delete [] mHal.state.fieldArraySizes; 54 delete [] mHal.state.fieldNames; 55 delete [] mHal.state.fieldNameLengths; 56 delete [] mHal.state.fieldOffsetBytes; 57 } 58 59 size_t Element::getSizeBits() const { 60 if (!mFieldCount) { 61 return mBits; 62 } 63 64 size_t total = 0; 65 for (size_t ct=0; ct < mFieldCount; ct++) { 66 total += mFields[ct].e->mBits * mFields[ct].arraySize; 67 } 68 return total; 69 } 70 71 size_t Element::getSizeBitsUnpadded() const { 72 if (!mFieldCount) { 73 return mBitsUnpadded; 74 } 75 76 size_t total = 0; 77 for (size_t ct=0; ct < mFieldCount; ct++) { 78 total += mFields[ct].e->mBitsUnpadded * mFields[ct].arraySize; 79 } 80 return total; 81 } 82 83 void Element::dumpLOGV(const char *prefix) const { 84 ObjectBase::dumpLOGV(prefix); 85 ALOGV("%s Element: fieldCount: %zu, size bytes: %zu", prefix, mFieldCount, getSizeBytes()); 86 mComponent.dumpLOGV(prefix); 87 for (uint32_t ct = 0; ct < mFieldCount; ct++) { 88 ALOGV("%s Element field index: %u ------------------", prefix, ct); 89 ALOGV("%s name: %s, offsetBits: %u, arraySize: %u", 90 prefix, mFields[ct].name.string(), mFields[ct].offsetBits, mFields[ct].arraySize); 91 mFields[ct].e->dumpLOGV(prefix); 92 } 93 } 94 95 void Element::serialize(Context *rsc, OStream *stream) const { 96 // Need to identify ourselves 97 stream->addU32((uint32_t)getClassId()); 98 99 String8 name(getName()); 100 stream->addString(&name); 101 102 mComponent.serialize(stream); 103 104 // Now serialize all the fields 105 stream->addU32(mFieldCount); 106 for (uint32_t ct = 0; ct < mFieldCount; ct++) { 107 stream->addString(&mFields[ct].name); 108 stream->addU32(mFields[ct].arraySize); 109 mFields[ct].e->serialize(rsc, stream); 110 } 111 } 112 113 Element *Element::createFromStream(Context *rsc, IStream *stream) { 114 // First make sure we are reading the correct object 115 RsA3DClassID classID = (RsA3DClassID)stream->loadU32(); 116 if (classID != RS_A3D_CLASS_ID_ELEMENT) { 117 ALOGE("element loading skipped due to invalid class id\n"); 118 return NULL; 119 } 120 121 String8 name; 122 stream->loadString(&name); 123 124 Component component; 125 component.loadFromStream(stream); 126 127 uint32_t fieldCount = stream->loadU32(); 128 if (!fieldCount) { 129 return (Element *)Element::create(rsc, 130 component.getType(), 131 component.getKind(), 132 component.getIsNormalized(), 133 component.getVectorSize()); 134 } 135 136 const Element **subElems = new const Element *[fieldCount]; 137 const char **subElemNames = new const char *[fieldCount]; 138 size_t *subElemNamesLengths = new size_t[fieldCount]; 139 uint32_t *arraySizes = new uint32_t[fieldCount]; 140 141 String8 elemName; 142 for (uint32_t ct = 0; ct < fieldCount; ct ++) { 143 stream->loadString(&elemName); 144 subElemNamesLengths[ct] = elemName.length(); 145 char *tmpName = new char[subElemNamesLengths[ct]]; 146 memcpy(tmpName, elemName.string(), subElemNamesLengths[ct]); 147 subElemNames[ct] = tmpName; 148 arraySizes[ct] = stream->loadU32(); 149 subElems[ct] = Element::createFromStream(rsc, stream); 150 } 151 152 const Element *elem = Element::create(rsc, fieldCount, subElems, subElemNames, 153 subElemNamesLengths, arraySizes); 154 for (uint32_t ct = 0; ct < fieldCount; ct ++) { 155 delete [] subElemNames[ct]; 156 subElems[ct]->decUserRef(); 157 } 158 delete[] subElems; 159 delete[] subElemNames; 160 delete[] subElemNamesLengths; 161 delete[] arraySizes; 162 163 return (Element *)elem; 164 } 165 166 void Element::compute() { 167 mHal.state.dataType = mComponent.getType(); 168 mHal.state.dataKind = mComponent.getKind(); 169 mHal.state.vectorSize = mComponent.getVectorSize(); 170 171 if (mFieldCount == 0) { 172 mBits = mComponent.getBits(); 173 mBitsUnpadded = mComponent.getBitsUnpadded(); 174 mHasReference = mComponent.isReference(); 175 176 mHal.state.elementSizeBytes = getSizeBytes(); 177 return; 178 } 179 180 uint32_t noPaddingFieldCount = 0; 181 for (uint32_t ct = 0; ct < mFieldCount; ct ++) { 182 if (mFields[ct].name.string()[0] != '#') { 183 noPaddingFieldCount ++; 184 } 185 } 186 187 mHal.state.fields = new const Element*[noPaddingFieldCount]; 188 mHal.state.fieldArraySizes = new uint32_t[noPaddingFieldCount]; 189 mHal.state.fieldNames = new const char*[noPaddingFieldCount]; 190 mHal.state.fieldNameLengths = new uint32_t[noPaddingFieldCount]; 191 mHal.state.fieldOffsetBytes = new uint32_t[noPaddingFieldCount]; 192 mHal.state.fieldsCount = noPaddingFieldCount; 193 194 size_t bits = 0; 195 size_t bitsUnpadded = 0; 196 for (size_t ct = 0, ctNoPadding = 0; ct < mFieldCount; ct++) { 197 mFields[ct].offsetBits = bits; 198 mFields[ct].offsetBitsUnpadded = bitsUnpadded; 199 bits += mFields[ct].e->getSizeBits() * mFields[ct].arraySize; 200 bitsUnpadded += mFields[ct].e->getSizeBitsUnpadded() * mFields[ct].arraySize; 201 202 if (mFields[ct].e->mHasReference) { 203 mHasReference = true; 204 } 205 206 if (mFields[ct].name.string()[0] == '#') { 207 continue; 208 } 209 210 mHal.state.fields[ctNoPadding] = mFields[ct].e.get(); 211 mHal.state.fieldArraySizes[ctNoPadding] = mFields[ct].arraySize; 212 mHal.state.fieldNames[ctNoPadding] = mFields[ct].name.string(); 213 mHal.state.fieldNameLengths[ctNoPadding] = mFields[ct].name.length() + 1; // to include 0 214 mHal.state.fieldOffsetBytes[ctNoPadding] = mFields[ct].offsetBits >> 3; 215 216 ctNoPadding ++; 217 } 218 219 mHal.state.elementSizeBytes = getSizeBytes(); 220 } 221 222 ObjectBaseRef<const Element> Element::createRef(Context *rsc, RsDataType dt, RsDataKind dk, 223 bool isNorm, uint32_t vecSize) { 224 ObjectBaseRef<const Element> returnRef; 225 // Look for an existing match. 226 ObjectBase::asyncLock(); 227 for (uint32_t ct=0; ct < rsc->mStateElement.mElements.size(); ct++) { 228 const Element *ee = rsc->mStateElement.mElements[ct]; 229 if (!ee->getFieldCount() && 230 (ee->getComponent().getType() == dt) && 231 (ee->getComponent().getKind() == dk) && 232 (ee->getComponent().getIsNormalized() == isNorm) && 233 (ee->getComponent().getVectorSize() == vecSize)) { 234 // Match 235 returnRef.set(ee); 236 ObjectBase::asyncUnlock(); 237 return ee; 238 } 239 } 240 ObjectBase::asyncUnlock(); 241 242 Element *e = new Element(rsc); 243 returnRef.set(e); 244 e->mComponent.set(dt, dk, isNorm, vecSize); 245 e->compute(); 246 247 ObjectBase::asyncLock(); 248 rsc->mStateElement.mElements.push(e); 249 ObjectBase::asyncUnlock(); 250 251 return returnRef; 252 } 253 254 ObjectBaseRef<const Element> Element::createRef(Context *rsc, size_t count, const Element **ein, 255 const char **nin, const size_t * lengths, const uint32_t *asin) { 256 257 ObjectBaseRef<const Element> returnRef; 258 // Look for an existing match. 259 ObjectBase::asyncLock(); 260 for (uint32_t ct=0; ct < rsc->mStateElement.mElements.size(); ct++) { 261 const Element *ee = rsc->mStateElement.mElements[ct]; 262 if (ee->getFieldCount() == count) { 263 bool match = true; 264 for (uint32_t i=0; i < count; i++) { 265 if ((ee->mFields[i].e.get() != ein[i]) || 266 (ee->mFields[i].name.length() != lengths[i]) || 267 (ee->mFields[i].name != nin[i]) || 268 (ee->mFields[i].arraySize != asin[i])) { 269 match = false; 270 break; 271 } 272 } 273 if (match) { 274 returnRef.set(ee); 275 ObjectBase::asyncUnlock(); 276 return returnRef; 277 } 278 } 279 } 280 ObjectBase::asyncUnlock(); 281 282 Element *e = new Element(rsc); 283 returnRef.set(e); 284 e->mFields = new ElementField_t [count]; 285 e->mFieldCount = count; 286 for (size_t ct=0; ct < count; ct++) { 287 e->mFields[ct].e.set(ein[ct]); 288 e->mFields[ct].name.setTo(nin[ct], lengths[ct]); 289 e->mFields[ct].arraySize = asin[ct]; 290 } 291 e->compute(); 292 293 ObjectBase::asyncLock(); 294 rsc->mStateElement.mElements.push(e); 295 ObjectBase::asyncUnlock(); 296 297 return returnRef; 298 } 299 300 void Element::incRefs(const void *ptr) const { 301 if (!mFieldCount) { 302 if (mComponent.isReference()) { 303 ObjectBase *const*obp = static_cast<ObjectBase *const*>(ptr); 304 ObjectBase *ob = obp[0]; 305 if (ob) ob->incSysRef(); 306 } 307 return; 308 } 309 310 const uint8_t *p = static_cast<const uint8_t *>(ptr); 311 for (uint32_t i=0; i < mFieldCount; i++) { 312 if (mFields[i].e->mHasReference) { 313 const uint8_t *p2 = &p[mFields[i].offsetBits >> 3]; 314 for (uint32_t ct=0; ct < mFields[i].arraySize; ct++) { 315 mFields[i].e->incRefs(p2); 316 p2 += mFields[i].e->getSizeBytes(); 317 } 318 } 319 } 320 } 321 322 void Element::decRefs(const void *ptr) const { 323 if (!mFieldCount) { 324 if (mComponent.isReference()) { 325 ObjectBase *const*obp = static_cast<ObjectBase *const*>(ptr); 326 ObjectBase *ob = obp[0]; 327 if (ob) ob->decSysRef(); 328 } 329 return; 330 } 331 332 const uint8_t *p = static_cast<const uint8_t *>(ptr); 333 for (uint32_t i=0; i < mFieldCount; i++) { 334 if (mFields[i].e->mHasReference) { 335 const uint8_t *p2 = &p[mFields[i].offsetBits >> 3]; 336 for (uint32_t ct=0; ct < mFields[i].arraySize; ct++) { 337 mFields[i].e->decRefs(p2); 338 p2 += mFields[i].e->getSizeBytes(); 339 } 340 } 341 } 342 } 343 344 Element::Builder::Builder() { 345 const uint32_t initialCapacity = 32; 346 mBuilderElementRefs.setCapacity(initialCapacity); 347 mBuilderElements.setCapacity(initialCapacity); 348 mBuilderNameStrings.setCapacity(initialCapacity); 349 mBuilderNameLengths.setCapacity(initialCapacity); 350 mBuilderArrays.setCapacity(initialCapacity); 351 } 352 353 void Element::Builder::add(const Element *e, const char *nameStr, uint32_t arraySize) { 354 mBuilderElementRefs.push(ObjectBaseRef<const Element>(e)); 355 mBuilderElements.push(e); 356 mBuilderNameStrings.push(nameStr); 357 mBuilderNameLengths.push(strlen(nameStr)); 358 mBuilderArrays.push(arraySize); 359 360 } 361 362 ObjectBaseRef<const Element> Element::Builder::create(Context *rsc) { 363 return Element::createRef(rsc, mBuilderElements.size(), 364 &(mBuilderElements.editArray()[0]), 365 &(mBuilderNameStrings.editArray()[0]), 366 mBuilderNameLengths.editArray(), 367 mBuilderArrays.editArray()); 368 } 369 370 371 ElementState::ElementState() { 372 } 373 374 ElementState::~ElementState() { 375 rsAssert(!mElements.size()); 376 } 377 378 ///////////////////////////////////////// 379 // 380 381 namespace android { 382 namespace renderscript { 383 384 RsElement rsi_ElementCreate(Context *rsc, 385 RsDataType dt, 386 RsDataKind dk, 387 bool norm, 388 uint32_t vecSize) { 389 return (RsElement)Element::create(rsc, dt, dk, norm, vecSize); 390 } 391 392 393 RsElement rsi_ElementCreate2(Context *rsc, 394 const RsElement * ein, 395 size_t ein_length, 396 397 const char ** names, 398 size_t nameLengths_length, 399 const size_t * nameLengths, 400 401 const uint32_t * arraySizes, 402 size_t arraySizes_length) { 403 return (RsElement)Element::create(rsc, ein_length, (const Element **)ein, 404 names, nameLengths, arraySizes); 405 } 406 407 } 408 } 409 410 void rsaElementGetNativeData(RsContext con, RsElement elem, 411 uint32_t *elemData, uint32_t elemDataSize) { 412 rsAssert(elemDataSize == 5); 413 // we will pack mType; mKind; mNormalized; mVectorSize; NumSubElements 414 Element *e = static_cast<Element *>(elem); 415 416 (*elemData++) = (uint32_t)e->getType(); 417 (*elemData++) = (uint32_t)e->getKind(); 418 (*elemData++) = e->getComponent().getIsNormalized() ? 1 : 0; 419 (*elemData++) = e->getComponent().getVectorSize(); 420 (*elemData++) = e->getFieldCount(); 421 } 422 423 void rsaElementGetSubElements(RsContext con, RsElement elem, uint32_t *ids, 424 const char **names, uint32_t *arraySizes, uint32_t dataSize) { 425 Element *e = static_cast<Element *>(elem); 426 rsAssert(e->getFieldCount() == dataSize); 427 428 for (uint32_t i = 0; i < dataSize; i ++) { 429 e->getField(i)->incUserRef(); 430 ids[i] = (uint32_t)e->getField(i); 431 names[i] = e->getFieldName(i); 432 arraySizes[i] = e->getFieldArraySize(i); 433 } 434 } 435