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

import os
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from gui_modules_animation.animation_base import Base
from moteur_modules_animation.mencoder import WidgetMEncoder
from moteur_modules_animation.mplayer import Mplayer

class Animation_SeparVideoEtAudio(QWidget):
	# ----------------------------------------------------------------------------------------
	# Cadre accueillant les widgets de : Animation >> Séparer le flux vidéo et le flux audio
	# ----------------------------------------------------------------------------------------
	def __init__(self, parent):
		QWidget.__init__(self)
		
		# -------------------------------
		# Parametres généraux du widget
		# -------------------------------
		self.base = Base(self) # module de animation
		#=== tout sera mis dans une boîte verticale ===#
		vbox=QVBoxLayout(self)
		
		#=== Variable de configuration ===#
		self.config=parent.config
		
		#=== Identifiant de la classe ===#
		self.idSection = "Animation - Separer Audio et Video"
		self.base.printSection()
		
		# -------------------------------------------------------------------
		# Boîte de groupe : "Fichier vidéo source"
		# -------------------------------------------------------------------
		self.base.widgetSource(vbox)
		
		# -------------------------------------------------------------------
		# Boîte de groupe "Réglage de sortie de l'encodage"
		# -------------------------------------------------------------------
		
		#=== Création de la boite de groupe de réglage (contenant la boite self.layoutReglage) ===#
		self.base.widgetReglage(vbox, nomReglage=_(u"Réglage du mode d'extraction audio/vidéo"), boite='vbox')
		
		#=== Widget qui seront inclus dans la boite de réglage ===#
		# boite de combo
		self.combo=QComboBox() # le self sert à afficher des informations sur les items à partir de la fonction
		# listeCombo=[(texte, clé QVariant)...]
		listeCombo=[	(_(u'Vidéo et audio') ,'video&audio'),\
				(_(u'Vidéo seulement') ,'video'),\
				(_(u'Audio seulement') , 'audio'),]
		
		# Insertion des codecs de compression dans la combo box
		for i in listeCombo:
                	self.combo.addItem(i[0],QVariant(i[1]))
		
		self.connect(self.combo, SIGNAL("activated(int)"), self.sauverTypeExtraction)
		
		self.layoutReglage.addWidget(self.combo, 0, Qt.AlignHCenter)
		
		# On tient-compte du paramètre de configuration
		try:
			typ = self.config.get(self.idSection,'type_extraction')
			indice = 0 # indice de la ligne de self.listeCombo correspondant au type d'ordre
			for i in listeCombo:
				if i[1]!=typ:
					indice += 1
				else:
					break
			self.combo.setCurrentIndex(indice)
		except:
			self.combo.setCurrentIndex(0)
		
		# ----------------------------
		# Boite de groupe de mplayer
		# ----------------------------
		group=QGroupBox("")
		vboxMplayer = QVBoxLayout(group)
		self.mplayer=Mplayer(taille=self.base.tailleMplayer)
		self.mplayer.setEnabled(False)
		self.mplayer.listeVideos = [self.ligneEditionSource.text()]
		hbox = QHBoxLayout()
		hbox.addStretch()
		hbox.addWidget(self.mplayer)
		hbox.addStretch()
		vboxMplayer.addLayout(hbox)
		group.setAlignment(Qt.AlignHCenter)
		vbox.addWidget(group)
		
		# -------------------------------------------------------------------
		# widgets du bas : ligne + boutons Aide et Appliquer
		# -------------------------------------------------------------------
		self.base.widgetBas(vbox)
		
		# affichage de la boîte principale
		self.setLayout(vbox)
	
	
	def sauverTypeExtraction(self,i):
		""" Sauvegarde du mode d'extraction """
		idCombo= str(self.combo.itemData(i).toStringList()[0])
		self.config.set(self.idSection,'type_extraction',idCombo)
	
	
	def afficherAide(self):
		""" Boîte de dialogue de l'aide """
		self.base.afficherAide(_(u"Blablablablablablablablablabla ... blablabla ... blablablabla ... blablabla."))
		'''
		messageAide=QMessageBox(self)
		messageAide.setText(_(u"Blablablabla ... blabla anim_separ_video_et_audio."))
		messageAide.setWindowTitle(_(u"Aide"))
		messageAide.setIcon(QMessageBox.Information)
		messageAide.exec_()
		'''
	
	
	def ouvrirSource(self, nomEntree=None):
		"""Récupération du chemin de la vidéo sélectionnée et activation de certains widgets"""
		
		# Récupération du chemin de la vidéo
		chemin = self.base.recupSource(nomEntree)
		if not chemin: return
		print "chemin vidéo d'entrée:", chemin, type(chemin)
		
		# Affichage du chemin + nom de fichier dans la ligne d'édition
		self.ligneEditionSource.setText(chemin)
		
		self.boutApp.setEnabled(True)
	
	
	def extraireVideo(self, cheminVideoEntre, SortieVideoSFA, laisserOuvert=1):
		"extraction de la vidéo du fichier"
		
		try:
			mencoder = WidgetMEncoder("extractionvideo", cheminVideoEntre, SortieVideoSFA, laisserOuvert=laisserOuvert)
			mencoder.setWindowTitle(_(u"Extraction vidéo"))
			mencoder.exec_()
			#os.system("mencoder -ovc lavc -nosound "+"\""+cheminVideoEntre+"\""+" -o "+"\""+SortieVideoSFA+"\"")
		except:
			messageErrAnEnc=QMessageBox(self)
			messageErrAnEnc.setText(_(u"Problème d'extraction vidéo (mencodeur)"))
			messageErrAnEnc.setWindowTitle(_(u"Error"))
			messageErrAnEnc.setIcon(QMessageBox.Warning)
			messageErrAnEnc.exec_()
			return
	
	
	def extraireAudio(self, cheminVideoEntre, SortieAudioSFA, laisserOuvert=1):
		"extraction de l'audio du fichier"
		
		try:
			mplayer = WidgetMEncoder("extractionaudio", cheminVideoEntre, SortieAudioSFA, laisserOuvert=laisserOuvert)
			mplayer.setWindowTitle(_(u"Extraction audio"))
			mplayer.exec_()
			#os.system("mplayer -ao pcm:waveheader:file="+"\""+SortieAudioSFA+"\""+" -vo null -vc null "+"\""+cheminVideoEntre+"\"")
			''' On peut aussi faire :
			os.system("mplayer -ao pcm:file="+SortieAudioSFA+" -vo null -vc null "+b) '''
		except:
			messageErrAnEnc=QMessageBox(self)
			messageErrAnEnc.setText(_(u"Problème d'extraction audio (mplayer)"))
			messageErrAnEnc.setWindowTitle(_(u"Error"))
			messageErrAnEnc.setIcon(QMessageBox.Warning)
			messageErrAnEnc.exec_()
			return
	
	
	def appliquer(self, nomSortie=None, ouvert=1):
		""" appelle la boite de dialogue de sélection de fichier à sauver et appel de la fonction de séparation audio-vidéo """
		
		#=== Détermination des chemins d'entrée et sortie ===#
		
		# récupération du chemin de la vidéo source
		cheminVideoEntre=str(self.ligneEditionSource.text())
		fich, ext=os.path.splitext(cheminVideoEntre)
		
		cheminVideoSorti=""
		
		# récupération du chemin de la vidéo de destination (à l'exception de l'extension)
		if not nomSortie:
			cheminVideoSorti=str(QFileDialog.getSaveFileName(None, _(u"Sauver"), os.path.expanduser(self.base.repSortieProv()), _(u"Tous les fichiers *.*")))
		else: # module séquentiel
			cheminVideoSorti=nomSortie
		
		if cheminVideoSorti=="": return
		
		# extension de fichier: ext
		fich, ext=os.path.splitext(cheminVideoEntre)
		
		# chemins complets de sortie vidéo et audio
		SortieVideoSFA = cheminVideoSorti+ext
		SortieAudioSFA = cheminVideoSorti+".wav"
		
		print "CHEMINS", SortieVideoSFA, SortieAudioSFA
		
		#=== Separation du fichier video ===#
		
		# récupération du mode d'extraction
		i=self.combo.currentIndex()
		idCombo = str(self.combo.itemData(i).toStringList()[0])
		print "Combo :", idCombo
		
		# extraction
		# extraction audio et vidéo
		if idCombo == 'video&audio':
			# le 3ème argument sert à fermer automatiquement la fenêtre d'encodage
			self.extraireVideo(cheminVideoEntre, SortieVideoSFA, 0)
			self.extraireAudio(cheminVideoEntre, SortieAudioSFA, ouvert)
		# extraction vidéo
		elif idCombo == 'video':
			self.extraireVideo(cheminVideoEntre, SortieVideoSFA, ouvert)
		# extraction audio
		elif idCombo == 'audio':
			self.extraireAudio(cheminVideoEntre, SortieAudioSFA, ouvert)
		
		return SortieVideoSFA
	
	
	def sequentiel(self, entree, sortie, ouvert=0):
		"""Utile dans le module du même nom. Applique les opérations de la classe. Retourne le vrai nom du fichier de sortie"""
		self.ouvrirSource(entree)
		return self.appliquer(sortie, ouvert)
	
	
	def sequentielReglage(self):
		"""Utile dans le module du même nom. Récupère le widget de réglage associé à l'identifiant donné en 1er argument. Retourne l'instance du widget de réglage"""
		return self.groupReglage