rsFileA3D.cpp revision ba5e591e2d595e5b361e749ec133de1f339bcdd5 
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#include "rsFileA3D.h"
20
21#include "rsMesh.h"
22#include "rsAnimation.h"
23#include "rs.h"
24
25#include <inttypes.h>
26
27namespace android {
28namespace renderscript {
29
30FileA3D::FileA3D(Context *rsc) : ObjectBase(rsc) {
31    mAlloc = nullptr;
32    mData = nullptr;
33    mWriteStream = nullptr;
34    mReadStream = nullptr;
35
36    mMajorVersion = 0;
37    mMinorVersion = 1;
38    mDataSize = 0;
39}
40
41FileA3D::~FileA3D() {
42    for (size_t i = 0; i < mIndex.size(); i ++) {
43        delete mIndex[i];
44    }
45    for (size_t i = 0; i < mWriteIndex.size(); i ++) {
46        delete mWriteIndex[i];
47    }
48    if (mWriteStream) {
49        delete mWriteStream;
50    }
51    if (mReadStream) {
52        delete mReadStream;
53    }
54    if (mAlloc) {
55        free(mAlloc);
56    }
57}
58
59void FileA3D::parseHeader(IStream *headerStream) {
60    mMajorVersion = headerStream->loadU32();
61    mMinorVersion = headerStream->loadU32();
62    uint32_t flags = headerStream->loadU32();
63    mUse64BitOffsets = (flags & 1) != 0;
64
65    uint32_t numIndexEntries = headerStream->loadU32();
66    for (uint32_t i = 0; i < numIndexEntries; i ++) {
67        A3DIndexEntry *entry = new A3DIndexEntry();
68        entry->mObjectName = headerStream->loadString();
69
70        //ALOGV("Header data, entry name = %s", entry->mObjectName.string());
71        entry->mType = (RsA3DClassID)headerStream->loadU32();
72        if (mUse64BitOffsets){
73            entry->mOffset = headerStream->loadOffset();
74            entry->mLength = headerStream->loadOffset();
75        } else {
76            entry->mOffset = headerStream->loadU32();
77            entry->mLength = headerStream->loadU32();
78        }
79        entry->mRsObj = nullptr;
80        mIndex.push(entry);
81    }
82}
83
84bool FileA3D::load(Asset *asset) {
85    return false;
86}
87
88bool FileA3D::load(const void *data, size_t length) {
89    const uint8_t *localData = (const uint8_t *)data;
90
91    size_t lengthRemaining = length;
92    size_t magicStrLen = 12;
93    if ((length < magicStrLen) ||
94        memcmp(data, "Android3D_ff", magicStrLen)) {
95        return false;
96    }
97
98    localData += magicStrLen;
99    lengthRemaining -= magicStrLen;
100
101    // Next we get our header size
102    uint64_t headerSize = 0;
103    if (lengthRemaining < sizeof(headerSize)) {
104        return false;
105    }
106
107    memcpy(&headerSize, localData, sizeof(headerSize));
108    localData += sizeof(headerSize);
109    lengthRemaining -= sizeof(headerSize);
110
111    if (lengthRemaining < headerSize) {
112        return false;
113    }
114
115    // Now open the stream to parse the header
116    IStream headerStream(localData, false);
117    parseHeader(&headerStream);
118
119    localData += headerSize;
120    lengthRemaining -= headerSize;
121
122    if (lengthRemaining < sizeof(mDataSize)) {
123        return false;
124    }
125
126    // Read the size of the data
127    memcpy(&mDataSize, localData, sizeof(mDataSize));
128    localData += sizeof(mDataSize);
129    lengthRemaining -= sizeof(mDataSize);
130
131    if (lengthRemaining < mDataSize) {
132        return false;
133    }
134
135    // We should know enough to read the file in at this point.
136    mData = (uint8_t *)localData;
137    mReadStream = new IStream(mData, mUse64BitOffsets);
138
139    return true;
140}
141
142bool FileA3D::load(FILE *f) {
143    char magicString[12];
144    size_t len;
145
146    ALOGV("file open 1");
147    len = fread(magicString, 1, 12, f);
148    if ((len != 12) ||
149        memcmp(magicString, "Android3D_ff", 12)) {
150        return false;
151    }
152
153    // Next thing is the size of the header
154    uint64_t headerSize = 0;
155    len = fread(&headerSize, 1, sizeof(headerSize), f);
156    if (len != sizeof(headerSize) || headerSize == 0) {
157        return false;
158    }
159
160    uint8_t *headerData = (uint8_t *)malloc(headerSize);
161    if (!headerData) {
162        return false;
163    }
164
165    len = fread(headerData, 1, headerSize, f);
166    if (len != headerSize) {
167        return false;
168    }
169
170    // Now open the stream to parse the header
171    IStream headerStream(headerData, false);
172    parseHeader(&headerStream);
173
174    free(headerData);
175
176    // Next thing is the size of the header
177    len = fread(&mDataSize, 1, sizeof(mDataSize), f);
178    if (len != sizeof(mDataSize) || mDataSize == 0) {
179        return false;
180    }
181
182    ALOGV("file open size = %" PRIi64, mDataSize);
183
184    // We should know enough to read the file in at this point.
185    mAlloc = malloc(mDataSize);
186    if (!mAlloc) {
187        return false;
188    }
189    mData = (uint8_t *)mAlloc;
190    len = fread(mAlloc, 1, mDataSize, f);
191    if (len != mDataSize) {
192        return false;
193    }
194
195    mReadStream = new IStream(mData, mUse64BitOffsets);
196
197    ALOGV("Header is read an stream initialized");
198    return true;
199}
200
201size_t FileA3D::getNumIndexEntries() const {
202    return mIndex.size();
203}
204
205FileA3D::A3DIndexEntry::~A3DIndexEntry() {
206    delete[] mObjectName;
207}
208
209const FileA3D::A3DIndexEntry *FileA3D::getIndexEntry(size_t index) const {
210    if (index < mIndex.size()) {
211        return mIndex[index];
212    }
213    return nullptr;
214}
215
216ObjectBase *FileA3D::initializeFromEntry(size_t index) {
217    if (index >= mIndex.size()) {
218        return nullptr;
219    }
220
221    FileA3D::A3DIndexEntry *entry = mIndex[index];
222    if (!entry) {
223        return nullptr;
224    }
225
226    if (entry->mRsObj) {
227        entry->mRsObj->incUserRef();
228        return entry->mRsObj;
229    }
230
231    // Seek to the beginning of object
232    mReadStream->reset(entry->mOffset);
233    switch (entry->mType) {
234        case RS_A3D_CLASS_ID_UNKNOWN:
235            return nullptr;
236        case RS_A3D_CLASS_ID_MESH:
237            entry->mRsObj = Mesh::createFromStream(mRSC, mReadStream);
238            break;
239        case RS_A3D_CLASS_ID_TYPE:
240            entry->mRsObj = Type::createFromStream(mRSC, mReadStream);
241            break;
242        case RS_A3D_CLASS_ID_ELEMENT:
243            entry->mRsObj = Element::createFromStream(mRSC, mReadStream);
244            break;
245        case RS_A3D_CLASS_ID_ALLOCATION:
246            entry->mRsObj = Allocation::createFromStream(mRSC, mReadStream);
247            break;
248        case RS_A3D_CLASS_ID_PROGRAM_VERTEX:
249            //entry->mRsObj = ProgramVertex::createFromStream(mRSC, mReadStream);
250            break;
251        case RS_A3D_CLASS_ID_PROGRAM_RASTER:
252            //entry->mRsObj = ProgramRaster::createFromStream(mRSC, mReadStream);
253            break;
254        case RS_A3D_CLASS_ID_PROGRAM_FRAGMENT:
255            //entry->mRsObj = ProgramFragment::createFromStream(mRSC, mReadStream);
256            break;
257        case RS_A3D_CLASS_ID_PROGRAM_STORE:
258            //entry->mRsObj = ProgramStore::createFromStream(mRSC, mReadStream);
259            break;
260        case RS_A3D_CLASS_ID_SAMPLER:
261            //entry->mRsObj = Sampler::createFromStream(mRSC, mReadStream);
262            break;
263        case RS_A3D_CLASS_ID_ANIMATION:
264            //entry->mRsObj = Animation::createFromStream(mRSC, mReadStream);
265            break;
266        case RS_A3D_CLASS_ID_ADAPTER_1D:
267            //entry->mRsObj = Adapter1D::createFromStream(mRSC, mReadStream);
268            break;
269        case RS_A3D_CLASS_ID_ADAPTER_2D:
270            //entry->mRsObj = Adapter2D::createFromStream(mRSC, mReadStream);
271            break;
272        case RS_A3D_CLASS_ID_SCRIPT_C:
273            break;
274        case RS_A3D_CLASS_ID_SCRIPT_KERNEL_ID:
275            break;
276        case RS_A3D_CLASS_ID_SCRIPT_INVOKE_ID:
277            break;
278        case RS_A3D_CLASS_ID_SCRIPT_FIELD_ID:
279            break;
280        case RS_A3D_CLASS_ID_SCRIPT_METHOD_ID:
281            break;
282        case RS_A3D_CLASS_ID_SCRIPT_GROUP:
283            break;
284        case RS_A3D_CLASS_ID_CLOSURE:
285            break;
286        case RS_A3D_CLASS_ID_SCRIPT_GROUP2:
287            break;
288    }
289    if (entry->mRsObj) {
290        entry->mRsObj->incUserRef();
291    }
292    return entry->mRsObj;
293}
294
295bool FileA3D::writeFile(const char *filename) {
296    if (!mWriteStream) {
297        ALOGE("No objects to write\n");
298        return false;
299    }
300    if (mWriteStream->getPos() == 0) {
301        ALOGE("No objects to write\n");
302        return false;
303    }
304
305    FILE *writeHandle = fopen(filename, "wb");
306    if (!writeHandle) {
307        ALOGE("Couldn't open the file for writing\n");
308        return false;
309    }
310
311    // Open a new stream to make writing the header easier
312    OStream headerStream(5*1024, false);
313    headerStream.addU32(mMajorVersion);
314    headerStream.addU32(mMinorVersion);
315    uint32_t is64Bit = 0;
316    headerStream.addU32(is64Bit);
317
318    uint32_t writeIndexSize = mWriteIndex.size();
319    headerStream.addU32(writeIndexSize);
320    for (uint32_t i = 0; i < writeIndexSize; i ++) {
321        headerStream.addString(mWriteIndex[i]->mObjectName);
322        headerStream.addU32((uint32_t)mWriteIndex[i]->mType);
323        if (mUse64BitOffsets){
324            headerStream.addOffset(mWriteIndex[i]->mOffset);
325            headerStream.addOffset(mWriteIndex[i]->mLength);
326        } else {
327            uint32_t offset = (uint32_t)mWriteIndex[i]->mOffset;
328            headerStream.addU32(offset);
329            offset = (uint32_t)mWriteIndex[i]->mLength;
330            headerStream.addU32(offset);
331        }
332    }
333
334    // Write our magic string so we know we are reading the right file
335    fwrite(A3D_MAGIC_KEY, sizeof(char), strlen(A3D_MAGIC_KEY), writeHandle);
336
337    // Store the size of the header to make it easier to parse when we read it
338    uint64_t headerSize = headerStream.getPos();
339    fwrite(&headerSize, sizeof(headerSize), 1, writeHandle);
340
341    // Now write our header
342    fwrite(headerStream.getPtr(), sizeof(uint8_t), headerStream.getPos(), writeHandle);
343
344    // Now write the size of the data part of the file for easier parsing later
345    uint64_t fileDataSize = mWriteStream->getPos();
346    fwrite(&fileDataSize, sizeof(fileDataSize), 1, writeHandle);
347
348    fwrite(mWriteStream->getPtr(), sizeof(uint8_t), mWriteStream->getPos(), writeHandle);
349
350    int status = fclose(writeHandle);
351
352    if (status != 0) {
353        ALOGE("Couldn't close file\n");
354        return false;
355    }
356
357    return true;
358}
359
360void FileA3D::appendToFile(Context *con, ObjectBase *obj) {
361    if (!obj) {
362        return;
363    }
364    if (!mWriteStream) {
365        const uint64_t initialStreamSize = 256*1024;
366        mWriteStream = new OStream(initialStreamSize, false);
367    }
368    A3DIndexEntry *indexEntry = new A3DIndexEntry();
369    indexEntry->mObjectName = rsuCopyString(obj->getName());
370    indexEntry->mType = obj->getClassId();
371    indexEntry->mOffset = mWriteStream->getPos();
372    indexEntry->mRsObj = obj;
373    mWriteIndex.push(indexEntry);
374    obj->serialize(con, mWriteStream);
375    indexEntry->mLength = mWriteStream->getPos() - indexEntry->mOffset;
376    mWriteStream->align(4);
377}
378
379} // namespace renderscript
380} // namespace android
381