Discussion :

[poukill]

Salut à tous,

Je cherche à calculer le FPS du film que je suis en train d'afficher, pour tester différents algos et leur performance.
Tout d'abord je sais que des bibliothèques le font nativement (WxWidget, et très certainement Qt), mais je cherche ici à comprendre le principe.

L'implémentation que j'ai proposée est vraiment nulle, il faut bien le dire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
#include <iostream>
#include <boost/thread.hpp>
#include "boost/date_time/posix_time/posix_time.hpp"
 
class Timer
{
public:
	Timer() : m_Update(false)	{}
 
        //Lancer un comptage jusqu'a 1, puis s'arrêter
	void Go() {
		m_Update = false;
		boost::thread myThread(boost::bind(&Timer::Count, this) );
	}
 
        // Fonction membre à appeler pour vérifier la fin du comptage
	bool IsSecond() const 	{return m_Update;}
 
 
private:
 
	void Count()
	{
		boost::posix_time::ptime time = boost::posix_time::microsec_clock::local_time();
		while(1) {
			boost::posix_time::ptime time2 = boost::posix_time::microsec_clock::local_time();
			if ((time2 - time).total_milliseconds() > 1000)  // 1 seconde
			{
				m_Update = true;
				break;
			}
		}
	}
 
	bool	m_Update;
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
int main()
{
	Timer timer;
	timer.Go();
 
	while(1)
	{
		if ( timer.IsSecond() == true )
		{
			std::cout << "1 seconde " << std::endl;
			timer.Go();
		}
	}
	return 0;
}

Mon while(1) prend un coeur tout entier...
Seulement, pour essayer d'être "exact" je vois pas vraiment comment faire. Je suppose que vous devez avoir plein d'idées.

Je vous écoute !

Poukill.

[khayyam90]

Bien le bonjour,

Si tu affiches un film, tu as déjà une boucle de rendu, dans laquelle tu peux rajouter un traitement, non ?
il suffit de repérer le début des secondes et de déterminer si une frame est sur la même seconde que la précédente, et voilà tu sais combien de frames ont été dans la seconde précédente.

Sinon, s'il ne s'agit que de mesurer des FPS sur un rendu, dans l'hypothèse ou tu utilises opengl ou direcxt sous windows, il existe des utilitaires comme fraps qui modifient juste les appels à la carte graphique et qui incrustent directement le framerate dans le rendu sans que tu n'aies besoin de changer quoi que ce soit dans le code.

[yan]

Un truc comme cela ne suffit pas??

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
clock_t t1 = clock();
int nbFrame =0;
bool bInit = false;
while (1)
{
    if ( !bInit )
   {
      t1 = clock();
      nbFrame =0;
      bInit = true;
   }
 
 
...
    ++nbFrame;
    clock_t t2 = clock();
    if ( (t2-t1) >CLOCKS_PER_SEC )
   {
       double frameRate = static_cast<double>(nbFrame) * CLOCKS_PER_SEC/((t2-t1);
       bInit = false;
   }
}

[poukill]

Ben si, mais le seul truc que j'aime pas dans cette approche c'est le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#define CLOCKS_PER_SEC 1000

Celà dit ça marche très bien... J'essayais juste de trouver un truc plus "sioux". Bon je me suis peut-être emballé...

[yan]

Ben si, mais le seul truc que j'aime pas dans cette approche c'est le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#define CLOCKS_PER_SEC 1000

T'es déjà à la millisecond prés. Pour calculer un FPS ca devrais suffire, non?

[poukill]

Oui c'est pas faux...
Je vais rester là dessus.

[nicroman]

Attention aux timers fous !

Il m'est déjà arrivé d'avoir (vive le MT préemptif) des calculs de FPS complètement foireux...

D'ailleurs en général, on ne calcule pas le nombre de frames effectuées par seconde, mais le temps qu'une frame met à se dessiner...
Et vu les OS actuels, il faut "lisser" un poil le truc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
#define  NUM_FRAMES   10
 
...
long sumOfFrameTimes = 0;
long timesInMs[NUM_FRAMES];
int curIdx = 0;
int maxIdx =0;
long lastTimeInMs = timeGetTime();
 
 
// Main-loop
{
   ...
   while (!ended) {
      ...
      DoFrame();
      ...
   }
   ....
}
 
// Frames
void DoFrame() {
 
    .. DO RENDERING (blocking... not taking 100% cpu)...
 
    long curTimeInMs = timeGetTime();
    long ellapsedMs = curTimeInMs - lastTimeInMs;
    lastTimeInMs = curTimeInMs;
#if (NUM_FRAMES > 1) 
    if (maxIdx >= NUM_FRAMES) {
       // removing current index, and adding last time
       sumOfFrameTimes -= timesInMs[curIdx];
       sumOfFrameTimes += ellapsedMs;
       timesInMs[curIdx] = ellapsedMs;
       curIdx = (curIdx + 1) % NUM_FRAMES;
    } else {
       timesInMs[curIdx++] = ellapsedMs;
       maxIdx = curIdx;
       sumOfFrameTimes = ellapsedMs;
    }
#else
    sumOfFrameTimes = ellapsedMs;
    maxIdx = 1;
#endif
}
 
// retrieving current FPS
long GetFps()
{
     return sumOfFrameTimes? (1000 * maxIdx / sumOfFrameTimes) : 0;
}

[yan]

D'ailleurs en général, on ne calcule pas le nombre de frames effectuées par seconde, mais le temps qu'une frame met à se dessiner...
Et vu les OS actuels, il faut "lisser" un poil le truc:

ton code reviens au même, non?
Sauf que tu te base sur le nombre d'image et moi sur le temps.