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
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
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