diff options
Diffstat (limited to 'libs/rs/rsElement.cpp')
| -rw-r--r-- | libs/rs/rsElement.cpp | 267 |
1 files changed, 215 insertions, 52 deletions
diff --git a/libs/rs/rsElement.cpp b/libs/rs/rsElement.cpp index 6288bc4..0b9e28c 100644 --- a/libs/rs/rsElement.cpp +++ b/libs/rs/rsElement.cpp @@ -14,9 +14,14 @@ * limitations under the License. */ -#include "rsContext.h" +#ifndef ANDROID_RS_BUILD_FOR_HOST +#include "rsContext.h" #include <GLES/gl.h> +#else +#include "rsContextHostStub.h" +#include <OpenGL/gl.h> +#endif using namespace android; using namespace android::renderscript; @@ -29,6 +34,7 @@ Element::Element(Context *rsc) : ObjectBase(rsc) mAllocLine = __LINE__; mFields = NULL; mFieldCount = 0; + mHasReference = false; } @@ -48,6 +54,7 @@ void Element::clear() delete [] mFields; mFields = NULL; mFieldCount = 0; + mHasReference = false; } size_t Element::getSizeBits() const @@ -58,20 +65,11 @@ size_t Element::getSizeBits() const size_t total = 0; for (size_t ct=0; ct < mFieldCount; ct++) { - total += mFields[ct].e->mBits; + total += mFields[ct].e->mBits * mFields[ct].arraySize;; } return total; } -size_t Element::getFieldOffsetBits(uint32_t componentNumber) const -{ - size_t offset = 0; - for (uint32_t ct = 0; ct < componentNumber; ct++) { - offset += mFields[ct].e->mBits; - } - return offset; -} - void Element::dumpLOGV(const char *prefix) const { ObjectBase::dumpLOGV(prefix); @@ -83,6 +81,100 @@ void Element::dumpLOGV(const char *prefix) const } } +void Element::serialize(OStream *stream) const +{ + // Need to identify ourselves + stream->addU32((uint32_t)getClassId()); + + String8 name(getName()); + stream->addString(&name); + + mComponent.serialize(stream); + + // Now serialize all the fields + stream->addU32(mFieldCount); + for(uint32_t ct = 0; ct < mFieldCount; ct++) { + stream->addString(&mFields[ct].name); + stream->addU32(mFields[ct].arraySize); + mFields[ct].e->serialize(stream); + } +} + +Element *Element::createFromStream(Context *rsc, IStream *stream) +{ + // First make sure we are reading the correct object + RsA3DClassID classID = (RsA3DClassID)stream->loadU32(); + if(classID != RS_A3D_CLASS_ID_ELEMENT) { + LOGE("element loading skipped due to invalid class id\n"); + return NULL; + } + + String8 name; + stream->loadString(&name); + + Element *elem = new Element(rsc); + elem->mComponent.loadFromStream(stream); + elem->mBits = elem->mComponent.getBits(); + elem->mHasReference = elem->mComponent.isReference(); + + elem->mFieldCount = stream->loadU32(); + if(elem->mFieldCount) { + uint32_t offset = 0; + elem->mFields = new ElementField_t [elem->mFieldCount]; + for(uint32_t ct = 0; ct < elem->mFieldCount; ct ++) { + stream->loadString(&elem->mFields[ct].name); + elem->mFields[ct].arraySize = stream->loadU32(); + Element *fieldElem = Element::createFromStream(rsc, stream); + elem->mFields[ct].e.set(fieldElem); + elem->mFields[ct].offsetBits = offset; + offset += fieldElem->getSizeBits(); + // Check if our sub-elements have references + if(fieldElem->mHasReference) { + elem->mHasReference = true; + } + } + } + + // We need to check if this already exists + for (uint32_t ct=0; ct < rsc->mStateElement.mElements.size(); ct++) { + Element *ee = rsc->mStateElement.mElements[ct]; + if(ee->isEqual(elem)) { + delete elem; + ee->incUserRef(); + return ee; + } + } + + rsc->mStateElement.mElements.push(elem); + return elem; +} + +bool Element::isEqual(const Element *other) const { + if(other == NULL) { + return false; + } + if (!other->getFieldCount() && !mFieldCount) { + if((other->getType() == getType()) && + (other->getKind() == getKind()) && + (other->getComponent().getIsNormalized() == getComponent().getIsNormalized()) && + (other->getComponent().getVectorSize() == getComponent().getVectorSize())) { + return true; + } + return false; + } + if (other->getFieldCount() == mFieldCount) { + for (uint32_t i=0; i < mFieldCount; i++) { + if ((!other->mFields[i].e->isEqual(mFields[i].e.get())) || + (other->mFields[i].name.length() != mFields[i].name.length()) || + (other->mFields[i].name != mFields[i].name) || + (other->mFields[i].arraySize != mFields[i].arraySize)) { + return false; + } + } + return true; + } + return false; +} const Element * Element::create(Context *rsc, RsDataType dt, RsDataKind dk, bool isNorm, uint32_t vecSize) @@ -104,12 +196,13 @@ const Element * Element::create(Context *rsc, RsDataType dt, RsDataKind dk, Element *e = new Element(rsc); e->mComponent.set(dt, dk, isNorm, vecSize); e->mBits = e->mComponent.getBits(); + e->mHasReference = e->mComponent.isReference(); rsc->mStateElement.mElements.push(e); return e; } const Element * Element::create(Context *rsc, size_t count, const Element **ein, - const char **nin, const size_t * lengths) + const char **nin, const size_t * lengths, const uint32_t *asin) { // Look for an existing match. for (uint32_t ct=0; ct < rsc->mStateElement.mElements.size(); ct++) { @@ -119,7 +212,8 @@ const Element * Element::create(Context *rsc, size_t count, const Element **ein, for (uint32_t i=0; i < count; i++) { if ((ee->mFields[i].e.get() != ein[i]) || (ee->mFields[i].name.length() != lengths[i]) || - (ee->mFields[i].name != nin[i])) { + (ee->mFields[i].name != nin[i]) || + (ee->mFields[i].arraySize != asin[i])) { match = false; break; } @@ -134,37 +228,24 @@ const Element * Element::create(Context *rsc, size_t count, const Element **ein, Element *e = new Element(rsc); e->mFields = new ElementField_t [count]; e->mFieldCount = count; + size_t bits = 0; for (size_t ct=0; ct < count; ct++) { e->mFields[ct].e.set(ein[ct]); e->mFields[ct].name.setTo(nin[ct], lengths[ct]); + e->mFields[ct].offsetBits = bits; + e->mFields[ct].arraySize = asin[ct]; + bits += ein[ct]->getSizeBits(); + + if (ein[ct]->mHasReference) { + e->mHasReference = true; + } } rsc->mStateElement.mElements.push(e); return e; } -String8 Element::getCStructBody(uint32_t indent) const -{ - String8 si; - for (uint32_t ct=0; ct < indent; ct++) { - si.append(" "); - } - - String8 s(si); - s.append("{\n"); - for (uint32_t ct = 0; ct < mFieldCount; ct++) { - s.append(si); - s.append(mFields[ct].e->getCType(indent+4)); - s.append(" "); - s.append(mFields[ct].name); - s.append(";\n"); - } - s.append(si); - s.append("}"); - return s; -} - -String8 Element::getCType(uint32_t indent) const +String8 Element::getGLSLType(uint32_t indent) const { String8 s; for (uint32_t ct=0; ct < indent; ct++) { @@ -173,38 +254,70 @@ String8 Element::getCType(uint32_t indent) const if (!mFieldCount) { // Basic component. - s.append(mComponent.getCType()); + s.append(mComponent.getGLSLType()); } else { - s.append("struct "); - s.append(getCStructBody(indent)); + rsAssert(0); + //s.append("struct "); + //s.append(getCStructBody(indent)); } return s; } -String8 Element::getGLSLType(uint32_t indent) const +void Element::incRefs(const void *ptr) const { - String8 s; - for (uint32_t ct=0; ct < indent; ct++) { - s.append(" "); + if (!mFieldCount) { + if (mComponent.isReference()) { + ObjectBase *const*obp = static_cast<ObjectBase *const*>(ptr); + ObjectBase *ob = obp[0]; + if (ob) ob->incSysRef(); + } + return; + } + + const uint8_t *p = static_cast<const uint8_t *>(ptr); + for (uint32_t i=0; i < mFieldCount; i++) { + if (mFields[i].e->mHasReference) { + p = &p[mFields[i].offsetBits >> 3]; + for (uint32_t ct=0; ct < mFields[i].arraySize; ct++) { + mFields[i].e->incRefs(p); + p += mFields[i].e->getSizeBytes(); + } + } } +} +void Element::decRefs(const void *ptr) const +{ if (!mFieldCount) { - // Basic component. - s.append(mComponent.getGLSLType()); - } else { - rsAssert(0); - //s.append("struct "); - //s.append(getCStructBody(indent)); + if (mComponent.isReference()) { + ObjectBase *const*obp = static_cast<ObjectBase *const*>(ptr); + ObjectBase *ob = obp[0]; + if (ob) ob->decSysRef(); + } + return; } - return s; + const uint8_t *p = static_cast<const uint8_t *>(ptr); + for (uint32_t i=0; i < mFieldCount; i++) { + if (mFields[i].e->mHasReference) { + p = &p[mFields[i].offsetBits >> 3]; + for (uint32_t ct=0; ct < mFields[i].arraySize; ct++) { + mFields[i].e->decRefs(p); + p += mFields[i].e->getSizeBytes(); + } + } + } } - ElementState::ElementState() { + const uint32_t initialCapacity = 32; + mBuilderElements.setCapacity(initialCapacity); + mBuilderNameStrings.setCapacity(initialCapacity); + mBuilderNameLengths.setCapacity(initialCapacity); + mBuilderArrays.setCapacity(initialCapacity); } ElementState::~ElementState() @@ -212,6 +325,29 @@ ElementState::~ElementState() rsAssert(!mElements.size()); } +void ElementState::elementBuilderBegin() { + mBuilderElements.clear(); + mBuilderNameStrings.clear(); + mBuilderNameLengths.clear(); + mBuilderArrays.clear(); +} + +void ElementState::elementBuilderAdd(const Element *e, const char *nameStr, uint32_t arraySize) { + mBuilderElements.push(e); + mBuilderNameStrings.push(nameStr); + mBuilderNameLengths.push(strlen(nameStr)); + mBuilderArrays.push(arraySize); + +} + +const Element *ElementState::elementBuilderCreate(Context *rsc) { + return Element::create(rsc, mBuilderElements.size(), + &(mBuilderElements.editArray()[0]), + &(mBuilderNameStrings.editArray()[0]), + mBuilderNameLengths.editArray(), + mBuilderArrays.editArray()); +} + ///////////////////////////////////////// // @@ -235,14 +371,41 @@ RsElement rsi_ElementCreate2(Context *rsc, size_t count, const RsElement * ein, const char ** names, - const size_t * nameLengths) + const size_t * nameLengths, + const uint32_t * arraySizes) { //LOGE("rsi_ElementCreate2 %i", count); - const Element *e = Element::create(rsc, count, (const Element **)ein, names, nameLengths); + const Element *e = Element::create(rsc, count, (const Element **)ein, names, nameLengths, arraySizes); e->incUserRef(); return (RsElement)e; } +void rsi_ElementGetNativeData(Context *rsc, RsElement elem, uint32_t *elemData, uint32_t elemDataSize) +{ + rsAssert(elemDataSize == 5); + // we will pack mType; mKind; mNormalized; mVectorSize; NumSubElements + Element *e = static_cast<Element *>(elem); + + (*elemData++) = (uint32_t)e->getType(); + (*elemData++) = (uint32_t)e->getKind(); + (*elemData++) = e->getComponent().getIsNormalized() ? 1 : 0; + (*elemData++) = e->getComponent().getVectorSize(); + (*elemData++) = e->getFieldCount(); + +} + +void rsi_ElementGetSubElements(Context *rsc, RsElement elem, uint32_t *ids, const char **names, uint32_t dataSize) +{ + Element *e = static_cast<Element *>(elem); + rsAssert(e->getFieldCount() == dataSize); + + for(uint32_t i = 0; i < dataSize; i ++) { + ids[i] = (uint32_t)e->getField(i); + names[i] = e->getFieldName(i); + } + +} + } } |