unsigned int CSentence::ComputeDataCheckSum()
{
#if PHONEME_EDITOR
int i;
int c;
CRC32_t crc;
CRC32_Init( &crc );
// Checksum the text
CRC32_ProcessBuffer( &crc, GetText(), Q_strlen( GetText() ) );
// Checsum words and phonemes
c = m_Words.Count();
for ( i = 0; i < c; ++i )
{
CWordTag *word = m_Words[ i ];
unsigned int wordCheckSum = word->ComputeDataCheckSum();
CRC32_ProcessBuffer( &crc, &wordCheckSum, sizeof( unsigned int ) );
}
// Checksum emphasis data
c = m_EmphasisSamples.Count();
for ( i = 0; i < c; ++i )
{
CRC32_ProcessBuffer( &crc, &m_EmphasisSamples[ i ].time, sizeof( float ) );
CRC32_ProcessBuffer( &crc, &m_EmphasisSamples[ i ].value, sizeof( float ) );
}
CRC32_Final( &crc );
return ( unsigned int )crc;
#else
Assert( 0 );
return 0;
#endif
}
unsigned int CWordTag::ComputeDataCheckSum()
{
int i;
int c;
CRC32_t crc;
CRC32_Init( &crc );
// Checksum the text
if ( m_pszWord != NULL )
{
CRC32_ProcessBuffer( &crc, m_pszWord, Q_strlen( m_pszWord ) );
}
// Checksum phonemes
c = m_Phonemes.Count();
for ( i = 0; i < c; ++i )
{
CPhonemeTag *phoneme = m_Phonemes[ i ];
unsigned int phonemeCheckSum = phoneme->ComputeDataCheckSum();
CRC32_ProcessBuffer( &crc, &phonemeCheckSum, sizeof( unsigned int ) );
}
// Checksum timestamps
CRC32_ProcessBuffer( &crc, &m_flStartTime, sizeof( float ) );
CRC32_ProcessBuffer( &crc, &m_flEndTime, sizeof( float ) );
CRC32_Final( &crc );
return ( unsigned int )crc;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : crc -
//-----------------------------------------------------------------------------
void SV_ComputeClassInfosCRC( CRC32_t* crc )
{
ServerClass *pClasses = serverGameDLL->GetAllServerClasses();
for ( ServerClass *pClass=pClasses; pClass; pClass=pClass->m_pNext )
{
CRC32_ProcessBuffer( crc, (void *)pClass->m_pNetworkName, Q_strlen( pClass->m_pNetworkName ) );
CRC32_ProcessBuffer( crc, (void *)pClass->m_pTable->GetName(), Q_strlen(pClass->m_pTable->GetName() ) );
}
}
//-----------------------------------------------------------------------------
// Purpose: Helper function get get determinisitc random values for shared/prediction code
// Input : seedvalue -
// *module -
// line -
// Output : static int
//-----------------------------------------------------------------------------
static int SeedFileLineHash( int seedvalue, const char *sharedname, int additionalSeed )
{
CRC32_t retval;
CRC32_Init( &retval );
CRC32_ProcessBuffer( &retval, (void *)&seedvalue, sizeof( int ) );
CRC32_ProcessBuffer( &retval, (void *)&additionalSeed, sizeof( int ) );
CRC32_ProcessBuffer( &retval, (void *)sharedname, Q_strlen( sharedname ) );
CRC32_Final( &retval );
return (int)( retval );
}
/*
====================
COM_BlockSequenceCRCByte
For proxy protecting
Turns the passed data into a
single byte block CRC based on current network sequence number.
====================
*/
byte COM_BlockSequenceCRCByte (byte *base, int length, int sequence)
{
CRC32_t crc;
byte *p;
byte chkb[60 + 4];
if (sequence < 0)
Sys_Error("sequence < 0, in COM_BlockSequenceCRCByte\n");
p = (byte *)pulCRCTable + (sequence % (NUM_BYTES * sizeof(CRC32_t) - 4));
// Use up to the first 60 bytes of data and a 4 byte value from the
// CRC lookup table (divided into the sequence)
if (length > 60)
length = 60;
memcpy (chkb, base, length);
chkb[length+0] = p[0];
chkb[length+1] = p[1];
chkb[length+2] = p[2];
chkb[length+3] = p[3];
length += 4;
// Compute a crc based on the buffer.
CRC32_Init(&crc);
CRC32_ProcessBuffer(&crc, chkb, length);
CRC32_Final(&crc);
// Chop down to byte size
return (byte)(crc & 0xFF);
}
CRC32_t CShaderDLLVerification::Function1( unsigned char *pData )
{
pData += SHADER_DLL_VERIFY_DATA_PTR_OFFSET;
g_pLastInputData = (unsigned char*)pData;
void *pVerifyPtr1 = &g_Blah;
CRC32_t testCRC;
CRC32_Init( &testCRC );
CRC32_ProcessBuffer( &testCRC, pData, SHADER_DLL_VERIFY_DATA_LEN1 );
CRC32_ProcessBuffer( &testCRC, &g_hDLLInst, 4 );
CRC32_ProcessBuffer( &testCRC, &pVerifyPtr1, 4 );
CRC32_Final( &testCRC );
return testCRC;
}
inline CRC32_t CRC32_ProcessSingleBuffer( const void *p , int len ) {
CRC32_t crc;
CRC32_Init( &crc );
CRC32_ProcessBuffer( &crc , p , len );
CRC32_Final( &crc );
return crc;
}
//-----------------------------------------------------------------------------
// Purpose: Playback sound file that contains phonemes
// Input : *actor -
// *parameters -
//-----------------------------------------------------------------------------
void C_SceneEntity::DispatchStartSpeak( CChoreoScene *scene, C_BaseFlex *actor, CChoreoEvent *event, soundlevel_t iSoundlevel )
{
// Emit sound
if ( IsClientOnly() && actor )
{
CSingleUserRecipientFilter filter( C_BasePlayer::GetLocalPlayer() );
float time_in_past = m_flCurrentTime - event->GetStartTime() ;
float soundtime = gpGlobals->curtime - time_in_past;
EmitSound_t es;
es.m_nChannel = CHAN_VOICE;
es.m_flVolume = 1;
es.m_SoundLevel = iSoundlevel;
es.m_flSoundTime = soundtime;
// No CC since we do it manually
// FIXME: This will change
es.m_bEmitCloseCaption = false;
es.m_pSoundName = event->GetParameters();
EmitSound( filter, actor->entindex(), es );
actor->AddSceneEvent( scene, event, NULL, IsClientOnly() );
// Close captioning only on master token no matter what...
if ( event->GetCloseCaptionType() == CChoreoEvent::CC_MASTER )
{
char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
bool validtoken = event->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) );
if ( validtoken )
{
CRC32_t tokenCRC;
CRC32_Init( &tokenCRC );
char lowercase[ 256 ];
Q_strncpy( lowercase, tok, sizeof( lowercase ) );
Q_strlower( lowercase );
CRC32_ProcessBuffer( &tokenCRC, lowercase, Q_strlen( lowercase ) );
CRC32_Final( &tokenCRC );
float endtime = event->GetLastSlaveEndTime();
float durationShort = event->GetDuration();
float durationLong = endtime - event->GetStartTime();
float duration = MAX( durationShort, durationLong );
CHudCloseCaption *hudCloseCaption = GET_HUDELEMENT( CHudCloseCaption );
if ( hudCloseCaption )
{
hudCloseCaption->ProcessCaption( lowercase, duration );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Create binary compiled version of VCD. Stores to a dictionary for later
// post processing
//-----------------------------------------------------------------------------
bool CreateTargetFile_VCD( const char *pSourceName, const char *pTargetName, bool bWriteToZip, bool bLittleEndian )
{
CUtlBuffer sourceBuf;
if ( !scriptlib->ReadFileToBuffer( pSourceName, sourceBuf ) )
{
return false;
}
CRC32_t crcSource;
CRC32_Init( &crcSource );
CRC32_ProcessBuffer( &crcSource, sourceBuf.Base(), sourceBuf.TellMaxPut() );
CRC32_Final( &crcSource );
ParseFromMemory( (char *)sourceBuf.Base(), sourceBuf.TellMaxPut() );
CChoreoScene *pChoreoScene = ChoreoLoadScene( pSourceName, NULL, &g_SceneTokenProcessor, Msg );
if ( !pChoreoScene )
{
return false;
}
int iScene = g_SceneFiles.AddToTail();
g_SceneFiles[iScene].fileName.Set( pSourceName );
// Walk all events looking for SPEAK events
CChoreoEvent *pEvent;
for ( int i = 0; i < pChoreoScene->GetNumEvents(); ++i )
{
pEvent = pChoreoScene->GetEvent( i );
FindSoundsInEvent( pEvent, g_SceneFiles[iScene].soundList );
}
// calc duration
g_SceneFiles[iScene].msecs = (unsigned int)( pChoreoScene->FindStopTime() * 1000.0f + 0.5f );
// compile to binary buffer
g_SceneFiles[iScene].compiledBuffer.SetBigEndian( !bLittleEndian );
pChoreoScene->SaveToBinaryBuffer( g_SceneFiles[iScene].compiledBuffer, crcSource, &g_ChoreoStringPool );
unsigned int compressedSize;
unsigned char *pCompressedBuffer = LZMA_Compress( (unsigned char *)g_SceneFiles[iScene].compiledBuffer.Base(), g_SceneFiles[iScene].compiledBuffer.TellMaxPut(), &compressedSize );
if ( pCompressedBuffer )
{
// replace the compiled buffer with the compressed version
g_SceneFiles[iScene].compiledBuffer.Purge();
g_SceneFiles[iScene].compiledBuffer.EnsureCapacity( compressedSize );
g_SceneFiles[iScene].compiledBuffer.Put( pCompressedBuffer, compressedSize );
free( pCompressedBuffer );
}
delete pChoreoScene;
return true;
}
unsigned int CPhonemeTag::ComputeDataCheckSum()
{
CRC32_t crc;
CRC32_Init( &crc );
// Checksum the text
CRC32_ProcessBuffer( &crc, m_szPhoneme, Q_strlen( m_szPhoneme ) );
int phonemeCode = GetPhonemeCode();
CRC32_ProcessBuffer( &crc, &phonemeCode, sizeof( int ) );
// Checksum timestamps
float startTime = GetStartTime();
float endTime = GetEndTime();
CRC32_ProcessBuffer( &crc, &startTime, sizeof( float ) );
CRC32_ProcessBuffer( &crc, &endTime, sizeof( float ) );
CRC32_Final( &crc );
return ( unsigned int )crc;
}
//-----------------------------------------------------------------------------
// Purpose: Calcs CRC of all stat data
//-----------------------------------------------------------------------------
int CTFStatPanel::CalcCRC( int iSteamID )
{
CRC32_t crc;
CRC32_Init( &crc );
// make a CRC of stat data
CRC32_ProcessBuffer( &crc, &iSteamID, sizeof( iSteamID ) );
for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass <= TF_LAST_NORMAL_CLASS; iClass++ )
{
// add each class' data to the CRC
ClassStats_t &classStats = GetClassStats( iClass );
CRC32_ProcessBuffer( &crc, &classStats, sizeof( classStats ) );
// since the class data structure is highly guessable from the file, add one other thing to make the CRC hard to hack w/o code disassembly
int iObfuscate = iClass * iClass;
CRC32_ProcessBuffer( &crc, &iObfuscate, sizeof( iObfuscate ) );
}
CRC32_Final( &crc );
return (int) ( crc & 0x7FFFFFFF );
}
unsigned int CSoundCombiner::ComputeChecksum()
{
CRC32_t crc;
CRC32_Init( &crc );
int c = m_Work.Count();
for ( int i = 0; i < c; ++i )
{
CombinerWork *curitem = m_Work[ i ];
unsigned int chk = curitem->sentence.ComputeDataCheckSum();
// Msg( " %i -> sentence %u, startoffset %f fn %s\n",
// i, chk, curitem->entry->startoffset, curitem->entry->wavefile );
CRC32_ProcessBuffer( &crc, &chk, sizeof( unsigned long ) );
CRC32_ProcessBuffer( &crc, &curitem->entry->startoffset, sizeof( float ) );
CRC32_ProcessBuffer( &crc, curitem->entry->wavefile, Q_strlen( curitem->entry->wavefile ) );
}
CRC32_Final( &crc );
return ( unsigned int )crc;
}
/*
===================
qboolean CRC_File(unsigned short *crcvalue, char *pszFileName)
Computes CRC for given file. If there is an error opening/reading the file, returns false,
otherwise returns true and sets the crc value passed to it. The value should be initialized
with CRC_Init
==================
*/
bool CRC_File(CRC32_t *crcvalue, const char *pszFileName)
{
// Always re-init the CRC buffer
CRC32_Init( crcvalue );
FileHandle_t fp;
byte chunk[1024];
int nBytesRead;
int nSize;
nSize = COM_OpenFile(pszFileName, &fp);
if ( !fp || ( nSize == -1 ) )
return FALSE;
// Now read in 1K chunks
while (nSize > 0)
{
if (nSize > 1024)
nBytesRead = g_pFileSystem->Read(chunk, 1024, fp);
else
nBytesRead = g_pFileSystem->Read(chunk, nSize, fp);
// If any data was received, CRC it.
if (nBytesRead > 0)
{
nSize -= nBytesRead;
CRC32_ProcessBuffer(crcvalue, chunk, nBytesRead);
}
// We we are end of file, break loop and return
if ( g_pFileSystem->EndOfFile( fp ) )
{
g_pFileSystem->Close( fp );
fp = 0;
break;
}
// If there was a disk error, indicate failure.
else if ( !g_pFileSystem->IsOk(fp) )
{
if ( fp )
g_pFileSystem->Close(fp);
return FALSE;
}
}
if ( fp )
g_pFileSystem->Close(fp);
return TRUE;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *classname -
// *module -
// line -
// Output : static int
//-----------------------------------------------------------------------------
static int ClassFileLineHash( const char *classname, const char *module, int line )
{
CRC32_t retval;
CRC32_Init( &retval );
char tempbuffer[ 512 ];
// ACK, have to go lower case due to issues with .dsp having different cases of drive
// letters, etc.!!!
Q_strncpy( tempbuffer, classname, sizeof( tempbuffer ) );
Q_strlower( tempbuffer );
CRC32_ProcessBuffer( &retval, (void *)tempbuffer, Q_strlen( tempbuffer ) );
Q_strncpy( tempbuffer, module, sizeof( tempbuffer ) );
Q_strlower( tempbuffer );
CRC32_ProcessBuffer( &retval, (void *)tempbuffer, Q_strlen( tempbuffer ) );
CRC32_ProcessBuffer( &retval, (void *)&line, sizeof( int ) );
CRC32_Final( &retval );
return (int)retval;
}
unsigned short UTIL_GetAchievementEventMask( void )
{
CRC32_t mapCRC;
CRC32_Init( &mapCRC );
char lowercase[ 256 ];
#ifdef CLIENT_DLL
Q_FileBase( engine->GetLevelName(), lowercase, sizeof( lowercase ) );
#else
Q_strncpy( lowercase, STRING( gpGlobals->mapname ), sizeof( lowercase ) );
#endif
Q_strlower( lowercase );
CRC32_ProcessBuffer( &mapCRC, lowercase, Q_strlen( lowercase ) );
CRC32_Final( &mapCRC );
return ( mapCRC & 0xFFFF );
}
void Sys_GetCDKey(char *pszCDKey, int *nLength, int *bDedicated)
{
char key[65];
char hostname[4096];
if (CRehldsPlatformHolder::get()->gethostname(hostname, sizeof(hostname)))
Q_snprintf(key, sizeof(key), "%u", RandomLong(0, 0x7FFFFFFF));
else
{
struct hostent *hostinfo;
hostinfo = CRehldsPlatformHolder::get()->gethostbyname(hostname);
if (hostinfo && hostinfo->h_length == 4 && *hostinfo->h_addr_list != NULL)
{
Q_snprintf(key, sizeof(key), "%u.%u.%u.%u",
(*hostinfo->h_addr_list)[0],
(*hostinfo->h_addr_list)[1],
(*hostinfo->h_addr_list)[2],
(*hostinfo->h_addr_list)[3]);
}
else
{
CRC32_t crc;
#ifdef REHLDS_FIXES
crc = 0;
#endif
CRC32_ProcessBuffer(&crc, hostname, Q_strlen(hostname));
Q_snprintf(key, sizeof(key), "%u", crc);
}
}
key[64] = 0;
Q_strcpy(pszCDKey, key);
if (nLength)
*nLength = Q_strlen(key);
if (bDedicated)
*bDedicated = 0;
}
CRC32_t IFaceposerModels::CFacePoserModel::GetBitmapCRC( int sequence )
{
CStudioHdr *hdr = m_pModel ? m_pModel->GetStudioHdr() : NULL;
if ( !hdr )
return (CRC32_t)-1;
if ( sequence < 0 || sequence >= hdr->GetNumSeq() )
return (CRC32_t)-1;
mstudioseqdesc_t &seqdesc = hdr->pSeqdesc( sequence );
CRC32_t crc;
CRC32_Init( &crc );
// For sequences, we'll checsum a bit of data
CRC32_ProcessBuffer( &crc, (void *)seqdesc.pszLabel(), Q_strlen( seqdesc.pszLabel() ) );
CRC32_ProcessBuffer( &crc, (void *)seqdesc.pszActivityName(), Q_strlen( seqdesc.pszActivityName() ) );
CRC32_ProcessBuffer( &crc, (void *)&seqdesc.flags, sizeof( seqdesc.flags ) );
//CRC32_ProcessBuffer( &crc, (void *)&seqdesc.numevents, sizeof( seqdesc.numevents ) );
CRC32_ProcessBuffer( &crc, (void *)&seqdesc.numblends, sizeof( seqdesc.numblends ) );
CRC32_ProcessBuffer( &crc, (void *)seqdesc.groupsize, sizeof( seqdesc.groupsize ) );
KeyValues *seqKeyValues = new KeyValues("");
if ( seqKeyValues->LoadFromBuffer( m_pModel->GetFileName( ), m_pModel->GetKeyValueText( sequence ) ) )
{
// Yuck, but I need it in a contiguous block of memory... oh well...
CUtlBuffer buf;
seqKeyValues->RecursiveSaveToFile( buf, 0 );
CRC32_ProcessBuffer( &crc, ( void * )buf.Base(), buf.TellPut() );
}
seqKeyValues->deleteThis();
CRC32_Final( &crc );
return crc;
}
CRC32_t GetChecksum(void) const
{
CRC32_t crc;
CRC32_Init(&crc);
CRC32_ProcessBuffer(&crc, &command_number, sizeof(command_number));
CRC32_ProcessBuffer(&crc, &tick_count, sizeof(tick_count));
CRC32_ProcessBuffer(&crc, &viewangles, sizeof(viewangles));
CRC32_ProcessBuffer(&crc, &aimdirection, sizeof(aimdirection));
CRC32_ProcessBuffer(&crc, &forwardmove, sizeof(forwardmove));
CRC32_ProcessBuffer(&crc, &sidemove, sizeof(sidemove));
CRC32_ProcessBuffer(&crc, &upmove, sizeof(upmove));
CRC32_ProcessBuffer(&crc, &buttons, sizeof(buttons));
CRC32_ProcessBuffer(&crc, &impulse, sizeof(impulse));
CRC32_ProcessBuffer(&crc, &weaponselect, sizeof(weaponselect));
CRC32_ProcessBuffer(&crc, &weaponsubtype, sizeof(weaponsubtype));
CRC32_ProcessBuffer(&crc, &random_seed, sizeof(random_seed));
CRC32_ProcessBuffer(&crc, &mousedx, sizeof(mousedx));
CRC32_ProcessBuffer(&crc, &mousedy, sizeof(mousedy));
CRC32_Final(&crc);
return crc;
}
CRC32_t SendTable_CRCTable( CRC32_t &crc, SendTable *pTable )
{
CRC32_ProcessBuffer( &crc, (void *)pTable->m_pNetTableName, Q_strlen( pTable->m_pNetTableName) );
int nProps = LittleLong( pTable->m_nProps );
CRC32_ProcessBuffer( &crc, (void *)&nProps, sizeof( pTable->m_nProps ) );
// Send each property.
for ( int iProp=0; iProp < pTable->m_nProps; iProp++ )
{
const SendProp *pProp = &pTable->m_pProps[iProp];
int type = LittleLong( pProp->m_Type );
CRC32_ProcessBuffer( &crc, (void *)&type, sizeof( type ) );
CRC32_ProcessBuffer( &crc, (void *)pProp->GetName() , Q_strlen( pProp->GetName() ) );
int flags = LittleLong( pProp->GetFlags() );
CRC32_ProcessBuffer( &crc, (void *)&flags, sizeof( flags ) );
if( pProp->m_Type == DPT_DataTable )
{
CRC32_ProcessBuffer( &crc, (void *)pProp->GetDataTable()->m_pNetTableName, Q_strlen( pProp->GetDataTable()->m_pNetTableName ) );
}
else
{
if ( pProp->IsExcludeProp() )
{
CRC32_ProcessBuffer( &crc, (void *)pProp->GetExcludeDTName(), Q_strlen( pProp->GetExcludeDTName() ) );
}
else if ( pProp->GetType() == DPT_Array )
{
int numelements = LittleLong( pProp->GetNumElements() );
CRC32_ProcessBuffer( &crc, (void *)&numelements, sizeof( numelements ) );
}
else
{
float lowvalue;
LittleFloat( &lowvalue, &pProp->m_fLowValue );
CRC32_ProcessBuffer( &crc, (void *)&lowvalue, sizeof( lowvalue ) );
float highvalue;
LittleFloat( &highvalue, &pProp->m_fHighValue );
CRC32_ProcessBuffer( &crc, (void *)&highvalue, sizeof( highvalue ) );
int bits = LittleLong( pProp->m_nBits );
CRC32_ProcessBuffer( &crc, (void *)&bits, sizeof( bits ) );
}
}
}
return crc;
}
/*
===================
qboolean CRC_MapFile(unsigned short *crcvalue, char *pszFileName)
Computes CRC for given map file. If there is an error opening/reading the file, returns false,
otherwise returns true and sets the crc value passed to it. The value should be initialized
with CRC_Init
For map (.bsp) files, the entity lump is not included in the CRC.
//FIXME make this work
==================
*/
bool CRC_MapFile(CRC32_t *crcvalue, const char *pszFileName)
{
FileHandle_t fp;
byte chunk[1024];
int i, l;
int nBytesRead;
dheader_t header;
int nSize;
lump_t *curLump;
long startOfs;
nSize = COM_OpenFile(pszFileName, &fp);
if ( !fp || ( nSize == -1 ) )
return false;
startOfs = g_pFileSystem->Tell(fp);
// Don't CRC the header.
if (g_pFileSystem->Read(&header, sizeof(dheader_t), fp) == 0)
{
Con_Printf("Could not read BSP header for map [%s].\n", pszFileName);
g_pFileSystem->Close(fp);
return false;
}
i = LittleLong (header.version);
if ( i != BSPVERSION )
{
g_pFileSystem->Close(fp);
Con_Printf("Map [%s] has incorrect BSP version (%i should be %i).\n", pszFileName, i, BSPVERSION);
return false;
}
// CRC across all lumps except for the Entities lump
for (l = 0; l < HEADER_LUMPS; l++)
{
if (l == LUMP_ENTITIES)
continue;
curLump = &header.lumps[l];
nSize = curLump->filelen;
g_pFileSystem->Seek( fp, startOfs + curLump->fileofs, FILESYSTEM_SEEK_HEAD );
// Now read in 1K chunks
while (nSize > 0)
{
if (nSize > 1024)
nBytesRead = g_pFileSystem->Read(chunk, 1024, fp);
else
nBytesRead = g_pFileSystem->Read(chunk, nSize, fp);
// If any data was received, CRC it.
if (nBytesRead > 0)
{
nSize -= nBytesRead;
CRC32_ProcessBuffer(crcvalue, chunk, nBytesRead);
}
// If there was a disk error, indicate failure.
if ( !g_pFileSystem->IsOk(fp) )
{
if ( fp )
g_pFileSystem->Close(fp);
return false;
}
}
}
if ( fp )
g_pFileSystem->Close(fp);
return true;
}
