[Thread] Signal/Slot et Thread

Version imprimable

Voir 40 message(s) de cette discussion en une page

10/05/2008, 08h19
yan

Citation:

Envoyé par ttone

Sinon une classe dérivant de QThread, ne serait qu'une classe pouvant contenir un run, lui même start-able depuis la classe qui l'instancie ?...

J'ai pas bien compris ta phrase... La fonction run est le code du thread.

Une QThread en elle même est un QObject. Si tu ne met pas tout dans le run, tu te trouve à devoir protéger toutes les variables partagé entre le run et la class pour être thread safe
10/05/2008, 17h27
ttone

Citation:

Citation:

Voir le message
Sinon une classe dérivant de QThread, ne serait qu'une classe pouvant contenir un run, lui même start-able depuis la classe qui l'instancie ?...

J'ai pas bien compris ta phrase... La fonction run est le code du thread.

je disais ca car dans ma QThread, mon run ne contenait que des déclaration de variable, utilisées dans les autres méthodes. Et ces méthodes étant appelée par le main, via des signaux GUI, le main ayant au préalable fait un thread.start()

Ca fonctionne très bien et pourtant ca ne correspond pas au modus operandi d'une QThread d'après ce que tu dis...

Je me demande si j'utilise cette classe véritablement comme un thread, d'ou ma redéfinition d'une QThread comme une classe simple, dont une méthode "lance" un thread exécutant le contenu de run
10/05/2008, 21h01
yan

Citation:

Envoyé par ttone

d'ou ma redéfinition d'une QThread comme une classe simple, dont une méthode "lance" un thread exécutant le contenu de run

exactement ca :king:
10/05/2008, 22h29
ttone

Excellent, :yaisse2: du coup j'ai mis mon "compteur" et mon "play" dans le run, et toutes les méthodes annexes me servent de télécommande à destination du flux threadé !

Thanks :king:
10/05/2008, 22h53
yan

Fait bien attention au partage de donné et de fonction entre thread. L'exemple de mandebrot est pas mal pour ca.
10/05/2008, 23h40
ttone

Je suis en train de m'y replonger, d'ailleurs dès le destructeur de renderThread, un truc me saute aux yeux : pourquoi un wait() et pas un exit() ? ce serait plus clean a priori ?...
11/05/2008, 07h47
yan

Citation:

At the end of the destructor, we call QThread::wait() to wait until run() has exited before the base class destructor is invoked.

c'est dans les explications ;)

Citation:

void QThread::exit ( int returnCode = 0 )

Tells the thread's event loop to exit with a return code.

After calling this function, the thread leaves the event loop and returns from the call to QEventLoop::exec(). The QEventLoop::exec() function returns returnCode.
By convention, a returnCode of 0 means success, any non-zero value indicates an error.

Note that unlike the C library function of the same name, this function does return to the caller -- it is event processing that stops.

This function does nothing if the thread does not have an event loop.

Pas tout à fait la même chose.

Au faite la thread utilise une event loop que si tu as appelé exec dans run ;)
Tes connect avec QThread s'exécute dans la thread principale (si j'ai bien compris ce que tu fait);
Chose plus interessant, tes connect de QThread vers les objet de la thread s'executerons dans la thread par son eventloop(si tu l'utilise) et les connect de la thread vers QThread seront exécuté dans la thread principale
11/05/2008, 20h10
ttone
Citation:

At the end of the destructor, we call QThread::wait() to wait until run() has exited before the base class destructor is invoked.

En effet, ca n'a rien à voir avec exit(). L'un se soumets aux procédures du thread, et l'autre le kill en gros c'est ca ? :aie:

Sinon concernant l'eventloop, je ne pense pas que ce soit mon intérêt d'y plonger... quoique...

Pour l'instant tous mes signaux de commande du thread (équivalent télécommande dans le réel), proviennent de l'eventloop du main, et vont slotter les méthodes de ma QThread... ces méthodes agissant sur le fichier lu dans le run.

Du coup finalement l'eventloop du thread n'est jamais touchée, peut etre que je devrais y caller mon compteur...

Aux derniers essais, je pouvais lancer la lecture depuis le run sans problème, mais en revanche le compteur y fonctionnait très mal : en fait les emit semblent ne pas parvenir au main, ... pourtant tout semble aller dans le même sens que le emit renderImage(var, var) de mandebrot. J'ai un emit renderPosition(unsigned int position), le slot correspondant, rMainPosition(unsigned int position) fonctionne, je l'ai testé depuis plusieurs niveaux, mais pas depuis le run apparemment...

J'ai fais un test de départ avec le emit uniquement
Code:

