Esempio n. 1
0
	def appliquer(self, nomSortie=None, ouvert=1):
		"Appel du moteur du cadre"
		
		if not nomSortie:
			#chemin = self.getFile()
			chemin = self.chemin
			
			self.suffix_sortie = os.path.splitext(chemin)[1]
			
			# Suffix du codec actif
                        saveDialog = EkdSaveDialog(self, mode="video", suffix=self.suffix_sortie, title=_(u"Sauver"))
			self.cheminFichierEnregistrerVideo = saveDialog.getFile()
			
		else: # module séquentiel
			self.cheminFichierEnregistrerVideo = nomSortie

		if not self.cheminFichierEnregistrerVideo:
			return
		
		# Appel de la classe
#		try:
                mencoder = WidgetMEncoder('tag_video', chemin, self.cheminFichierEnregistrerVideo, valeurNum = self.tags.get_tags(), laisserOuvert=ouvert)
                mencoder.setWindowTitle(_(u"Créer des tags vidéo"))
                mencoder.exec_()
#		except:
#			messageErrTagVid=QMessageBox(self)
#			messageErrTagVid.setText(_(u"Un problème est survenu lors de l'exécution de Mencoder"))
#			messageErrTagVid.setWindowTitle(_(u"Erreur"))
#			messageErrTagVid.setIcon(QMessageBox.Warning)
#			messageErrTagVid.exec_()
#			return

		### Information à l'utilisateur
		self.lstFichiersSortie = self.cheminFichierEnregistrerVideo
		self.infoLog(None, chemin, None, self.cheminFichierEnregistrerVideo)
    def appliquer(self):
        """Découpage de la vidéo"""

        # Récupération du chemin source
        chemin = unicode(self.chemin)
        # suffix du fichier actif
        suffix = os.path.splitext(chemin)[1]
        # Modifié le 30/06/2009 : On joue avec l'éritage de Base
        saveDialog = EkdSaveDialog(self, mode="video", suffix=suffix, title=_(u"Sauver"))

        cheminFichierEnregistrerVideo = saveDialog.getFile()

        if not cheminFichierEnregistrerVideo:
            return
        ###########################################################################################################################

        tempsDebut = float("%.1f" % self.valeurDebut)
        tempsFin = float("%.1f" % self.valeurFin)
        dureeSelection = str(tempsFin - tempsDebut)
        #

        # Extension du fichier
        # print "extension :", suffix, type(suffix)
        EkdPrint(u"extension : %s %s" % (suffix, type(suffix)))

        try:
            mencoder = WidgetMEncoder(
                "decoupervideo",
                chemin,
                cheminFichierEnregistrerVideo,
                valeurNum=(str(tempsDebut), str(dureeSelection)),
                optionSpeciale=self.extraireSon,
                laisserOuvert=1,
            )
            mencoder.setWindowTitle(_(u"Découper une vidéo"))
            mencoder.exec_()
        except:
            messageErrAnEnc = QMessageBox(self)
            messageErrAnEnc.setText(_(u'Un problème est survenu lors de l\'exécution de "mencoder -ss ..."'))
            messageErrAnEnc.setWindowTitle(_(u"Error"))
            messageErrAnEnc.setIcon(QMessageBox.Warning)
            messageErrAnEnc.exec_()
            return

        self.fichierSortie = cheminFichierEnregistrerVideo
        self.radioSource.setEnabled(True)
        self.radioSource.setChecked(False)
        self.radioConvert.setEnabled(True)
        self.radioConvert.setChecked(True)
        ### Information à l'utilisateur
        self.infoLog(None, chemin, None, cheminFichierEnregistrerVideo)
	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_()
		except:
			messageErrAnEnc=QMessageBox(self)
			messageErrAnEnc.setText(_(u"Problème d'extraction vidéo (mencoder)"))
			messageErrAnEnc.setWindowTitle(_(u"Error"))
			messageErrAnEnc.setIcon(QMessageBox.Warning)
			messageErrAnEnc.exec_()
			return
