/*****************************************************************************
* CTTSEngObj::MapFile *
*---------------------*
* Description:
* Helper function used by SetObjectToken to map file. This function
* assumes that m_cpToken has been initialized.
*****************************************************************************/
HRESULT CTTSEngObj::MapFile( const WCHAR * pszTokenVal, // Value that contains file path
HANDLE * phMapping, // Pointer to file mapping handle
void ** ppvData ) // Pointer to the data
{
USES_CONVERSION;
HRESULT hr = S_OK;
CSpDynamicString dstrFilePath;
hr = m_cpToken->GetStringValue( pszTokenVal, &dstrFilePath );
if ( SUCCEEDED( hr ) )
{
bool fWorked = false;
*phMapping = NULL;
*ppvData = NULL;
HANDLE hFile;
#ifdef _WIN32_WCE
hFile = CreateFileForMapping( dstrFilePath, GENERIC_READ,
FILE_SHARE_READ, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL );
#else
hFile = CreateFile( W2T(dstrFilePath), GENERIC_READ,
FILE_SHARE_READ, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL );
#endif
if (hFile != INVALID_HANDLE_VALUE)
{
*phMapping = ::CreateFileMapping( hFile, NULL, PAGE_READONLY, 0, 0, NULL );
if (*phMapping)
{
*ppvData = ::MapViewOfFile( *phMapping, FILE_MAP_READ, 0, 0, 0 );
if (*ppvData)
{
fWorked = true;
}
}
::CloseHandle( hFile );
}
if (!fWorked)
{
hr = HRESULT_FROM_WIN32(::GetLastError());
if (*phMapping)
{
::CloseHandle(*phMapping);
*phMapping = NULL;
}
}
}
return hr;
} /* CTTSEngObj::MapFile */
BOOL CReader::Open(LPCTSTR pszFileName)
{
CAutoLock lock(&m_csec);
#if defined(_WIN32_WCE)
m_hFile=CreateFileForMapping(pszFileName,GENERIC_READ,NULL,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
#else
m_hFile = CreateFile(pszFileName, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);
#endif
//m_hFile = CreateFile(pszFileName, GENERIC_READ, FILE_SHARE_READ,
// NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (m_hFile == INVALID_HANDLE_VALUE)
{
return FALSE;
}
#if defined(_WIN32_WCE)
else
{
m_dwFileSize=GetFileSize(m_hFile,NULL);
m_dwReadenSize = 0;
SetFilePointer(m_hFile,0,0,FILE_BEGIN);
m_hMapFile=CreateFileMapping(m_hFile,NULL,PAGE_READONLY,0,m_dwFileSize,_T("MUSICMEM"));
if(NULL == m_hMapFile)
{
CloseHandle(m_hFile);
return FALSE;
}
m_byData =(BYTE *)MapViewOfFile(m_hMapFile,FILE_MAP_READ,0,0,0);
if(NULL == m_byData)
{
CloseHandle(m_hFile);
CloseHandle(m_hMapFile);
return FALSE;
}
}
#endif
return TRUE;
}
GF_DataMap *gf_isom_fmo_new(const char *sPath, u8 mode)
{
GF_FileMappingDataMap *tmp;
HANDLE fileH, fileMapH;
DWORD err;
#ifdef _WIN32_WCE
unsigned short sWPath[MAX_PATH];
#endif
//only in read only
if (mode != GF_ISOM_DATA_MAP_READ) return NULL;
tmp = (GF_FileMappingDataMap *) gf_malloc(sizeof(GF_FileMappingDataMap));
if (!tmp) return NULL;
memset(tmp, 0, sizeof(GF_FileMappingDataMap));
tmp->type = GF_ISOM_DATA_FILE_MAPPING;
tmp->mode = mode;
tmp->name = gf_strdup(sPath);
//
// Open the file
//
#ifdef _WIN32_WCE
//convert to WIDE
CE_CharToWide((char *)sPath, sWPath);
fileH = CreateFileForMapping(sWPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
(FILE_ATTRIBUTE_READONLY | FILE_FLAG_RANDOM_ACCESS), NULL );
#else
fileH = CreateFile(sPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
(FILE_ATTRIBUTE_READONLY | FILE_FLAG_RANDOM_ACCESS), NULL );
#endif
if (fileH == INVALID_HANDLE_VALUE) {
gf_free(tmp->name);
gf_free(tmp);
return NULL;
}
tmp->file_size = GetFileSize(fileH, NULL);
if (tmp->file_size == 0xFFFFFFFF) {
CloseHandle(fileH);
gf_free(tmp->name);
gf_free(tmp);
return NULL;
}
//
// Create the mapping
//
fileMapH = CreateFileMapping(fileH, NULL, PAGE_READONLY, 0, 0, NULL);
if (fileMapH == NULL) {
CloseHandle(fileH);
gf_free(tmp->name);
gf_free(tmp);
err = GetLastError();
return NULL;
}
tmp->byte_map = MapViewOfFile(fileMapH, FILE_MAP_READ, 0, 0, 0);
if (tmp->byte_map == NULL) {
CloseHandle(fileMapH);
CloseHandle(fileH);
gf_free(tmp->name);
gf_free(tmp);
return NULL;
}
CloseHandle(fileH);
CloseHandle(fileMapH);
//finaly open our bitstream (from buffer)
tmp->bs = gf_bs_new(tmp->byte_map, tmp->file_size, GF_BITSTREAM_READ);
return (GF_DataMap *)tmp;
}
SDL_RWops *SDL_RWMemoryMapFile(const char *file, const char *mode)
{
SDL_RWops *srcMapFile = NULL, *auxFile = NULL;
HANDLE hFile = NULL, hMapping = NULL;
char *mapBuffer = NULL;
int fileSize = 0;
//Adjust unicode
#ifdef UNICODE
TCHAR uBuf[256];
MultiByteToWideChar(CP_ACP, 0, file, -1, uBuf, 255);
#else
const char *uBuf = file;
#endif
//Get the file size
auxFile = SDL_RWFromFile(file, mode);
if(auxFile)
{
SDL_RWseek( auxFile, 0, SEEK_END ); //tell error without this
fileSize = SDL_RWtell( auxFile );
SDL_RWclose(auxFile);
if(fileSize)
{
//Open file for map
#ifdef _WIN32_WCE
hFile = CreateFileForMapping(uBuf, GENERIC_READ,0, NULL, OPEN_EXISTING, 0, NULL);
#else
hFile = CreateFile(uBuf, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS, NULL);
#endif
if(hFile && hFile != INVALID_HANDLE_VALUE )
{
//Create map
hMapping = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
if(hMapping && hMapping != INVALID_HANDLE_VALUE )
{
//Map whole file (don't allocate memory on PocketPC)
mapBuffer = (char *)MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
if(mapBuffer)
{
srcMapFile = SDL_RWFromMem(mapBuffer, fileSize);
if(srcMapFile)
{
srcMapFile->hidden.mem.hFile = hFile;
srcMapFile->hidden.mem.hMapping = hMapping;
srcMapFile->close = mapfile_close;
}
else
{
UnmapViewOfFile(mapBuffer);
CloseHandle(hMapping);
CloseHandle(hFile);
}
}
else
{
CloseHandle(hMapping);
CloseHandle(hFile);
}
}
else
{
CloseHandle(hFile);
}
}
}
}
if(!srcMapFile)
{
//Open in normal way
return SDL_RWFromFile(file, mode);
}
srcMapFile->hidden.mem.bAutoExpand = 0;
return srcMapFile;
}
/* Map a file into system meory, return the file size */
Ipp64u vm_mmap_create(vm_mmap *handle, vm_char *file, Ipp32s fileAccessAttr)
{
LARGE_INTEGER sizet;
/* check error(s) */
if (NULL == handle)
return 0;
handle->fd_map = NULL;
handle->address = NULL;
if (FLAG_ATTRIBUTE_READ & fileAccessAttr)
{
#ifdef _WIN32_WCE
handle->fd_file = CreateFileForMapping(file,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
#else /* !_WIN32_WCE */
handle->fd_file = CreateFile(file,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_READONLY|FILE_FLAG_RANDOM_ACCESS,
0);
#endif /* _WIN32_WCE */
if (INVALID_HANDLE_VALUE == handle->fd_file)
return 0;
sizet.LowPart = GetFileSize(handle->fd_file, (LPDWORD) &sizet.HighPart);
handle->fd_map = CreateFileMapping(handle->fd_file,
NULL,
PAGE_READONLY,
sizet.HighPart,
sizet.LowPart,
0);
}
else
{
#ifdef _WIN32_WCE
handle->fd_file = CreateFileForMapping(file,
GENERIC_WRITE|GENERIC_READ,
FILE_SHARE_WRITE,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
#else /* !_WIN32_WCE */
handle->fd_file = CreateFile(file,
GENERIC_WRITE|GENERIC_READ,
FILE_SHARE_WRITE,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
0);
#endif /* _WIN32_WCE */
if (INVALID_HANDLE_VALUE == handle->fd_file)
return 0;
sizet.LowPart = 0;
sizet.HighPart = 1;
handle->fd_map = CreateFileMapping(handle->fd_file,
NULL,
PAGE_READWRITE,
0,
sizet.LowPart,
0);
sizet.LowPart = 1024 * 1024 * 1024;
sizet.HighPart = 0;
while (!handle->fd_map)
{
Ipp32u error;
handle->fd_map = CreateFileMapping(handle->fd_file,
NULL,
PAGE_READWRITE,
0,
sizet.LowPart,
0);
error = GetLastError();
if (ERROR_NOT_ENOUGH_MEMORY == error || ERROR_DISK_FULL == error)
sizet.LowPart /= 2;
else
break;
}
}
handle->fAccessAttr = fileAccessAttr;
if (FLAG_ATTRIBUTE_READ & fileAccessAttr || 16*1024*1024 <= sizet.LowPart)
{
if (handle->fd_map)
return (Ipp64u) sizet.QuadPart;
}
vm_mmap_close(handle);
return 0;
} /* Ipp64u vm_mmap_create(vm_mmap *handle, vm_char *file, Ipp32s fileAccessAttr) */
bool CPlaylist::LoadParam()
{
DWORD dwIndex;
DWORD dwFileSize;
DWORD dwFileAttrib;
const char * pszASXFile;
const char * pszParam;
HANDLE hFile;
HANDLE hMap;
bool bLastEntry = false;
bool bGenerator = false;
enum {E_INVALID = 0, E_NOERROR, E_EOF, E_BADMATCH} eError = E_NOERROR;
if (m_bHidden)
{
dwFileAttrib = FILE_ATTRIBUTE_HIDDEN;
}
else
{
dwFileAttrib = FILE_ATTRIBUTE_NORMAL;
}
hFile = CreateFileForMapping(m_pszPath, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, dwFileAttrib, NULL);
if (INVALID_HANDLE_VALUE == hFile)
{
return false;
}
hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
if (NULL == hMap)
{
CloseHandle(hFile);
return false;
}
dwFileSize = GetFileSize(hFile, NULL);
pszASXFile = (char*)MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
if (NULL == pszASXFile)
{
CloseHandle(hMap);
CloseHandle(hFile);
return false;
}
// find the occurance of "LAST ENTRY" (case insensitive)
pszParam = (char*)strnistr(pszASXFile, dwFileSize, "LAST ENTRY");
if((((DWORD)pszParam)-(DWORD)pszASXFile) > (DWORD)pszASXFile)
{
CloseHandle(hMap);
CloseHandle(hFile);
return false;
}
dwIndex = (DWORD)pszParam - (DWORD)pszASXFile;
if (pszParam)
{
dwIndex += strlen("LAST ENTRY");
// skip the trailing quote
if (dwIndex < dwFileSize)
{
if ('\"' == pszASXFile[dwIndex])
{
dwIndex++;
}
}
else if (E_NOERROR == eError)
{
eError = E_EOF;
}
// skip spaces
while (E_NOERROR == eError
&& dwIndex < dwFileSize
&& isspace(pszASXFile[dwIndex]))
{
dwIndex++;
}
if (dwIndex >= dwFileSize && E_NOERROR == eError)
{
eError = E_EOF;
}
// match "VALUE"
if (E_NOERROR == eError
&& dwIndex < dwFileSize
&& 0 == _strnicmp(pszASXFile + dwIndex, "VALUE", 5))
{
dwIndex += strlen("VALUE");
}
else if (E_NOERROR == eError && dwIndex > dwFileSize)
{
eError = E_EOF;
}
// skip spaces
while (E_NOERROR == eError
&& dwIndex < dwFileSize
&& isspace(pszASXFile[dwIndex]))
{
dwIndex++;
}
if (dwIndex >= dwFileSize && E_NOERROR == eError)
{
eError = E_EOF;
}
// match "="
if (dwIndex < dwFileSize && E_NOERROR == eError)
{
if ('=' == pszASXFile[dwIndex])
{
dwIndex++;
}
else
{
eError = E_BADMATCH;
}
}
else if (E_NOERROR == eError)
{
eError = E_EOF;
}
// skip spaces
while (E_NOERROR == eError
&& dwIndex < dwFileSize
&& isspace(pszASXFile[dwIndex]))
{
dwIndex++;
}
if (dwIndex >= dwFileSize && E_NOERROR == eError)
{
eError = E_EOF;
}
// match quote
if (dwIndex < dwFileSize && E_NOERROR == eError)
{
if ('\"' == pszASXFile[dwIndex])
{
dwIndex++;
}
}
else if (E_NOERROR == eError)
{
eError = E_EOF;
}
// get the number
if (E_NOERROR == eError
&& dwIndex < dwFileSize
&& 1 == sscanf(pszASXFile + dwIndex, "%d", &m_iCurrentTrack))
{
bLastEntry = true;
}
else if (E_NOERROR == eError && dwIndex >= dwFileSize)
{
eError = E_BADMATCH;
SetCurrent(-1);
}
}
// find the occurance of "GENERATOR" (case insensitive)
pszParam = (char*)strnistr(pszASXFile, dwFileSize, "GENERATOR");
dwIndex = (DWORD)pszParam - (DWORD)pszASXFile;
if (pszParam)
{
dwIndex += strlen("GENERATOR");
// skip the trailing quote
if (dwIndex < dwFileSize)
{
if ('\"' == pszASXFile[dwIndex])
{
dwIndex++;
}
}
else if (E_NOERROR == eError)
{
eError = E_EOF;
}
// skip spaces
while (E_NOERROR == eError
&& dwIndex < dwFileSize
&& isspace(pszASXFile[dwIndex]))
{
dwIndex++;
}
if (dwIndex >= dwFileSize && E_NOERROR == eError)
{
eError = E_EOF;
}
// match "VALUE"
if (E_NOERROR == eError
&& dwIndex < dwFileSize
&& 0 == _strnicmp(pszASXFile + dwIndex, "VALUE", 5))
{
dwIndex += strlen("VALUE");
}
else if (E_NOERROR == eError && dwIndex > dwFileSize)
{
eError = E_EOF;
}
// skip spaces
while (E_NOERROR == eError
&& dwIndex < dwFileSize
&& isspace(pszASXFile[dwIndex]))
{
dwIndex++;
}
if (dwIndex >= dwFileSize && E_NOERROR == eError)
{
eError = E_EOF;
}
// match "="
if (dwIndex < dwFileSize && E_NOERROR == eError)
{
if ('=' == pszASXFile[dwIndex])
{
dwIndex++;
}
else
{
eError = E_BADMATCH;
}
}
else if (E_NOERROR == eError)
{
eError = E_EOF;
}
// skip spaces
while (E_NOERROR == eError
&& dwIndex < dwFileSize
&& isspace(pszASXFile[dwIndex]))
{
dwIndex++;
}
if (dwIndex >= dwFileSize && E_NOERROR == eError)
{
eError = E_EOF;
}
// match quote
if (dwIndex < dwFileSize && E_NOERROR == eError)
{
if ('\"' == pszASXFile[dwIndex])
{
dwIndex++;
}
}
else if (E_NOERROR == eError)
{
eError = E_EOF;
}
// examine the value
if (E_NOERROR == eError
&& dwIndex < dwFileSize
&& 0 == _strnicmp(pszASXFile + dwIndex, "CEPLAYER", 8))
{
bGenerator = true;
m_bCEPlaylist = true;
}
else if (E_NOERROR == eError && dwIndex >= dwFileSize)
{
eError = E_BADMATCH;
}
}
UnmapViewOfFile(pszASXFile);
CloseHandle(hMap);
CloseHandle(hFile);
return bLastEntry && bGenerator;
}
