/*************************************************************************** fps.c - description ------------------- begin : Sun Oct 28 2001 copyright : (C) 2001 by Pete Bernert email : BlackDove@addcom.de ***************************************************************************/ /*************************************************************************** * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. See also the license.txt file for * * additional informations. * * * ***************************************************************************/ // FPS stuff float fFrameRateHz=0; DWORD dwFrameRateTicks=16; float fFrameRate=200.0f; int iFrameLimit=2; int UseFrameLimit=0; int UseFrameSkip=0; // FPS skipping / limit BOOL bInitCap = TRUE; float fps_skip = 0; float fps_cur = 0; #define TIMEBASE 100000 #define MAXLACE 16 #define MAXSKIP 120 static void calcfps(void); static void FrameCap(void); void CheckFrameRate(void) { if(UseFrameSkip) // skipping mode? { if(!(dwActFixes&0x80)) // not old skipping mode? { dwLaceCnt++; // -> store cnt of vsync between frames if(dwLaceCnt>=MAXLACE && UseFrameLimit) // -> if there are many laces without screen toggling, { // do std frame limitation if(dwLaceCnt==MAXLACE) bInitCap=TRUE; FrameCap(); } } else if(UseFrameLimit) FrameCap(); calcfps(); // -> calc fps display in skipping mode } else // non-skipping mode: { if(UseFrameLimit) FrameCap(); // -> do it calcfps(); // -> and calc fps display } } static unsigned long timeGetTime(void) { struct timeval tv; gettimeofday(&tv, 0); // well, maybe there are better ways return tv.tv_sec * 100000 + tv.tv_usec/10; // to do that, but at least it works } static void FrameCap (void) { static unsigned long curticks, lastticks, _ticks_since_last_update; static unsigned int TicksToWait = 0; int overslept=0, tickstogo=0; BOOL Waiting = TRUE; { curticks = timeGetTime(); _ticks_since_last_update = curticks - lastticks; if((_ticks_since_last_update > TicksToWait) || (curticks dwFrameRateTicks) TicksToWait=0; else TicksToWait=dwFrameRateTicks - overslept; } else { while (Waiting) { curticks = timeGetTime(); _ticks_since_last_update = curticks - lastticks; tickstogo = TicksToWait - _ticks_since_last_update; if ((_ticks_since_last_update > TicksToWait) || (curticks < lastticks) || tickstogo < overslept) { Waiting = FALSE; lastticks = curticks; overslept = _ticks_since_last_update - TicksToWait; TicksToWait = dwFrameRateTicks - overslept; return; } if (tickstogo >= 200 && !(dwActFixes&16)) usleep(tickstogo*10 - 200); } } } } static void FrameSkip(void) { static int iNumSkips=0,iAdditionalSkip=0; // number of additional frames to skip static DWORD dwLastLace=0; // helper var for frame limitation static DWORD curticks, lastticks, _ticks_since_last_update; int tickstogo=0; static int overslept=0; if(!dwLaceCnt) return; // important: if no updatelace happened, we ignore it completely if(iNumSkips) // we are in skipping mode? { dwLastLace+=dwLaceCnt; // -> calc frame limit helper (number of laces) bSkipNextFrame = TRUE; // -> we skip next frame iNumSkips--; // -> ok, one done } else // ok, no additional skipping has to be done... { // we check now, if some limitation is needed, or a new skipping has to get started DWORD dwWaitTime; if(bInitCap || bSkipNextFrame) // first time or we skipped before? { if(UseFrameLimit && !bInitCap) // frame limit wanted and not first time called? { DWORD dwT=_ticks_since_last_update; // -> that's the time of the last drawn frame dwLastLace+=dwLaceCnt; // -> and that's the number of updatelace since the start of the last drawn frame curticks = timeGetTime(); // -> now we calc the time of the last drawn frame + the time we spent skipping _ticks_since_last_update= dwT+curticks - lastticks; dwWaitTime=dwLastLace*dwFrameRateTicks; // -> and now we calc the time the real psx would have needed if(_ticks_since_last_update we were too fast? { if((dwWaitTime-_ticks_since_last_update)> // -> some more security, to prevent (60*dwFrameRateTicks)) // wrong waiting times _ticks_since_last_update=dwWaitTime; while(_ticks_since_last_update loop until we have reached the real psx time { // (that's the additional limitation, yup) curticks = timeGetTime(); _ticks_since_last_update = dwT+curticks - lastticks; } } else // we were still too slow ?!!? { if(iAdditionalSkip well, somewhen we really have to stop skipping on very slow systems { iAdditionalSkip++; // -> inc our watchdog var dwLaceCnt=0; // -> reset lace count lastticks = timeGetTime(); return; // -> done, we will skip next frame to get more speed } } } bInitCap=FALSE; // -> ok, we have inited the frameskip func iAdditionalSkip=0; // -> init additional skip bSkipNextFrame=FALSE; // -> we don't skip the next frame lastticks = timeGetTime(); // -> we store the start time of the next frame dwLaceCnt=0; // -> and we start to count the laces dwLastLace=0; _ticks_since_last_update=0; return; // -> done, the next frame will get drawn } bSkipNextFrame=FALSE; // init the frame skip signal to 'no skipping' first curticks = timeGetTime(); // get the current time (we are now at the end of one drawn frame) _ticks_since_last_update = curticks - lastticks; dwLastLace=dwLaceCnt; // store curr count (frame limitation helper) dwWaitTime=dwLaceCnt*dwFrameRateTicks; // calc the 'real psx lace time' if (dwWaitTime >= overslept) dwWaitTime-=overslept; if(_ticks_since_last_update>dwWaitTime) // hey, we needed way too long for that frame... { if(UseFrameLimit) // if limitation, we skip just next frame, { // and decide after, if we need to do more iNumSkips=0; } else { iNumSkips=_ticks_since_last_update/dwWaitTime; // -> calc number of frames to skip to catch up iNumSkips--; // -> since we already skip next frame, one down if(iNumSkips>MAXSKIP) iNumSkips=MAXSKIP; // -> well, somewhere we have to draw a line } bSkipNextFrame = TRUE; // -> signal for skipping the next frame } else // we were faster than real psx? fine :) if(UseFrameLimit) // frame limit used? so we wait til the 'real psx time' has been reached { if(dwLaceCnt>MAXLACE) // -> security check _ticks_since_last_update=dwWaitTime; while(_ticks_since_last_update just do a waiting loop... { curticks = timeGetTime(); _ticks_since_last_update = curticks - lastticks; tickstogo = dwWaitTime - _ticks_since_last_update; if (tickstogo-overslept >= 200 && !(dwActFixes&16)) usleep(tickstogo*10 - 200); } } overslept = _ticks_since_last_update - dwWaitTime; if (overslept < 0) overslept = 0; lastticks = timeGetTime(); // ok, start time of the next frame } dwLaceCnt=0; // init lace counter } static void calcfps(void) { static unsigned long curticks,_ticks_since_last_update,lastticks; static long fps_cnt = 0; static unsigned long fps_tck = 1; static long fpsskip_cnt = 0; static unsigned long fpsskip_tck = 1; { curticks = timeGetTime(); _ticks_since_last_update=curticks-lastticks; if(UseFrameSkip && !UseFrameLimit && _ticks_since_last_update) fps_skip=min(fps_skip,((float)TIMEBASE/(float)_ticks_since_last_update+1.0f)); lastticks = curticks; } if(UseFrameSkip && UseFrameLimit) { fpsskip_tck += _ticks_since_last_update; if(++fpsskip_cnt==2) { fps_skip = (float)2000/(float)fpsskip_tck; fps_skip +=6.0f; fpsskip_cnt = 0; fpsskip_tck = 1; } } fps_tck += _ticks_since_last_update; if(++fps_cnt==20) { fps_cur = (float)(TIMEBASE*20)/(float)fps_tck; fps_cnt = 0; fps_tck = 1; } } static void PCFrameCap (void) { static unsigned long curticks, lastticks, _ticks_since_last_update; static unsigned long TicksToWait = 0; BOOL Waiting = TRUE; while (Waiting) { curticks = timeGetTime(); _ticks_since_last_update = curticks - lastticks; if ((_ticks_since_last_update > TicksToWait) || (curticks < lastticks)) { Waiting = FALSE; lastticks = curticks; TicksToWait = (TIMEBASE/ (unsigned long)fFrameRateHz); } } } static void PCcalcfps(void) { static unsigned long curticks,_ticks_since_last_update,lastticks; static long fps_cnt = 0; static float fps_acc = 0; float CurrentFPS=0; curticks = timeGetTime(); _ticks_since_last_update=curticks-lastticks; if(_ticks_since_last_update) CurrentFPS=(float)TIMEBASE/(float)_ticks_since_last_update; else CurrentFPS = 0; lastticks = curticks; fps_acc += CurrentFPS; if(++fps_cnt==10) { fps_cur = fps_acc / 10; fps_acc = 0; fps_cnt = 0; } fps_skip=CurrentFPS+1.0f; } void SetAutoFrameCap(void) { if(iFrameLimit==1) { fFrameRateHz = fFrameRate; dwFrameRateTicks=(TIMEBASE*100 / (unsigned long)(fFrameRateHz*100)); return; } if(dwActFixes&32) { if (PSXDisplay.Interlaced) fFrameRateHz = PSXDisplay.PAL?50.0f:60.0f; else fFrameRateHz = PSXDisplay.PAL?25.0f:30.0f; } else { fFrameRateHz = PSXDisplay.PAL?50.0f:59.94f; dwFrameRateTicks=(TIMEBASE*100 / (unsigned long)(fFrameRateHz*100)); } } static void InitFPS(void) { if(!fFrameRate) fFrameRate=200.0f; if(fFrameRateHz==0) fFrameRateHz=fFrameRate; // set user framerate dwFrameRateTicks=(TIMEBASE / (unsigned long)fFrameRateHz); }