resfile.cpp

liu7788414

/*
* ============================================================================
*  Name     : CResFile from ResFile.cpp
*  Part of  : Game
*  Created  : 2003-06-16 by Qiu Wei Min
*  Implementation notes:
*  Modified : 2003-09-03 by Zheng Jie Sheng
*      To decompress from zlib compressed package. Using old packing tool. 
*  Version  :
*  Copyright: Gameloft S.A.
*
* ============================================================================
*/

// INCLUDE FILES
//#include <AEE.h> 
//#include <AEEfile.h> 
//#include <AEEStdLib.h>
//#include "engine.h"
#include "simplememory.h"
#include "resfile.h"
#include "../zlib/zlib.h"
#include "gfx.h"
//#include "game.h"
// ================= MEMBER FUNCTIONS =======================
// Base
//const int Sign8_cos[] = {0, 1, 1, 1, 0, -1, -1, -1};
//const int Sign8_sin[] = {-1, -1, 0, 1, 1, 1, 0, -1};
extern CSimpleMemory *SMemory;
int FLength=0;

CResFile::CResFile(void)
{
//	m_pEngine = pEngine;
	m_nEntry = 0;
//	m_handle = NULL;
	m_pZlib  = NULL;
	m_pZlib = new CZLibBrew();
	SYS_ASSERT(NULL != m_pZlib);
	if(m_pZlib)
	{
		f = (FileIO*)MALLOC(sizeof(FileIO));
		SYS_ASSERT(NULL != f);
		if(NULL != f)
			CSimpleMemory::Fill((void*)f, 0, sizeof(FileIO));
	}
}

CResFile::~CResFile()
{
/*	if(m_handle)
	{
		IFILE_Release((IFile*)m_handle);
		m_handle = NULL;
	}
*/
	if( m_handle != CFile::hFileNull )
	{
		m_handle.Close();
	}
/*	if(m_pZlib)
	{
		delete m_pZlib;
		m_pZlib = NULL;
	}
*/
	if(f)
	{
		FREE(f);
		f = NULL;
	}
}

bool CResFile::Open(const char *fn)
{
	int iRet = 0;
	long nPak; //number of pakage entry

	if(NULL == f)
		return false;
/*    m_handle = IFILEMGR_OpenFile ((IFileMgr*) m_pEngine->pFileMgr ,fn, _OFM_READ);
	SYS_ASSERT(NULL != m_handle);
	if(NULL ==m_handle)
		return false;
*/
	CFileException ex;
	BOOL ret;

    ret = m_handle.Open(fn, CFile::modeRead | CFile::shareDenyWrite, &ex)
	SYS_ASSERT(NULL != ret);
	SYS_ASSERT(CFile::hFileNull != m_handle);
	if(CFile::hFileNull ==m_handle)
		return false;

	f->isPaked = (char)(m_handle !=NULL);

	int size;
//	iRet = IFILE_Read(m_handle, &nPak, sizeof(nPak)); 
	iRet = m_handle.Read(&nPak, sizeof(nPak));
	if(iRet != sizeof(nPak))
	{
		return false;
	}
	m_nEntry = (int)nPak;
	SYS_ASSERT(nPak >= 0 && nPak <=64000); //max file number on brew.
	size = sizeof(struct Pak ) + nPak *sizeof(struct PakEntry);


	f->pak = (struct Pak*)SMemory->GlobalMalloc(size);
	SYS_ASSERT(NULL != f->pak);
	if(NULL == f->pak)
		return false;
//	IFILE_Seek(m_handle,_SEEK_START,0);
//	IFILE_Read(m_handle, f->pak, size);
	m_handle.Seek(0, CFile::begin);
	m_handle.Read(f->pak, size);

	return true;
}

void* CResFile::FindRecord(const char *name)
{
	unsigned long h = ComputeHash(name);
	int i;
	struct PakEntry *p;
	for(i=0, p=f->pak->aPak; i<f->pak->nPak; i++, p++){
		if(p->nameHash == h)
			return	p;//(void*)i;
	}
	SYS_ASSERT(0);//open failed
	return NULL;
}