1 2 3 4 QThread::run(){ emit renderPosition(5); //sleep(1); }
dans le header :
Code:

1 2 signals: renderPosition(unsigned int position);
et enfin dans le mainThread :

Code:

connect(thread, SIGNAL(renderPosition(unsigned int position)), this, SLOT(rMainPosition(unsigned int position)));
11/05/2008, 21h11
yan

Citation:

Envoyé par ttone

En effet, ca n'a rien à voir avec exit(). L'un se soumets aux procédures du thread, et l'autre le kill en gros c'est ca ? :aie:

Elle n'ont pas le même but
wait : attend la fin de l'execution du run
exit : arrête l'eventloop de la thread pour sortir du run. Elle ne sert à rien si tu n'utilise pas d'eventloop

Citation:

Envoyé par ttone

Du coup finalement l'eventloop du thread n'est jamais touchée, peut etre que je devrais y caller mon compteur...

Si t'es emit sont dans le run, tu ne doit surement pas utiliser l'eventloop de la thread. L'exemple mandelbrot n'utilise pas d'eventloop

Pour tes connect avec QThread qui touche à des variables utilisées dans le run, n'oublie pas de les protéger avec un mutex. Car les slot du QThread seront executé dans le thread principale et non la thread du run.

Si tu peut mettre un peu de ton code, ce serait plus simple pour comprendre ce que tu fait et te dire les choses ne vont pas (si il y en as bien sur;)).
12/05/2008, 16h50
ttone

Effectivement, ca sera plus clair...
Donc, voici la GUI :

-------------o---------------
(play/pause) (stop) (loop) --> bouttons

Effectivement, ca sera plus clair...
Donc, voici la GUI gloablement:

Code:

1
2
3
4
5
6
7
8
9

[v]               --> checkBox solo
--o--     --> slider level

-------------o---------------    --> slider transportSlider
(play/pause) (stop) (loop)    --> bouttons

mediaInfoLabel : ....      timeLabel : ....         -->Labels

Le header de la GUI (mainThread):

Code:

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
/////////////////mainThread
 
#include "ui_GUI.h"//issu de GUI.ui
#include "src/mediaLib.h"//librairies pour le media
#include "Media.h"//QThread::Media class
#include <QThread>
 
using namespace std;
 
class GUI : public QMainWindow
{
Q_OBJECT
 
public:
    GUI(QWidget *parent = 0);
	~GUI();
 
private slots:
        //pour les signaux venant de QThread::thread
	void rPlay();
	void rStop();
	void rPause();
	void rPosition(unsigned int position);
 
        //pour les signaux locaux
	void sPlay();
	void sStop();
	void sPosition();
	void sLoop();
	void sVolume();
 
private:
        Ui_GUI interface;
	Media *thread;
	bool launchedAudio, paused;
 
 
 
protected:
	void keyPressEvent(QKeyEvent *event);
};

son .cpp

Code:

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include "GUI.h"
#include <stdio.h>
#include <QtGui>
#include <QtCore>
#include <time.h>
#include <string>
#include <fstream>
#include <iostream>
#include <QKeyEvent>
 
using namespace std;
 
GUI::GUI(QWidget *parent)
: QMainWindow(parent)
{
	//initialise l'interface
	this->interface.setupUi(this);
	thread = new Media(this);
	paused=true;
 
	//émission vers le thread
	connect(this->interface.playButton, SIGNAL(clicked()), this, SLOT(sPlay()));
	connect(this->interface.loopButton, SIGNAL(clicked()), this, SLOT(sLoop()));
	connect(this->interface.stopButton, SIGNAL(clicked()), this, SLOT(sStop()));
	connect(this->interface.transportSlider, SIGNAL(sliderReleased()), this, SLOT(sPosition()));
	connect(this->interface.solo, SIGNAL(clicked()), this, SLOT(sVolume()));
	connect(this->interface.level, SIGNAL(released()), this, SLOT(sVolume()));
 
	//réception depuis thread :
	connect(thread, SIGNAL(renderPlay()), this, SLOT(rPlay()));
	connect(thread, SIGNAL(renderPause()), this, SLOT(rPause()));
	connect(thread, SIGNAL(renderStop()), this, SLOT(rStop()));
	connect(thread, SIGNAL(renderPosition(unsigned int position)), this, SLOT(rPosition(unsigned int position)));
 
 
 
};
 
 
 
 
GUI::~GUI(){
};
 
//reception from keyboard
void GUI::keyPressEvent(QKeyEvent *event){
	if (event->key()==Qt::Key_Space){
               sPlay();//alterne play et pause
     }
 
	if (event->key()==Qt::Key_S){//solo-mute pour le son, également daisable avec la checkBox solo
               this->interface.solo->setChecked(!this->interface.solo1->isChecked());//actualise la checkBox solo
              sVolume();// volume 0 (si muté) ou x, avec x = la valeur du slider de volume
     }
 
	if (event->key()==Qt::Key_P){
			   sPlay();//play ou pause, en fonction de bool::paused
     }
};
 
 
 
