1
2/*
3 * Copyright (C) 2009 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18#include "rsContext.h"
19
20
21#include <utils/String8.h>
22#include "rsFileA3D.h"
23
24#include "rsMesh.h"
25
26using namespace android;
27using namespace android::renderscript;
28
29
30
31FileA3D::FileA3D()
32{
33    mRsc = NULL;
34}
35
36FileA3D::~FileA3D()
37{
38}
39
40bool FileA3D::load(Context *rsc, FILE *f)
41{
42    char magicString[12];
43    size_t len;
44
45    LOGE("file open 1");
46    len = fread(magicString, 1, 12, f);
47    if ((len != 12) ||
48        memcmp(magicString, "Android3D_ff", 12)) {
49        return false;
50    }
51
52    LOGE("file open 2");
53    len = fread(&mMajorVersion, 1, sizeof(mMajorVersion), f);
54    if (len != sizeof(mMajorVersion)) {
55        return false;
56    }
57
58    LOGE("file open 3");
59    len = fread(&mMinorVersion, 1, sizeof(mMinorVersion), f);
60    if (len != sizeof(mMinorVersion)) {
61        return false;
62    }
63
64    LOGE("file open 4");
65    uint32_t flags;
66    len = fread(&flags, 1, sizeof(flags), f);
67    if (len != sizeof(flags)) {
68        return false;
69    }
70    mUse64BitOffsets = (flags & 1) != 0;
71
72    LOGE("file open 64bit = %i", mUse64BitOffsets);
73
74    if (mUse64BitOffsets) {
75        len = fread(&mDataSize, 1, sizeof(mDataSize), f);
76        if (len != sizeof(mDataSize)) {
77            return false;
78        }
79    } else {
80        uint32_t tmp;
81        len = fread(&tmp, 1, sizeof(tmp), f);
82        if (len != sizeof(tmp)) {
83            return false;
84        }
85        mDataSize = tmp;
86    }
87
88    LOGE("file open size = %lli", mDataSize);
89
90    // We should know enough to read the file in at this point.
91    fseek(f, SEEK_SET, 0);
92    mAlloc= malloc(mDataSize);
93    if (!mAlloc) {
94        return false;
95    }
96    mData = (uint8_t *)mAlloc;
97    len = fread(mAlloc, 1, mDataSize, f);
98    if (len != mDataSize) {
99        return false;
100    }
101
102    LOGE("file start processing");
103    return process(rsc);
104}
105
106bool FileA3D::processIndex(Context *rsc, A3DIndexEntry *ie)
107{
108    bool ret = false;
109    IO io(mData + ie->mOffset, mUse64BitOffsets);
110
111    LOGE("process index, type %i", ie->mType);
112
113    switch(ie->mType) {
114    case CHUNK_ELEMENT:
115        processChunk_Element(rsc, &io, ie);
116        break;
117    case CHUNK_ELEMENT_SOURCE:
118        processChunk_ElementSource(rsc, &io, ie);
119        break;
120    case CHUNK_VERTICIES:
121        processChunk_Verticies(rsc, &io, ie);
122        break;
123    case CHUNK_MESH:
124        processChunk_Mesh(rsc, &io, ie);
125        break;
126    case CHUNK_PRIMITIVE:
127        processChunk_Primitive(rsc, &io, ie);
128        break;
129    default:
130        LOGE("FileA3D Unknown chunk type");
131        break;
132    }
133    return (ie->mRsObj != NULL);
134}
135
136bool FileA3D::process(Context *rsc)
137{
138    LOGE("process");
139    IO io(mData + 12, mUse64BitOffsets);
140    bool ret = true;
141
142    // Build the index first
143    LOGE("process 1");
144    io.loadU32(); // major version, already loaded
145    io.loadU32(); // minor version, already loaded
146    LOGE("process 2");
147
148    io.loadU32();  // flags
149    io.loadOffset(); // filesize, already loaded.
150    LOGE("process 4");
151    uint64_t mIndexOffset = io.loadOffset();
152    uint64_t mStringOffset = io.loadOffset();
153
154    LOGE("process mIndexOffset= 0x%016llx", mIndexOffset);
155    LOGE("process mStringOffset= 0x%016llx", mStringOffset);
156
157    IO index(mData + mIndexOffset, mUse64BitOffsets);
158    IO stringTable(mData + mStringOffset, mUse64BitOffsets);
159
160    uint32_t stringEntryCount = stringTable.loadU32();
161    LOGE("stringEntryCount %i", stringEntryCount);
162    mStrings.setCapacity(stringEntryCount);
163    mStringIndexValues.setCapacity(stringEntryCount);
164    if (stringEntryCount) {
165        uint32_t stringType = stringTable.loadU32();
166        LOGE("stringType %i", stringType);
167        rsAssert(stringType==0);
168        for (uint32_t ct = 0; ct < stringEntryCount; ct++) {
169            uint64_t offset = stringTable.loadOffset();
170            LOGE("string offset 0x%016llx", offset);
171            IO tmp(mData + offset, mUse64BitOffsets);
172            String8 s;
173            tmp.loadString(&s);
174            LOGE("string %s", s.string());
175            mStrings.push(s);
176        }
177    }
178
179    LOGE("strings done");
180    uint32_t indexEntryCount = index.loadU32();
181    LOGE("index count %i", indexEntryCount);
182    mIndex.setCapacity(indexEntryCount);
183    for (uint32_t ct = 0; ct < indexEntryCount; ct++) {
184        A3DIndexEntry e;
185        uint32_t stringIndex = index.loadU32();
186        LOGE("index %i", ct);
187        LOGE("  string index %i", stringIndex);
188        e.mType = (A3DChunkType)index.loadU32();
189        LOGE("  type %i", e.mType);
190        e.mOffset = index.loadOffset();
191        LOGE("  offset 0x%016llx", e.mOffset);
192
193        if (stringIndex && (stringIndex < mStrings.size())) {
194            e.mID = mStrings[stringIndex];
195            mStringIndexValues.editItemAt(stringIndex) = ct;
196            LOGE("  id %s", e.mID.string());
197        }
198
199        mIndex.push(e);
200    }
201    LOGE("index done");
202
203    // At this point the index should be fully populated.
204    // We can now walk though it and load all the objects.
205    for (uint32_t ct = 0; ct < indexEntryCount; ct++) {
206        LOGE("processing index entry %i", ct);
207        processIndex(rsc, &mIndex.editItemAt(ct));
208    }
209
210    return ret;
211}
212
213
214FileA3D::IO::IO(const uint8_t *buf, bool use64)
215{
216    mData = buf;
217    mPos = 0;
218    mUse64 = use64;
219}
220
221uint64_t FileA3D::IO::loadOffset()
222{
223    uint64_t tmp;
224    if (mUse64) {
225        mPos = (mPos + 7) & (~7);
226        tmp = reinterpret_cast<const uint64_t *>(&mData[mPos])[0];
227        mPos += sizeof(uint64_t);
228        return tmp;
229    }
230    return loadU32();
231}
232
233void FileA3D::IO::loadString(String8 *s)
234{
235    LOGE("loadString");
236    uint32_t len = loadU32();
237    LOGE("loadString len %i", len);
238    s->setTo((const char *)&mData[mPos], len);
239    mPos += len;
240}
241
242
243void FileA3D::processChunk_Mesh(Context *rsc, IO *io, A3DIndexEntry *ie)
244{
245    Mesh * m = new Mesh(rsc);
246
247    m->mPrimitivesCount = io->loadU32();
248    m->mPrimitives = new Mesh::Primitive_t *[m->mPrimitivesCount];
249
250    for (uint32_t ct = 0; ct < m->mPrimitivesCount; ct++) {
251        uint32_t index = io->loadU32();
252
253        m->mPrimitives[ct] = (Mesh::Primitive_t *)mIndex[index].mRsObj;
254    }
255    ie->mRsObj = m;
256}
257
258void FileA3D::processChunk_Primitive(Context *rsc, IO *io, A3DIndexEntry *ie)
259{
260    Mesh::Primitive_t * p = new Mesh::Primitive_t;
261
262    p->mIndexCount = io->loadU32();
263    uint32_t vertIdx = io->loadU32();
264    p->mRestartCounts = io->loadU16();
265    uint32_t bits = io->loadU8();
266    p->mType = (RsPrimitive)io->loadU8();
267
268    LOGE("processChunk_Primitive count %i, bits %i", p->mIndexCount, bits);
269
270    p->mVerticies = (Mesh::Verticies_t *)mIndex[vertIdx].mRsObj;
271
272    p->mIndicies = new uint16_t[p->mIndexCount];
273    for (uint32_t ct = 0; ct < p->mIndexCount; ct++) {
274        switch(bits) {
275        case 8:
276            p->mIndicies[ct] = io->loadU8();
277            break;
278        case 16:
279            p->mIndicies[ct] = io->loadU16();
280            break;
281        case 32:
282            p->mIndicies[ct] = io->loadU32();
283            break;
284        }
285        LOGE("  idx %i", p->mIndicies[ct]);
286    }
287
288    if (p->mRestartCounts) {
289        p->mRestarts = new uint16_t[p->mRestartCounts];
290        for (uint32_t ct = 0; ct < p->mRestartCounts; ct++) {
291            switch(bits) {
292            case 8:
293                p->mRestarts[ct] = io->loadU8();
294                break;
295            case 16:
296                p->mRestarts[ct] = io->loadU16();
297                break;
298            case 32:
299                p->mRestarts[ct] = io->loadU32();
300                break;
301            }
302            LOGE("  idx %i", p->mRestarts[ct]);
303        }
304    } else {
305        p->mRestarts = NULL;
306    }
307
308    ie->mRsObj = p;
309}
310
311void FileA3D::processChunk_Verticies(Context *rsc, IO *io, A3DIndexEntry *ie)
312{
313    Mesh::Verticies_t *cv = new Mesh::Verticies_t;
314    cv->mAllocationCount = io->loadU32();
315    cv->mAllocations = new Allocation *[cv->mAllocationCount];
316    LOGE("processChunk_Verticies count %i", cv->mAllocationCount);
317    for (uint32_t ct = 0; ct < cv->mAllocationCount; ct++) {
318        uint32_t i = io->loadU32();
319        cv->mAllocations[ct] = (Allocation *)mIndex[i].mRsObj;
320        LOGE("  idx %i", i);
321    }
322    ie->mRsObj = cv;
323}
324
325void FileA3D::processChunk_Element(Context *rsc, IO *io, A3DIndexEntry *ie)
326{
327    /*
328    rsi_ElementBegin(rsc);
329
330    uint32_t count = io->loadU32();
331    LOGE("processChunk_Element count %i", count);
332    while (count--) {
333        RsDataKind dk = (RsDataKind)io->loadU8();
334        RsDataType dt = (RsDataType)io->loadU8();
335        uint32_t bits = io->loadU8();
336        bool isNorm = io->loadU8() != 0;
337        LOGE("  %i %i %i %i", dk, dt, bits, isNorm);
338        rsi_ElementAdd(rsc, dk, dt, isNorm, bits, 0);
339    }
340    LOGE("processChunk_Element create");
341    ie->mRsObj = rsi_ElementCreate(rsc);
342    */
343}
344
345void FileA3D::processChunk_ElementSource(Context *rsc, IO *io, A3DIndexEntry *ie)
346{
347    uint32_t index = io->loadU32();
348    uint32_t count = io->loadU32();
349
350    LOGE("processChunk_ElementSource count %i, index %i", count, index);
351
352    RsElement e = (RsElement)mIndex[index].mRsObj;
353
354    RsAllocation a = rsi_AllocationCreateSized(rsc, e, count);
355    Allocation * alloc = static_cast<Allocation *>(a);
356
357    float * data = (float *)alloc->getPtr();
358    while(count--) {
359        *data = io->loadF();
360        LOGE("  %f", *data);
361        data++;
362    }
363    ie->mRsObj = alloc;
364}
365
366namespace android {
367namespace renderscript {
368
369
370RsFile rsi_FileOpen(Context *rsc, char const *path, unsigned int len)
371{
372    FileA3D *fa3d = new FileA3D;
373
374    FILE *f = fopen("/sdcard/test.a3d", "rb");
375    if (f) {
376        fa3d->load(rsc, f);
377        fclose(f);
378        return fa3d;
379    }
380    delete fa3d;
381    return NULL;
382}
383
384
385}
386}
387