unsigned long CResFile::ComputeHash(const char *s)
{
	unsigned long h=0;
	const char *p;
	for(p = s; *p ; p ++) 
		h = ( h << 5 ) - h + *p;
  return h;
}

//void* CResFile::ReadToStack(void *hRecord)
void* CResFile::ReadToStack(const char *fName)
{
/*	int len = GetDecompressedSize(hRecord);
	if(len>=0)
	{
		void* p = SMemory->StackMalloc(len);
		if(NULL != p)
		{
			if(Read(hRecord, p, len))
				return p;
			SMemory->StackFree(p);
		}
	}
	return NULL;
*/
	CFile file;

	if( file.Open(fName, CFile::modeRead | CFile::shareDenyWrite) )
	{
		int len = file.GetLength();
		if( len>0 )
		{
			void *p = SMemory->StackMalloc(len);
			if( p != NULL )
			{
//				if(Read(file, p, len))
				if(file.Read(p, len) == len)
				{
					FLength = len;
					return p;
				}
				else
					SMemory->StackFree(p);
			}
		}
	}

	return NULL;
}

int CResFile::LoadFileToStack(const char *fName, void **pData)
{
	*pData = NULL;
/*	void *h = FindRecord(fName);
	SYS_ASSERT(NULL != h);
	if(NULL == h)
		return -1;
*/
//	void *p = ReadToStack(h);
	void *p = ReadToStack(fName);
	if(p)
	{
//		int size = GetDecompressedSize(h);
//		if(size >= 0)
		{
			*pData = p;
			return FLength;// read to stack ok
		}
//		SMemory->StackFree(NULL);
	}
	return -1;
}

// Size after compression
int CResFile::GetRecordSize(void *hRecord)
{
	
	PakEntry *p = (PakEntry*)hRecord;
	SYS_ASSERT(p != NULL);
	if(NULL == p)
		return -1;
	return p->len;

	/*
	int iRet = -1;
	PakEntry *p = (PakEntry*)hRecord;
	struct lzo *lzo;
	
	//read to temp buf
	lzo = (struct lzo*)SMemory->StackMalloc(sizeof(struct lzo));
	if(NULL == lzo)
		return -1;
	if(SUCCESS != IFILE_Seek((IFile*)m_handle, _SEEK_START, (p->start<<2)))
	{
		SMemory->StackFree(NULL);
		return -1;
	}
	if(IFILE_Read((IFile*)m_handle, lzo, sizeof(struct lzo)) != sizeof(struct lzo)){
		SMemory->StackFree(NULL);
		return -1;
	}
	//len after compress
	iRet = lzo->fileLen;
	SMemory->StackFree(NULL);
	return iRet;*/
}

// Size before compression
int CResFile::GetDecompressedSize(void *hRecord)
{
	int iRet = -1;
	PakEntry *p = (PakEntry*)hRecord;
	struct lzo *lzo;

	//read to temp buf
	lzo = (struct lzo*)SMemory->StackMalloc(sizeof(struct lzo));
	if(NULL == lzo)
		return -1;
//	if(SUCCESS != IFILE_Seek((IFile*)m_handle, _SEEK_START, (p->start<<2)))
	if( !m_handle.Seek((p->start<<2), CFile::begin ))
	{
		SMemory->StackFree(NULL);
		return -1;
	}
//	if(IFILE_Read((IFile*)m_handle, lzo, sizeof(struct lzo)) != sizeof(struct lzo)){
	if(m_handle.Read(lzo, sizeof(struct lzo)) != sizeof(struct lzo)){
		SMemory->StackFree(NULL);
		return -1;
	}
	//len after decompress
	iRet = lzo->uncompLen;
	SMemory->StackFree(NULL);
	return iRet;
}

