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
27 namespace android {
28 namespace renderscript {
29
FileA3D(Context * rsc)30 FileA3D::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
~FileA3D()41 FileA3D::~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
parseHeader(IStream * headerStream)59 void 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_back(entry);
81 }
82 }
83
load(Asset * asset)84 bool FileA3D::load(Asset *asset) {
85 return false;
86 }
87
load(const void * data,size_t length)88 bool 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
load(FILE * f)142 bool 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 free(headerData);
168 return false;
169 }
170
171 // Now open the stream to parse the header
172 IStream headerStream(headerData, false);
173 parseHeader(&headerStream);
174
175 free(headerData);
176
177 // Next thing is the size of the header
178 len = fread(&mDataSize, 1, sizeof(mDataSize), f);
179 if (len != sizeof(mDataSize) || mDataSize == 0) {
180 return false;
181 }
182
183 ALOGV("file open size = %" PRIi64, mDataSize);
184
185 // We should know enough to read the file in at this point.
186 mAlloc = malloc(mDataSize);
187 if (!mAlloc) {
188 return false;
189 }
190 mData = (uint8_t *)mAlloc;
191 len = fread(mAlloc, 1, mDataSize, f);
192 if (len != mDataSize) {
193 return false;
194 }
195
196 mReadStream = new IStream(mData, mUse64BitOffsets);
197
198 ALOGV("Header is read an stream initialized");
199 return true;
200 }
201
getNumIndexEntries() const202 size_t FileA3D::getNumIndexEntries() const {
203 return mIndex.size();
204 }
205
~A3DIndexEntry()206 FileA3D::A3DIndexEntry::~A3DIndexEntry() {
207 delete[] mObjectName;
208 }
209
getIndexEntry(size_t index) const210 const FileA3D::A3DIndexEntry *FileA3D::getIndexEntry(size_t index) const {
211 if (index < mIndex.size()) {
212 return mIndex[index];
213 }
214 return nullptr;
215 }
216
initializeFromEntry(size_t index)217 ObjectBase *FileA3D::initializeFromEntry(size_t index) {
218 if (index >= mIndex.size()) {
219 return nullptr;
220 }
221
222 FileA3D::A3DIndexEntry *entry = mIndex[index];
223 if (!entry) {
224 return nullptr;
225 }
226
227 if (entry->mRsObj) {
228 entry->mRsObj->incUserRef();
229 return entry->mRsObj;
230 }
231
232 // Seek to the beginning of object
233 mReadStream->reset(entry->mOffset);
234 switch (entry->mType) {
235 case RS_A3D_CLASS_ID_UNKNOWN:
236 return nullptr;
237 case RS_A3D_CLASS_ID_MESH:
238 entry->mRsObj = Mesh::createFromStream(mRSC, mReadStream);
239 break;
240 case RS_A3D_CLASS_ID_TYPE:
241 entry->mRsObj = Type::createFromStream(mRSC, mReadStream);
242 break;
243 case RS_A3D_CLASS_ID_ELEMENT:
244 entry->mRsObj = Element::createFromStream(mRSC, mReadStream);
245 break;
246 case RS_A3D_CLASS_ID_ALLOCATION:
247 entry->mRsObj = Allocation::createFromStream(mRSC, mReadStream);
248 break;
249 case RS_A3D_CLASS_ID_PROGRAM_VERTEX:
250 //entry->mRsObj = ProgramVertex::createFromStream(mRSC, mReadStream);
251 break;
252 case RS_A3D_CLASS_ID_PROGRAM_RASTER:
253 //entry->mRsObj = ProgramRaster::createFromStream(mRSC, mReadStream);
254 break;
255 case RS_A3D_CLASS_ID_PROGRAM_FRAGMENT:
256 //entry->mRsObj = ProgramFragment::createFromStream(mRSC, mReadStream);
257 break;
258 case RS_A3D_CLASS_ID_PROGRAM_STORE:
259 //entry->mRsObj = ProgramStore::createFromStream(mRSC, mReadStream);
260 break;
261 case RS_A3D_CLASS_ID_SAMPLER:
262 //entry->mRsObj = Sampler::createFromStream(mRSC, mReadStream);
263 break;
264 case RS_A3D_CLASS_ID_ANIMATION:
265 //entry->mRsObj = Animation::createFromStream(mRSC, mReadStream);
266 break;
267 case RS_A3D_CLASS_ID_ADAPTER_1D:
268 //entry->mRsObj = Adapter1D::createFromStream(mRSC, mReadStream);
269 break;
270 case RS_A3D_CLASS_ID_ADAPTER_2D:
271 //entry->mRsObj = Adapter2D::createFromStream(mRSC, mReadStream);
272 break;
273 case RS_A3D_CLASS_ID_SCRIPT_C:
274 break;
275 case RS_A3D_CLASS_ID_SCRIPT_KERNEL_ID:
276 break;
277 case RS_A3D_CLASS_ID_SCRIPT_INVOKE_ID:
278 break;
279 case RS_A3D_CLASS_ID_SCRIPT_FIELD_ID:
280 break;
281 case RS_A3D_CLASS_ID_SCRIPT_METHOD_ID:
282 break;
283 case RS_A3D_CLASS_ID_SCRIPT_GROUP:
284 break;
285 case RS_A3D_CLASS_ID_CLOSURE:
286 break;
287 case RS_A3D_CLASS_ID_SCRIPT_GROUP2:
288 break;
289 }
290 if (entry->mRsObj) {
291 entry->mRsObj->incUserRef();
292 }
293 return entry->mRsObj;
294 }
295
writeFile(const char * filename)296 bool FileA3D::writeFile(const char *filename) {
297 if (!mWriteStream) {
298 ALOGE("No objects to write\n");
299 return false;
300 }
301 if (mWriteStream->getPos() == 0) {
302 ALOGE("No objects to write\n");
303 return false;
304 }
305
306 FILE *writeHandle = fopen(filename, "wbe");
307 if (!writeHandle) {
308 ALOGE("Couldn't open the file for writing\n");
309 return false;
310 }
311
312 // Open a new stream to make writing the header easier
313 OStream headerStream(5*1024, false);
314 headerStream.addU32(mMajorVersion);
315 headerStream.addU32(mMinorVersion);
316 uint32_t is64Bit = 0;
317 headerStream.addU32(is64Bit);
318
319 uint32_t writeIndexSize = mWriteIndex.size();
320 headerStream.addU32(writeIndexSize);
321 for (uint32_t i = 0; i < writeIndexSize; i ++) {
322 headerStream.addString(mWriteIndex[i]->mObjectName);
323 headerStream.addU32((uint32_t)mWriteIndex[i]->mType);
324 if (mUse64BitOffsets){
325 headerStream.addOffset(mWriteIndex[i]->mOffset);
326 headerStream.addOffset(mWriteIndex[i]->mLength);
327 } else {
328 uint32_t offset = (uint32_t)mWriteIndex[i]->mOffset;
329 headerStream.addU32(offset);
330 offset = (uint32_t)mWriteIndex[i]->mLength;
331 headerStream.addU32(offset);
332 }
333 }
334
335 // Write our magic string so we know we are reading the right file
336 fwrite(A3D_MAGIC_KEY, sizeof(char), strlen(A3D_MAGIC_KEY), writeHandle);
337
338 // Store the size of the header to make it easier to parse when we read it
339 uint64_t headerSize = headerStream.getPos();
340 fwrite(&headerSize, sizeof(headerSize), 1, writeHandle);
341
342 // Now write our header
343 fwrite(headerStream.getPtr(), sizeof(uint8_t), headerStream.getPos(), writeHandle);
344
345 // Now write the size of the data part of the file for easier parsing later
346 uint64_t fileDataSize = mWriteStream->getPos();
347 fwrite(&fileDataSize, sizeof(fileDataSize), 1, writeHandle);
348
349 fwrite(mWriteStream->getPtr(), sizeof(uint8_t), mWriteStream->getPos(), writeHandle);
350
351 int status = fclose(writeHandle);
352
353 if (status != 0) {
354 ALOGE("Couldn't close file\n");
355 return false;
356 }
357
358 return true;
359 }
360
appendToFile(Context * con,ObjectBase * obj)361 void FileA3D::appendToFile(Context *con, ObjectBase *obj) {
362 if (!obj) {
363 return;
364 }
365 if (!mWriteStream) {
366 const uint64_t initialStreamSize = 256*1024;
367 mWriteStream = new OStream(initialStreamSize, false);
368 }
369 A3DIndexEntry *indexEntry = new A3DIndexEntry();
370 indexEntry->mObjectName = rsuCopyString(obj->getName());
371 indexEntry->mType = obj->getClassId();
372 indexEntry->mOffset = mWriteStream->getPos();
373 indexEntry->mRsObj = obj;
374 mWriteIndex.push_back(indexEntry);
375 obj->serialize(con, mWriteStream);
376 indexEntry->mLength = mWriteStream->getPos() - indexEntry->mOffset;
377 mWriteStream->align(4);
378 }
379
380 } // namespace renderscript
381 } // namespace android
382