//send to thread
void GUI::sStop(){
	thread->stop();//ou quit ? exit ?... ou ~thread() ?
};
 
void GUI::sPosition(){
	int new_pos = this->interface.transportSlider->value();
	thread->setTrackPosition(new_pos);//change la position de la tete de lecture dans le media, ca marche très bien
};
 
void GUI::sPlay(){
	if(!thread->launched) {//si on a pas démarré la lecture
		this->sPosition();//position tete lecture, ca ne marche pas ici
		thread->start();//lancement du thread contenant play
		thread->launched=true;//actualisation état play/stop
	}
	else{
 
		paused=!paused;//actualisation état play/pause
		thread->pause();
	}
};
 
void GUI::sLoop(){
	thread->loop(this->interface.loopButton->isChecked());//pour l'instant les 2 états sont en mode OFF
};
 
void GUI::sVolume(){
	if(this->interface.solo->isChecked()){//si on est en solo, réglage volume
	unsigned int new_vol=this->interface.level1->value();
	thread->setMainVolume(new_vol);
    }
	else{//sinon on mute le son
	thread->setMainVolume(0);
	}
};
 
 
 
 
//reception from thread
void GUI::rStop(){//affiche le checker "stop", remonte le boutton play
	this->interface.mediaInfoLabel->setText(QString("stop"));
	this->interface.playButton->setChecked(false);
};
 
void GUI::rPause(){
	this->interface.mediaInfoLabel->setText(QString("pause"));//affiche le checker pause
this->interface.playButton->setChecked(!paused);//change état du toggleButton, il est forcé ici, si on ne se fie qu'à un stateChange, les états s'inversent...
};
 
void GUI::rPlay(){
 
	this->interface.mediaInfoLabel->setText(QString("play"));//checker play
};
 
void GUI::rPosition(unsigned int position){	
	this->interface.transportSlider->setValue(position);//la conversion en % est gérée..., actualise la position du slider, contraint par le compteur en boucle perpetuelle
	this->interface.timeLabel->setText(QString(position));//la conversion en seconde est gérée..., idem mais en texte
};

et puis le header de la QThread:

Code:

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
#ifndef MEDIA_H
#define MEDIA_H

#include <QMutex>
#include <QSize>
#include <QThread>
#include <QWaitCondition>

#include "src/MediaLib.h"

//#include "mediaFileTimer.h"

class Media : public QThread
 {
     Q_OBJECT
	
public:
    Media(QObject *parent = 0);
	~Media();
    void run();
	bool launched;
	unsigned int length;
		
public slots:
	void play(int startPosition);
	void stop();
	void pause();
	void loop(bool yes);
	void setTrackPosition(unsigned int new_pos);
	void setMainVolume(unsigned int new_vol);
	void setTimer();
	
signals:
    void renderPause();
    void renderPlay();
    void renderStop();
	void renderPosition(unsigned int position);

private:
	//mediaFileTimer *transportThread;
	MediaLib::System     *system;
        MediaLib::Channel    *channel;
	MediaLib::mediaFile      *mediaFile;
	bool timecount;
	bool paused;
 };
#endif

Code:

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#include "Media.h"
#include <QtGui>
#include <fstream>
#include <iostream>
#include <QKeyEvent>

using namespace std;

Media::Media(QObject *parent)
: QThread(parent)
{
	MediaLib::System_Create(&system);
	channel = 0;
	paused = false;
	launched = false;
	timecount = true;
	unsigned int version;
 
	

    system->init(1, MediaLib_INIT_NORMAL, NULL);
	
//transportThread = new mediaFileTimer(this);
//	transportThread->start();//sans activité, transportThread->timemediaFile() est dispo
//	connect(transportThread, SIGNAL(renderPosition(unsigned int position)), this, SIGNAL(renderPosition(unsigned int position)));


// Global Settings
	system->createmediaFile("1234.mp3", MediaLib_SOFTWARE, 0, &mediaFile);
	mediaFile->setMode(MediaLib_LOOP_OFF);
	channel->setPosition(0, MediaLib_TIMEUNIT_MS);
	mediaFile->getLength(&length,MediaLib_TIMEUNIT_MS);
};
   
Media::~Media(){
	timecount=false;
	mediaFile->release();
	system->close();
        this->quit();
};

void Media::run()
{

	unsigned int position=0;//pour forcer
	
	this->play(position);
	foreach{
		channel->getPosition(&position,MediaLib_TIMEUNIT_MS);//entre 0 et length ms
		position = (int)(position*100/(length));//conversion 0à100
		emit renderPosition(position);//renderPosition(7), ne marche pas plus
	//	sleep(1);
	}
	

}

