diff options
Diffstat (limited to 'libs/rs/rsAllocation.cpp')
| -rw-r--r-- | libs/rs/rsAllocation.cpp | 685 |
1 files changed, 500 insertions, 185 deletions
diff --git a/libs/rs/rsAllocation.cpp b/libs/rs/rsAllocation.cpp index 4e8278d..4ade714 100644 --- a/libs/rs/rsAllocation.cpp +++ b/libs/rs/rsAllocation.cpp @@ -13,21 +13,31 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - +#ifndef ANDROID_RS_BUILD_FOR_HOST #include "rsContext.h" #include <GLES/gl.h> #include <GLES2/gl2.h> #include <GLES/glext.h> +#else +#include "rsContextHostStub.h" + +#include <OpenGL/gl.h> +#include <OpenGl/glext.h> +#endif + +#include "utils/StopWatch.h" using namespace android; using namespace android::renderscript; -Allocation::Allocation(Context *rsc, const Type *type) : ObjectBase(rsc) -{ +Allocation::Allocation(Context *rsc, const Type *type) : ObjectBase(rsc) { init(rsc, type); mPtr = malloc(mType->getSizeBytes()); + if (mType->getElement()->getHasReferences()) { + memset(mPtr, 0, mType->getSizeBytes()); + } if (!mPtr) { LOGE("Allocation::Allocation, alloc failure"); } @@ -35,8 +45,7 @@ Allocation::Allocation(Context *rsc, const Type *type) : ObjectBase(rsc) Allocation::Allocation(Context *rsc, const Type *type, void *bmp, void *callbackData, RsBitmapCallback_t callback) -: ObjectBase(rsc) -{ + : ObjectBase(rsc) { init(rsc, type); mPtr = bmp; @@ -44,10 +53,7 @@ Allocation::Allocation(Context *rsc, const Type *type, void *bmp, mUserBitmapCallbackData = callbackData; } -void Allocation::init(Context *rsc, const Type *type) -{ - mAllocFile = __FILE__; - mAllocLine = __LINE__; +void Allocation::init(Context *rsc, const Type *type) { mPtr = NULL; mCpuWrite = false; @@ -73,8 +79,7 @@ void Allocation::init(Context *rsc, const Type *type) mPtr = NULL; } -Allocation::~Allocation() -{ +Allocation::~Allocation() { if (mUserBitmapCallback != NULL) { mUserBitmapCallback(mUserBitmapCallbackData); } else { @@ -94,29 +99,23 @@ Allocation::~Allocation() } } -void Allocation::setCpuWritable(bool) -{ +void Allocation::setCpuWritable(bool) { } -void Allocation::setGpuWritable(bool) -{ +void Allocation::setGpuWritable(bool) { } -void Allocation::setCpuReadable(bool) -{ +void Allocation::setCpuReadable(bool) { } -void Allocation::setGpuReadable(bool) -{ +void Allocation::setGpuReadable(bool) { } -bool Allocation::fixAllocation() -{ +bool Allocation::fixAllocation() { return false; } -void Allocation::deferedUploadToTexture(const Context *rsc, bool genMipmap, uint32_t lodOffset) -{ +void Allocation::deferedUploadToTexture(const Context *rsc, bool genMipmap, uint32_t lodOffset) { rsAssert(lodOffset < mType->getLODCount()); mIsTexture = true; mTextureLOD = lodOffset; @@ -124,9 +123,22 @@ void Allocation::deferedUploadToTexture(const Context *rsc, bool genMipmap, uint mTextureGenMipmap = !mType->getDimLOD() && genMipmap; } -void Allocation::uploadToTexture(const Context *rsc) -{ - //rsAssert(!mTextureId); +uint32_t Allocation::getGLTarget() const { + if (mIsTexture) { + if (mType->getDimFaces()) { + return GL_TEXTURE_CUBE_MAP; + } else { + return GL_TEXTURE_2D; + } + } + if (mIsVertexBuffer) { + return GL_ARRAY_BUFFER; + } + return 0; +} + + +void Allocation::uploadToTexture(const Context *rsc) { mIsTexture = true; if (!rsc->checkDriver()) { @@ -141,6 +153,8 @@ void Allocation::uploadToTexture(const Context *rsc) return; } + bool isFirstUpload = false; + if (!mTextureID) { glGenTextures(1, &mTextureID); @@ -153,33 +167,90 @@ void Allocation::uploadToTexture(const Context *rsc) mUploadDefered = true; return; } + isFirstUpload = true; } - glBindTexture(GL_TEXTURE_2D, mTextureID); + + GLenum target = (GLenum)getGLTarget(); + glBindTexture(target, mTextureID); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + if (target == GL_TEXTURE_2D) { + upload2DTexture(isFirstUpload); + } else if (target == GL_TEXTURE_CUBE_MAP) { + uploadCubeTexture(isFirstUpload); + } + + if (mTextureGenMipmap) { +#ifndef ANDROID_RS_BUILD_FOR_HOST + glGenerateMipmap(target); +#endif //ANDROID_RS_BUILD_FOR_HOST + } + + rsc->checkError("Allocation::uploadToTexture"); +} + +void Allocation::upload2DTexture(bool isFirstUpload) { + GLenum type = mType->getElement()->getComponent().getGLType(); + GLenum format = mType->getElement()->getComponent().getGLFormat(); + Adapter2D adapt(getContext(), this); - for(uint32_t lod = 0; (lod + mTextureLOD) < mType->getLODCount(); lod++) { + for (uint32_t lod = 0; (lod + mTextureLOD) < mType->getLODCount(); lod++) { adapt.setLOD(lod+mTextureLOD); uint16_t * ptr = static_cast<uint16_t *>(adapt.getElement(0,0)); - glTexImage2D(GL_TEXTURE_2D, lod, format, - adapt.getDimX(), adapt.getDimY(), - 0, format, type, ptr); - } - if (mTextureGenMipmap) { - glGenerateMipmap(GL_TEXTURE_2D); + if (isFirstUpload) { + glTexImage2D(GL_TEXTURE_2D, lod, format, + adapt.getDimX(), adapt.getDimY(), + 0, format, type, ptr); + } else { + glTexSubImage2D(GL_TEXTURE_2D, lod, 0, 0, + adapt.getDimX(), adapt.getDimY(), + format, type, ptr); + } } +} + +void Allocation::uploadCubeTexture(bool isFirstUpload) { + GLenum type = mType->getElement()->getComponent().getGLType(); + GLenum format = mType->getElement()->getComponent().getGLFormat(); + GLenum faceOrder[] = { + GL_TEXTURE_CUBE_MAP_POSITIVE_X, + GL_TEXTURE_CUBE_MAP_NEGATIVE_X, + GL_TEXTURE_CUBE_MAP_POSITIVE_Y, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, + GL_TEXTURE_CUBE_MAP_POSITIVE_Z, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z + }; + + Adapter2D adapt(getContext(), this); + for (uint32_t face = 0; face < 6; face ++) { + adapt.setFace(face); + + for (uint32_t lod = 0; (lod + mTextureLOD) < mType->getLODCount(); lod++) { + adapt.setLOD(lod+mTextureLOD); + + uint16_t * ptr = static_cast<uint16_t *>(adapt.getElement(0,0)); + + if (isFirstUpload) { + glTexImage2D(faceOrder[face], lod, format, + adapt.getDimX(), adapt.getDimY(), + 0, format, type, ptr); + } else { + glTexSubImage2D(faceOrder[face], lod, 0, 0, + adapt.getDimX(), adapt.getDimY(), + format, type, ptr); + } + } + } } -void Allocation::deferedUploadToBufferObject(const Context *rsc) -{ +void Allocation::deferedUploadToBufferObject(const Context *rsc) { mIsVertexBuffer = true; mUploadDefered = true; } -void Allocation::uploadToBufferObject(const Context *rsc) -{ +void Allocation::uploadToBufferObject(const Context *rsc) { rsAssert(!mType->getDimY()); rsAssert(!mType->getDimZ()); @@ -197,14 +268,14 @@ void Allocation::uploadToBufferObject(const Context *rsc) mUploadDefered = true; return; } - - glBindBuffer(GL_ARRAY_BUFFER, mBufferID); - glBufferData(GL_ARRAY_BUFFER, mType->getSizeBytes(), getPtr(), GL_DYNAMIC_DRAW); - glBindBuffer(GL_ARRAY_BUFFER, 0); + GLenum target = (GLenum)getGLTarget(); + glBindBuffer(target, mBufferID); + glBufferData(target, mType->getSizeBytes(), getPtr(), GL_DYNAMIC_DRAW); + glBindBuffer(target, 0); + rsc->checkError("Allocation::uploadToBufferObject"); } -void Allocation::uploadCheck(const Context *rsc) -{ +void Allocation::uploadCheck(const Context *rsc) { if (mUploadDefered) { mUploadDefered = false; if (mIsVertexBuffer) { @@ -217,25 +288,28 @@ void Allocation::uploadCheck(const Context *rsc) } -void Allocation::data(const void *data, uint32_t sizeBytes) -{ +void Allocation::data(Context *rsc, const void *data, uint32_t sizeBytes) { uint32_t size = mType->getSizeBytes(); if (size != sizeBytes) { LOGE("Allocation::data called with mismatched size expected %i, got %i", size, sizeBytes); return; } + + if (mType->getElement()->getHasReferences()) { + incRefs(data, sizeBytes / mType->getElement()->getSizeBytes()); + decRefs(mPtr, sizeBytes / mType->getElement()->getSizeBytes()); + } + memcpy(mPtr, data, size); sendDirty(); mUploadDefered = true; } -void Allocation::read(void *data) -{ +void Allocation::read(void *data) { memcpy(data, mPtr, mType->getSizeBytes()); } -void Allocation::subData(uint32_t xoff, uint32_t count, const void *data, uint32_t sizeBytes) -{ +void Allocation::subData(Context *rsc, uint32_t xoff, uint32_t count, const void *data, uint32_t sizeBytes) { uint32_t eSize = mType->getElementSizeBytes(); uint8_t * ptr = static_cast<uint8_t *>(mPtr); ptr += eSize * xoff; @@ -246,14 +320,19 @@ void Allocation::subData(uint32_t xoff, uint32_t count, const void *data, uint32 mType->dumpLOGV("type info"); return; } + + if (mType->getElement()->getHasReferences()) { + incRefs(data, count); + decRefs(ptr, count); + } + memcpy(ptr, data, size); sendDirty(); mUploadDefered = true; } -void Allocation::subData(uint32_t xoff, uint32_t yoff, - uint32_t w, uint32_t h, const void *data, uint32_t sizeBytes) -{ +void Allocation::subData(Context *rsc, uint32_t xoff, uint32_t yoff, + uint32_t w, uint32_t h, const void *data, uint32_t sizeBytes) { uint32_t eSize = mType->getElementSizeBytes(); uint32_t lineSize = eSize * w; uint32_t destW = mType->getDimX(); @@ -268,7 +347,10 @@ void Allocation::subData(uint32_t xoff, uint32_t yoff, } for (uint32_t line=yoff; line < (yoff+h); line++) { - uint8_t * ptr = static_cast<uint8_t *>(mPtr); + if (mType->getElement()->getHasReferences()) { + incRefs(src, w); + decRefs(dst, w); + } memcpy(dst, src, lineSize); src += lineSize; dst += destW * eSize; @@ -277,18 +359,95 @@ void Allocation::subData(uint32_t xoff, uint32_t yoff, mUploadDefered = true; } -void Allocation::subData(uint32_t xoff, uint32_t yoff, uint32_t zoff, - uint32_t w, uint32_t h, uint32_t d, const void *data, uint32_t sizeBytes) -{ +void Allocation::subData(Context *rsc, uint32_t xoff, uint32_t yoff, uint32_t zoff, + uint32_t w, uint32_t h, uint32_t d, const void *data, uint32_t sizeBytes) { +} + +void Allocation::subElementData(Context *rsc, uint32_t x, const void *data, + uint32_t cIdx, uint32_t sizeBytes) { + uint32_t eSize = mType->getElementSizeBytes(); + uint8_t * ptr = static_cast<uint8_t *>(mPtr); + ptr += eSize * x; + + if (cIdx >= mType->getElement()->getFieldCount()) { + LOGE("Error Allocation::subElementData component %i out of range.", cIdx); + rsc->setError(RS_ERROR_BAD_VALUE, "subElementData component out of range."); + return; + } + + if (x >= mType->getDimX()) { + LOGE("Error Allocation::subElementData X offset %i out of range.", x); + rsc->setError(RS_ERROR_BAD_VALUE, "subElementData X offset out of range."); + return; + } + + const Element * e = mType->getElement()->getField(cIdx); + ptr += mType->getElement()->getFieldOffsetBytes(cIdx); + + if (sizeBytes != e->getSizeBytes()) { + LOGE("Error Allocation::subElementData data size %i does not match field size %i.", sizeBytes, e->getSizeBytes()); + rsc->setError(RS_ERROR_BAD_VALUE, "subElementData bad size."); + return; + } + + if (e->getHasReferences()) { + e->incRefs(data); + e->decRefs(ptr); + } + + memcpy(ptr, data, sizeBytes); + sendDirty(); + mUploadDefered = true; +} + +void Allocation::subElementData(Context *rsc, uint32_t x, uint32_t y, + const void *data, uint32_t cIdx, uint32_t sizeBytes) { + uint32_t eSize = mType->getElementSizeBytes(); + uint8_t * ptr = static_cast<uint8_t *>(mPtr); + ptr += eSize * (x + y * mType->getDimX()); + + if (x >= mType->getDimX()) { + LOGE("Error Allocation::subElementData X offset %i out of range.", x); + rsc->setError(RS_ERROR_BAD_VALUE, "subElementData X offset out of range."); + return; + } + + if (y >= mType->getDimY()) { + LOGE("Error Allocation::subElementData X offset %i out of range.", x); + rsc->setError(RS_ERROR_BAD_VALUE, "subElementData X offset out of range."); + return; + } + + if (cIdx >= mType->getElement()->getFieldCount()) { + LOGE("Error Allocation::subElementData component %i out of range.", cIdx); + rsc->setError(RS_ERROR_BAD_VALUE, "subElementData component out of range."); + return; + } + + const Element * e = mType->getElement()->getField(cIdx); + ptr += mType->getElement()->getFieldOffsetBytes(cIdx); + + if (sizeBytes != e->getSizeBytes()) { + LOGE("Error Allocation::subElementData data size %i does not match field size %i.", sizeBytes, e->getSizeBytes()); + rsc->setError(RS_ERROR_BAD_VALUE, "subElementData bad size."); + return; + } + + if (e->getHasReferences()) { + e->incRefs(data); + e->decRefs(ptr); + } + + memcpy(ptr, data, sizeBytes); + sendDirty(); + mUploadDefered = true; } -void Allocation::addProgramToDirty(const Program *p) -{ - mToDirtyList.add(p); +void Allocation::addProgramToDirty(const Program *p) { + mToDirtyList.push(p); } -void Allocation::removeProgramToDirty(const Program *p) -{ +void Allocation::removeProgramToDirty(const Program *p) { for (size_t ct=0; ct < mToDirtyList.size(); ct++) { if (mToDirtyList[ct] == p) { mToDirtyList.removeAt(ct); @@ -298,8 +457,7 @@ void Allocation::removeProgramToDirty(const Program *p) rsAssert(0); } -void Allocation::dumpLOGV(const char *prefix) const -{ +void Allocation::dumpLOGV(const char *prefix) const { ObjectBase::dumpLOGV(prefix); String8 s(prefix); @@ -313,55 +471,139 @@ void Allocation::dumpLOGV(const char *prefix) const LOGV("%s allocation mIsTexture=%i mTextureID=%i, mIsVertexBuffer=%i, mBufferID=%i", prefix, mIsTexture, mTextureID, mIsVertexBuffer, mBufferID); +} + +void Allocation::serialize(OStream *stream) const { + // Need to identify ourselves + stream->addU32((uint32_t)getClassId()); + + String8 name(getName()); + stream->addString(&name); + + // First thing we need to serialize is the type object since it will be needed + // to initialize the class + mType->serialize(stream); + + uint32_t dataSize = mType->getSizeBytes(); + // Write how much data we are storing + stream->addU32(dataSize); + // Now write the data + stream->addByteArray(mPtr, dataSize); +} + +Allocation *Allocation::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_ALLOCATION) { + LOGE("allocation loading skipped due to invalid class id\n"); + return NULL; + } + + String8 name; + stream->loadString(&name); + + Type *type = Type::createFromStream(rsc, stream); + if (!type) { + return NULL; + } + type->compute(); + + // Number of bytes we wrote out for this allocation + uint32_t dataSize = stream->loadU32(); + if (dataSize != type->getSizeBytes()) { + LOGE("failed to read allocation because numbytes written is not the same loaded type wants\n"); + ObjectBase::checkDelete(type); + return NULL; + } + + Allocation *alloc = new Allocation(rsc, type); + alloc->setName(name.string(), name.size()); + + // Read in all of our allocation data + alloc->data(rsc, stream->getPtr() + stream->getPos(), dataSize); + stream->reset(stream->getPos() + dataSize); + return alloc; } -void Allocation::sendDirty() const -{ +void Allocation::sendDirty() const { for (size_t ct=0; ct < mToDirtyList.size(); ct++) { mToDirtyList[ct]->forceDirty(); } } -///////////////// -// +void Allocation::incRefs(const void *ptr, size_t ct, size_t startOff) const { + const uint8_t *p = static_cast<const uint8_t *>(ptr); + const Element *e = mType->getElement(); + uint32_t stride = e->getSizeBytes(); + p += stride * startOff; + while (ct > 0) { + e->incRefs(p); + ct --; + p += stride; + } +} -namespace android { -namespace renderscript { +void Allocation::decRefs(const void *ptr, size_t ct, size_t startOff) const { + const uint8_t *p = static_cast<const uint8_t *>(ptr); + const Element *e = mType->getElement(); + uint32_t stride = e->getSizeBytes(); -RsAllocation rsi_AllocationCreateTyped(Context *rsc, RsType vtype) -{ - const Type * type = static_cast<const Type *>(vtype); + p += stride * startOff; + while (ct > 0) { + e->decRefs(p); + ct --; + p += stride; + } +} - Allocation * alloc = new Allocation(rsc, type); - alloc->incUserRef(); - return alloc; +void Allocation::copyRange1D(Context *rsc, const Allocation *src, int32_t srcOff, int32_t destOff, int32_t len) { } -RsAllocation rsi_AllocationCreateSized(Context *rsc, RsElement e, size_t count) -{ - Type * type = new Type(rsc); - type->setDimX(count); - type->setElement(static_cast<Element *>(e)); - type->compute(); - return rsi_AllocationCreateTyped(rsc, type); +void Allocation::resize1D(Context *rsc, uint32_t dimX) { + Type *t = mType->cloneAndResize1D(rsc, dimX); + + uint32_t oldDimX = mType->getDimX(); + if (dimX == oldDimX) { + return; + } + + if (dimX < oldDimX) { + decRefs(mPtr, oldDimX - dimX, dimX); + } + mPtr = realloc(mPtr, t->getSizeBytes()); + + if (dimX > oldDimX) { + const Element *e = mType->getElement(); + uint32_t stride = e->getSizeBytes(); + memset(((uint8_t *)mPtr) + stride * oldDimX, 0, stride * (dimX - oldDimX)); + } + mType.set(t); } -void rsi_AllocationUploadToTexture(Context *rsc, RsAllocation va, bool genmip, uint32_t baseMipLevel) -{ +void Allocation::resize2D(Context *rsc, uint32_t dimX, uint32_t dimY) { + LOGE("not implemented"); +} + +///////////////// +// + + +namespace android { +namespace renderscript { + +void rsi_AllocationUploadToTexture(Context *rsc, RsAllocation va, bool genmip, uint32_t baseMipLevel) { Allocation *alloc = static_cast<Allocation *>(va); alloc->deferedUploadToTexture(rsc, genmip, baseMipLevel); } -void rsi_AllocationUploadToBufferObject(Context *rsc, RsAllocation va) -{ +void rsi_AllocationUploadToBufferObject(Context *rsc, RsAllocation va) { Allocation *alloc = static_cast<Allocation *>(va); alloc->deferedUploadToBufferObject(rsc); } -static void mip565(const Adapter2D &out, const Adapter2D &in) -{ +static void mip565(const Adapter2D &out, const Adapter2D &in) { uint32_t w = out.getDimX(); uint32_t h = out.getDimY(); @@ -379,8 +621,7 @@ static void mip565(const Adapter2D &out, const Adapter2D &in) } } -static void mip8888(const Adapter2D &out, const Adapter2D &in) -{ +static void mip8888(const Adapter2D &out, const Adapter2D &in) { uint32_t w = out.getDimX(); uint32_t h = out.getDimY(); @@ -398,8 +639,7 @@ static void mip8888(const Adapter2D &out, const Adapter2D &in) } } -static void mip8(const Adapter2D &out, const Adapter2D &in) -{ +static void mip8(const Adapter2D &out, const Adapter2D &in) { uint32_t w = out.getDimX(); uint32_t h = out.getDimY(); @@ -417,9 +657,8 @@ static void mip8(const Adapter2D &out, const Adapter2D &in) } } -static void mip(const Adapter2D &out, const Adapter2D &in) -{ - switch(out.getBaseType()->getElement()->getSizeBits()) { +static void mip(const Adapter2D &out, const Adapter2D &in) { + switch (out.getBaseType()->getElement()->getSizeBits()) { case 32: mip8888(out, in); break; @@ -429,60 +668,51 @@ static void mip(const Adapter2D &out, const Adapter2D &in) case 8: mip8(out, in); break; - } - } typedef void (*ElementConverter_t)(void *dst, const void *src, uint32_t count); -static void elementConverter_cpy_16(void *dst, const void *src, uint32_t count) -{ +static void elementConverter_cpy_16(void *dst, const void *src, uint32_t count) { memcpy(dst, src, count * 2); } -static void elementConverter_cpy_8(void *dst, const void *src, uint32_t count) -{ +static void elementConverter_cpy_8(void *dst, const void *src, uint32_t count) { memcpy(dst, src, count); } -static void elementConverter_cpy_32(void *dst, const void *src, uint32_t count) -{ +static void elementConverter_cpy_32(void *dst, const void *src, uint32_t count) { memcpy(dst, src, count * 4); } - -static void elementConverter_888_to_565(void *dst, const void *src, uint32_t count) -{ +static void elementConverter_888_to_565(void *dst, const void *src, uint32_t count) { uint16_t *d = static_cast<uint16_t *>(dst); const uint8_t *s = static_cast<const uint8_t *>(src); - while(count--) { + while (count--) { *d = rs888to565(s[0], s[1], s[2]); d++; s+= 3; } } -static void elementConverter_8888_to_565(void *dst, const void *src, uint32_t count) -{ +static void elementConverter_8888_to_565(void *dst, const void *src, uint32_t count) { uint16_t *d = static_cast<uint16_t *>(dst); const uint8_t *s = static_cast<const uint8_t *>(src); - while(count--) { + while (count--) { *d = rs888to565(s[0], s[1], s[2]); d++; s+= 4; } } -static ElementConverter_t pickConverter(const Element *dst, const Element *src) -{ +static ElementConverter_t pickConverter(const Element *dst, const Element *src) { GLenum srcGLType = src->getComponent().getGLType(); GLenum srcGLFmt = src->getComponent().getGLFormat(); GLenum dstGLType = dst->getComponent().getGLType(); GLenum dstGLFmt = dst->getComponent().getGLFormat(); if (srcGLFmt == dstGLFmt && srcGLType == dstGLType) { - switch(dst->getSizeBytes()) { + switch (dst->getSizeBytes()) { case 4: return elementConverter_cpy_32; case 2: @@ -495,7 +725,7 @@ static ElementConverter_t pickConverter(const Element *dst, const Element *src) if (srcGLType == GL_UNSIGNED_BYTE && srcGLFmt == GL_RGB && dstGLType == GL_UNSIGNED_SHORT_5_6_5 && - dstGLType == GL_RGB) { + dstGLFmt == GL_RGB) { return elementConverter_888_to_565; } @@ -503,116 +733,201 @@ static ElementConverter_t pickConverter(const Element *dst, const Element *src) if (srcGLType == GL_UNSIGNED_BYTE && srcGLFmt == GL_RGBA && dstGLType == GL_UNSIGNED_SHORT_5_6_5 && - dstGLType == GL_RGB) { + dstGLFmt == GL_RGB) { return elementConverter_8888_to_565; } LOGE("pickConverter, unsuported combo, src %p, dst %p", src, dst); + LOGE("pickConverter, srcGLType = %x, srcGLFmt = %x", srcGLType, srcGLFmt); + LOGE("pickConverter, dstGLType = %x, dstGLFmt = %x", dstGLType, dstGLFmt); + src->dumpLOGV("SRC "); + dst->dumpLOGV("DST "); return 0; } +#ifndef ANDROID_RS_BUILD_FOR_HOST + RsAllocation rsi_AllocationCreateBitmapRef(Context *rsc, RsType vtype, - void *bmp, void *callbackData, RsBitmapCallback_t callback) -{ + void *bmp, void *callbackData, + RsBitmapCallback_t callback) { const Type * type = static_cast<const Type *>(vtype); Allocation * alloc = new Allocation(rsc, type, bmp, callbackData, callback); alloc->incUserRef(); return alloc; } -RsAllocation rsi_AllocationCreateFromBitmap(Context *rsc, uint32_t w, uint32_t h, RsElement _dst, RsElement _src, bool genMips, const void *data) -{ +void rsi_AllocationUpdateFromBitmap(Context *rsc, RsAllocation va, + RsElement _src, const void *data) { + Allocation *texAlloc = static_cast<Allocation *>(va); const Element *src = static_cast<const Element *>(_src); - const Element *dst = static_cast<const Element *>(_dst); - - // Check for pow2 on pre es 2.0 versions. - rsAssert(rsc->checkVersion2_0() || (!(w & (w-1)) && !(h & (h-1)))); - - //LOGE("rsi_AllocationCreateFromBitmap %i %i %i %i %i", w, h, dstFmt, srcFmt, genMips); - rsi_TypeBegin(rsc, _dst); - rsi_TypeAdd(rsc, RS_DIMENSION_X, w); - rsi_TypeAdd(rsc, RS_DIMENSION_Y, h); - if (genMips) { - rsi_TypeAdd(rsc, RS_DIMENSION_LOD, 1); - } - RsType type = rsi_TypeCreate(rsc); - - RsAllocation vTexAlloc = rsi_AllocationCreateTyped(rsc, type); - Allocation *texAlloc = static_cast<Allocation *>(vTexAlloc); - if (texAlloc == NULL) { - LOGE("Memory allocation failure"); - return NULL; - } + const Element *dst = texAlloc->getType()->getElement(); + uint32_t w = texAlloc->getType()->getDimX(); + uint32_t h = texAlloc->getType()->getDimY(); + bool genMips = texAlloc->getType()->getDimLOD(); ElementConverter_t cvt = pickConverter(dst, src); - cvt(texAlloc->getPtr(), data, w * h); - - if (genMips) { - Adapter2D adapt(rsc, texAlloc); - Adapter2D adapt2(rsc, texAlloc); - for(uint32_t lod=0; lod < (texAlloc->getType()->getLODCount() -1); lod++) { - adapt.setLOD(lod); - adapt2.setLOD(lod + 1); - mip(adapt2, adapt); + if (cvt) { + cvt(texAlloc->getPtr(), data, w * h); + if (genMips) { + Adapter2D adapt(rsc, texAlloc); + Adapter2D adapt2(rsc, texAlloc); + for (uint32_t lod=0; lod < (texAlloc->getType()->getLODCount() -1); lod++) { + adapt.setLOD(lod); + adapt2.setLOD(lod + 1); + mip(adapt2, adapt); + } } + } else { + rsc->setError(RS_ERROR_BAD_VALUE, "Unsupported bitmap format"); } - - return texAlloc; } -RsAllocation rsi_AllocationCreateFromBitmapBoxed(Context *rsc, uint32_t w, uint32_t h, RsElement _dst, RsElement _src, bool genMips, const void *data) -{ - const Element *srcE = static_cast<const Element *>(_src); - const Element *dstE = static_cast<const Element *>(_dst); - uint32_t w2 = rsHigherPow2(w); - uint32_t h2 = rsHigherPow2(h); +void rsi_AllocationData(Context *rsc, RsAllocation va, const void *data, uint32_t sizeBytes) { + Allocation *a = static_cast<Allocation *>(va); + a->data(rsc, data, sizeBytes); +} - if ((w2 == w) && (h2 == h)) { - return rsi_AllocationCreateFromBitmap(rsc, w, h, _dst, _src, genMips, data); - } +void rsi_Allocation1DSubData(Context *rsc, RsAllocation va, uint32_t xoff, uint32_t count, const void *data, uint32_t sizeBytes) { + Allocation *a = static_cast<Allocation *>(va); + a->subData(rsc, xoff, count, data, sizeBytes); +} - uint32_t bpp = srcE->getSizeBytes(); - size_t size = w2 * h2 * bpp; - uint8_t *tmp = static_cast<uint8_t *>(malloc(size)); - memset(tmp, 0, size); +void rsi_Allocation2DSubElementData(Context *rsc, RsAllocation va, uint32_t x, uint32_t y, const void *data, uint32_t eoff, uint32_t sizeBytes) { + Allocation *a = static_cast<Allocation *>(va); + a->subElementData(rsc, x, y, data, eoff, sizeBytes); +} - const uint8_t * src = static_cast<const uint8_t *>(data); - for (uint32_t y = 0; y < h; y++) { - uint8_t * ydst = &tmp[(y + ((h2 - h) >> 1)) * w2 * bpp]; - memcpy(&ydst[((w2 - w) >> 1) * bpp], src, w * bpp); - src += w * bpp; - } +void rsi_Allocation1DSubElementData(Context *rsc, RsAllocation va, uint32_t x, const void *data, uint32_t eoff, uint32_t sizeBytes) { + Allocation *a = static_cast<Allocation *>(va); + a->subElementData(rsc, x, data, eoff, sizeBytes); +} - RsAllocation ret = rsi_AllocationCreateFromBitmap(rsc, w2, h2, _dst, _src, genMips, tmp); - free(tmp); - return ret; +void rsi_Allocation2DSubData(Context *rsc, RsAllocation va, uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h, const void *data, uint32_t sizeBytes) { + Allocation *a = static_cast<Allocation *>(va); + a->subData(rsc, xoff, yoff, w, h, data, sizeBytes); } -void rsi_AllocationData(Context *rsc, RsAllocation va, const void *data, uint32_t sizeBytes) -{ +void rsi_AllocationRead(Context *rsc, RsAllocation va, void *data) { Allocation *a = static_cast<Allocation *>(va); - a->data(data, sizeBytes); + a->read(data); } -void rsi_Allocation1DSubData(Context *rsc, RsAllocation va, uint32_t xoff, uint32_t count, const void *data, uint32_t sizeBytes) -{ +void rsi_AllocationResize1D(Context *rsc, RsAllocation va, uint32_t dimX) { Allocation *a = static_cast<Allocation *>(va); - a->subData(xoff, count, data, sizeBytes); + a->resize1D(rsc, dimX); } -void rsi_Allocation2DSubData(Context *rsc, RsAllocation va, uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h, const void *data, uint32_t sizeBytes) -{ +void rsi_AllocationResize2D(Context *rsc, RsAllocation va, uint32_t dimX, uint32_t dimY) { Allocation *a = static_cast<Allocation *>(va); - a->subData(xoff, yoff, w, h, data, sizeBytes); + a->resize2D(rsc, dimX, dimY); } -void rsi_AllocationRead(Context *rsc, RsAllocation va, void *data) -{ +#endif //ANDROID_RS_BUILD_FOR_HOST + +} +} + +const void * rsaAllocationGetType(RsContext con, RsAllocation va) { Allocation *a = static_cast<Allocation *>(va); - a->read(data); + a->getType()->incUserRef(); + + return a->getType(); } +RsAllocation rsaAllocationCreateTyped(RsContext con, RsType vtype) { + Context *rsc = static_cast<Context *>(con); + Allocation * alloc = new Allocation(rsc, static_cast<Type *>(vtype)); + alloc->incUserRef(); + return alloc; +} + +RsAllocation rsaAllocationCreateFromBitmap(RsContext con, uint32_t w, uint32_t h, RsElement _dst, RsElement _src, bool genMips, const void *data) { + Context *rsc = static_cast<Context *>(con); + const Element *src = static_cast<const Element *>(_src); + const Element *dst = static_cast<const Element *>(_dst); + + //LOGE("%p rsi_AllocationCreateFromBitmap %i %i %i", rsc, w, h, genMips); + RsDimension dims[] = {RS_DIMENSION_X, RS_DIMENSION_Y, RS_DIMENSION_LOD}; + uint32_t dimValues[] = {w, h, genMips}; + RsType type = rsaTypeCreate(rsc, _dst, 3, dims, dimValues); + + RsAllocation vTexAlloc = rsaAllocationCreateTyped(rsc, type); + Allocation *texAlloc = static_cast<Allocation *>(vTexAlloc); + if (texAlloc == NULL) { + LOGE("Memory allocation failure"); + return NULL; + } + ElementConverter_t cvt = pickConverter(dst, src); + if (cvt) { + cvt(texAlloc->getPtr(), data, w * h); + if (genMips) { + Adapter2D adapt(rsc, texAlloc); + Adapter2D adapt2(rsc, texAlloc); + for (uint32_t lod=0; lod < (texAlloc->getType()->getLODCount() -1); lod++) { + adapt.setLOD(lod); + adapt2.setLOD(lod + 1); + mip(adapt2, adapt); + } + } + } else { + rsc->setError(RS_ERROR_BAD_VALUE, "Unsupported bitmap format"); + delete texAlloc; + return NULL; + } + + return texAlloc; } + +RsAllocation rsaAllocationCubeCreateFromBitmap(RsContext con, uint32_t w, uint32_t h, RsElement _dst, RsElement _src, bool genMips, const void *data) { + Context *rsc = static_cast<Context *>(con); + const Element *src = static_cast<const Element *>(_src); + const Element *dst = static_cast<const Element *>(_dst); + + // Cubemap allocation's faces should be Width by Width each. + // Source data should have 6 * Width by Width pixels + // Error checking is done in the java layer + RsDimension dims[] = {RS_DIMENSION_X, RS_DIMENSION_Y, RS_DIMENSION_LOD, RS_DIMENSION_FACE}; + uint32_t dimValues[] = {w, w, genMips, true}; + RsType type = rsaTypeCreate(rsc, _dst, 4, dims, dimValues); + + RsAllocation vTexAlloc = rsaAllocationCreateTyped(rsc, type); + Allocation *texAlloc = static_cast<Allocation *>(vTexAlloc); + if (texAlloc == NULL) { + LOGE("Memory allocation failure"); + return NULL; + } + + uint8_t *sourcePtr = (uint8_t*)data; + ElementConverter_t cvt = pickConverter(dst, src); + if (cvt) { + for (uint32_t face = 0; face < 6; face ++) { + Adapter2D faceAdapter(rsc, texAlloc); + faceAdapter.setFace(face); + + cvt(faceAdapter.getElement(0, 0), sourcePtr, w * w); + + // Move the data pointer to the next cube face + sourcePtr += w * w * src->getSizeBytes(); + + if (genMips) { + Adapter2D adapt(rsc, texAlloc); + Adapter2D adapt2(rsc, texAlloc); + adapt.setFace(face); + adapt2.setFace(face); + for (uint32_t lod=0; lod < (texAlloc->getType()->getLODCount() -1); lod++) { + adapt.setLOD(lod); + adapt2.setLOD(lod + 1); + mip(adapt2, adapt); + } + } + } + } else { + rsc->setError(RS_ERROR_BAD_VALUE, "Unsupported bitmap format"); + delete texAlloc; + return NULL; + } + + return texAlloc; } |