#!/usr/bin/python
# -*- coding: Utf-8 -*-

# script grandement inspiré du code c++ de http://doc.qtfr.org/public/2007/qt_mplayer.tar.gz
# merci à IrmatDen

import sys, os
from PyQt4.QtGui import *
from PyQt4.QtCore import *

class TracerChrono(QWidget):
	"""On trace le temps car il ne s'affiche pas bien autrement"""
	TAILLE = "0:00:00"
	def __init__(self):
		# parent nous permettra d'accéder à la valeur du curseur
		QWidget.__init__(self)
		self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.MinimumExpanding)
		self.num = "0:00:00"
	
	def paintEvent(self, event):
		paint = QPainter()
		paint.begin(self)
		paint.drawText(event.rect(), Qt.AlignCenter, self.num)
		paint.end()
	
	def minimumSizeHint(self):
		"Pour être sûr que le texte du chrono ne soit pas tronqué"
		font = QFont(self.font())
		font.setPointSize(font.pointSize() - 1)
		fm = QFontMetricsF(font)
		l = fm.width(TracerChrono.TAILLE) + 4.
		L = fm.height() + 2.
		return QSize(l, L)


class Mplayer(QWidget):
	
	PAS_PRECEDENT_SUIVANT, PRECEDENT_SUIVANT, CURSEUR_SUR_UNE_LIGNE,\
		CURSEUR_A_PART, PARCOURIR, PAS_PARCOURIR = range(6)
	HAUTEUR, LARGEUR = range(2)
	
	def __init__(self, cheminVideo=[], taille=(250,225),
			choixWidget=(PAS_PRECEDENT_SUIVANT,CURSEUR_SUR_UNE_LIGNE,PAS_PARCOURIR),
			debutFin=(0,0), cheminMPlayer=None, barreTaches=None, facteurLimitant=HAUTEUR):
		"""widget mplayer"""
		QWidget.__init__(self)
		
		#=== Paramètres généraux ===#
		
		self.systeme = os.name
		
		# système d'exploitation
		if self.systeme in ['posix', 'mac'] and not cheminMPlayer:
			self.cheminMPlayer="mplayer"	# moteur de lecture mplayer
		elif cheminMPlayer: # windows à priori
			self.cheminMPlayer=cheminMPlayer # avec le *.exe
		
		# liste de chemins vidéos
		self.listeVideos=cheminVideo
		
		# est-ce que la vidéo est lue?
		self.estLue=False
		
		# est-ce que la vidéo est en pause?
		self.estEnPause=False
		
		# (x,y) démarrer à la seconde x et terminer à la seconde y
		# si (0,0), alors la lecture se fait normalement
		self.debutFin = debutFin
		
		# Nom du fichier courant (le self n'est pas encore utile)
		if self.listeVideos.__len__()!=0:
			self.fichierCourant = self.listeVideos[0]
		else: self.fichierCourant = [_(u"Pas de fichier lu"), None]
		
		# Barre des tâches de la fenêtre
		self.barreTaches = barreTaches
		
		# Taille de la vidéo
		self.tailleLargeur=taille[0]
		self.tailleHauteur=taille[1]
		
		# Drapeau pour afficher plus de boutons
		plusBoutons = choixWidget[0]
		
		# Drapeau pour mettre le curseur à part
		curseurAPart = choixWidget[1]
		
		# paramètres des boutons-icones
		iconTaille=22
		flat=1
		
		# largeur ou hauteur initiale de l'image en pixels
		# rq: tailleLargeur/tailleHauteur différent de 4/3 en général
		#self.tailleLargeur, self.tailleHauteur = 250, 225 
		
		# Pour récupérer le temps courant depuis certains cadre
		self.temps = 0
		# Cette variable a été créé pour modifier la durée du timer
		# depuis une instance de la classe
		self.dureeTimer = 1000 # temps en ms
		
		# Permet de récupérer la durée de la vidéo depuis une instance de la classe
		# Sert dans certains cadres
		self.dureeVideo = 0
		
		# La largeur ou la hauteur sera fixe lors du clic sur le bouton de lecture
		# Format 4/3 avant lecture
		self.fixeHauteurOuLargeur =  facteurLimitant # 'largeur' ou 'hauteur'
		if self.fixeHauteurOuLargeur == Mplayer.LARGEUR: # largeur fixe -> la hauteur s'adapte
			self.taille = (self.tailleLargeur, int(self.tailleLargeur/(4./3)))
		elif self.fixeHauteurOuLargeur == Mplayer.HAUTEUR: # hauteur fixe -> la largeur s'adapte
			self.taille = (int((4./3)*self.tailleHauteur), self.tailleHauteur)
		
		print "self.taille avant lecture :", self.taille, type(self.taille)
		
		#=== Widgets ===#
		
		self.icone_lire=QIcon("Icones/player_play.png")
		self.icone_pause=QIcon("Icones/player_pause.png")
		self.icone_arret=QIcon("Icones/player_stop.png")
		
		if Mplayer.PARCOURIR in choixWidget:
			self.bout_ouvVideo = QPushButton(_(u"Parcourir..."))
			
		if Mplayer.PRECEDENT_SUIVANT in choixWidget:
			self.bout_prec = QPushButton(QIcon("Icones/player_rew.png"),"")
			self.bout_prec.setIconSize(QSize(iconTaille, iconTaille))
			self.bout_prec.setFlat(flat)
			self.bout_suivant = QPushButton(QIcon("Icones/player_fwd.png"),"")
			self.bout_suivant.setIconSize(QSize(iconTaille, iconTaille))
			self.bout_suivant.setFlat(flat)
		
		self.bout_LectPause = QPushButton(self.icone_lire,"")
		self.bout_LectPause.setIconSize(QSize(iconTaille, iconTaille))
		self.bout_LectPause.setFlat(flat)
		
		self.bout_Arret = QPushButton(self.icone_arret,"")
		self.bout_Arret.setIconSize(QSize(iconTaille, iconTaille))
		self.bout_Arret.setFlat(flat)
		
		# widget qui contiendra la vidéo
		self.cibleVideo = QWidget(self)
		#self.cibleVideo.setAttribute(Qt.WA_PaintOnScreen) # utile ?
		# par défaut le widget-cible est noir
		color = QColor(0, 0, 0)
		self.cibleVideo.setStyleSheet("QWidget { background-color: %s }" % color.name())
		self.cibleVideo.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
		self.cibleVideo.setMinimumSize(self.taille[0],self.taille[1])
		self.cibleVideo.setToolTip(self.fichierCourant[0])
		
		self.slider = QSlider(Qt.Horizontal)
		
		self.mplayerProcess = QProcess(self)
		
		self.timer = QTimer(self)
		
		self.tempsChrono = TracerChrono()
		
		#=== mise-en-page/plan ===#
		
		vbox = QVBoxLayout()
		vbox.addWidget(self.cibleVideo)
		hbox = QHBoxLayout()
		if Mplayer.PARCOURIR in choixWidget:
			hbox.addWidget(self.bout_ouvVideo)
		hbox.addWidget(self.bout_LectPause)
		hbox.addWidget(self.bout_Arret)
		if Mplayer.PRECEDENT_SUIVANT in choixWidget:
			hbox.addWidget(self.bout_prec)
			hbox.addWidget(self.bout_suivant)
		hbox.addWidget(self.tempsChrono)
		if Mplayer.CURSEUR_A_PART not in choixWidget:
			hbox.addWidget(self.slider)
		vbox.addLayout(hbox)
		if Mplayer.CURSEUR_A_PART in choixWidget:
			hbox.setAlignment(Qt.AlignLeft)
			hbox = QHBoxLayout()
			hbox.addWidget(self.slider)
			vbox.addLayout(hbox)
		self.setLayout(vbox)
		
		#=== connexion des widgets à des fonctions ===#
		
		if Mplayer.PARCOURIR in choixWidget:
			self.connect(self.bout_ouvVideo, SIGNAL('clicked()'), self.ouvrirVideo)
		if Mplayer.PRECEDENT_SUIVANT in choixWidget:
			self.connect(self.bout_prec, SIGNAL('clicked()'), self.precedent)
			self.connect(self.bout_suivant, SIGNAL('clicked()'), self.suivant)
		self.connect(self.bout_LectPause, SIGNAL('clicked()'), self.lectPause)
		self.connect(self.bout_Arret, SIGNAL('clicked()'), self.arretMPlayer)
		self.connect(self.mplayerProcess, SIGNAL('readyReadStandardOutput()'), self.recupSortie)
		self.connect(self.mplayerProcess, SIGNAL('finished(int,QProcess::ExitStatus)'), self.finVideo)
		self.connect(self.timer, SIGNAL('timeout()'), self.sonderTempsActuel)
		self.connect(self.slider, SIGNAL('sliderMoved(int)'), self.changerTempsCurseur)
	
	
	def ouvrirVideo(self):
		"""Ouverture de la boîte de dialogue de fichiers"""
		txt = _(u"Fichiers vidéo")
		self.listeVideos=QFileDialog.getOpenFileNames(None, _(u"Ouvrir"), os.path.expanduser('~'), "%s (*.avi *.mpg *.mpeg *.mjpeg *.flv *.mp4 *.ogg)\n*" %txt)
	
	def demarrerMPlayer(self):
		"""démarrage de mplayer avec les arguments choisis"""
		if self.estLue:
			return True
		
		args = QStringList()	# Liste Qt qui contiendra les options de mplayer
					# Ajout d'options à liste: args << "-option"
		
		# mplayer fonctionnera comme un terminal dans ce script
		args << "-slave"
		# on ne veut pas avoir des commentaires sans grand intérêt
		args << "-quiet"
		
		# Sous linux, aucun driver n'a été nécessaire et pas de manip pour Wid :)
		if self.systeme=='posix':
			# try - except?
			# la fenêtre de mplayer restera attaché à la fenêtre
			# wid prend en valeur le nombre identifiant le widget (celui qui contiendra la vidéo)
			args << "-wid" << QString.number(self.cibleVideo.winId()) # Objet QString car args est une liste de ch de caractères
			
		# Sous windows
		else:
			# reinterpret_cast<qlonglong> obligatoire, winId() ne se laissant pas convertir gentiment ;)
			args << "-wid" << self.cibleVideo.winId().__hex__()
			args << "-vo" << "directx:noaccel"
			#args << "-vo" << "gl" # alternative
		
		# chemin de la vidéo
		args << self.listeVideos

		# mode de canal: on fusionne le canal de sortie normal (stdout) et celui des erreurs (stderr)
		self.mplayerProcess.setProcessChannelMode(QProcess.MergedChannels)
		# démarrage de mplayer (en tenant compte des arguments définis ci-dessus) 
		# comme un nouveau processus
		self.mplayerProcess.start(self.cheminMPlayer, args)
		# au cas où mplayer ne démarrerait pas au bout de 3 sec (ex. problème de codec)
		if not self.mplayerProcess.waitForStarted(3000):
			qDebug("Bogue au lancement de la vidéo avec mplayer")
			return False
		
		# On récupère les infos de base ('$ mplayer -input cmdlist' pour avoir la liste complète - file:///usr/share/doc/mplayer-doc/tech/slave.txt.gz pour plus de détails)
		# de la vidéo et on en prend compte ???
		self.mplayerProcess.write("get_video_resolution\n") # récupère la résolution de la vidéo
		self.mplayerProcess.write("get_time_length\n") # récupère la durée de la vidéo
		
		# donne le temps toutes les x secondes
		self.timer.start(self.dureeTimer)
		
		self.estLue = True
		
		return True
	
	def recupSortie(self):
		"""récupère les lignes d'information émises par QProcess (mplayerProcess) et en tire les conséquences"""
		while self.mplayerProcess.canReadLine(): # renvoie True si une ligne complète peut être lue à partir du système
			# stocker l'ensemble des bits d'une ligne
			tampon=QByteArray(self.mplayerProcess.readLine()) # readline: lit une ligne ascii à partir du système
			
			#print "tampon :", tampon
			
			# On vérifie si on a eu des réponses
			if tampon.startsWith("Playing"):
				self.mplayerProcess.write("get_video_resolution\n") # récupère la résolution de la vidéo
				self.mplayerProcess.write("get_time_length\n")
				# Nouveau fichier chargé -> on récupère son nom
				ind = tampon.length() - 2 # suppression du '.' à la fin
				tampon.remove(ind,ind)
				tampon.remove(0, 8) # vire Playing
				tampon.replace(QByteArray("\n"), QByteArray(""))
				tampon.replace(QByteArray("\r"), QByteArray(""))
				self.fichierCourant[1] = str(tampon)
				self.cibleVideo.setToolTip(self.fichierCourant[1])
				if self.barreTaches!=None:
					self.barreTaches.showMessage(self.fichierCourant[1])
			
			# réponse à get_video_resolution : ANS_VIDEO_RESOLUTION='<width> x <height>'
			if tampon.startsWith("ANS_VIDEO_RESOLUTION"): # retourne True si l'ensemble de bits démarre avec "..."
				print "tampon :",tampon # ex. -> ANS_VIDEO_RESOLUTION='352 x 288'
				tampon.remove(0, 21) # suppression des 21 1er caract -> '352 x 288'
				tampon.replace(QByteArray("'"), QByteArray("")) # -> 352 x 288
				tampon.replace(QByteArray(" "), QByteArray("")) # -> 352x288
				tampon.replace(QByteArray("\n"), QByteArray("")) # -> 352x288 # retour chariot unix
				tampon.replace(QByteArray("\r"), QByteArray("")) # -> 352x288 # retour chariot windows
				#print "-----tampon.indexOf('x') :", tampon.indexOf('x'), type(tampon.indexOf('x'))
				sepIndex = tampon.indexOf('x') # récupère la position de 'x' # 3 <type 'int'>
				#print "-----tampon.left(sepIndex).toInt():", tampon.left(sepIndex).toInt(), type(tampon.left(sepIndex).toInt())
				resX = tampon.left(sepIndex).toInt()[0] # -> 352 # (352, True) <type 'tuple'>
				#print "-----tampon.mid(sepIndex+1).toInt() :", tampon.mid(sepIndex+1).toInt(), type(tampon.mid(sepIndex+1).toInt())
				resY = tampon.mid(sepIndex+1).toInt()[0] # -> 288 # (288, True) <type 'tuple'>
				
				# on définit les nouvelles dimensions de l'image du widget-mplayer.
				# try pour éviter les bogues sur les fichiers audio (sans dimension d'image)!!!
				try:
					ratio=float(resX)/resY
					print "ratio :", ratio, type(ratio)
				
					if self.fixeHauteurOuLargeur == Mplayer.LARGEUR: # largeur fixe -> la hauteur s'adapte
						largeur, hauteur = self.taille[0], self.taille[0]/ratio
					elif self.fixeHauteurOuLargeur == Mplayer.HAUTEUR: # hauteur fixe -> la largeur s'adapte
						largeur, hauteur = int(ratio*self.taille[1]), self.taille[1]
					print "largeur, hauteur :", largeur, hauteur
					
					self.cibleVideo.setMinimumSize(largeur, hauteur) # nouvelle taille du widget de la vidéo
					print "nouvelle résolution :", int(ratio*self.taille[1]), "x", self.taille[1]
				except: 
					print "fichier audio"
			
			# réponse à get_time_length : ANS_LENGTH=xx.yy
			elif tampon.startsWith("ANS_LENGTH"):
				print "tampon :",tampon # -> ANS_LENGTH=279.38
				tampon.remove(0, 11) # vire ANS_LENGTH=
				tampon.replace(QByteArray("'"), QByteArray(""))
				tampon.replace(QByteArray(" "), QByteArray(""))
				tampon.replace(QByteArray("\n"), QByteArray(""))
				tampon.replace(QByteArray("\r"), QByteArray("")) # -> 279.38
				#print "-----tampon.toFloat() :", tampon.toFloat(), type(tampon.toFloat())
				tempsMax = tampon.toFloat()[0] # (279.3800048828125, True) <type 'tuple'>
				self.dureeVideo = tempsMax
				self.slider.setMaximum(tempsMax) # déf du domaine de valeur du curseur
				
				# ATTENTION J'AI COMMENTE CETTE LIGNE !!!
				#self.slider.setMaximum(tempsMax)
			
			# réponse à get_time_pos : ANS_TIME_POSITION=xx.y
			elif tampon.startsWith("ANS_TIME_POSITION"):
				#print "tampon :",tampon # -> ANS_TIME_POSITION=1.4 (temps courant)
				tampon.remove(0, 18) # vire ANS_TIME_POSITION=
				tampon.replace(QByteArray("'"), QByteArray(""))
				tampon.replace(QByteArray(" "), QByteArray(""))
				tampon.replace(QByteArray("\n"), QByteArray(""))
				tampon.replace(QByteArray("\r"), QByteArray(""))
				#print "-----tampon.toFloat() :", tampon.toFloat(), type(tampon.toFloat())
				tempsCourant = tampon.toFloat()[0] # (1.3999999761581421, True) <type 'tuple'>
				# récupération du temps courant: utile dans certains cadres
				self.temps = tempsCourant
				# Programmer un arrêt. Utile pour les aperçus
				#print "self.temps", self.temps, type(self.temps)
				#print "self.debutFin", self.debutFin[1], type(self.debutFin[1])
				temps = float("%.1f" %self.temps)
				#print "temps", temps, type(temps), '\n'
				if self.debutFin!=(0,0) and self.debutFin[1]==temps:
					self.arretMPlayer()
					return
				self.slider.setValue(tempsCourant) # aller au temps courant
				self.changerTempsChrono(tempsCourant) # modifier le chrono du bouton
	
	
	def sonderTempsActuel(self):
		"""envoie le temps correspondant à la position de la vidéo dans le tampon"""
		self.mplayerProcess.write("get_time_pos\n")
	
	def changerTempsCurseur(self, pos):
		"""change la partie de la vidéo qui sera lue"""
		# on arrête le temps pendant le changement de position de la vidéo 
		# sinon le curseur ne bouge plus
		#print "changerTempsCurseur"
		self.timer.stop()
		# le 2 indique qu'on veut la position absolue
		self.mplayerProcess.write("seek " + str(pos) + " 2\n") 
		#self.mplayerProcess.write(QString("seek " + QString.number(pos) + " 2\n").toUtf8()) # anciennement
		self.timer.start()
		self.estLue, self.estEnPause = True, False
		self.bout_LectPause.setIcon(self.icone_pause)
		
	
	def changerTempsChrono(self,nvTemps):
		"""affichage du temps sous la forme h:mm:ss dans un bouton"""
		temps0 = QTime(0, 0, 0)
		temps = temps0.addSecs(nvTemps)
		if temps.minute()<10:
			mn='0'+str(temps.minute())
		else:
			mn=str(temps.minute())
		if temps.second()<10:
			s='0'+str(temps.second())
		else:
			s=str(temps.second())
		chrono = str(temps.hour())+':'+mn+':'+s
		self.tempsChrono.num = chrono
		self.tempsChrono.repaint()
	
	
	def precedent(self):
		"""affiche la vidéo précédente"""
		if self.estLue:
			self.mplayerProcess.write("pt_step -1\n")
			self.estEnPause = False
			self.bout_LectPause.setIcon(self.icone_pause)
	
	
	def suivant(self):
		"""affiche la vidéo suivante"""
		if self.estLue:
			self.mplayerProcess.write("pt_step 1\n")
			self.estEnPause = False
			self.bout_LectPause.setIcon(self.icone_pause)
	
	
	def lectPause(self):
		"""lecture/pause de la vidéo avec mplayer"""
		if not self.estLue:
			if not self.demarrerMPlayer(): # lecture de la vidéo
				return # au cas où mplayer ne démarrerait pas au bout de 3 sec (ex. problème de codec)
			self.estLue, self.estEnPause = True, False
			self.bout_LectPause.setIcon(self.icone_pause)
			if self.debutFin!=(0,0) and self.debutFin[0]!= 0:
				self.mplayerProcess.write("seek " + str(self.debutFin[0]) + " 2\n")
		elif self.estLue and not self.estEnPause: # lecture -> pause
			self.mplayerProcess.write("pause\n")
			self.timer.stop()
			self.bout_LectPause.setIcon(self.icone_lire)
			self.estLue, self.estEnPause = True, True
		elif self.estLue and self.estEnPause: # pause -> lecture
			# prévoir le cas où mplayer ne se mettrait pas en pause au bout de 3 sec
			self.timer.start()
			self.bout_LectPause.setIcon(self.icone_pause)
			self.estLue, self.estEnPause = True, False
	
	def arretMPlayer(self):
		""""Arrete la lecture de la vidéo et réinitialise les icones et variables"""
		if self.mplayerProcess.state() == QProcess.NotRunning: # ajouté pour ne pas avoir de bogue à la fin de la lecture de la vidéo.
    			return True
		
		self.mplayerProcess.write("quit\n") # arrêt de la vidéo
		
		# au cas où mplayer ne s'arrêterait pas au bout de 3 sec
		if not self.mplayerProcess.waitForFinished(3000):
			qDebug("Bogue à la tentative d'arrêt de la vidéo avec mplayer")
			return False
		
		self.tempsChrono.num = "0:00:00"
		self.tempsChrono.repaint()
		self.slider.setValue(0)
		self.estLue, self.estEnPause = False, False
		self.bout_LectPause.setIcon(self.icone_lire)
		return True
	
	def finVideo(self, statutDeSortie, codeSortie):
		"""On change certaines variables à la fin de vidéo"""
		# d'après ce que j'ai compris: récupération du statut de sortie (0: normal ; 1: crash)
		#  pas de récupération du code de sortie (de toute façon je vois pas trop à quoi il servirait)
		if statutDeSortie==1:
			print "Crash de mplayer lors de la fin de la lecture de la vidéo"
		self.estLue, self.estEnPause = False, False
		self.bout_LectPause.setIcon(self.icone_lire)
		self.timer.stop()
		self.cibleVideo.setToolTip(self.fichierCourant[0])
		if self.barreTaches!=None:
			self.barreTaches.clearMessage()