///play pause stop loop

void Media::stop(){
	channel->stop();
	launched=false;
	this->quit();
	emit renderStop();
};

void Media::pause(){
	channel->getPaused(&paused);
	channel->setPaused(!paused);
	paused=!paused;
	if(paused)	{emit renderPause();}
	else {emit renderPlay();}		
};

void Media::play(int startPosition){
	launched=true;
	emit renderPlay();
	//Play the mediaFile.
    system->playmediaFile(MediaLib_CHANNEL_FREE, mediaFile, false, &channel);
}

void Media::loop(bool yes){
	if(yes)
	mediaFile->setMode(MediaLib_LOOP_OFF);
	else
	mediaFile->setMode(MediaLib_LOOP_OFF);
	
}


void Media::setTrackPosition(unsigned  int new_pos){
    new_pos=(unsigned int)(length/100*new_pos);//new_pos : conversion pourcentage -> ms
	channel->setPosition(new_pos, MediaLib_TIMEUNIT_MS);
}

void Media::setTimer(){
	//transportThread->timemediaFile(length, channel);
}

void Media::setMainVolume(unsigned  int new_vol){
	float volume=(float)(new_vol);
	volume/=100;
	channel->setVolume(volume);
}

Bon décryptage

12/05/2008, 17h05
ttone

L'ensemble peut paraitre tordu et compliqué pour rien, en fait ca fonctionne comme ca :

GUI event --> GUI SLOT sMethode (s pour send) --> thread.Methode --> thred.renderMethode --> SLOT GUI rMethode (r pour render)

j'aurai pu fusionner les GUI::rMethode avec les GUI::sMethode pour alléger tout ca, mais de cette facon je suis assuré que les thread::Methode ont bien été faite quand les GUI::rMethode s'exécutent...

En francais, quand "play" s'affiche sur ma GUI, ou quand le boutton est enfoncé, c'est que l'acion play est bien parvenu au thread avant.
12/05/2008, 17h24
ttone

N'hésite pas pour les questions, je préfère répondre ensuite que surcharger le code de comment... :bebe:

Je savais bien que j'ai bien fait d'insister...

ce code s'execute dans le thread créé
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 void Media::run() { unsigned int position=0;//pour forcer this->play(position); foreach{ channel->getPosition(&position,MediaLib_TIMEUNIT_MS);//entre 0 et length ms position = (int)(position*100/(length));//conversion 0à100 emit renderPosition(position);//renderPosition(7), ne marche pas plus // sleep(1); } }
ce code est executé dans la thread principale
Code:

1 2 3 4 5 6 7 void Media::stop(){ channel->stop(); launched=false; this->quit(); emit renderStop(); };
Tu accède donc à channel par deux thread differentes!!!. Il te faut donc un mutex pour protéger cette variable (et surement aussi length) comme dans l'exemple de mandelbro.

C'est cette subtilité qui est trés dure à comprendre.

13/05/2008, 18h40
ttone
J'en prends note, si la variable est accédée par le thread et par le mainThread en meme temps, explosion ?

En revanche le code que j'avais sous les mains durant mes derniers post n'avait qu'une ligne dans le run :
Code:

1 2 3 ...::run{ emir renderPosition(50); }
Et ca ne marchait pas non plus.

Je ne comprends pas pourquoi, puisque :
1/ les tests sur le SLOT sont positifs
2/ les test sur le emit depuis le mainThread sont positifs
3/ le thread->start() est déjà passé
13/05/2008, 18h52
yan

Peut tu faire un code minimal et compilable?
illustrant ce que tu veut faire?
14/05/2008, 11h28
ttone

Je t'ai mis tout ca en ligne :
http://27sens.com/people/developpez

Tu ne devrais pas à avoir à installer FMODex, juste placer les .dylib au bon endroit.

Mon objectif, c'est d'utiliser le thread d'audioThread pour faire tourner un timer,

concrètement, ce timer émit une position, qui est censé actualiser la position du slider, pour obtenir enfin une tête de lecture qui se déplace en fonction du morceau

Après quelques tests je soupçonne un probleme de mutex, ...
14/05/2008, 13h14
ttone

A priori, je peux dériver ma classe qui gère la GUI directement en QThread ?
14/05/2008, 13h28
yan

Citation:

Envoyé par ttone

A priori, je peux dériver ma classe qui gère la GUI directement en QThread ?

8O????
quoi??
14/05/2008, 13h48
ttone

:lol:
Je voulais dire, est ce que je peux faire de ma classe "GUI", celle qui implèmente l'interface graphique, une QThread, et éviter de passer ainsi par une autre classe QThread...

J'ai lu que c'était peu souhaitable.

Voir 40 message(s) de cette discussion en une page