Esempio n. 4
0
    def appliquer(self, nomSortie=None, ouvert=1):
        """Appel du moteur du cadre"""

        # quel est l'index du dernier item sélectionné de la boîte de combo?
        index = self.combo.currentIndex()
        if not nomSortie:

            ## On utilise la nouvelle interface de récupération des vidéos
            # Récupération du chemin source
            chemin = unicode(self.getFile())
            # suffix du codec actif
            suffix = self.listeCombo[index][3]
            if suffix == "":
                suffix = os.path.splitext(chemin)[1]

                # ------------------------------------------------------------------- #
                # Gestion des fichiers mod (extension .mod). Ce sont (apparemment)
                # des fichiers mpeg avec une extension .mod. Les fichiers en question
                # ont juste besoin d'être renommés avec une extension .mpg avant le
                # traitement.
                # ------------------------------------------------------------------- #
            ext_chargee = os.path.splitext(chemin)[1]
            nom_fich_sans_ext = os.path.splitext(os.path.basename(chemin))[0]
            if ext_chargee in [".mod", ".MOD"]:
                # Copie du fichier concerné dans le rep tampon et renommage avec ext .mpg
                shutil.copy(chemin, self.repTempFichiersMod + nom_fich_sans_ext + ".mpg")
                chemin = unicode(self.repTempFichiersMod + nom_fich_sans_ext + ".mpg")

                # suffix du codec actif
            saveDialog = EkdSaveDialog(self, mode="video", suffix=suffix, title=_(u"Sauver"))
            cheminFichierEnregistrerVideo = saveDialog.getFile()
            ###################################################################################################################

        else:  # module séquentiel
            chemin = cheminFichierEnregistrerVideo = nomSortie

        if not cheminFichierEnregistrerVideo:
            return

            # quel est l'index du dernier item sélectionné de la boîte de combo?
            # print 'index', index
        EkdPrint("index " + str(index))
        # identifiant du codec actif
        idCodec = self.listeCombo[index][0]
        # print 'idCodec', idCodec
        EkdPrint("idCodec " + idCodec)

        # Condition pour détection windows
        if os.name == "nt":
            mencoder = WidgetMEncoder(idCodec, chemin, cheminFichierEnregistrerVideo, laisserOuvert=ouvert)
            # Condition pour détection Linux
        elif os.name in ["posix", "mac"]:
            mencoder = WidgetMEncoder(idCodec, chemin, cheminFichierEnregistrerVideo, laisserOuvert=ouvert)
        mencoder.setWindowTitle(_(u"Encodage vidéo - Pour le web"))
        mencoder.exec_()

        # Condition pour détection windows
        if os.name == "nt":
            self.lstFichiersSortie = cheminFichierEnregistrerVideo  # pour la boite de dialogue de comparaison
            # Condition pour détection Linux
        elif os.name in ["posix", "mac"]:
            self.lstFichiersSortie = cheminFichierEnregistrerVideo  # pour la boite de dialogue de comparaison
        self.radioConvert.setChecked(True)
        self.radioSource.setEnabled(True)
        self.radioSource.setChecked(False)
        self.radioConvert.setEnabled(True)
        self.boutCompare.setEnabled(True)
        ### Information à l'utilisateur
        self.infoLog(None, chemin, None, cheminFichierEnregistrerVideo)

        return cheminFichierEnregistrerVideo  # module séquentiel
