1 /******************************************************************************
2 
3  @File         PVRTResourceFile.cpp
4 
5  @Title        PVRTResourceFile.cpp
6 
7  @Version
8 
9  @Copyright    Copyright (c) Imagination Technologies Limited.
10 
11  @Platform     ANSI compatible
12 
13  @Description  Simple resource file wrapper
14 
15 ******************************************************************************/
16 
17 #include "PVRTResourceFile.h"
18 #include <stdio.h>
19 #include <string.h>
20 
21 #include "PVRTResourceFile.h"
22 #include "PVRTString.h"
23 #include "PVRTMemoryFileSystem.h"
24 
25 CPVRTString CPVRTResourceFile::s_ReadPath;
26 
27 static void* LoadFileFunc(const char* pFilename, char** pData, size_t &size)
28 {
29 	size = 0;
30 
31 	FILE* pFile = fopen(pFilename, "rb");
32 
33 	if (pFile)
34 	{
35 		// Get the file size
36 		fseek(pFile, 0, SEEK_END);
37 		size = ftell(pFile);
38 		fseek(pFile, 0, SEEK_SET);
39 
40 		// read the data
41 		char* pTmp = new char[size];
42 		size_t BytesRead = fread(pTmp, 1, size, pFile);
43 
44 		if (BytesRead != size)
45 		{
46 			delete [] pTmp;
47 			pTmp = NULL;
48 			size = 0;
49 		}
50 		else
51 			*pData = pTmp;
52 
53 		fclose(pFile);
54 		return pTmp;
55 	}
56 
57 	return 0;
58 }
59 
60 static bool ReleaseFileFunc(void* handle)
61 {
62 	if(handle)
63 	{
64 		delete[] (char*) handle;
65 		return true;
66 	}
67 
68 	return false;
69 }
70 
71 PFNLoadFileFunc CPVRTResourceFile::s_pLoadFileFunc = &LoadFileFunc;
72 PFNReleaseFileFunc CPVRTResourceFile::s_pReleaseFileFunc = &ReleaseFileFunc;
73 
74 /*!***************************************************************************
75 @Function			SetReadPath
76 @Input				pszReadPath The path where you would like to read from
77 @Description		Sets the read path
78 *****************************************************************************/
79 void CPVRTResourceFile::SetReadPath(const char* const pszReadPath)
80 {
81 	s_ReadPath = (pszReadPath) ? pszReadPath : "";
82 }
83 
84 /*!***************************************************************************
85 @Function			GetReadPath
86 @Returns			The currently set read path
87 @Description		Returns the currently set read path
88 *****************************************************************************/
89 CPVRTString CPVRTResourceFile::GetReadPath()
90 {
91 	return CPVRTString(s_ReadPath);
92 }
93 
94 /*!***************************************************************************
95 @Function			SetLoadReleaseFunctions
96 @Input				pLoadFileFunc Function to use for opening a file
97 @Input				pReleaseFileFunc Function to release any data allocated by the load function
98 @Description		This function is used to override the CPVRTResource file loading functions. If
99                     you pass NULL in as the load function CPVRTResource will use the default functions.
100 *****************************************************************************/
101 void CPVRTResourceFile::SetLoadReleaseFunctions(void* pLoadFileFunc, void* pReleaseFileFunc)
102 {
103 	if(pLoadFileFunc)
104 	{
105 		s_pLoadFileFunc = (PFNLoadFileFunc) pLoadFileFunc;
106 		s_pReleaseFileFunc = (PFNReleaseFileFunc) pReleaseFileFunc;
107 	}
108 	else
109 	{
110 		s_pLoadFileFunc = &LoadFileFunc;
111 		s_pReleaseFileFunc = &ReleaseFileFunc;
112 	}
113 }
114 
115 /*!***************************************************************************
116 @Function			CPVRTResourceFile
117 @Input				pszFilename Name of the file you would like to open
118 @Description		Constructor
119 *****************************************************************************/
120 CPVRTResourceFile::CPVRTResourceFile(const char* const pszFilename) :
121 	m_bOpen(false),
122 	m_bMemoryFile(false),
123 	m_Size(0),
124 	m_pData(0),
125 	m_Handle(0)
126 {
127 	CPVRTString Path(s_ReadPath);
128 	Path += pszFilename;
129 
130 	m_Handle = s_pLoadFileFunc(Path.c_str(), (char**) &m_pData, m_Size);
131 	m_bOpen = (m_pData && m_Size) != 0;
132 
133 	if (!m_bOpen)
134 	{
135 		m_bOpen = m_bMemoryFile = CPVRTMemoryFileSystem::GetFile(pszFilename, (const void**)(&m_pData), &m_Size);
136 	}
137 }
138 
139 /*!***************************************************************************
140 @Function			CPVRTResourceFile
141 @Input				pData A pointer to the data you would like to use
142 @Input				i32Size The size of the data
143 @Description		Constructor
144 *****************************************************************************/
145 CPVRTResourceFile::CPVRTResourceFile(const char* pData, size_t i32Size) :
146 	m_bOpen(true),
147 	m_bMemoryFile(true),
148 	m_Size(i32Size),
149 	m_pData(pData),
150 	m_Handle(0)
151 {
152 }
153 
154 /*!***************************************************************************
155 @Function			~CPVRTResourceFile
156 @Description		Destructor
157 *****************************************************************************/
158 CPVRTResourceFile::~CPVRTResourceFile()
159 {
160 	Close();
161 }
162 
163 /*!***************************************************************************
164 @Function			IsOpen
165 @Returns			true if the file is open
166 @Description		Is the file open
167 *****************************************************************************/
168 bool CPVRTResourceFile::IsOpen() const
169 {
170 	return m_bOpen;
171 }
172 
173 /*!***************************************************************************
174 @Function			IsMemoryFile
175 @Returns			true if the file was opened from memory
176 @Description		Was the file opened from memory
177 *****************************************************************************/
178 bool CPVRTResourceFile::IsMemoryFile() const
179 {
180 	return m_bMemoryFile;
181 }
182 
183 /*!***************************************************************************
184 @Function			Size
185 @Returns			The size of the opened file
186 @Description		Returns the size of the opened file
187 *****************************************************************************/
188 size_t CPVRTResourceFile::Size() const
189 {
190 	return m_Size;
191 }
192 
193 /*!***************************************************************************
194 @Function			DataPtr
195 @Returns			A pointer to the file data
196 @Description		Returns a pointer to the file data
197 *****************************************************************************/
198 const void* CPVRTResourceFile::DataPtr() const
199 {
200 	return m_pData;
201 }
202 
203 /*!***************************************************************************
204 @Function			Close
205 @Description		Closes the file
206 *****************************************************************************/
207 void CPVRTResourceFile::Close()
208 {
209 	if (m_bOpen)
210 	{
211 		if (!m_bMemoryFile && s_pReleaseFileFunc)
212 		{
213 			s_pReleaseFileFunc(m_Handle);
214 		}
215 
216 		m_bMemoryFile = false;
217 		m_bOpen = false;
218 		m_pData = 0;
219 		m_Size = 0;
220 	}
221 }
222 
223 /****************************************************************************
224 ** class CPVRTMemoryFileSystem
225 ****************************************************************************/
226 CPVRTMemoryFileSystem::CAtExit CPVRTMemoryFileSystem::s_AtExit;
227 CPVRTMemoryFileSystem::SFileInfo* CPVRTMemoryFileSystem::s_pFileInfo = 0;
228 int CPVRTMemoryFileSystem::s_i32Capacity = 0;
229 int CPVRTMemoryFileSystem::s_i32NumFiles = 0;
230 
231 /*!***************************************************************************
232 @Function		Destructor
233 @Description	Destructor of CAtExit class. Workaround for platforms that
234 		        don't support the atexit() function. This deletes any memory
235 				file system data.
236 *****************************************************************************/
237 CPVRTMemoryFileSystem::CAtExit::~CAtExit()
238 {
239 	for (int i = 0; i < CPVRTMemoryFileSystem::s_i32NumFiles; ++i)
240 	{
241 		if (CPVRTMemoryFileSystem::s_pFileInfo[i].bAllocated)
242 		{
243 			delete [] (char*)CPVRTMemoryFileSystem::s_pFileInfo[i].pszFilename;
244 			delete [] (char*)CPVRTMemoryFileSystem::s_pFileInfo[i].pBuffer;
245 		}
246 	}
247 	delete [] CPVRTMemoryFileSystem::s_pFileInfo;
248 }
249 
250 CPVRTMemoryFileSystem::CPVRTMemoryFileSystem(const char* pszFilename, const void* pBuffer, size_t Size, bool bCopy)
251 {
252 	RegisterMemoryFile(pszFilename, pBuffer, Size, bCopy);
253 }
254 
255 /*!***************************************************************************
256 @Function		RegisterMemoryFile
257 @Input			pszFilename		Name of file to register
258 @Input			pBuffer			Pointer to file data
259 @Input			Size			File size
260 @Input			bCopy			Name and data should be copied?
261 @Description	Registers a block of memory as a file that can be looked up
262 				by name.
263 *****************************************************************************/
264 void CPVRTMemoryFileSystem::RegisterMemoryFile(const char* pszFilename, const void* pBuffer, size_t Size, bool bCopy)
265 {
266 	if (s_i32NumFiles == s_i32Capacity)
267 	{
268 		SFileInfo* pFileInfo = new SFileInfo[s_i32Capacity + 10];
269 		memcpy(pFileInfo, s_pFileInfo, sizeof(SFileInfo) * s_i32Capacity);
270 		delete [] s_pFileInfo;
271 		s_pFileInfo = pFileInfo;
272 		s_i32Capacity += 10;
273 	}
274 
275 	s_pFileInfo[s_i32NumFiles].pszFilename = pszFilename;
276 	s_pFileInfo[s_i32NumFiles].pBuffer = pBuffer;
277 	if (bCopy)
278 	{
279 		char* pszNewFilename = new char[strlen(pszFilename) + 1];
280 		strcpy(pszNewFilename, pszFilename);
281 		s_pFileInfo[s_i32NumFiles].pszFilename = pszNewFilename;
282 
283 		void* pszNewBuffer = new char[Size];
284 		memcpy(pszNewBuffer, pBuffer, Size);
285 		s_pFileInfo[s_i32NumFiles].pBuffer = pszNewBuffer;
286 	}
287 	s_pFileInfo[s_i32NumFiles].Size = Size;
288 	s_pFileInfo[s_i32NumFiles].bAllocated = bCopy;
289 	++s_i32NumFiles;
290 }
291 
292 /*!***************************************************************************
293 @Function		GetFile
294 @Input			pszFilename		Name of file to open
295 @Output			ppBuffer		Pointer to file data
296 @Output			pSize			File size
297 @Return			true if the file was found in memory, false otherwise
298 @Description	Looks up a file in the memory file system by name. Returns a
299 				pointer to the file data as well as its size on success.
300 *****************************************************************************/
301 bool CPVRTMemoryFileSystem::GetFile(const char* pszFilename, const void** ppBuffer, size_t* pSize)
302 {
303 	for (int i = 0; i < s_i32NumFiles; ++i)
304 	{
305 		if (strcmp(s_pFileInfo[i].pszFilename, pszFilename) == 0)
306 		{
307 			if (ppBuffer) *ppBuffer = s_pFileInfo[i].pBuffer;
308 			if (pSize) *pSize = s_pFileInfo[i].Size;
309 			return true;
310 		}
311 	}
312 	return false;
313 }
314 
315 /*!***************************************************************************
316 @Function		GetNumFiles
317 @Return			The number of registered files
318 @Description	Getter for the number of registered files
319 *****************************************************************************/
320 int CPVRTMemoryFileSystem::GetNumFiles()
321 {
322 	return s_i32NumFiles;
323 }
324 
325 /*!***************************************************************************
326 @Function		GetFilename
327 @Input			i32Index		Index of file
328 @Return			A pointer to the filename of the requested file
329 @Description	Looks up a file in the memory file system by name. Returns a
330 				pointer to the file data as well as its size on success.
331 *****************************************************************************/
332 const char* CPVRTMemoryFileSystem::GetFilename(int i32Index)
333 {
334 	if (i32Index < 0 || i32Index > s_i32NumFiles) return 0;
335 
336 	return s_pFileInfo[i32Index].pszFilename;
337 }
338 
339 
340 /*****************************************************************************
341  End of file (PVRTResourceFile.cpp)
342 *****************************************************************************/
343