void* CResFile::ReadBMPToHeap(void *hRecord, bool bGlobal)
{
	int len = GetDecompressedSize(hRecord);
	if(len>=0)
	{
		void* p = SMemory->StackMalloc(len);
		SYS_ASSERT(NULL != p);
		if(NULL == p)
			return NULL;
		if(Read(hRecord, p, len))
		{
			GFXBMP *pBMPHeader;
			if(bGlobal)
				pBMPHeader = (GFXBMP*)SMemory->GlobalMalloc(sizeof(GFXBMP));
			else
				pBMPHeader = (GFXBMP*)SMemory->HeapMalloc(sizeof(GFXBMP));
			SYS_ASSERT(NULL != pBMPHeader);
			CSimpleMemory::Fill(pBMPHeader, 0, sizeof(GFXBMP));
#ifdef BREW11
			MEMCPY(pBMPHeader, p, sizeof(GFXBMP) - 4 - 4);
			int n = len - (sizeof(GFXBMP) - 4 - 4);
#else
			MEMCPY(pBMPHeader, p, sizeof(GFXBMP) - 4);
			int n = len - sizeof(GFXBMP) + 4;
#endif
			if(bGlobal)
				pBMPHeader->pData = (unsigned char*)SMemory->GlobalMalloc(n);
			else
				pBMPHeader->pData = (unsigned char*)SMemory->HeapMalloc(n);
			SYS_ASSERT(NULL != pBMPHeader->pData);
#ifdef BREW11
			MEMCPY(pBMPHeader->pData, (unsigned char*)p + sizeof(GFXBMP) - 4 - 4, n);
#else
			MEMCPY(pBMPHeader->pData, (unsigned char*)p + sizeof(GFXBMP) - 4, n);
#endif

			SMemory->StackFree(p);
			return pBMPHeader;
		}
		SMemory->StackFree(p);
	}
	return NULL;
}

bool CResFile::Read(void *hRecord, void *pBuf, int len, int ofs)
//bool CResFile::Read(CFile file, void *pBuf, int len, int ofs)
{
	struct PakEntry *p = (struct PakEntry*)hRecord;

	struct lzo *lzo;

	if(len == -1) 
		return false;		
	int iCompressedSize = GetRecordSize(hRecord);
	SYS_ASSERT( iCompressedSize >= 0);
	if(iCompressedSize < 0)
		return false;
	//read to temp buf
	lzo = (struct lzo*)SMemory->StackMalloc(iCompressedSize/*len*/);
	SYS_ASSERT(NULL != lzo);
	if(NULL == lzo)
		return false;
//	if(SUCCESS != IFILE_Seek((IFile*)m_handle, _SEEK_START, (p->start<<2)+ ofs))
	if( !m_handle.Seek((p->start<<2)+ ofs, CFile::begin ))
	{
		SMemory->StackFree(NULL);
		return false;
	}
	
//	if( IFILE_Read((IFile*)m_handle, lzo, iCompressedSize) != iCompressedSize)
	if(m_handle.Read(lzo, iCompressedSize) != iCompressedSize)
	{
		SMemory->StackFree(NULL);
		return false;
	}
	SYS_ASSERT(lzo->magic == 'lzod');

	//decompress
#define zbufSize  180000
	void *buf1 = SMemory->StackMalloc(zbufSize);
	SYS_ASSERT(NULL != buf1);
	if(NULL == buf1)
	{
		SMemory->StackFree(NULL);
		return false;
	}
	void *buf2 = SMemory->StackMalloc(zbufSize);
	SYS_ASSERT(NULL != buf2);
	if(NULL == buf2)
	{
		SMemory->StackFree(NULL);
		SMemory->StackFree(NULL);
		return false;
	}
	m_pZlib->initZlibTempBuff( buf1, zbufSize, buf2, zbufSize);

	int out_len = lzo->uncompLen;
	uncompress(	(unsigned char*)m_pZlib,
			(Bytef*)		pBuf,
			(uLongf*)		&out_len,
			(const Bytef*)	lzo->comp,
			(uLong)			lzo->compLen);
	m_pZlib->freeZlibTempBuff();

	SMemory->StackFree(NULL);
	SMemory->StackFree(NULL);
	SMemory->StackFree(NULL);

	return true;
}