void Movie::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
if (usesDebugMessages())
{
printWithTime("audio playing : " + ftostr(m_audio->getPlayingOffset().asSeconds()) + "s");
printWithTime("reference playing : " + ftostr(getPlayingOffset().asSeconds()) + "s");
}
states.transform *= getTransform();
m_video->draw(target, states);
}
void _MEMInfo::_UpdateMI( )
{
#ifdef WIN32
MEMORYSTATUS MS;
GlobalMemoryStatus( &MS );
m_MI.nTotalMem = MS.dwTotalPhys / 1024;
m_MI.nFreeMem = MS.dwAvailPhys / 1024;
#else
char* szfile = ftostr( "/proc/meminfo" );
char* szfind = NULL;
if( szfile )
{
szfind = strstr( szfile, "MemTotal" );
if( szfind )
sscanf( szfind, "MemTotal:\t%u kB",
&m_MI.nTotalMem );
szfind = strstr( szfile, "MemFree" );
if( szfind )
sscanf( szfind, "MemFree:\t%u kB",
&m_MI.nFreeMem );
}
#endif
}
/*
* returns the length of the variable
*/
int v_length(var_t *var) {
char tmpsb[64];
switch (var->type) {
case V_STR:
return strlen(var->v.p.ptr);
case V_MAP:
return map_length(var);
case V_PTR:
ltostr(var->v.ap.p, tmpsb);
return strlen(tmpsb);
case V_INT:
ltostr(var->v.i, tmpsb);
return strlen(tmpsb);
case V_NUM:
ftostr(var->v.n, tmpsb);
return strlen(tmpsb);
case V_ARRAY:
return var->v.a.size;
case V_REF:
return v_length(var->v.ref);
}
return 1;
}
/*
* returns the length of the variable
*/
int v_length(var_t *var) {
char tmpsb[64];
switch (var->type) {
case V_STR:
return strlen((char *) var->v.p.ptr);
case V_UDS:
return uds_length(var);
case V_HASH:
return hash_length(var);
case V_PTR:
ltostr(var->v.ap.p, tmpsb);
return strlen(tmpsb);
case V_INT:
ltostr(var->v.i, tmpsb);
return strlen(tmpsb);
case V_NUM:
ftostr(var->v.n, tmpsb);
return strlen(tmpsb);
case V_ARRAY:
return var->v.a.size;
}
return 1;
}
/*
* returns the string representation of the variable
*/
char *v_str(var_t *arg) {
char *buffer;
switch (arg->type) {
case V_INT:
buffer = malloc(64);
ltostr(arg->v.i, buffer);
break;
case V_NUM:
buffer = malloc(64);
ftostr(arg->v.n, buffer);
break;
case V_STR:
buffer = strdup(arg->v.p.ptr);
break;
case V_ARRAY:
case V_MAP:
buffer = map_to_str(arg);
break;
case V_FUNC:
case V_PTR:
buffer = malloc(5);
strcpy(buffer, "func");
break;
default:
buffer = malloc(1);
buffer[0] = '\0';
break;
}
return buffer;
}
/*
* converts the variable to string-variable
*/
void v_tostr(var_t *arg) {
if (arg->type != V_STR) {
char *tmp;
int l;
tmp = tmp_alloc(64);
switch (arg->type) {
case V_UDS:
uds_to_str(arg, tmp, 64);
uds_free(arg);
break;
case V_HASH:
hash_to_str(arg, tmp, 64);
hash_free_var(arg);
break;
case V_PTR:
ltostr(arg->v.ap.p, tmp);
break;
case V_INT:
ltostr(arg->v.i, tmp);
break;
case V_NUM:
ftostr(arg->v.n, tmp);
break;
default:
err_varisarray();
tmp_free(tmp);
return;
}
l = strlen(tmp) + 1;
arg->type = V_STR;
arg->v.p.ptr = tmp_alloc(l);
arg->v.p.size = l;
strcpy(arg->v.p.ptr, tmp);
tmp_free(tmp);
}
}
/*
* add two variables
* result = a + b
*/
void v_add(var_t *result, var_t *a, var_t *b) {
char tmpsb[64];
if (a->type == V_STR && b->type == V_STR) {
result->type = V_STR;
result->v.p.ptr = malloc(strlen(a->v.p.ptr) +
strlen(b->v.p.ptr) + 1);
strcpy(result->v.p.ptr, a->v.p.ptr);
strcat(result->v.p.ptr, b->v.p.ptr);
result->v.p.size = strlen(result->v.p.ptr) + 1;
return;
} else if (a->type == V_INT && b->type == V_INT) {
result->type = V_INT;
result->v.i = a->v.i + b->v.i;
return;
} else if (a->type == V_NUM && b->type == V_NUM) {
result->type = V_NUM;
result->v.n = a->v.n + b->v.n;
return;
} else if (a->type == V_NUM && b->type == V_INT) {
result->type = V_NUM;
result->v.n = a->v.n + b->v.i;
return;
} else if (a->type == V_INT && b->type == V_NUM) {
result->type = V_NUM;
result->v.n = a->v.i + b->v.n;
return;
} else if (a->type == V_STR && (b->type == V_INT || b->type == V_NUM)) {
if (is_number(a->v.p.ptr)) {
result->type = V_NUM;
if (b->type == V_INT) {
result->v.n = b->v.i + v_getval(a);
} else {
result->v.n = b->v.n + v_getval(a);
}
} else {
result->type = V_STR;
result->v.p.ptr = (char *)malloc(strlen(a->v.p.ptr) + 64);
strcpy(result->v.p.ptr, a->v.p.ptr);
if (b->type == V_INT) {
ltostr(b->v.i, tmpsb);
} else {
ftostr(b->v.n, tmpsb);
}
strcat(result->v.p.ptr, tmpsb);
result->v.p.size = strlen(result->v.p.ptr) + 1;
}
} else if ((a->type == V_INT || a->type == V_NUM) && b->type == V_STR) {
if (is_number(b->v.p.ptr)) {
result->type = V_NUM;
if (a->type == V_INT) {
result->v.n = a->v.i + v_getval(b);
} else {
result->v.n = a->v.n + v_getval(b);
}
} else {
result->type = V_STR;
result->v.p.ptr = (char *)malloc(strlen(b->v.p.ptr) + 64);
if (a->type == V_INT) {
ltostr(a->v.i, tmpsb);
} else {
ftostr(a->v.n, tmpsb);
}
strcpy(result->v.p.ptr, tmpsb);
strcat(result->v.p.ptr, b->v.p.ptr);
result->v.p.size = strlen(result->v.p.ptr) + 1;
}
}
}
void _PROCInfo::_UpdatePI( )
{
int nUseCount = 0;
#ifdef WIN32
HINSTANCE hLib = LoadLibrary("ntdll.dll");
if( hLib == NULL )
return;
NtQuerySystemInformation NTQSI = (NtQuerySystemInformation)
GetProcAddress(hLib,"NtQuerySystemInformation");
if( NTQSI == NULL )
{
FreeLibrary( hLib );
return;
}
char szBuf[MAX_TEMPBUF * 20];
ULONG ulRetLen;
unsigned long ulRet =
NTQSI(
SystemProcessInformation,
szBuf,
MAX_TEMPBUF * 20,
&ulRetLen );
ULONG ulTotalOffset = 0;
PSYSTEM_PROCESSES pSystemProc = (PSYSTEM_PROCESSES)(szBuf);
while( pSystemProc )
{
if( pSystemProc->ProcessId == 0 )
{
strcpy( m_PI.Process[nUseCount].szName, "System Idle Process" );
}
else
{
WideCharToMultiByte(
CP_ACP,
0,
pSystemProc->ProcessName.Buffer,
pSystemProc->ProcessName.Length,
m_PI.Process[nUseCount].szName,
MAX_NAME,
NULL,
NULL);
}
m_PI.Process[nUseCount].nPid = pSystemProc->ProcessId;
m_PI.Process[nUseCount].nMemUseSize =
pSystemProc->VmCounters.WorkingSetSize / 1024;
m_PI.Process[nUseCount].nVmSize =
pSystemProc->VmCounters.PagefileUsage / 1024;
m_PI.Process[nUseCount].nThreadCount = pSystemProc->ThreadCount;
INT64 KnrlTime = 0;
INT64 UserTime = 0;
INT64 CPUTime = 0;
memcpy( &KnrlTime, &pSystemProc->KernelTime, sizeof(INT64) );
memcpy( &UserTime, &pSystemProc->UserTime, sizeof(INT64) );
CPUTime = KnrlTime + UserTime;
CPUTime /= 10000;
CPUTime /= 1000;
m_PI.Process[nUseCount].ulCPUTime = (unsigned long)CPUTime;
nUseCount++;
if( !pSystemProc->NextEntryDelta ||
nUseCount >= MAX_PROCESS_COUNT )
break;
ulTotalOffset += pSystemProc->NextEntryDelta;
pSystemProc = (PSYSTEM_PROCESSES)( szBuf + ulTotalOffset );
}
FreeLibrary( hLib );
#else
DIR* dir;
dirent* ent;
dir = opendir( "/proc" );
while( ent = readdir( dir ) )
{
if( ent->d_name[0] > '0' && ent->d_name[0] < '9' )
{
int nPID = atoi( ent->d_name );
char szFileName[MAX_NAME] = {0};
char* szfile = NULL;
char* szfind = NULL;
unsigned long ulTemp;
INT64 KnrlTime;
INT64 UserTime;
sprintf( szFileName, "/proc/%d/statm", nPID );
szfile = ftostr( szFileName );
if( szfile )
sscanf( szfile, "%u",
&m_PI.Process[nUseCount].nMemUseSize );
sprintf( szFileName, "/proc/%d/status", nPID );
szfile = ftostr( szFileName );
if( szfile )
{
szfind = strstr( szfile, "Name" );
if( szfind )
sscanf(
szfind,
"Name:\t%s",
m_PI.Process[nUseCount].szName );
m_PI.Process[nUseCount].szName[MAX_NAME/6-1] = 0;
szfind = strstr( szfile, "VmSize" );
if( szfind )
sscanf(
szfind,
"VmSize:\t%u kB",
&m_PI.Process[nUseCount].nVmSize );
szfind = strstr( szfile, "Threads" );
if( szfind )
sscanf(
szfind,
"Threads:\t%d",
&m_PI.Process[nUseCount].nThreadCount );
}
m_PI.Process[nUseCount].nPid = nPID;
sprintf( szFileName, "/proc/%d/stat", nPID );
szfile = ftostr( szFileName );
if( szfile )
sscanf(
szfile,
"%d "
"%s "
"%c "
"%d %d %d %d %d "
"%lu %lu %lu %lu %lu %Lu %Lu ",
&ulTemp,
szFileName,
&szFileName[0],
&ulTemp, &ulTemp, &ulTemp, &ulTemp, &ulTemp,
&ulTemp, &ulTemp, &ulTemp, &ulTemp, &ulTemp, &KnrlTime, &UserTime);
m_PI.Process[nUseCount].ulCPUTime = ( KnrlTime + UserTime ) / 100;
nUseCount++;
}
if( nUseCount >= MAX_PROCESS_COUNT )
break;
}
closedir( dir );
#endif
m_PI.nProcessCount = nUseCount;
}
void _CPUInfo::_UpdateCL( )
{
#ifdef WIN32
unsigned long ulElapsedTime =
GetTimetoTickCount( ) - m_ulLoadStart;
if( ulElapsedTime == 0 )
return;
HINSTANCE hLib = LoadLibrary("ntdll.dll");
if( hLib == NULL )
return;
NtQuerySystemInformation NTQSI = (NtQuerySystemInformation)
GetProcAddress(hLib,"NtQuerySystemInformation");
if( NTQSI == NULL )
{
FreeLibrary( hLib );
return;
}
char szBuf[MAX_TEMPBUF];
ULONG ulRetLen;
unsigned long ulRet =
NTQSI(
SystemProcessorPerformanceInformation,
szBuf,
MAX_TEMPBUF,
&ulRetLen );
if( ulRet != fseye_success )
return;
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION* pSI =
(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION*)szBuf;
int nAllCPULoad = 0;
for( int nLoopCount = 0; nLoopCount < m_CI.nProcessorCount; nLoopCount++ )
{
INT64 IdleTime = 0;
memcpy( &IdleTime, &pSI[nLoopCount].IdleTime, sizeof(INT64) );
unsigned int nCPUIdle = (unsigned int)((IdleTime - m_CI.Processor[nLoopCount].CIdleTime) * 100 / (ulElapsedTime * 10000));
nCPUIdle = nCPUIdle > 100 ? 100 : nCPUIdle;
m_CI.Processor[nLoopCount].CIdleTime = IdleTime;
m_CI.Processor[nLoopCount].nLoad = 100 - nCPUIdle;
nAllCPULoad += m_CI.Processor[nLoopCount].nLoad;
}
m_CI.nTotalLoad = nAllCPULoad / m_CI.nProcessorCount;
FreeLibrary( hLib );
#else
char szContent[MAX_NAME];
char szTemp[MAX_NAME];
INT64 nTemp;
INT64 IdleTick = 0;
unsigned long ulElapsedTime =
GetTimetoTickCount( ) - m_ulLoadStart;
if( ulElapsedTime == 0 )
return;
char* szfile = ftostr( "/proc/stat" );
int nAllCPULoad = 0;
for( int nLoopCount = 0; nLoopCount < m_CI.nProcessorCount; nLoopCount++ )
{
INT64 IdleTime = 0;
sprintf( szTemp, "cpu%d", nLoopCount );
char* szfind = strstr( szfile, szTemp );
sscanf(
szfind,
"%s %Lu %Lu %Lu %Lu %[^\n]",
szContent,
&nTemp,
&nTemp,
&nTemp,
&IdleTime,
szTemp );
unsigned int nCPUIdle =
( ( IdleTime - m_CI.Processor[nLoopCount].CIdleTime ) * 100 ) / ( ulElapsedTime / 10 + 1 );
m_CI.Processor[nLoopCount].CIdleTime = IdleTime;
nCPUIdle = nCPUIdle > 100 ? 100 : nCPUIdle;
m_CI.Processor[nLoopCount].nLoad = 100 - nCPUIdle;
nAllCPULoad += m_CI.Processor[nLoopCount].nLoad;
}
m_CI.nTotalLoad = nAllCPULoad / m_CI.nProcessorCount;
#endif
m_ulLoadStart = GetTimetoTickCount( );
}
/*
* add two variables
* result = a + b
*/
void v_add(var_t *result, var_t *a, var_t *b) {
char tmpsb[INT_STR_LEN];
if (a->type == V_STR && b->type == V_STR) {
int length = strlen(a->v.p.ptr) + strlen(b->v.p.ptr);
result->type = V_STR;
result->v.p.ptr = malloc(length + 1);
strcpy(result->v.p.ptr, a->v.p.ptr);
strcat(result->v.p.ptr, b->v.p.ptr);
result->v.p.ptr[length] = '\0';
result->v.p.length = length + 1;
return;
} else if (a->type == V_INT && b->type == V_INT) {
result->type = V_INT;
result->v.i = a->v.i + b->v.i;
return;
} else if (a->type == V_NUM && b->type == V_NUM) {
result->type = V_NUM;
result->v.n = a->v.n + b->v.n;
return;
} else if (a->type == V_NUM && b->type == V_INT) {
result->type = V_NUM;
result->v.n = a->v.n + b->v.i;
return;
} else if (a->type == V_INT && b->type == V_NUM) {
result->type = V_NUM;
result->v.n = a->v.i + b->v.n;
return;
} else if (a->type == V_STR && (b->type == V_INT || b->type == V_NUM)) {
if (is_number(a->v.p.ptr)) {
result->type = V_NUM;
if (b->type == V_INT) {
result->v.n = b->v.i + v_getval(a);
} else {
result->v.n = b->v.n + v_getval(a);
}
} else {
result->type = V_STR;
result->v.p.ptr = (char *)malloc(strlen(a->v.p.ptr) + INT_STR_LEN);
strcpy(result->v.p.ptr, a->v.p.ptr);
if (b->type == V_INT) {
ltostr(b->v.i, tmpsb);
} else {
ftostr(b->v.n, tmpsb);
}
strcat(result->v.p.ptr, tmpsb);
result->v.p.length = strlen(result->v.p.ptr) + 1;
}
} else if ((a->type == V_INT || a->type == V_NUM) && b->type == V_STR) {
if (is_number(b->v.p.ptr)) {
result->type = V_NUM;
if (a->type == V_INT) {
result->v.n = a->v.i + v_getval(b);
} else {
result->v.n = a->v.n + v_getval(b);
}
} else {
result->type = V_STR;
result->v.p.ptr = (char *)malloc(strlen(b->v.p.ptr) + INT_STR_LEN);
if (a->type == V_INT) {
ltostr(a->v.i, tmpsb);
} else {
ftostr(a->v.n, tmpsb);
}
strcpy(result->v.p.ptr, tmpsb);
strcat(result->v.p.ptr, b->v.p.ptr);
result->v.p.length = strlen(result->v.p.ptr) + 1;
}
} else if (b->type == V_MAP) {
char *map = map_to_str(b);
v_set(result, a);
v_strcat(result, map);
free(map);
}
}
