| /* | |
| * Copyright (C) 2009 The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| #include "rsContext.h" | |
| #include <utils/String8.h> | |
| #include "rsFileA3D.h" | |
| #include "rsMesh.h" | |
| using namespace android; | |
| using namespace android::renderscript; | |
| FileA3D::FileA3D() | |
| { | |
| mRsc = NULL; | |
| } | |
| FileA3D::~FileA3D() | |
| { | |
| } | |
| bool FileA3D::load(Context *rsc, FILE *f) | |
| { | |
| char magicString[12]; | |
| size_t len; | |
| LOGE("file open 1"); | |
| len = fread(magicString, 1, 12, f); | |
| if ((len != 12) || | |
| memcmp(magicString, "Android3D_ff", 12)) { | |
| return false; | |
| } | |
| LOGE("file open 2"); | |
| len = fread(&mMajorVersion, 1, sizeof(mMajorVersion), f); | |
| if (len != sizeof(mMajorVersion)) { | |
| return false; | |
| } | |
| LOGE("file open 3"); | |
| len = fread(&mMinorVersion, 1, sizeof(mMinorVersion), f); | |
| if (len != sizeof(mMinorVersion)) { | |
| return false; | |
| } | |
| LOGE("file open 4"); | |
| uint32_t flags; | |
| len = fread(&flags, 1, sizeof(flags), f); | |
| if (len != sizeof(flags)) { | |
| return false; | |
| } | |
| mUse64BitOffsets = (flags & 1) != 0; | |
| LOGE("file open 64bit = %i", mUse64BitOffsets); | |
| if (mUse64BitOffsets) { | |
| len = fread(&mDataSize, 1, sizeof(mDataSize), f); | |
| if (len != sizeof(mDataSize)) { | |
| return false; | |
| } | |
| } else { | |
| uint32_t tmp; | |
| len = fread(&tmp, 1, sizeof(tmp), f); | |
| if (len != sizeof(tmp)) { | |
| return false; | |
| } | |
| mDataSize = tmp; | |
| } | |
| LOGE("file open size = %lli", mDataSize); | |
| // We should know enough to read the file in at this point. | |
| fseek(f, SEEK_SET, 0); | |
| mAlloc= malloc(mDataSize); | |
| if (!mAlloc) { | |
| return false; | |
| } | |
| mData = (uint8_t *)mAlloc; | |
| len = fread(mAlloc, 1, mDataSize, f); | |
| if (len != mDataSize) { | |
| return false; | |
| } | |
| LOGE("file start processing"); | |
| return process(rsc); | |
| } | |
| bool FileA3D::processIndex(Context *rsc, A3DIndexEntry *ie) | |
| { | |
| bool ret = false; | |
| IO io(mData + ie->mOffset, mUse64BitOffsets); | |
| LOGE("process index, type %i", ie->mType); | |
| switch(ie->mType) { | |
| case CHUNK_ELEMENT: | |
| processChunk_Element(rsc, &io, ie); | |
| break; | |
| case CHUNK_ELEMENT_SOURCE: | |
| processChunk_ElementSource(rsc, &io, ie); | |
| break; | |
| case CHUNK_VERTICIES: | |
| processChunk_Verticies(rsc, &io, ie); | |
| break; | |
| case CHUNK_MESH: | |
| processChunk_Mesh(rsc, &io, ie); | |
| break; | |
| case CHUNK_PRIMITIVE: | |
| processChunk_Primitive(rsc, &io, ie); | |
| break; | |
| default: | |
| LOGE("FileA3D Unknown chunk type"); | |
| break; | |
| } | |
| return (ie->mRsObj != NULL); | |
| } | |
| bool FileA3D::process(Context *rsc) | |
| { | |
| LOGE("process"); | |
| IO io(mData + 12, mUse64BitOffsets); | |
| bool ret = true; | |
| // Build the index first | |
| LOGE("process 1"); | |
| io.loadU32(); // major version, already loaded | |
| io.loadU32(); // minor version, already loaded | |
| LOGE("process 2"); | |
| io.loadU32(); // flags | |
| io.loadOffset(); // filesize, already loaded. | |
| LOGE("process 4"); | |
| uint64_t mIndexOffset = io.loadOffset(); | |
| uint64_t mStringOffset = io.loadOffset(); | |
| LOGE("process mIndexOffset= 0x%016llx", mIndexOffset); | |
| LOGE("process mStringOffset= 0x%016llx", mStringOffset); | |
| IO index(mData + mIndexOffset, mUse64BitOffsets); | |
| IO stringTable(mData + mStringOffset, mUse64BitOffsets); | |
| uint32_t stringEntryCount = stringTable.loadU32(); | |
| LOGE("stringEntryCount %i", stringEntryCount); | |
| mStrings.setCapacity(stringEntryCount); | |
| mStringIndexValues.setCapacity(stringEntryCount); | |
| if (stringEntryCount) { | |
| uint32_t stringType = stringTable.loadU32(); | |
| LOGE("stringType %i", stringType); | |
| rsAssert(stringType==0); | |
| for (uint32_t ct = 0; ct < stringEntryCount; ct++) { | |
| uint64_t offset = stringTable.loadOffset(); | |
| LOGE("string offset 0x%016llx", offset); | |
| IO tmp(mData + offset, mUse64BitOffsets); | |
| String8 s; | |
| tmp.loadString(&s); | |
| LOGE("string %s", s.string()); | |
| mStrings.push(s); | |
| } | |
| } | |
| LOGE("strings done"); | |
| uint32_t indexEntryCount = index.loadU32(); | |
| LOGE("index count %i", indexEntryCount); | |
| mIndex.setCapacity(indexEntryCount); | |
| for (uint32_t ct = 0; ct < indexEntryCount; ct++) { | |
| A3DIndexEntry e; | |
| uint32_t stringIndex = index.loadU32(); | |
| LOGE("index %i", ct); | |
| LOGE(" string index %i", stringIndex); | |
| e.mType = (A3DChunkType)index.loadU32(); | |
| LOGE(" type %i", e.mType); | |
| e.mOffset = index.loadOffset(); | |
| LOGE(" offset 0x%016llx", e.mOffset); | |
| if (stringIndex && (stringIndex < mStrings.size())) { | |
| e.mID = mStrings[stringIndex]; | |
| mStringIndexValues.editItemAt(stringIndex) = ct; | |
| LOGE(" id %s", e.mID.string()); | |
| } | |
| mIndex.push(e); | |
| } | |
| LOGE("index done"); | |
| // At this point the index should be fully populated. | |
| // We can now walk though it and load all the objects. | |
| for (uint32_t ct = 0; ct < indexEntryCount; ct++) { | |
| LOGE("processing index entry %i", ct); | |
| processIndex(rsc, &mIndex.editItemAt(ct)); | |
| } | |
| return ret; | |
| } | |
| FileA3D::IO::IO(const uint8_t *buf, bool use64) | |
| { | |
| mData = buf; | |
| mPos = 0; | |
| mUse64 = use64; | |
| } | |
| uint64_t FileA3D::IO::loadOffset() | |
| { | |
| uint64_t tmp; | |
| if (mUse64) { | |
| mPos = (mPos + 7) & (~7); | |
| tmp = reinterpret_cast<const uint64_t *>(&mData[mPos])[0]; | |
| mPos += sizeof(uint64_t); | |
| return tmp; | |
| } | |
| return loadU32(); | |
| } | |
| void FileA3D::IO::loadString(String8 *s) | |
| { | |
| LOGE("loadString"); | |
| uint32_t len = loadU32(); | |
| LOGE("loadString len %i", len); | |
| s->setTo((const char *)&mData[mPos], len); | |
| mPos += len; | |
| } | |
| void FileA3D::processChunk_Mesh(Context *rsc, IO *io, A3DIndexEntry *ie) | |
| { | |
| Mesh * m = new Mesh(rsc); | |
| m->mPrimitivesCount = io->loadU32(); | |
| m->mPrimitives = new Mesh::Primitive_t *[m->mPrimitivesCount]; | |
| for (uint32_t ct = 0; ct < m->mPrimitivesCount; ct++) { | |
| uint32_t index = io->loadU32(); | |
| m->mPrimitives[ct] = (Mesh::Primitive_t *)mIndex[index].mRsObj; | |
| } | |
| ie->mRsObj = m; | |
| } | |
| void FileA3D::processChunk_Primitive(Context *rsc, IO *io, A3DIndexEntry *ie) | |
| { | |
| Mesh::Primitive_t * p = new Mesh::Primitive_t; | |
| p->mIndexCount = io->loadU32(); | |
| uint32_t vertIdx = io->loadU32(); | |
| p->mRestartCounts = io->loadU16(); | |
| uint32_t bits = io->loadU8(); | |
| p->mType = (RsPrimitive)io->loadU8(); | |
| LOGE("processChunk_Primitive count %i, bits %i", p->mIndexCount, bits); | |
| p->mVerticies = (Mesh::Verticies_t *)mIndex[vertIdx].mRsObj; | |
| p->mIndicies = new uint16_t[p->mIndexCount]; | |
| for (uint32_t ct = 0; ct < p->mIndexCount; ct++) { | |
| switch(bits) { | |
| case 8: | |
| p->mIndicies[ct] = io->loadU8(); | |
| break; | |
| case 16: | |
| p->mIndicies[ct] = io->loadU16(); | |
| break; | |
| case 32: | |
| p->mIndicies[ct] = io->loadU32(); | |
| break; | |
| } | |
| LOGE(" idx %i", p->mIndicies[ct]); | |
| } | |
| if (p->mRestartCounts) { | |
| p->mRestarts = new uint16_t[p->mRestartCounts]; | |
| for (uint32_t ct = 0; ct < p->mRestartCounts; ct++) { | |
| switch(bits) { | |
| case 8: | |
| p->mRestarts[ct] = io->loadU8(); | |
| break; | |
| case 16: | |
| p->mRestarts[ct] = io->loadU16(); | |
| break; | |
| case 32: | |
| p->mRestarts[ct] = io->loadU32(); | |
| break; | |
| } | |
| LOGE(" idx %i", p->mRestarts[ct]); | |
| } | |
| } else { | |
| p->mRestarts = NULL; | |
| } | |
| ie->mRsObj = p; | |
| } | |
| void FileA3D::processChunk_Verticies(Context *rsc, IO *io, A3DIndexEntry *ie) | |
| { | |
| Mesh::Verticies_t *cv = new Mesh::Verticies_t; | |
| cv->mAllocationCount = io->loadU32(); | |
| cv->mAllocations = new Allocation *[cv->mAllocationCount]; | |
| LOGE("processChunk_Verticies count %i", cv->mAllocationCount); | |
| for (uint32_t ct = 0; ct < cv->mAllocationCount; ct++) { | |
| uint32_t i = io->loadU32(); | |
| cv->mAllocations[ct] = (Allocation *)mIndex[i].mRsObj; | |
| LOGE(" idx %i", i); | |
| } | |
| ie->mRsObj = cv; | |
| } | |
| void FileA3D::processChunk_Element(Context *rsc, IO *io, A3DIndexEntry *ie) | |
| { | |
| /* | |
| rsi_ElementBegin(rsc); | |
| uint32_t count = io->loadU32(); | |
| LOGE("processChunk_Element count %i", count); | |
| while (count--) { | |
| RsDataKind dk = (RsDataKind)io->loadU8(); | |
| RsDataType dt = (RsDataType)io->loadU8(); | |
| uint32_t bits = io->loadU8(); | |
| bool isNorm = io->loadU8() != 0; | |
| LOGE(" %i %i %i %i", dk, dt, bits, isNorm); | |
| rsi_ElementAdd(rsc, dk, dt, isNorm, bits, 0); | |
| } | |
| LOGE("processChunk_Element create"); | |
| ie->mRsObj = rsi_ElementCreate(rsc); | |
| */ | |
| } | |
| void FileA3D::processChunk_ElementSource(Context *rsc, IO *io, A3DIndexEntry *ie) | |
| { | |
| uint32_t index = io->loadU32(); | |
| uint32_t count = io->loadU32(); | |
| LOGE("processChunk_ElementSource count %i, index %i", count, index); | |
| RsElement e = (RsElement)mIndex[index].mRsObj; | |
| RsAllocation a = rsi_AllocationCreateSized(rsc, e, count); | |
| Allocation * alloc = static_cast<Allocation *>(a); | |
| float * data = (float *)alloc->getPtr(); | |
| while(count--) { | |
| *data = io->loadF(); | |
| LOGE(" %f", *data); | |
| data++; | |
| } | |
| ie->mRsObj = alloc; | |
| } | |
| namespace android { | |
| namespace renderscript { | |
| RsFile rsi_FileOpen(Context *rsc, char const *path, unsigned int len) | |
| { | |
| FileA3D *fa3d = new FileA3D; | |
| FILE *f = fopen("/sdcard/test.a3d", "rb"); | |
| if (f) { | |
| fa3d->load(rsc, f); | |
| fclose(f); | |
| return fa3d; | |
| } | |
| delete fa3d; | |
| return NULL; | |
| } | |
| } | |
| } |