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

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

class WidgetMEncoder(QDialog):
	def __init__(self, idCodec, cheminVideoEntre, cheminSorti, valeurNum=0, laisserOuvert=1, tailleIm=None, systeme=None, cheminMEncoder=None, cheminFfmpeg2theora=None, cheminMPlayer=None):
		"""widget mplayer"""
		QDialog.__init__(self)
		
		#=== Paramètres généraux ===#
		
		self.systeme=systeme
		# système d'exploitation
		if self.systeme=='linux' or self.systeme==None:
			self.cheminMEncoder="mencoder"	# moteur de lecture mplayer
			self.cheminFfmpeg2theora="ffmpeg2theora"
			self.cheminMPlayer="mplayer"
		elif self.systeme=='windows':
			self.cheminMEncoder=cheminMEncoder
			self.cheminFfmpeg2theora=cheminFfmpeg2theora
			self.cheminMPlayer=cheminMPlayer
		
		# chemins vidéos
		self.cheminVideoEntre = cheminVideoEntre
		self.cheminSorti = cheminSorti
		
		# identifiant du codec
		self.idCodec = idCodec
		
		# valeur de la boite de spin pour l'encodage
		self.valeurNum = valeurNum
		
		# dimension des images (liste de 2 éléments)
		self.tailleIm = tailleIm
		
		# laisser ouvert la fenêtre après encodage
		self.laisserOuvert = laisserOuvert
		
		# drapeau pour ne pas lancer 2 fois l'encodage
		self.estLancee = False
		
		self.log = [] # stocke les infos de mplayer et mencoder
		
		self.resize(500, 100)
		
		#=== Widgets ===#
		
		self.zoneTexte = QTextEdit("") # là où s'afficheront les infos
		self.zoneTexte.setReadOnly(True)
		self.zoneTexte.hide()
		
		#self.bout_demarrer = QPushButton("encode and save")
		
		self.bout_annuler = QPushButton(_(u"Annuler"))
		
		self.bout_preZoneTexte = QPushButton(_("Voir les informations de l'encodage"))
		self.bout_preZoneTexte.hide()
		
		self.pbar = QProgressBar()
		self.pbar.setMaximum(100)
		
		self.mencoderProcess = QProcess(self)
		self.ffmpeg2theoraProcess = QProcess(self)
		self.mplayerProcess = QProcess(self)
		
		#=== mise-en-page/plan ===#
		
		vbox = QVBoxLayout()
		#vbox.addStretch()
		#hbox = QHBoxLayout()
		#hbox.addWidget(self.bout_demarrer)
		vbox.addWidget(self.bout_preZoneTexte)
		#vbox.addLayout(hbox)
		vbox.addWidget(self.zoneTexte)
		hbox = QHBoxLayout()
		hbox.addWidget(self.pbar)
		hbox.addWidget(self.bout_annuler)
		vbox.addLayout(hbox)
		self.setLayout(vbox)
		
		#self.adjustSize()
		
		#=== connexion des widgets à des fonctions ===#
		
		#self.demarrerMEncoder() # TEST # sert à calculer la durée d'exécution du script -> comparaison avec avec et sans traitement des lignes de sortie de QProcess
		# 'readyReadStandardOutput()': signal émis lors de la sortie standart de lecture
		self.connect(self.mencoderProcess, SIGNAL('readyReadStandardOutput()'), self.recupSortieMencoder)
		self.connect(self.ffmpeg2theoraProcess, SIGNAL('readyReadStandardOutput()'), self.recupSortieFfmpeg2theora)
		self.connect(self.mplayerProcess, SIGNAL('readyReadStandardOutput()'), self.recupSortieMplayer)
		
		self.connect(self.mencoderProcess, SIGNAL('finished(int)'), self.finEncodage)
		self.connect(self.ffmpeg2theoraProcess, SIGNAL('finished(int)'), self.finEncodage)
		self.connect(self.mplayerProcess, SIGNAL('finished(int)'), self.finEncodage)
		
		self.connect(self.bout_annuler, SIGNAL('clicked()'), self.close)
		self.connect(self.bout_preZoneTexte, SIGNAL('clicked()'), self.afficherLog)
		
		# Si le codec OGG THEORA est sélectionné
		if idCodec=='codecoggtheora':
			self.demarrerEncodeur('Ffmpeg2theora')
		elif idCodec in ['extractionaudio','jpeg', 'encodage_wav']:
			self.demarrerEncodeur('MPlayer Conversion')
		# Autrement ...
		else:
			self.demarrerEncodeur('Mencoder')
	
	
	def demarrerEncodeur(self, encodeur):
		"""démarrage de mencoder avec les arguments choisis"""
		
		if self.estLancee == False: # pas question de démarrer 2 fois l'encodage
			
			print '\n'
			
			a = "########################"
			b = "# Informations MPlayer :"
			c = "########################"
			
			infos = '\n'+a+'\n'+b+'\n'+c+'\n'
			print infos
			self.log.append(infos)
			
			if str(type(self.cheminVideoEntre)) == "<type 'tuple'>": # chemin vidéo et audio
				recDonnees_Video=os.popen(self.cheminMPlayer +' ' + self.cheminVideoEntre[0] + ' -vo null -ao null -frames 0 -identify "$@" 2>/dev/null').readlines()
			else: # chemin vidéo uniquement (le plus probable)
				recDonnees_Video=os.popen(self.cheminMPlayer +' ' + self.cheminVideoEntre + ' -vo null -ao null -frames 0 -identify "$@" 2>/dev/null').readlines()
			
			for ligne in recDonnees_Video:
				print ligne
				self.log.append(ligne)
				
				# Recupération directement ds Mplayer de la durée de la vidéo
				# Cette donnée est très importante ...
				if encodeur == 'Ffmpeg2theora' or encodeur == 'MPlayer Conversion':
					if 'ID_LENGTH' in ligne:
						self.dureeTotaleVideo=float(ligne[10:])
			
			print '\n'
			
			a = "############################"
			b = "# Informations %s :" %encodeur
			c = "############################"
			
			infos = '\n'+a+'\n'+b+'\n'+c+'\n'
			print infos
			self.log.append(infos)
			
			if encodeur == 'Ffmpeg2theora':
				# mode de canal: on fusionne le canal de sortie normal 
				# (stdout) et celui des erreurs (stderr)
				self.ffmpeg2theoraProcess.setProcessChannelMode(QProcess.MergedChannels)
				
				commande = self.commandeFfmpeg2theora(self.idCodec, self.cheminVideoEntre, self.cheminSorti, self.valeurNum, self.cheminFfmpeg2theora)
				print commande
				self.log.append(commande+'\n\n')
				self.ffmpeg2theoraProcess.start(commande)
				
				# au cas où ffmpeg2theora ne démarrerait pas au bout
				# de 3 sec (ex. problème de codec)
				if not self.ffmpeg2theoraProcess.waitForStarted(3000):
					qDebug("Bogue au lancement de la conversion avec ffmpeg2theora")
			
			elif encodeur == 'MPlayer Conversion':
				if self.idCodec=='extractionaudio':
					commande = self.commandeMplayerSeparation(self.cheminVideoEntre, self.cheminSorti, self.cheminMPlayer)
					print commande
					self.log.append(commande+'\n\n')
					# mode de canal: on fusionne le canal de sortie normal 
					# (stdout) et celui des erreurs (stderr)
					self.mplayerProcess.setProcessChannelMode(QProcess.MergedChannels)
					self.mplayerProcess.start(commande)
					
					# 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 l'extraction audio avec mplayer")
				
				elif self.idCodec=='jpeg': # convertir animation en images
					commande = self.commandeMplayerConvAnimImg(self.cheminVideoEntre, self.cheminSorti, self.cheminMPlayer)
					print commande
					self.log.append(commande+'\n\n')
					#os.system(commande)
					self.mplayerProcess.setProcessChannelMode(QProcess.MergedChannels)
					self.mplayerProcess.start(commande)
					
					# 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 conversion animation en images avec mplayer")

				elif self.idCodec=='encodage_wav': # encodage de fichiers audio en wav
					commande = self.commandeMplayerEncodageWav(self.cheminVideoEntre, self.cheminSorti, self.cheminMPlayer)
					print commande
					self.log.append(commande+'\n\n')
					self.mplayerProcess.setProcessChannelMode(QProcess.MergedChannels)
					self.mplayerProcess.start(commande)
					
					# 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 l'encodage de fichiers audio en wav")

			else: # MEncoder
				if self.idCodec in ['copie', 'avirawsanscompression', 'codecdivx4', 'codecmotionjpeg', 'codecmpeg1', 'codecmpeg2', 'codecwmv2', 'codecxvid', 'qualitesvcd', 'qualiteDVD', 'macromediaflashvideo', 'codech264mpeg4']:
					
					# mode de canal: on fusionne le canal de sortie normal 
					# (stdout) et celui des erreurs (stderr)
					self.mencoderProcess.setProcessChannelMode(QProcess.MergedChannels)
				
					commande = self.commandeMencoderEncodage(self.idCodec, self.cheminVideoEntre, self.cheminSorti, self.valeurNum, self.cheminMEncoder)
					print commande
					self.log.append(commande+'\n\n')
					self.mencoderProcess.start(commande)
				
				elif self.idCodec in ['niveaudegris', 'placesoustitres', 'luminositecontraste','decoupercrop', 'couleursaturationhue', 'miroir', 'flouboitebloxblur'] or self.idCodec[0]== 'bruit':
					
					print "self.idCodec de mencoder", self.idCodec
					
					# mode de canal: on fusionne le canal de sortie normal 
					# (stdout) et celui des erreurs (stderr)
					self.mencoderProcess.setProcessChannelMode(QProcess.MergedChannels)
					
					commande = self.commandeMencoderFiltresVideo1(self.idCodec, self.cheminVideoEntre, self.cheminSorti, self.valeurNum, self.cheminMEncoder)
					print commande
					self.log.append(commande+'\n\n')
					self.mencoderProcess.start(commande)
				
				elif self.idCodec == "extractionvideo":
					commande = self.commandeMencoderSeparation(self.cheminVideoEntre, self.cheminSorti, self.cheminMEncoder)
					print commande
					self.log.append(commande+'\n\n')
					# mode de canal: on fusionne le canal de sortie normal 
					# (stdout) et celui des erreurs (stderr)
					self.mencoderProcess.setProcessChannelMode(QProcess.MergedChannels)
					self.mencoderProcess.start(commande)
				
				elif self.idCodec in ['mpeg1video','mjpeg','h263p','mpeg4','msmpeg4v2','ljpeg']:
					commande = self.commandeMencoderConvertImg(self.idCodec, self.cheminVideoEntre, self.cheminSorti, self.valeurNum, self.tailleIm, self.cheminMEncoder)
					print commande
					self.log.append(commande+'\n\n')
					# mode de canal: on fusionne le canal de sortie normal 
					# (stdout) et celui des erreurs (stderr)
					self.mencoderProcess.setProcessChannelMode(QProcess.MergedChannels)
					self.mencoderProcess.start(commande)
				
				elif self.idCodec=='idx': # change le nombre d'images/s
					commande = self.commandeMencoderNbrImgSec(self.cheminVideoEntre, self.cheminSorti, self.valeurNum, self.cheminMEncoder)
					print commande
					self.log.append(commande+'\n\n')
					self.mencoderProcess.setProcessChannelMode(QProcess.MergedChannels)
					self.mencoderProcess.start(commande)
				
				elif self.idCodec=='fusion_video': # Collage de vidéos
					commande = self.commandeMencoderMontageVideo(self.cheminVideoEntre, self.cheminSorti, self.cheminMEncoder)
					print commande
					self.log.append(commande+'\n\n')
					self.mencoderProcess.setProcessChannelMode(QProcess.MergedChannels)
					self.mencoderProcess.start(commande)
				
				# Collage de vidéos et d'audios (1)
				elif self.idCodec in ['fusion_audio_et_video_1', 'fusion_audio_et_video_2']:
					cheminVideoEntre, cheminAudioEntre = self.cheminVideoEntre # tuple
					commande = self.commandeMencoderMontageVideoetAudio(self.idCodec, cheminVideoEntre, cheminAudioEntre, self.cheminSorti, self.cheminMEncoder)
					print commande
					self.log.append(commande+'\n\n')
					self.mencoderProcess.setProcessChannelMode(QProcess.MergedChannels)
					self.mencoderProcess.start(commande)
				
				# au cas où mencoder ne démarrerait pas au bout 
				# de 3 sec (ex. problème de codec)
				if not self.mencoderProcess.waitForStarted(3000):
					qDebug("Bogue au lancement de la conversion avec mencoder")
			
			self.estLancee = True


	def recupSortieMencoder(self):
		"""récupère les lignes d'information émises par QProcess et en tire les conséquences"""
		
		# stocke l'ensemble des bits d'une ligne
		# readline: lit une ligne ascii à partir du système
		tampon=QByteArray(self.mencoderProcess.readLine()) 
		
		# on récupère les lignes de mencoder
		if '\n' in tampon: 
			# informations mencoder
			print tampon 
			self.log.append(tampon)
		
		#print "tampon_mencoder :",tampon
		
		# On vérifie si on a eu des réponses sur la progression de mencoder -> affichage
		# retourne True si l'ensemble de bits démarre avec "..."
		if tampon.startsWith("Pos:"): 
			# chaîne de caractères du %
			ch=''
			# quand drapeau=1, on entre dans la parenthèse contenant le %
			drapeau=0
			for i in tampon:
				if i =='(':
					drapeau=1
				elif drapeau==1:
					if i =='%':
						break
					elif i == ' ':
						pass
					else:
						ch=ch+i
			# % de progression de mencoder
			pourCent = int(ch)
			# affichage du % dans la barre de progression
			self.pbar.setValue(pourCent)
	
	
	def recupSortieFfmpeg2theora(self):
		"""récupère les lignes d'information émises par QProcess et en tire les conséquences"""
		
		# stocke l'ensemble des bits d'une ligne
		# readline: lit une ligne ascii à partir du système
		tampon=QByteArray(self.ffmpeg2theoraProcess.readLine())
		
		if '\r' in tampon:
			# En fait le début est comme ceci : \r      0:...
			tampon.replace(QByteArray("\r"), QByteArray(""))
			# Tampon 2 (tampon est transformé en string) et les espaces 
			# disgracieux en début de chaîne sont supprimés . Sert pour
			# le calcul des heures, minutes, secondes
			tampon_2=str(QString(tampon)).strip()
			# Calcul des heures, minutes, secondes
			tamponHeures, tamponMinutes, tamponScondes = float(tampon_2[0]), float(tampon_2[2:4]), float(tampon_2[5:9])
			# Temps total écoulé en secondes
			tamponTotalSecondes=(tamponHeures*3600)+(tamponMinutes*60)+tamponScondes
			# Calcul du pourcentage écoulé 
			pourCent=int((tamponTotalSecondes*100)/float(self.dureeTotaleVideo))
			# affichage du % dans la barre de progression
			self.pbar.setValue(pourCent)
			
		# N'affiche que les informations nécessaires (pas le temps passé
		# par le process --> qui est ici évidemment complètement inutile)
		else :
			self.log.append(tampon)
			print tampon
	
	
	def recupSortieMplayer(self):
		"""récupère les lignes d'information émises par QProcess et en tire les conséquences"""
		
		# stocke l'ensemble des bits d'une ligne
		# readline: lit une ligne ascii à partir du système
		tampon=QByteArray(self.mplayerProcess.readLine())
		
		#print "TAMPON MPLAYER :", tampon
		
		# on récupère le temps de la vidéo
		if '\r' in tampon:
			# En fait le début est comme ceci : \r      0:...
			tampon.replace(QByteArray("\r"), QByteArray(""))
			# tampon est transformé en string
			tampon = str(tampon)
			tampon = tampon.split(' ')
			tampon2 = tampon
			for i in tampon:
				if i=='':
					tampon2.remove('')
			tpsCourant = float(tampon2[1])
			
			# Calcul du pourcentage
			pourCent=int(tpsCourant/float(self.dureeTotaleVideo)*100)
			
			# affichage du % dans la barre de progression
			self.pbar.setValue(pourCent)
		
		# N'affiche que les informations nécessaires (pas le temps passé
		# par le process --> qui est ici évidemment complètement inutile)
		else :
			self.log.append(tampon)
			print tampon
	
	
	def finEncodage(self, statutDeSortie):
		"""choses à faire à la fin de l'encodage de la vidéo"""
		if statutDeSortie==1:
			print "Crash de l'encodeur!"
			self.log.append("-------------------------\n Crash de l'encodeur!\n---------------------")
			self.pbar.setValue(0)
			self.bout_annuler.setText(_(u"Fermer"))
			self.bout_preZoneTexte.setText(_(u'Problème! Voir les informations'))
			self.bout_preZoneTexte.show()
			return
		
		# fermer la fenêtre à la fin de l'encodage
		elif not self.laisserOuvert:
			self.close()
		
		print "fini!"
		self.pbar.setValue(100)
		# l'encodage est fini. Il ne peut plus être annulé. La  
		# seule action possible devient ainsi la fermeture
		self.bout_annuler.setText(_(u"Fermer"))
		self.bout_preZoneTexte.show()
	
	
	def afficherLog(self):
		"""afficher les information de la vidéo de départ et de l'encodage"""
		texte =  "#######\n# LOG :\n#######\n"
		for ligne in self.log:
			texte = texte + str(ligne) # ligne est de type ByteArray
		
		self.zoneTexte.setText(texte)
		self.zoneTexte.show()
		self.resize(500, 300)
	
	
	def commandeMencoderEncodage(self, idCodec, cheminVideoEntre, cheminVideoSorti, valeurNum, cheminMEncoder):
		"""renvoie la commande d'encodage à exécuter"""
		
		if idCodec=='copie':
			commande=cheminMEncoder+' '+"\""+cheminVideoEntre+"\""+' -ovc copy -oac copy -o '+"\""+cheminVideoSorti+"\""
		
		elif idCodec=='avirawsanscompression':
			commande=cheminMEncoder+' '+"\""+cheminVideoEntre+"\""+' -ovc raw -vf format=i420 -oac copy -o '+"\""+cheminVideoSorti+"\""
		
		elif idCodec=='codecdivx4':
			commande=cheminMEncoder+' '+"\""+cheminVideoEntre+"\""+' -ovc lavc -lavcopts vcodec=mpeg4:vqmin='+valeurNum+':vpass=1 -oac copy -o '+"\""+cheminVideoSorti+"\""
		
		elif idCodec=='codecmotionjpeg':
			commande=cheminMEncoder+' '+"\""+cheminVideoEntre+"\""+' -ovc lavc -lavcopts vcodec=mjpeg:vqmin='+valeurNum+':vpass=1 -oac copy -o '+"\""+cheminVideoSorti+"\""
		
		elif idCodec=='codecmpeg1':
			commande=cheminMEncoder+' '+"\""+cheminVideoEntre+"\""+' -ovc lavc -lavcopts vcodec=mpeg1video:vqmin='+valeurNum+':vpass=1 -oac copy -o '+"\""+cheminVideoSorti+"\""
		
		elif idCodec=='codecmpeg2':
			commande=cheminMEncoder+' '+"\""+cheminVideoEntre+"\""+' -ovc lavc -lavcopts vcodec=mpeg2video:vqmin='+valeurNum+':vpass=1 -oac copy -o '+"\""+cheminVideoSorti+"\""
		
		elif idCodec=='codecwmv2':
			commande=cheminMEncoder+' '+"\""+cheminVideoEntre+"\""+' -ovc lavc -lavcopts vcodec=wmv2:vqmin='+valeurNum+':vpass=1 -oac copy -o '+"\""+cheminVideoSorti+"\""
		
		elif idCodec=='codecxvid':
			commande=cheminMEncoder+' '+"\""+cheminVideoEntre+"\""+' -ovc lavc -ffourcc xvid -oac copy -o '+"\""+cheminVideoSorti+"\""
		
		elif idCodec=='qualitesvcd':
			'''
			# NE PAS RETIRER POUR L'INSTANT
			commande=cheminMEncoder+' -oac lavc -ovc lavc -of mpeg -mpegopts format=xsvcd -vf scale=576:480,harddup -srate 44100 -af lavcresample=44100 -lavcopts vcodec=mpeg2video:mbd=2:keyint=15:vrc_buf_size=917:vrc_minrate=600:vbitrate=2500:vrc_maxrate=2500:acodec=mp2:abitrate=224 -ofps 25 '+"\""+cheminVideoEntre+"\""+' -o '+' '+"\""+cheminVideoSorti+'.mpg'+"\""
			'''
			commande=cheminMEncoder+' -oac lavc -ovc lavc -of mpeg -mpegopts format=xsvcd -vf scale=576:480,harddup -srate 44100 -af lavcresample=44100 -lavcopts vcodec=mpeg2video:mbd=2:keyint=15:vrc_buf_size=917:vrc_minrate=600:vbitrate=2500:vrc_maxrate=2500:abitrate=224 -oac copy -ofps 25 '+"\""+cheminVideoEntre+"\""+' -o '+' '+"\""+cheminVideoSorti+"\""
			
		elif idCodec=='qualiteDVD':
			'''
			# NE PAS RETIRER POUR L'INSTANT
			commande=cheminMEncoder+' -oac lavc -ovc lavc -of mpeg -mpegopts format=dvd -vf scale=720:576,harddup -srate 48000 -af lavcresample=48000 -lavcopts vcodec=mpeg2video:vrc_buf_size=1835:vrc_maxrate=9800:vbitrate=5000:keyint=15:acodec=ac3:abitrate=192:aspect=4/3 -ofps 25 -o '+"\""+cheminVideoSorti+'_dvd.mpg'+"\""+' '+"\""+cheminVideoEntre+"\""
			'''
			commande=cheminMEncoder+' -oac lavc -ovc lavc -of mpeg -mpegopts format=dvd -vf scale=720:576,harddup -srate 48000 -af lavcresample=48000 -lavcopts vcodec=mpeg2video:vrc_buf_size=1835:vrc_maxrate=9800:vbitrate=5000:keyint=15:aspect=4/3 -oac copy -ofps 25 '+"\""+cheminVideoEntre+"\""+' -o '+' '+"\""+cheminVideoSorti+"\""
			
		elif idCodec=='macromediaflashvideo':
			commande=cheminMEncoder+' -oac copy -ffourcc FLV1 -ovc lavc -lavcopts vcodec=flv:vbitrate='+valeurNum+' '+"\""+cheminVideoEntre+"\""+' -o '+"\""+cheminVideoSorti+"\""
		
		elif idCodec=='codech264mpeg4':
			commande=cheminMEncoder+' '+"\""+cheminVideoEntre+"\""+' -oac copy -of lavf -lavfopts format=mp4:i_certify_that_my_video_stream_does_not_use_b_frames -ovc x264 -o '+"\""+cheminVideoSorti+"\""
		
		return commande
	
	
	def commandeFfmpeg2theora(self, idCodec, cheminVideoEntre, cheminVideoSorti, valeurNum, cheminFfmpeg2theora):
		if idCodec=='codecoggtheora':
			commande=cheminFfmpeg2theora+' '+"\""+cheminVideoEntre+"\""+' -v '+valeurNum+' -o '+"\""+cheminVideoSorti+"\""
		
		return commande
	
	
	def commandeMencoderFiltresVideo1(self, idCodec, cheminVideoEntre, cheminVideoSorti, valeurNum, cheminMEncoder):
		"""renvoie la commande d'encodage à exécuter"""
		
		# valeurNum est toujours un tuple de taille 2 dans cette fonction
		
		if idCodec=='niveaudegris':
			commande = cheminMEncoder+' -ovc lavc -lavcopts gray -oac pcm -o '+"\""+cheminVideoSorti+"\""+' '+"\""+cheminVideoEntre+"\""
		
		elif idCodec=='placesoustitres':
			commande = cheminMEncoder+' -ovc lavc -vf expand=0:-50:0:0 -oac copy -o '+"\""+cheminVideoSorti+"\""+' '+"\""+cheminVideoEntre+"\""
		
		elif idCodec[0]=='bruit':
			# idLuma ou idChroma = "u" ("bruituniforme")
			# idLuma ou idChroma = "t" ("bruittemporel")
			# idLuma ou idChroma = "a" ("bruittemporelm")
			# idLuma ou idChroma = "h" ("hautequalite")
			# idLuma ou idChroma = "p" ("mixedubruit")
			idLuma, idChroma = idCodec[1], idCodec[2]
			
			commande = cheminMEncoder+' -ovc lavc -vf noise='+idLuma+'['+valeurNum[0]+']:'+idChroma+'['+valeurNum[1]+']'+' -oac copy -o '+"\""+cheminVideoSorti+"\""+' '+"\""+cheminVideoEntre+"\""
		
		elif idCodec=='luminositecontraste':
			commande = cheminMEncoder+' -ovc lavc -vf eq='+valeurNum[0]+':'+valeurNum[1]+' -oac copy -o '+"\""+cheminVideoSorti+"\""+' '+"\""+cheminVideoEntre+"\""
		
		elif idCodec=='decoupercrop':
			commande = cheminMEncoder+' -ovc lavc -vf crop='+valeurNum[0]+':'+valeurNum[1]+' -oac copy -o '+"\""+cheminVideoSorti+"\""+' '+"\""+cheminVideoEntre+"\""
		
		elif idCodec=='couleursaturationhue':
			commande = cheminMEncoder+' -ovc lavc -vf hue='+valeurNum[0]+':'+valeurNum[1]+' -oac copy -o '+"\""+cheminVideoSorti+"\""+' '+"\""+cheminVideoEntre+"\""
		
		elif idCodec=='miroir':
			commande = cheminMEncoder+' -ovc lavc -vf mirror -oac copy -o '+"\""+cheminVideoSorti+"\""+' '+"\""+cheminVideoEntre+"\""
		
		elif idCodec=='flouboitebloxblur':
			commande = cheminMEncoder+' -ovc lavc -vf boxblur='+valeurNum[0]+':'+valeurNum[1]+' -oac copy -o '+"\""+cheminVideoSorti+"\""+' '+"\""+cheminVideoEntre+"\""
		
		return commande
	
	
	def commandeMencoderSeparation(self, cheminVideoEntre, cheminVideoSorti, cheminMEncoder):
		""
		commande = cheminMEncoder+" -ovc lavc -nosound "+"\""+cheminVideoEntre+"\""+" -o "+"\""+cheminVideoSorti+"\""
		
		return commande
	
	
	def commandeMencoderConvertImg(self, idCombo, cheminVideoEntre, cheminVideoSorti, valeurNum, tailleIm, cheminMEncoder):
		""
		commande = cheminMEncoder+' mf://'+"\""+cheminVideoEntre+"\""+' -mf fps='+valeurNum+':w='+tailleIm[0]+':h='+tailleIm[1]+' -ovc lavc -lavcopts vcodec='+idCombo+' -o '+"\""+cheminVideoSorti+"\""
		
		return commande
	
	
	def commandeMplayerSeparation(self, cheminVideoEntre, cheminAudioSorti, cheminMPlayer):
		""
		commande = cheminMPlayer+" -ao pcm:waveheader:file="+"\""+cheminAudioSorti+"\""+" -vo null -vc null "+"\""+cheminVideoEntre+"\""
		
		return commande
	
	
	def commandeMplayerEncodageWav(self, cheminVideoEntre, cheminAudioSorti, cheminMPlayer):
		""
		commande = cheminMPlayer+' '+"\""+cheminVideoEntre+"\""+' -ao pcm:waveheader:file='+"\""+cheminAudioSorti+'.wav'+"\""
		
		return commande
	
	
	def commandeMencoderNbrImgSec(self, cheminVideoSource, cheminVideoSorti, valeurNum, cheminMEncoder):
		""
		commande = cheminMEncoder+' -idx -ovc copy -oac copy -ofps '+valeurNum+' -o '+"\""+cheminVideoSorti+"\""+' '+"\""+cheminVideoSource+"\""
		
		return commande
	
	
	def commandeMplayerConvAnimImg(self, cheminVideoSource, cheminRepDestination, cheminMPlayer):
		""
		commande = cheminMPlayer+" \""+cheminVideoSource+"\" -vo jpeg:outdir=\""+cheminRepDestination+"\":quality=100"
		
		return commande
	
	def commandeMencoderMontageVideo(self, cheminVideoEntre, cheminVideoSorti, cheminMEncoder):
		commande = cheminMEncoder+" -noidx -oac copy -ovc copy -o" + " \"" + cheminVideoSorti + "\" " + cheminVideoEntre
		
		return commande
	
	def commandeMencoderMontageVideoetAudio(self, idCodec, cheminVideoEntre, cheminAudioEntre, cheminVideoSorti, cheminMEncoder):
		if idCodec=='fusion_audio_et_video_1':
			commande = cheminMEncoder + " -noidx -audiofile " + cheminAudioEntre + " -oac lavc -lavcopts acodec=ac3 -stereo 0 -ovc copy -o " + "\"" + cheminVideoSorti + "\" " + cheminVideoEntre
		elif idCodec=='fusion_audio_et_video_2':
			commande = cheminMEncoder + " -noidx -audiofile " + cheminAudioEntre + " -oac copy -stereo 0 -ovc copy -o " + "\"" + cheminVideoSorti + "\" " + cheminVideoEntre
		
		return commande
	