class MetaMPlayer(QDialog):
	def __init__(self, mplayer1=None, mplayer2=None):
		"Boite de dalogue de comparaison de 2 vidéos via mplayer"
		QDialog.__init__(self)
		
		self.setWindowTitle(_(u"Comparateur de vidéos"))
		
		# paramètres des boutons-icones
		iconTaille=32
		flat=1
		
		self.icone_lire=QIcon("Icones/player_play.png")
		self.icone_pause=QIcon("Icones/player_pause.png")
		self.icone_arret=QIcon("Icones/player_stop.png")
		
		self.bout_ouvVideo = QPushButton(u"Parcourir...")
		
		self.bout_LectPause = self.bout_LectPause2 = QPushButton(self.icone_lire,"")
		
		self.bout_LectPause.setIconSize(QSize(iconTaille, iconTaille))
		self.bout_LectPause.setFlat(flat)
		
		self.bout_Arret = QPushButton(self.icone_arret,"")
		self.bout_Arret.setIconSize(QSize(iconTaille, iconTaille))
		self.bout_Arret.setFlat(flat)
		
		#self.slider = QSlider(Qt.Horizontal)
		
		#self.tempsChrono = TracerChrono()
		
		vbox = QVBoxLayout(self)
		vbox.addStretch()
		hbox = QHBoxLayout()
		hbox.addStretch()
		vboxG = QVBoxLayout()
		vboxG.addWidget(QLabel(_(u"Vidéo avant traitement")),0,Qt.AlignHCenter)
		vboxG.addWidget(mplayer1)
		hbox.addLayout(vboxG,0)
		vboxD = QVBoxLayout()
		vboxD.addWidget(QLabel(_(u"Vidéo après traitement")),0,Qt.AlignHCenter)
		vboxD.addWidget(mplayer2)
		hbox.addLayout(vboxD,0)
		hbox.addStretch()
		vbox.addLayout(hbox)
		
		hbox = QHBoxLayout()
		hbox.addStretch()
		hbox.addWidget(self.bout_LectPause)
		hbox.addWidget(self.bout_Arret)
		hbox.addStretch()
		vbox.addLayout(hbox)
		vbox.addStretch()
		#hbox.addWidget(self.tempsChrono)
		#hbox.addWidget(self.slider)
		
		if mplayer1!=None and mplayer2!=None:
			self.lier2MPlayer(mplayer1, mplayer2)
	
	def connecter1MPlayer(self, mplayer):
		"connexion d'un mplayer"
		self.connect(self.bout_ouvVideo, SIGNAL('clicked()'), mplayer.ouvrirVideo)
		self.connect(self.bout_LectPause, SIGNAL('clicked()'), mplayer.lectPause)
		self.connect(self.bout_Arret, SIGNAL('clicked()'), mplayer.arretMPlayer)
		## 'readyReadStandardOutput()': signal émis lors de la sortie standart de lecture
		#self.connect(self.mplayerProcess, SIGNAL('readyReadStandardOutput()'), mplayer.recupSortie)
		## QProcess.ExitStatus: statut de sortie: normale ou crash (à priori un int en python)
		#self.connect(self.mplayerProcess, SIGNAL('finished(int)'), mplayer.finVideo)
		#self.connect(self.timer, SIGNAL('timeout()'), mplayer.sonderTempsActuel)
		#self.connect(self.slider, SIGNAL('sliderMoved(int)'), mplayer.changerTempsCurseur)
	
	def lier2MPlayer(self, mplayer1, mplayer2):
		" actions "
		self.connecter1MPlayer(mplayer1)
		self.connecter1MPlayer(mplayer2)
	