[pcsx_rearmed.git] / plugins / dfxvideo / fps.c

/***************************************************************************
                          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 <lastticks))
    {
     lastticks = curticks;
     overslept = _ticks_since_last_update - TicksToWait;
     if((_ticks_since_last_update-TicksToWait) > 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<dwWaitTime)         // -> 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<dwWaitTime)    // -> 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<MAXSKIP)                   // -> 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<dwWaitTime)        // -> 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);
}
Commit	Line	Data
	1	/***************************************************************************
	2	fps.c - description
	3	-------------------
	4	begin : Sun Oct 28 2001
	5	copyright : (C) 2001 by Pete Bernert
	6	email : BlackDove@addcom.de
	7	***************************************************************************/
	8	/***************************************************************************
	9	* *
	10	* This program is free software; you can redistribute it and/or modify *
	11	* it under the terms of the GNU General Public License as published by *
	12	* the Free Software Foundation; either version 2 of the License, or *
	13	* (at your option) any later version. See also the license.txt file for *
	14	* additional informations. *
	15	* *
	16	***************************************************************************/
	17
	18	// FPS stuff
	19	float fFrameRateHz=0;
	20	DWORD dwFrameRateTicks=16;
	21	float fFrameRate=200.0f;
	22	int iFrameLimit=2;
	23	int UseFrameLimit=0;
	24	int UseFrameSkip=0;
	25
	26	// FPS skipping / limit
	27	BOOL bInitCap = TRUE;
	28	float fps_skip = 0;
	29	float fps_cur = 0;
	30
	31	#define TIMEBASE 100000
	32	#define MAXLACE 16
	33	#define MAXSKIP 120
	34
	35	static void calcfps(void);
	36	static void FrameCap(void);
	37
	38	void CheckFrameRate(void)
	39	{
	40	if(UseFrameSkip) // skipping mode?
	41	{
	42	if(!(dwActFixes&0x80)) // not old skipping mode?
	43	{
	44	dwLaceCnt++; // -> store cnt of vsync between frames
	45	if(dwLaceCnt>=MAXLACE && UseFrameLimit) // -> if there are many laces without screen toggling,
	46	{ // do std frame limitation
	47	if(dwLaceCnt==MAXLACE) bInitCap=TRUE;
	48	FrameCap();
	49	}
	50	}
	51	else if(UseFrameLimit) FrameCap();
	52	calcfps(); // -> calc fps display in skipping mode
	53	}
	54	else // non-skipping mode:
	55	{
	56	if(UseFrameLimit) FrameCap(); // -> do it
	57	calcfps(); // -> and calc fps display
	58	}
	59	}
	60
	61	static unsigned long timeGetTime(void)
	62	{
	63	struct timeval tv;
	64	gettimeofday(&tv, 0); // well, maybe there are better ways
	65	return tv.tv_sec * 100000 + tv.tv_usec/10; // to do that, but at least it works
	66	}
	67
	68	static void FrameCap (void)
	69	{
	70	static unsigned long curticks, lastticks, _ticks_since_last_update;
	71	static unsigned int TicksToWait = 0;
	72	int overslept=0, tickstogo=0;
	73	BOOL Waiting = TRUE;
	74
	75	{
	76	curticks = timeGetTime();
	77	_ticks_since_last_update = curticks - lastticks;
	78
	79	if((_ticks_since_last_update > TicksToWait) \|\|
	80	(curticks <lastticks))
	81	{
	82	lastticks = curticks;
	83	overslept = _ticks_since_last_update - TicksToWait;
	84	if((_ticks_since_last_update-TicksToWait) > dwFrameRateTicks)
	85	TicksToWait=0;
	86	else
	87	TicksToWait=dwFrameRateTicks - overslept;
	88	}
	89	else
	90	{
	91	while (Waiting)
	92	{
	93	curticks = timeGetTime();
	94	_ticks_since_last_update = curticks - lastticks;
	95	tickstogo = TicksToWait - _ticks_since_last_update;
	96	if ((_ticks_since_last_update > TicksToWait) \|\|
	97	(curticks < lastticks) \|\| tickstogo < overslept)
	98	{
	99	Waiting = FALSE;
	100	lastticks = curticks;
	101	overslept = _ticks_since_last_update - TicksToWait;
	102	TicksToWait = dwFrameRateTicks - overslept;
	103	return;
	104	}
	105	if (tickstogo >= 200 && !(dwActFixes&16))
	106	usleep(tickstogo*10 - 200);
	107	}
	108	}
	109	}
	110	}
	111
	112	static void FrameSkip(void)
	113	{
	114	static int iNumSkips=0,iAdditionalSkip=0; // number of additional frames to skip
	115	static DWORD dwLastLace=0; // helper var for frame limitation
	116	static DWORD curticks, lastticks, _ticks_since_last_update;
	117	int tickstogo=0;
	118	static int overslept=0;
	119
	120	if(!dwLaceCnt) return; // important: if no updatelace happened, we ignore it completely
	121
	122	if(iNumSkips) // we are in skipping mode?
	123	{
	124	dwLastLace+=dwLaceCnt; // -> calc frame limit helper (number of laces)
	125	bSkipNextFrame = TRUE; // -> we skip next frame
	126	iNumSkips--; // -> ok, one done
	127	}
	128	else // ok, no additional skipping has to be done...
	129	{ // we check now, if some limitation is needed, or a new skipping has to get started
	130	DWORD dwWaitTime;
	131
	132	if(bInitCap \|\| bSkipNextFrame) // first time or we skipped before?
	133	{
	134	if(UseFrameLimit && !bInitCap) // frame limit wanted and not first time called?
	135	{
	136	DWORD dwT=_ticks_since_last_update; // -> that's the time of the last drawn frame
	137	dwLastLace+=dwLaceCnt; // -> and that's the number of updatelace since the start of the last drawn frame
	138
	139	curticks = timeGetTime(); // -> now we calc the time of the last drawn frame + the time we spent skipping
	140	_ticks_since_last_update= dwT+curticks - lastticks;
	141
	142	dwWaitTime=dwLastLace*dwFrameRateTicks; // -> and now we calc the time the real psx would have needed
	143
	144	if(_ticks_since_last_update<dwWaitTime) // -> we were too fast?
	145	{
	146	if((dwWaitTime-_ticks_since_last_update)> // -> some more security, to prevent
	147	(60*dwFrameRateTicks)) // wrong waiting times
	148	_ticks_since_last_update=dwWaitTime;
	149
	150	while(_ticks_since_last_update<dwWaitTime) // -> loop until we have reached the real psx time
	151	{ // (that's the additional limitation, yup)
	152	curticks = timeGetTime();
	153	_ticks_since_last_update = dwT+curticks - lastticks;
	154	}
	155	}
	156	else // we were still too slow ?!!?
	157	{
	158	if(iAdditionalSkip<MAXSKIP) // -> well, somewhen we really have to stop skipping on very slow systems
	159	{
	160	iAdditionalSkip++; // -> inc our watchdog var
	161	dwLaceCnt=0; // -> reset lace count
	162	lastticks = timeGetTime();
	163	return; // -> done, we will skip next frame to get more speed
	164	}
	165	}
	166	}
	167
	168	bInitCap=FALSE; // -> ok, we have inited the frameskip func
	169	iAdditionalSkip=0; // -> init additional skip
	170	bSkipNextFrame=FALSE; // -> we don't skip the next frame
	171	lastticks = timeGetTime(); // -> we store the start time of the next frame
	172	dwLaceCnt=0; // -> and we start to count the laces
	173	dwLastLace=0;
	174	_ticks_since_last_update=0;
	175	return; // -> done, the next frame will get drawn
	176	}
	177
	178	bSkipNextFrame=FALSE; // init the frame skip signal to 'no skipping' first
	179
	180	curticks = timeGetTime(); // get the current time (we are now at the end of one drawn frame)
	181	_ticks_since_last_update = curticks - lastticks;
	182
	183	dwLastLace=dwLaceCnt; // store curr count (frame limitation helper)
	184	dwWaitTime=dwLaceCnt*dwFrameRateTicks; // calc the 'real psx lace time'
	185	if (dwWaitTime >= overslept)
	186	dwWaitTime-=overslept;
	187
	188	if(_ticks_since_last_update>dwWaitTime) // hey, we needed way too long for that frame...
	189	{
	190	if(UseFrameLimit) // if limitation, we skip just next frame,
	191	{ // and decide after, if we need to do more
	192	iNumSkips=0;
	193	}
	194	else
	195	{
	196	iNumSkips=_ticks_since_last_update/dwWaitTime; // -> calc number of frames to skip to catch up
	197	iNumSkips--; // -> since we already skip next frame, one down
	198	if(iNumSkips>MAXSKIP) iNumSkips=MAXSKIP; // -> well, somewhere we have to draw a line
	199	}
	200	bSkipNextFrame = TRUE; // -> signal for skipping the next frame
	201	}
	202	else // we were faster than real psx? fine :)
	203	if(UseFrameLimit) // frame limit used? so we wait til the 'real psx time' has been reached
	204	{
	205	if(dwLaceCnt>MAXLACE) // -> security check
	206	_ticks_since_last_update=dwWaitTime;
	207
	208	while(_ticks_since_last_update<dwWaitTime) // -> just do a waiting loop...
	209	{
	210	curticks = timeGetTime();
	211	_ticks_since_last_update = curticks - lastticks;
	212
	213	tickstogo = dwWaitTime - _ticks_since_last_update;
	214	if (tickstogo-overslept >= 200 && !(dwActFixes&16))
	215	usleep(tickstogo*10 - 200);
	216	}
	217	}
	218	overslept = _ticks_since_last_update - dwWaitTime;
	219	if (overslept < 0)
	220	overslept = 0;
	221	lastticks = timeGetTime(); // ok, start time of the next frame
	222	}
	223
	224	dwLaceCnt=0; // init lace counter
	225	}
	226
	227	static void calcfps(void)
	228	{
	229	static unsigned long curticks,_ticks_since_last_update,lastticks;
	230	static long fps_cnt = 0;
	231	static unsigned long fps_tck = 1;
	232	static long fpsskip_cnt = 0;
	233	static unsigned long fpsskip_tck = 1;
	234
	235	{
	236	curticks = timeGetTime();
	237	_ticks_since_last_update=curticks-lastticks;
	238
	239	if(UseFrameSkip && !UseFrameLimit && _ticks_since_last_update)
	240	fps_skip=min(fps_skip,((float)TIMEBASE/(float)_ticks_since_last_update+1.0f));
	241
	242	lastticks = curticks;
	243	}
	244
	245	if(UseFrameSkip && UseFrameLimit)
	246	{
	247	fpsskip_tck += _ticks_since_last_update;
	248
	249	if(++fpsskip_cnt==2)
	250	{
	251	fps_skip = (float)2000/(float)fpsskip_tck;
	252	fps_skip +=6.0f;
	253	fpsskip_cnt = 0;
	254	fpsskip_tck = 1;
	255	}
	256	}
	257
	258	fps_tck += _ticks_since_last_update;
	259
	260	if(++fps_cnt==20)
	261	{
	262	fps_cur = (float)(TIMEBASE*20)/(float)fps_tck;
	263
	264	fps_cnt = 0;
	265	fps_tck = 1;
	266	}
	267
	268	}
	269
	270	static void PCFrameCap (void)
	271	{
	272	static unsigned long curticks, lastticks, _ticks_since_last_update;
	273	static unsigned long TicksToWait = 0;
	274	BOOL Waiting = TRUE;
	275
	276	while (Waiting)
	277	{
	278	curticks = timeGetTime();
	279	_ticks_since_last_update = curticks - lastticks;
	280	if ((_ticks_since_last_update > TicksToWait) \|\|
	281	(curticks < lastticks))
	282	{
	283	Waiting = FALSE;
	284	lastticks = curticks;
	285	TicksToWait = (TIMEBASE/ (unsigned long)fFrameRateHz);
	286	}
	287	}
	288	}
	289
	290	static void PCcalcfps(void)
	291	{
	292	static unsigned long curticks,_ticks_since_last_update,lastticks;
	293	static long fps_cnt = 0;
	294	static float fps_acc = 0;
	295	float CurrentFPS=0;
	296
	297	curticks = timeGetTime();
	298	_ticks_since_last_update=curticks-lastticks;
	299	if(_ticks_since_last_update)
	300	CurrentFPS=(float)TIMEBASE/(float)_ticks_since_last_update;
	301	else CurrentFPS = 0;
	302	lastticks = curticks;
	303
	304	fps_acc += CurrentFPS;
	305
	306	if(++fps_cnt==10)
	307	{
	308	fps_cur = fps_acc / 10;
	309	fps_acc = 0;
	310	fps_cnt = 0;
	311	}
	312
	313	fps_skip=CurrentFPS+1.0f;
	314	}
	315
	316	void SetAutoFrameCap(void)
	317	{
	318	if(iFrameLimit==1)
	319	{
	320	fFrameRateHz = fFrameRate;
	321	dwFrameRateTicks=(TIMEBASE100 / (unsigned long)(fFrameRateHz100));
	322	return;
	323	}
	324
	325	if(dwActFixes&32)
	326	{
	327	if (PSXDisplay.Interlaced)
	328	fFrameRateHz = PSXDisplay.PAL?50.0f:60.0f;
	329	else fFrameRateHz = PSXDisplay.PAL?25.0f:30.0f;
	330	}
	331	else
	332	{
	333	fFrameRateHz = PSXDisplay.PAL?50.0f:59.94f;
	334	dwFrameRateTicks=(TIMEBASE100 / (unsigned long)(fFrameRateHz100));
	335	}
	336	}
	337
	338	static void InitFPS(void)
	339	{
	340	if(!fFrameRate) fFrameRate=200.0f;
	341	if(fFrameRateHz==0) fFrameRateHz=fFrameRate; // set user framerate
	342	dwFrameRateTicks=(TIMEBASE / (unsigned long)fFrameRateHz);
	343	}