Esempio n. 5
0
	def appliquer(self, nomSortie=None, ouvert=1):
		"""appel du moteur de ekd -> encodage"""

		if not nomSortie:
			index=self.combo.currentIndex()
			chemin = unicode(self.getFile())

			# suffix du codec actif
			suffix=self.listeCombo[index][4]
			if suffix=='':
				suffix=os.path.splitext(chemin)[1]
				
			ext_chargee = os.path.splitext(chemin)[1]
			codec_reglage = self.listeCombo[index][1]
			
			# ------------------------------------------------------------------- #
			# Gestion des fichiers mod (extension .mod). Ce sont (apparemment)
			# des fichiers mpeg avec une extension .mod. Les fichiers en question 
			# ont juste besoin d'être renommés avec une extension .mpg avant le 
			# traitement.
			# ------------------------------------------------------------------- #
			nom_fich_sans_ext = os.path.splitext(os.path.basename(chemin))[0]
			if ext_chargee in ['.mod', '.MOD']:
				# Copie du fichier concerné dans le rep tampon et renommage avec ext .mpg
				shutil.copy(chemin, self.repTempFichiersMod+nom_fich_sans_ext + '.mpg')
				chemin = unicode(self.repTempFichiersMod + nom_fich_sans_ext + '.mpg')

                        saveDialog = EkdSaveDialog(self, mode="video", suffix=suffix, title=_(u"Sauver"))
			cheminFichierEnregistrerVideo = saveDialog.getFile()

		else: # module séquentiel
			chemin=cheminFichierEnregistrerVideo=nomSortie

		if not cheminFichierEnregistrerVideo:
			return

		# quel est l'index du dernier item sélectionné de la boîte de combo?
		i=self.combo.currentIndex()
		# identifiant du codec actif
		idCodec=str(self.combo.itemData(i).toStringList()[0]) # méthode de QVariant

		# pas de spin pour Copie (format original) - AVI-RAW Sans Compression
		# Codec XVID - Qualite SVCD - Qualite DVD - Codec H264 MPEG 4
		spin=None # par défaut

		for j in self.listeCombo: # attribution de la valeur du spin s'il existe
			if j[0]==idCodec and j[5]==1:
				if j[0] in ['codecmotionjpeg', 'codecmpeg2', 'codech264mpeg4', 'codech264mpeg4_ext_h264', 'codecdivx4', 'codecmpeg1', 'macromediaflashvideo', 'codecwmv2']:
					# La valeur de compression vidéo va de 31 à 1 (31 --> mauvaise qualité
					# jusqu'à à 1 --> très bonne qualité). Ici on va calculer en mettant
					# en place un réglage qui partira de 1 à 100 (1 --> mauvaise qualité
					# et 100 --> très bonne qualité)
					calculValComp = (31 * j[3].spinCompression.value()) / 100
					# Il faut soustraire le résultat à 31 pour
					# avoir une valeur reconnue par Mencoder
					calculValComp = 31 - calculValComp
					# Si la la valeur de réglage de la compression est réglée sur
					# 100, la valeur retournée sera 0 (ce qui va générer une erreur
					# dans Mencoder ... et ainsi stopper le process), la valeur
					# retournée sera donc de 1 (ce qui sera ok)
					if j[3].spinCompression.value() == 100: calculValComp = 1
					# Dimension de la vidéo (preset). Exception pour contrôler 
					# les cas où l'utilisateur laisse par défaut: 
					# Pas de changement (vidéo avec la même taille que l'original)
					try: valeurSizeGeneral = str(j[3].idComboGeneral)
					except: valeurSizeGeneral = ''
					# La valeur est sous forme de tuple et contient au moins 3 valeurs
					spin = (str(j[3].spinBitrateVideo.value()), str(calculValComp), str(valeurSizeGeneral))
				elif j[0] in ['codec_vob_ffmpeg']:
					# La valeur de compression vidéo va de 255 à 1 (255 --> mauvaise qualité
					# jusqu'à 1 --> très bonne qualité). Ici on va calculer en mettant
					# en place un réglage qui partira de 1 à 100 (1 --> mauvaise qualité
					# et 100 --> très bonne qualité)
					calculValComp = (255 * j[3].spinCompression.value()) / 100
					# Il faut soustraire le résultat à 255 pour
					# avoir une valeur reconnue par Mencoder
					calculValComp = 255 - calculValComp
					# Si la la valeur de réglage de la compression est réglée sur
					# 100, la valeur retournée sera 0 (ce qui va générer une erreur
					# dans Mencoder ... et ainsi stopper le process), la valeur
					# retournée sera donc de 1 (ce qui sera ok)
					if j[3].spinCompression.value() == 100: calculValComp = 1
					# On attribue la valeur
					spin = str(calculValComp)
				elif j[0] in ['codec_3GP_ffmpeg']:
					# On affecte la valeur de la résolution pour le 3GP
					# sélectionnée par l'utilisateur
					self.valeurSize3GP = j[3].resoSortie3gp.currentText()
				elif j[0] in ['codec_AMV_ffmpeg']:
					# On affecte la valeur de la résolution pour l'AMV
					# sélectionnée par l'utilisateur
					self.valeurSizeAMV = j[3].resoSortieAMV.currentText()
				elif j[0] in ['codec_mov_ffmpeg']: 
					# La valeur de compression vidéo va de 31 à 1 (31 --> mauvaise qualité
					# jusqu'à à 1 --> très bonne qualité). Ici on va calculer en mettant
					# en place un réglage qui partira de 1 à 100 (1 --> mauvaise qualité
					# et 100 --> très bonne qualité)
					calculValComp = (31 * j[3].spinCompression.value()) / 100
					# Il faut soustraire le résultat à 31 pour
					# avoir une valeur reconnue par Mencoder
					calculValComp = 31 - calculValComp
					# Si la la valeur de réglage de la compression est réglée sur
					# 100, la valeur retournée sera 0 (ce qui va générer une erreur
					# dans Mencoder ... et ainsi stopper le process), la valeur
					# retournée sera donc de 1 (ce qui sera ok)
					if j[3].spinCompression.value() == 100: calculValComp = 1
					# Appel de la fonction dans laquelle sont définies les tailles 
					# des vidéos pour un traitement pour un changement de syntaxe
					self.tailleVideoRetouche()
					# La valeur est sous forme de tuple et contient au moins 2 valeurs
					self.valeurCompSizeMOV = (str(calculValComp), str(self.valeurSizeGeneral))
				elif j[0] in ['avirawsanscompression']:
					# Appel de la fonction dans laquelle sont définies les tailles 
					# des vidéos pour un traitement pour un changement de syntaxe
					self.tailleVideoRetouche()
					self.valeurSizeAVI_RAW = str(self.valeurSizeGeneral)
				elif j[0] in ['codecxvid']:
					# Appel de la fonction dans laquelle sont définies les tailles 
					# des vidéos pour un traitement pour un changement de syntaxe
					self.tailleVideoRetouche()
					valeurSizeXVID = str(self.valeurSizeGeneral)
					# La valeur est sous forme de tuple et contient au moins 2 valeurs
					spin = (str(j[3].spinBitrateVideo.value()), valeurSizeXVID)
				elif j[0] in ['codec_hfyu_ffmpeg']:
					# Appel de la fonction dans laquelle sont définies les tailles 
					# des vidéos pour un traitement pour un changement de syntaxe
					self.tailleVideoRetouche()
					self.valeurSizeHFYU = str(self.valeurSizeGeneral)

				else:
					spin = str(j[3].spinCompression.value())
		
		debug( "%s %s %s %s" % (idCodec, chemin, spin, type(spin)))
		
		# Collecte des infos codec audio
		infosCodecAudio = {'Fichier':chemin}
		getParamVideo(chemin, ['ID_AUDIO_CODEC'], infosCodecAudio)
		try: audioCodec = infosCodecAudio['ID_AUDIO_CODEC']
		except: audioCodec = "codec audio non disponible"

		# Appel des classes après séparation des traitements gérés par Mencoder, FFmpeg
		# et FFmpeg2theora.
		# Appel du moteur -> animation encodage avec un codec particulier
		try:
			if idCodec in ['copie', 'codecdivx4', 'codecmotionjpeg', 'codecmpeg1', 'codecmpeg2', 'codecwmv2', 'codecxvid', 'macromediaflashvideo', 'codech264mpeg4', 'codech264mpeg4_ext_h264']:
				mencoder = WidgetMEncoder(idCodec, chemin, cheminFichierEnregistrerVideo, valeurNum = spin, laisserOuvert=ouvert)
				mencoder.setWindowTitle(_(u"Transcodage vidéo"))
				mencoder.exec_()

			elif idCodec in ['avirawsanscompression']:
				mencoder = WidgetMEncoder(idCodec, chemin, cheminFichierEnregistrerVideo, valeurNum = self.valeurSizeAVI_RAW, laisserOuvert=ouvert)
				mencoder.setWindowTitle(_(u"Transcodage vidéo"))
				mencoder.exec_()

			elif idCodec in ['codecxvid']:
				mencoder = WidgetMEncoder(idCodec, chemin, cheminFichierEnregistrerVideo, valeurNum = spin, laisserOuvert=ouvert)
				mencoder.setWindowTitle(_(u"Transcodage vidéo"))
				mencoder.exec_()

			elif idCodec in ['codec_hfyu_ffmpeg']:
				ffmpeg = WidgetFFmpeg(idCodec, chemin, cheminFichierEnregistrerVideo, valeurNum = self.valeurSizeHFYU, laisserOuvert=ouvert)
				ffmpeg.setWindowTitle(_(u"Transcodage vidéo"))
				ffmpeg.exec_()
				
			elif idCodec == 'codec_3GP_ffmpeg':
				# Pour le transcodage 3GP, si on charge une vidéo qui
				# comporte un canal audio, le transcodage n'a pas lieu
				if audioCodec == "codec audio non disponible":
					ffmpeg = WidgetFFmpeg(idCodec, chemin, cheminFichierEnregistrerVideo, valeurNum = self.valeurSize3GP, laisserOuvert=ouvert)
					ffmpeg.setWindowTitle(_(u"Transcodage vidéo"))
					ffmpeg.exec_()
				else:
					messErr3GP=QMessageBox(self)
					messErr3GP.setText(_(u"<p>Le transcodage des vidéos comportant une piste audio en 3GP a momentanément été désactivé.</b></p>"))
					messErr3GP.setWindowTitle(_(u"Erreur"))
					messErr3GP.setIcon(QMessageBox.Warning)
					messErr3GP.exec_()
					return
					
			elif idCodec == 'codec_AMV_ffmpeg':
				ffmpeg = WidgetFFmpeg(idCodec, chemin, cheminFichierEnregistrerVideo, valeurNum = self.valeurSizeAMV, laisserOuvert=ouvert)
				ffmpeg.setWindowTitle(_(u"Transcodage vidéo"))
				ffmpeg.exec_()

			elif idCodec == 'codec_mov_ffmpeg':
				ffmpeg = WidgetFFmpeg(idCodec, chemin, cheminFichierEnregistrerVideo, valeurNum = self.valeurCompSizeMOV, laisserOuvert=ouvert)
				ffmpeg.setWindowTitle(_(u"Transcodage vidéo"))
				ffmpeg.exec_()

			elif idCodec == 'codecoggtheora':
				#### Gestion de l'extension .h264 ####
				# Si on charge une vidéo avec extension .h264, ffmpeg2theora ne peut 
				# pas effectuer l'encodage
				if ext_chargee == '.h264':
					messErrExtH264ffmpeg2th=QMessageBox(self)
					messErrExtH264ffmpeg2th.setText(_(u"<p>Il n'est pas possible de donner suite au traitement <b>à partir d'une vidéo avec extension h264 et en ayant choisi: %s.</b></p><p><b>Veuillez choisir un autre codec dans la liste proposée.</b></p>" % codec_reglage))
					messErrExtH264ffmpeg2th.setWindowTitle(_(u"Erreur"))
					messErrExtH264ffmpeg2th.setIcon(QMessageBox.Warning)
					messErrExtH264ffmpeg2th.exec_()
					return
				else:	
					ffmpeg2theora = WidgetFFmpeg2theora(idCodec, chemin, cheminFichierEnregistrerVideo, valeurNum = spin, laisserOuvert=ouvert)
					ffmpeg2theora.setWindowTitle(_(u"Transcodage vidéo"))
					ffmpeg2theora.exec_()

			else:
				#### Gestion de l'extension .h264 ####
				# Si on charge une vidéo avec extension .h264, FFmpeg ne peut 
				# pas effectuer l'encodage
				if ext_chargee == '.h264':
					if codec_reglage in [u'Codec DV (.dv)', u'Codec QuickTime MOV (.mov)', u'Codec HFYU: Huffman Lossless YUV (yuv422p) (.avi)', u'Codec VOB (DVD-Video stream MPEG-2) (.vob)', u'Codec 3GP (3rd Generation Partnership Project) (.3gp)', u'Codec AMV: pour lecteurs mp4 (.avi)']:
						messErrExtH264ffmpeg=QMessageBox(self)
						messErrExtH264ffmpeg.setText(_(u"<p>Il n'est pas possible de donner suite au traitement <b>à partir d'une vidéo avec extension h264 et en ayant choisi: %s.</b></p><p><b>Veuillez choisir un autre codec dans la liste proposée.</b></p>" % codec_reglage))
						messErrExtH264ffmpeg.setWindowTitle(_(u"Erreur"))
						messErrExtH264ffmpeg.setIcon(QMessageBox.Warning)
						messErrExtH264ffmpeg.exec_()
						return
				else:
					ffmpeg = WidgetFFmpeg(idCodec, chemin, cheminFichierEnregistrerVideo, valeurNum = spin, laisserOuvert=ouvert)
					ffmpeg.setWindowTitle(_(u"Transcodage vidéo"))
					ffmpeg.exec_()

		#except Exception, e:
		except None:
			messageErreur=QMessageBox(self)
			messageErreur.setText(_(u"Un problème est survenu.")+str(e))
			messageErreur.setWindowTitle(_(u"Erreur"))
			messageErreur.setIcon(QMessageBox.Warning)
			messageErreur.exec_()
			return


		self.lstFichiersSortie =  cheminFichierEnregistrerVideo # pour la boite de dialogue de comparaison
		self.radioConvert.setChecked(True)
		self.radioSource.setEnabled(True)
		self.radioSource.setChecked(False)
		self.radioConvert.setEnabled(True)
		self.boutCompare.setEnabled(True)
		### Information à l'utilisateur
		self.infoLog(None, chemin, None, cheminFichierEnregistrerVideo)

		return cheminFichierEnregistrerVideo # module séquentiel