Action limité dans le temps

Bonjour,

Je souhaiterais limité dans le temps l'action d'une méthode d'une classe.
J'ai pensé au thread et au timer mais mon esprit est encore confus.

Voici l'idée très simple (en soit) de mon projet :

je lis un son à l'aide de la librairie SndObj

J'ai un fichier texte à côté dans lequel j'indique qu'à la 5ème seconde on entend un homme parler.

Citation:

---

son.txt :

---

Code:

---

5 : homme qui parle

---

Je souhaite lire mon fichier texte et afficher à la 5ème seconde de la lecture du fichier son le texte correspondant. Un peu comme des sous-titre.

L'idée final est en réalité de manipuler une image et de modifier son aspect de façon séquentiel en fonction d'un son. Comme si je crée une ligne de temps et que je venais placer des événements se déclenchant à un temps t1 donné par le fichier son et qui s'arrête à un temps t2 donnée aussi par le fichier son. La ligne séquentielle étant donnée par le fichier texte.

Mes effet suivent une structure du style :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

class Effect{   protected: int m_startTime; int m_stopTime; int m_duree; char m_activity;   public:   //Destructor virtual ~Effect();   void start(void); void stop(void);   virtual void update(void) = 0; };

---

ainsi dans le corps du programme je souhaiterais appeler mon effet à l'aide de start() et qu'il s'arrête lorsque la valeur stopTime est atteinte.

J'ai voulu utiliser des timer que j'associe à mes objets... mais cette solution ne semble pas idéale et surtout ne fonctionne pas :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

void Effect::start(void) { struct itimerval timerEffect; int duree = m_duree; //en secondes int u_duree = 0; //en milliseconde timerEffect.it_interval.tv_sec = 0; timerEffect.it_interval.tv_usec = 0; timerEffect.it_value.tv_sec = duree; /* set timer for variable duree in seconds */ timerEffect.it_value.tv_usec = u_duree; /* set timer for variable u_duree in milliseconds */ setitimer(ITIMER_REAL, &tout_val,0);   signal(SIGALRM,stop); /* set the Alarm signal capture */   m_activity = 1; }   void Effect::stop(void) { m_activity = 0; cout<<"Timer finished : fin"<<endl; signal(SIGALRM,stop); }

---

Ça ne passe pas la compilation et je m'en doutais bien car la fonction associé au timer doit être une fonction et non une méthode....

Je ne vois donc pas comment faire.

Une idée ??

Merci d'avance !


Merci d'avance pour votre aide.

J'ai rencontré ce problème quand j'ai voulu utiliser OpenGL. Tu ne peux pas passer une méthode d'objet, qui requiert un type de pointeur spécifique, mais tu peux par contre passer une méthode de classe (déclarée avec static) ; si tu peux trouver un moyen d'appeler la méthode nécessaire sur l'objet dont tu as besoin en passant par cette méthode static, ça ira. Tu auras peut-être besoin de recourrir à d'autres ruses, utiliser un pattern comme le singleton, par exemple.

Citation:

---

Envoyé par SpongeBob

Ça ne passe pas la compilation et je m'en doutais bien car la fonction associé au timer doit être une fonction et non une méthode....

---

Tu peux préciser le prototype?
(peut etre tu peux t'en sortir avec boost::bind)

Comme je l'ai compris :

l'appel de signal system nécessite l'utilisation de fonctions global ou statique et non une fonction membre C++ comme celle-ci ( stop() ).

Comme je souhaite faire des actions spécifique suivant les objets, cette méthode de l'utilisation du timer n'est pas viable.

Donc Bind je vois pas trop ce que ça vient faire ici.

Pouvons-nous approfondir cette idée ?


Noxen qu'elle est plus précisément ton idée ?

Merci à vous

Je pensais à :

Code:

---

1 2	signal(SIGALRM, boost::bind(&Effect::stop, *this) )

---

bind est fait pour ça, non ? ;)

L'initialisation de glut et opengl nécessite de lui passer des pointeurs vers des fonctions. Par exemple, il y a besoin d'une fonction d'affichage pour que la bibliothèque sache ce qu'elle doit afficher :

Code:

---

1 2 3 4 5 6 7 8

void paintApp(){ .... } // fonction d'affichage de l'application   int main(){ ..... glutDisplayFunc(paintApp); // glut a besoin qu'on lui passe une fonction void func (void) ... }

---

A la place on peut lui passer une méthode de classe, static:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class LibraryInterface{ public: static void paint() { .... } ...... };   int main(){ glutDisplayFunc(LibraryInterface::paint); .... }

---

Sauf que tu peux mémoriser des informations dans ta classe via des variables static (entre autre). Donc dans ton cas :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class LibraryInterface{ private: static Effect* currentEffect; ... public: void setEffect(Effect* ef) {currentEffect = ef;}   void stopEffect() { if(currentEffect) currentEffect->stop(); }   ..... };

---

Et dans le code appellant :

Code:

---

1 2 3 4 5 6 7 8

Effect::start(){ ....   LibraryInterface::setEffect(this); signal(SIGALRM, LibraryInterface::stopEffect); ... }

---

Ceci-dit, je ne connais pas boost::bind, alors il est très possible que ce soit une meilleure solution.

Citation:

---

Envoyé par Noxen

Ceci-dit, je ne connais pas boost::bind, alors il est très possible que ce soit une meilleure solution.

---

Ben tu peux vraiment faire ce que tu veux avec boost::bind (et même std::tr1::bind maintenant ;) ). C'est fait pour ça! Pas besoin de changer ton code... :)

Il va vraiment faloir que je m'accorde un peu de temps pour étudier boost ;)

Je suis pas certain que l'utilisation d'un signal soit le plus pertinent dans le cas que tu décris (mais je suis pas un unixien de base, et l'utilisation des signaux n'est pas ma spécialité).

Tu pourrais stoker l'ensemble de tes événements (les objets Effect) dans un container et traiter cette liste soit avec une boucle suivit éventuellement d'un Sleep ou d'une synchro vidéo (cas classique des programme d'animation 2D ou 3D), soit utiliser un thread dédié aux effets et qui attendrait sagement à l'aide d'un sleep le moment du prochain événement.

Si tu veux tout de même utilisé un signal, il suffit que tu le programme pour appeler une fonction traitant le conteneur d'effets.

L'utilisation d'une thread+sleep est proche de l'utilisation du signal, dans les deux cas, il faut que tu programme la duré a attendre en fonction du prochain effet à jouer.

Par contre, dans le cas de la boucle d'affichage, il te suffit de vérifier à chaque tour de boucle si l'effet en tête du conteneur doit être jouer 'maintenant'.

Dans tous les cas, peux être dicté par la précision temporelle que tu cherches à atteindre (en dessous de qlq 10aine de ms, ça devient très difficile)