CArchiveScanner::CArchiveScanner()
: isDirty(false)
{
std::ostringstream file;
// the "cache" dir is created in DataDirLocater
file << FileSystem::GetCacheDir();
file << FileSystem::GetNativePathSeparator();
file << "ArchiveCache.lua";
cachefile = file.str();
ReadCacheData(dataDirLocater.GetWriteDirPath() + GetFilename());
const std::vector<std::string>& datadirs = dataDirLocater.GetDataDirPaths();
std::vector<std::string> scanDirs;
for (std::vector<std::string>::const_reverse_iterator d = datadirs.rbegin(); d != datadirs.rend(); ++d) {
scanDirs.push_back(*d + "maps");
scanDirs.push_back(*d + "base");
scanDirs.push_back(*d + "games");
scanDirs.push_back(*d + "packages");
}
// ArchiveCache has been parsed at this point --> archiveInfos is populated
ScanDirs(scanDirs, true);
WriteCacheData(dataDirLocater.GetWriteDirPath() + GetFilename());
}
int CStreamParser::MpegStreamSync( __int64 * checked )
{
BYTE *ptr ;
FRAME_HEADER * head ;
DWORD synced ;
int count ;
int ret = 0;
//Copy to temp buffer
if( m_DataLeft < 0 )
{
//TRACE( "CStreamParser::MpegStreamSync m_Dataleft = %d\r\n\r\n", m_DataLeft );
return 0;
}
assert( m_DataLeft >= 0 );
memcpy( m_synTempBuf , m_StreamData , m_DataLeft ) ;
head = ( FRAME_HEADER * ) m_StreamData ;
head->SyncFlag = SYN_HEADER ;
count = m_DataLeft ;
//shift = 0xFFFFFFFF ;
synced = 0 ;
//DWORD SyncFlag = SYN_HEADER;
while(1)
{
ptr = m_synTempBuf ;
while( count > 4 )
{
if( *(DWORD*)ptr == SYN_HEADER )
{
assert( count >= 0 );
memcpy( m_StreamData , ptr , count ) ;
m_DataLeft = count ;
//int test = ( synced - 4 );
if( checked )
*checked = ( synced ) ;
return 1 ;
}
ptr++;
count--;
synced++ ;//同步掉的字节数，即从当前字节直到找到SYN_HEADER字节扔掉的字节数
}
//Copy剩下的四个字节
memcpy( m_synTempBuf, ptr, count );
ptr = m_synTempBuf + count;
ret = ReadCacheData( ptr , MAX_STREAM_BUFFER_LEN - count ) ; //同步时尽量多读点
if( ret <= 0 )
return ret;
count += ret;
}
//return 0 ;
}
CArchiveScanner::CArchiveScanner()
: isDirty(false)
{
// the "cache" dir is created in DataDirLocater
const std:: string cacheFolder = dataDirLocater.GetWriteDirPath() + FileSystem::EnsurePathSepAtEnd(FileSystem::GetCacheBaseDir());
cachefile = cacheFolder + IntToString(INTERNAL_VER, "ArchiveCache%i.lua");
ReadCacheData(GetFilepath());
if (archiveInfos.empty()) {
// when versioned ArchiveCache%i.lua is missing or empty, try old unversioned filename
ReadCacheData(cacheFolder + "ArchiveCache.lua");
}
const std::vector<std::string>& datadirs = dataDirLocater.GetDataDirPaths();
std::vector<std::string> scanDirs;
for (auto d = datadirs.rbegin(); d != datadirs.rend(); ++d) {
scanDirs.push_back(*d + "maps");
scanDirs.push_back(*d + "base");
scanDirs.push_back(*d + "games");
scanDirs.push_back(*d + "packages");
}
// ArchiveCache has been parsed at this point --> archiveInfos is populated
ScanDirs(scanDirs, true);
WriteCacheData(GetFilepath());
}
void CArchiveScanner::Reload()
{
// {Read,Write,Scan}* all grab this too but we need the entire reloading-sequence to appear atomic
std::lock_guard<spring::recursive_mutex> lck(scannerMutex);
// dtor
if (isDirty)
WriteCacheData(GetFilepath());
archiveInfos.clear();
brokenArchives.clear();
cachefile.clear();
// ctor
ReadCacheData(cachefile = FileSystem::EnsurePathSepAtEnd(FileSystem::GetCacheDir()) + IntToString(INTERNAL_VER, "ArchiveCache%i.lua"));
ScanAllDirs();
}
void CSimRequest::RunL()
{
TBool stop = EFalse;
if (iStage == EUninitialized) {
iStage = EInitialized;
if (iType == EHistoryCache) {
stop = CheckFile();
}
else if (iType == EFileCache) {
iObserver->OnSimRequestData(MSimRequestObserver::ESimReqHeader);
}
else if (iType == ESimNoCacheError) {
iObserver->OnSimRequestData(MSimRequestObserver::ESimReqNoCache);
stop = ETrue;
}
else if (iType == ESimApError) {
iObserver->OnSimRequestData(MSimRequestObserver::ESimReqError);
stop = ETrue;
}
else
stop = ETrue;
}
else if (iStage != EError) {
if (iType == EHistoryCache)
stop = ReadData();
else if (iType == EFileCache)
stop = ReadCacheData();
else
stop = ETrue;
}
if (stop) {
iStage = EError;
}
else {
iTimer.After(iStatus, 5);
SetActive();
}
}
CArchiveScanner::CArchiveScanner()
: isDirty(false)
{
std::ostringstream file;
// the "cache" dir is created in DataDirLocater
file << "cache" << (char)FileSystemHandler::GetNativePathSeparator() << "ArchiveCache.lua";
cachefile = file.str();
FileSystemHandler& fsh = FileSystemHandler::GetInstance();
ReadCacheData(fsh.GetWriteDir() + GetFilename());
const std::vector<std::string>& datadirs = fsh.GetDataDirectories();
std::vector<std::string> scanDirs;
for (std::vector<std::string>::const_reverse_iterator d = datadirs.rbegin(); d != datadirs.rend(); ++d) {
scanDirs.push_back(*d + "maps");
scanDirs.push_back(*d + "base");
scanDirs.push_back(*d + "mods");
scanDirs.push_back(*d + "packages");
}
ScanDirs(scanDirs, true);
WriteCacheData(fsh.GetWriteDir() + GetFilename());
}
//
// GetOneFrame
// 从内部数据区解析一帧(包括4个字节的尾部)，如果失去同步，则自动进行同步处理
//
//int CStreamParser::GetOneFrameAndTail( BYTE * dst , FRAME_HEADER * frameHeader )
//增加同步头，无同步尾
int CStreamParser::GetOneFrame( BYTE * dst , FRAME_HEADER * frameHeader )
{
FRAME_HEADER * head ;
BYTE *pBuf ;
int ret ;
int len = 0 ;
int retval = 0;
//先填充一个帧头长的数据
if( m_DataLeft < sizeof(FRAME_HEADER) )
{
BYTE* pData = m_StreamData + m_DataLeft ;
ret = ReadCacheData( pData , sizeof(FRAME_HEADER) - m_DataLeft ) ;
if( ret <= 0 )
{
//TRACE(_T("ReadCacheData return:%d \r\n",ret);
return ret;
}
m_DataLeft += ret ;
}
head = ( FRAME_HEADER * ) m_StreamData ;
pBuf = ( BYTE * )( head + 1 ) ;
while(1)
{
if ( head->SyncFlag == SYN_HEADER )
{
if( m_DataLeft < sizeof(FRAME_HEADER) )//缓冲中不够一个帧头的长度
{
ReadCacheData( m_StreamData + m_DataLeft, sizeof(FRAME_HEADER) - m_DataLeft );
m_DataLeft = sizeof( FRAME_HEADER );
}
len = htonl( head->FrameLength) ;
ret = len ;
memcpy( frameHeader, head, sizeof(FRAME_HEADER) );
m_DataLeft -= sizeof( FRAME_HEADER );
if( ret <= 0 )
{
//TRACE(_T("帧长度异常为负数 ret = %d\r\n", ret );
return ret;
}
if( ret > (MAX_FRAME_LENGTH - 1024 * 1024) )
{
//TRACE(_T("帧太长 ret = %d\r\n", ret );
return -1;
}
if( len <= m_DataLeft )//如果缓冲中有数据
{
//最后的剩余数据
assert( len > 0 );
memcpy( dst , pBuf , len ) ;
//Adjust the internal buffer
m_DataLeft -= len ;
pBuf += len ;
assert( m_DataLeft >= 0 );
memmove( m_StreamData , pBuf , m_DataLeft ) ;
if( ret <= 0 )
{
//TRACE(_T("GetOneFrame::ret = %d\r\n", ret);
}
return ret ;
}
//data is not enough, we should read more
if(m_DataLeft < 0)
m_DataLeft = 0;
assert( m_DataLeft >= 0 );
if( m_DataLeft > 0 )
memcpy( dst , pBuf , m_DataLeft ) ;
len -= m_DataLeft ;
dst += m_DataLeft ;
m_DataLeft = 0 ;
while( len > 0 )//不可能死循环
{
//接下来从直接从Cache中读数据
retval = ReadCacheData( dst, len );
if( retval <= 0 )
return retval;
len -= retval;
dst += retval;
}
return ret;
}
//帧没有同步上，开始进行同步搜索
ret = MpegStreamSync( NULL );
if( ret <= 0 )
{
//TRACE(_T("GetOneFrame::MpegStreamSync return 0\r\n");
return ret ;
}
head = ( FRAME_HEADER * ) m_StreamData ;
pBuf = ( BYTE * )( head + 1 ) ;
}
}
CArchiveScanner::CArchiveScanner(): isDirty(false)
{
// the "cache" dir is created in DataDirLocater
ReadCacheData(cachefile = FileSystem::EnsurePathSepAtEnd(FileSystem::GetCacheDir()) + IntToString(INTERNAL_VER, "ArchiveCache%i.lua"));
ScanAllDirs();
}
