def sauverSpin_2(self,i):
"""conserver le spin dans le fichier de configuration et modifie le curseur"""
debug("%s %d" % (self.choixCodec,i))
#EkdConfig.set(self.idSection,self.choixCodec,i)
EkdConfig.set('animation_encodage_general_bitrate_video',self.choixCodec,i)
# sauver curseur
self.curseur_2.setValue(i)
def run(self):
for nb_1, fichier_1 in enumerate(self.cheminVideoEntre):
if self.cancel: break
commande = self.cheminFFmpeg+u" -i \""+unicode(fichier_1)+u"\" -ab 192k -ar 44100 -ac 2 -f wav -y \""+self.rep_audio+u"audio_"+unicode(string.zfill(str(nb_1+1), 5))+u".wav\""
try:
# Travail avec subprocess
#sp = subprocess.Popen(commande.encode(coding), shell=True, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=os.setsid)
sp = EkdProcess(commande.encode(coding), outputerr=subprocess.STDOUT)
# Important permet le traitement (!)
self.tampon = sp.stdout.readlines()
except Exception:
debug (u"Erreur dans le lancement de %s" % commande)
# Ca marche mieux avec pourcent calculé comme ça
pourcent=((nb_1+1)*100)/len(self.cheminVideoEntre)
# Emetteur pour la récup des valeurs du pourcentage
self.emit(SIGNAL("increment(int)"), pourcent)
# Emetteur pour (essayer) d'afficher chaque fichier chargé
# (pour info) au bon moment dans la barre de progression
self.emit(SIGNAL("travail_avec_fichier"), fichier_1)
debug("%d " % (nb_1))
def setTailleFenetre(self): "Affichage taille fenetre" # Gestion de la taille #- Si l'image rentre ##- Si l'image est trop grande # On retaille l'image en gardant le ratio entre # le min (si l'image ne rentre pas dans le cadre), le max (sinon) de : # * La largeur de la fenetre # * La largeur de l'image # * La hauteur de la fenetre # * La hauteur de l'image if (self.preview.height() < self.height()) and (self.preview.width() < self.width()): width=max(self.preview.width(), self.width()) height=max(self.preview.height(), self.height()) else : width=min(self.preview.width(), self.width()) height=min(self.preview.height(), self.height()) if self.gif: self.redimGif(width - 5, height - 5) else: resultat = self.preview.get_preview().scaled(width - 5, height - 5, Qt.KeepAspectRatio, self.modeTransformation) debug(u"Preview : %s, taille : %d, %d" % (self.preview.get_imageName(), self.preview.width(), self.preview.height())) self.factor = min(float(self.height())/self.preview.height(), float(self.width())/self.preview.width()) #-- On met l'image et on redimensionne le Label pour les images simples if not self.gif: self.imageLabel.setPixmap(resultat)
def addLog(self, line):
"""
Ajout une ligne de log dans self.log et envoie un signal log(string)
"""
try:
debug(u"Mencoder log : %s" % unicode(line, EkdConfig.coding))
self.log = "%s\n%s" % (self.log, unicode(line, EkdConfig.coding))
self.emit(SIGNAL("log(QString)"), line)
except:
debug(u"Mencoder log : %s" % unicode(line, EkdConfig.coding))
self.log = "%s\n%s" % (self.log, line)
self.emit(SIGNAL("log(QString)"), line)
def run(self):
""" Démarre le processus mencoder """
if self.command == None :
debug("FFmpeg: Commande mencoder non définie")
raise Exception
self.addLog(self.command.encode(EkdConfig.coding))
try :
self.process = EkdProcess( self.command.encode(EkdConfig.coding),
stdinput = None)
self.emit(SIGNAL("void started()"))
except Exception, e:
debug("Erreur dans le lancement de %s\n(%s)" % (self.command, e))
raise
def finEncodage(self, statutDeSortie):
"""choses à faire à la fin de l'encodage de la vidéo"""
# fermer la fenêtre à la fin de l'encodage
if not self.laisserOuvert:
self.close()
debug("fini!")
self.labelAttente.hide()
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 run(self):
""" Démarre le processus ffmpeg """
if self.command == None :
debug(u"FFmpeg: Commande ffmpeg non définie")
raise Exception
self.addLog(self.command.encode(EkdConfig.coding))
try :
## Attention, ffmpeg envoie sa sortie de progression sur stderr !!!
self.process = EkdProcess( self.command.encode(EkdConfig.coding),
stdinput = None, output = None)
self.emit(SIGNAL("void started()"))
except Exception, e:
debug(u"Erreur dans le lancement de %s\n(%s)" % (self.command, e))
raise
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: debug(u"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.slider.setEnabled(False) # évite un bogue #self.slider.setEnabled(True) self.cibleVideo.setToolTip(self.fichierCourant[0]) if self.barreTaches is not None: self.barreTaches.clearMessage()
def finEncodage(self, statutDeSortie):
"""choses à faire à la fin de l'encodage de la vidéo"""
# fermer la fenêtre à la fin de l'encodage
if not self.laisserOuvert:
self.close()
debug("fini!")
self.labelAttente.hide()
self.pbar.setValue(100)
if statutDeSortie == QProcess.CrashExit:
self.bout_preZoneTexte.setText(_(u'Problème! Voir les informations'))
self.bout_annuler.setText(_(u"Crash"))
self.log.append(_(u"Une erreur est survenue lors de l'encodage"))
else:
# 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()
if self.exec_():
self.chemin = unicode(self.selectedFile())
if QFile.exists(self.chemin) and (not self.multiple):
ok = QMessageBox.warning(self, _(u"Attention"), _(u"Le fichier existe, voulez-vous écraser le fichier existant ?"), QMessageBox.Ok | QMessageBox.Cancel, QMessageBox.Ok)
else :
return None
## On met à jour les chemins d'enregistrement
if self.mode == "image" :
EkdConfig.set("general", "image_output_path", os.path.dirname(self.chemin))
elif self.mode == "video" :
EkdConfig.set("general", "video_output_path", os.path.dirname(self.chemin))
elif self.mode == "audio" :
EkdConfig.set("general", "sound_output_path", os.path.dirname(self.chemin))
debug('EkdSaveDialog:: Suffix : %s Filename : %s' % (self.suffix, self.chemin))
return self.chemin
def setAcceptMode(self, mode=QFileDialog.AcceptSave):
""" Défini le mode d'ouvertue Ouverture ou Sauvegarde """
self.mode = mode
if self.mode == QFileDialog.AcceptSave :
self.saveButton.setText(_(u"Enregistrer"))
elif self.mode == QFileDialog.AcceptOpen :
self.saveButton.setText(_(u"Ouvrir"))
self.fileField.setReadOnly(True)
class EkdOpenDialog(EkdSaveDialog):
'''
EkdSaveDialog : Classe représentant la boite de dialogue utiliser lors de l'ouverture de fichier
def fichierDeTravail(self, fichier_1):
debug("Fichier chargé: %s" % fichier_1)
def setCommand(self, parametres, apercu = False):
"""
Définie la ligne de commande de façon générique pour le traitement
video
"""
if parametres :
debug (u"Mencoder : type de parametres : %s len : %s " % (type(parametres), len(parametres)))
for param in parametres :
debug (u"Mencoder : parametres : %s" % param)
if type(parametres) != list and type(parametres) != tuple and type(parametres) != dict:
codecs_command = {
'copie' : '-ovc copy -oac pcm',
'youtube_16/9_HQ' : '-oac mp3lame -lameopts cbr=256 -ffourcc xvid -ovc lavc -lavcopts vbitrate=3000 -vf scale=512:288',
'youtube_16/9_MQ' : '-oac mp3lame -lameopts cbr=128 -ffourcc xvid -ovc lavc -lavcopts vbitrate=1000 -vf scale=512:288',
'youtube_16/9_LQ' : '-oac mp3lame -lameopts cbr=128 -ffourcc xvid -ovc lavc -lavcopts vbitrate=564 -vf scale=512:288',
'youtube_4/3_HQ' : '-oac mp3lame -lameopts cbr=256 -ffourcc xvid -ovc lavc -lavcopts vbitrate=3000 -vf scale=482:361',
'youtube_4/3_MQ' : '-oac mp3lame -lameopts cbr=128 -ffourcc xvid -ovc lavc -lavcopts vbitrate=1000 -vf scale=482:361',
'youtube_4/3_LQ' : '-oac mp3lame -lameopts cbr=128 -ffourcc xvid -ovc lavc -lavcopts vbitrate=564 -vf scale=482:361',
'google_video_16/9_HQ' : '-oac mp3lame -lameopts cbr=256 -ffourcc xvid -ovc lavc -lavcopts vbitrate=3000 -vf scale=872:520',
'google_video_16/9_MQ' : '-oac mp3lame -lameopts cbr=128 -ffourcc xvid -ovc lavc -lavcopts vbitrate=1000 -vf scale=872:520',
'google_video_16/9_LQ' : '-oac mp3lame -lameopts cbr=128 -ffourcc xvid -ovc lavc -lavcopts vbitrate=564 -vf scale=872:520',
'google_video_4/3_HQ' : '-oac mp3lame -lameopts cbr=256 -ffourcc xvid -ovc lavc -lavcopts vbitrate=3000 -vf scale=694:520',
'google_video_4/3_MQ' : '-oac mp3lame -lameopts cbr=128 -ffourcc xvid -ovc lavc -lavcopts vbitrate=1000 -vf scale=694:520',
'google_video_4/3_LQ' : '-oac mp3lame -lameopts cbr=128 -ffourcc xvid -ovc lavc -lavcopts vbitrate=564 -vf scale=694:520',
'dailymotion_sd_4/3' : '-oac faac -faacopts mpeg=4:raw:br=192 -of lavf -lavfopts format=mp4 -srate 44100 -ovc x264 ' \
'-x264encopts bitrate=2400 -vf scale=640:480 -lavcopts aspect=4/3 -ofps 25',
'dailymotion_sd_16/9' : '-oac faac -faacopts mpeg=4:raw:br=192 -of lavf -lavfopts format=mp4 -srate 44100 -ovc x264 ' \
'-x264encopts bitrate=2400 -vf scale=848:480 -lavcopts aspect=16/9 -ofps 25',
'dailymotion_HD720p' : '-oac faac -faacopts mpeg=4:raw:br=192 -of lavf -lavfopts format=mp4 -srate 44100 -ovc x264 ' \
'-x264encopts bitrate=4800 -vf scale=1280:720 -lavcopts aspect=16/9 -ofps 25',
'niveaudegris':'-ovc lavc -lavcopts gray -oac pcm',
'placesoustitres':'-ovc lavc -vf expand=0:-50:0:0 -oac pcm',
'miroir':'-ovc lavc -vf mirror -oac pcm',
'tournervideo':'-vf rotate=1 -oac pcm -ovc lavc',
'desentrelacer':'-vf pp=0x20000 -oac pcm -ovc lavc',
'extractionvideo': '-ovc lavc -nosound',
'fusion_video': '-noidx -oac pcm -ovc copy',
'fusion_audio_et_video_1': '-idx -audiofile \"%s\" -oac lavc -lavcopts acodec=ac3 -stereo 0 -ovc copy' % self.audiofile ,
'fusion_audio_et_video_2': '-idx -audiofile \"%s\" -oac pcm -stereo 0 -ovc copy' % self.audiofile,
'avirawsanscompression' : '-ovc raw -vf %sformat=i420 -oac pcm' % parametres,
}
#### Changé/rectifié le 26/03/11 ###########################################
# ('codecdivx4', 'codecmotionjpeg', 'codecmpeg1', 'codecmpeg2', 'codecwmv2',
# 'macromediaflashvideo', 'codech264mpeg4_ext_h264', 'codech264mpeg4' et
# 'codech264mpeg4_nosound' ont été enlevés ici et mis juste en dessous car
# la plupart comportent maintenant 2 réglages).
#### Changé/rectifié le 10/04/11 ###########################################
# 'avirawsanscompression' comporte maintenant le réglage de la taille de la
# vidéo.
#### Changé/rectifié le 10/04/11 ###########################################
# 'codecxvid' a été enlevé ici et mis juste en dessous car il comporte
# maintenant 2 réglages.
elif len(parametres) == 2 and type(parametres) != dict :
# Cas de parametres standards
codecs_command = {}
codecs_command['luminositecontraste'] = '-ovc lavc -vf eq=%s:%s -oac pcm' % (parametres[0], parametres[1])
codecs_command['decoupervideo'] = '-ss %s -endpos %s -oac pcm -ovc copy' % (parametres[0], parametres[1])
codecs_command['couleursaturationhue'] ='-ovc lavc -vf hue=%s:%s -oac pcm' % (parametres[0], parametres[1])
codecs_command['decoupervideo_nosound'] = '-ss %s -endpos %s -nosound -ovc copy' % (parametres[0], parametres[1])
codecs_command['flouboitebloxblur'] = '-ovc lavc -vf boxblur=%s:%s -oac pcm' % (parametres[0], parametres[1])
codecs_command['changement_resolution'] = '-vf scale=%s:%s -ovc lavc -lavcopts vcodec=mjpeg:vqmin=1:vpass=1 -oac pcm' % (parametres[0], parametres[1])
codecs_command['codecxvid'] = '-ovc lavc -ffourcc xvid -xvidencopts pass=1:bitrate=%s %s -oac pcm' % (parametres[0], parametres[1])
elif len(parametres) == 3 and type(parametres) != dict :
codecs_command = {}
#### Changé/rectifié le 26/03/11 -- intégration de réglages supplémentaires ###################
#### Le 02/03/11 --> Intégration de la condition pour == 3 et de parametres[2] pour les presets
# de taille vidéo ####
codecs_command['codecmotionjpeg'] = '-ovc lavc -lavcopts vcodec=mjpeg:vbitrate=%s:vqmin=%s:vpass=1 %s -oac pcm' % (parametres[0], parametres[1], parametres[2])
codecs_command['codecmpeg1'] = '-ovc lavc -lavcopts vcodec=mpeg1video:vbitrate=%s:vqmin=%s:vpass=1 %s -oac pcm' % (parametres[0], parametres[1], parametres[2])
codecs_command['codecmpeg2'] = '-ovc lavc -lavcopts vcodec=mpeg2video:vbitrate=%s:vqmin=%s:vpass=1 %s -oac pcm' % (parametres[0], parametres[1], parametres[2])
codecs_command['codech264mpeg4'] = '-oac faac -faacopts mpeg=4:raw:br=24 -of lavf -lavfopts format=mp4 %s -ovc x264 -x264encopts bitrate=%s' % (parametres[2], parametres[0]) # Ajout du paramètre du bitrate vidéo + le 02/04/11 le paramètre de la taille de la vidéo (preset) #### (1 seul paramètre utilisé sur les présents 2 ds le tuple)
codecs_command['codech264mpeg4_nosound'] = '-of lavf -lavfopts format=mp4 %s -nosound -ovc x264 -x264encopts bitrate=1200' % parametres[2] # Pas de paramètre utilisé mais ici le paramètre pour codech264mpeg4 est un tuple de 2 valeurs
codecs_command['macromediaflashvideo'] = '-ovc lavc -ffourcc FLV1 -lavcopts vcodec=flv:vbitrate=%s:vqmin=%s %s -oac pcm' % (parametres[0], parametres[1], parametres[2])
codecs_command['codech264mpeg4_ext_h264'] = '-nosound -of lavf -lavfopts format=h264 %s -ovc x264 -x264encopts bitrate=%s' % (parametres[2], parametres[0]) # Ajout du paramètre du bitrate vidéo + le 02/04/11 le paramètre de la taille de la vidéo (preset) #### (1 seul paramètre utilisé sur les présents 2 ds le tuple)
codecs_command['codecdivx4'] = '-ovc lavc -lavcopts vcodec=mpeg4:vbitrate=%s:vqmin=%s:vpass=1 %s -oac pcm' % (parametres[0], parametres[1], parametres[2])
codecs_command['codecwmv2'] = '-ovc lavc -lavcopts vcodec=wmv2:vbitrate=%s:vqmin=%s:vpass=1 %s -oac pcm' % (parametres[0], parametres[1], parametres[2])
###############################################################################################
elif len(parametres) == 4 and type(parametres) != dict :
codecs_command = {}
# Cas Luma et Chroma et découpage, on a besoin de 4 parametres
codecs_command['bruit'] = '-ovc lavc -vf noise=%s[%s]:%s[%s] -oac pcm' % (parametres[2], parametres[0], parametres[3], parametres[1])
codecs_command['decoupagelibre'] ='-ovc lavc -vf crop=%s:%s:%s:%s -oac pcm' % (parametres[0], parametres[1],parametres[2],parametres[3])
codecs_command['decoupageassiste'] ='-ovc lavc -vf crop=%s:%s:%s:%s -oac pcm' % (parametres[0], parametres[1],parametres[2],parametres[3])
### Ajouté le 05/09/10 pour la gestion des tags vidéo #### ##########################################################
else :
codecs_command = {}
info = ""
# Cas de Vidéo > Tags vidéo
for key in parametres.keys():
valeur = parametres[key.capitalize()]
if valeur == "":
## On évite de planter la ligne de commande si un champ n'a pas été renseigné
valeur = " "
if key == "Title" :
## On traite le bug de Title dans la ligne de commande qui est en fait remplacée par name
key = "name"
elif key == "Comments":
## On traite le bug de Comments dans la ligne de commande qui est en fait remplacée par comment
key = "comment"
info = '%s:%s="%s"' % (info, key.lower(), valeur)
codecs_command['tag_video'] ='-ovc copy -oac copy -info %s' % info.strip(":")
##########################################################
if apercu :
apercu_cmd = "-ss %s -frames 2" % (apercu)
else:
apercu_cmd = ""
self.command = u"%s %s \"%s\" %s %s -o \"%s\"" % \
(self.location, self.dfltOptions, self.inputfile, codecs_command[self.codec], apercu_cmd, self.outputfile)
def sauverSpin_1(self,i):
"""conserver le spin dans le fichier de configuration et modifie le curseur"""
debug("%s %d" % (self.choixCodec,i))
EkdConfig.set(self.idSection,self.choixCodec,i)
# sauver curseur
self.curseur_1.setValue(i)
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
def end(self) :
debug(u"Conversion AVCHD terminé")
self.parent.actionsFin(self.fichiers_traites)
def getParamVideo(cheminVideoEntre, parameter, hashInfo = None):
"""Renvoie un ou plusieurs paramètres de la vidéo sous forme de flottant.
La variable «cheminVideoEntre» est le chemin de la vidéo de type unicode.
La variable «parameter» est un tuple de paramètres à renvoyer.
La dernière variable renvoyée est un tuple des lignes de log
23/07/2009 : hashInfo contiendra la hashmap des infos demandées
"""
#cheminVideoEntre = cheminVideoEntre.encode("UTF8")
if hashInfo == None:
hashInfo = {}
# Condition pour détection windows
if os.name == 'nt':
commande = u'mplayer.exe -vo null -ao null -identify -frames 0 '+ u"\"" + unicode(cheminVideoEntre) + u"\""
# Condition pour détection Linux ou MacOSX
elif os.name in ['posix', 'mac']:
commande = u'mplayer ' + u"\""+ unicode(cheminVideoEntre) + u"\" -vo null -ao null -frames 0 -identify '$@' 2>/dev/null"
#recupDonneesVideo = os.popen(commande.encode(coding)).readlines()
processus = QProcess()
processus.start(commande)
if (not processus.waitForStarted()):
raise (u"Erreur de récupération des informations")
if ( not processus.waitForFinished()):
raise (u"Erreur de récupération des informations")
recupDonneesVideo = QString(processus.readAllStandardOutput())
lstValeurs = []
log = []
#for ligne in recupDonneesVideo:
for ligne in recupDonneesVideo.split("\n"):
try:
# On veut que les caractères non ASCII s'affichent
# correctement pour les noms de fichiers
log.append(ligne)
except UnicodeDecodeError:
debug("Traitement d'exception unicode au niveau de " \
"getParamVideo() probablement dûe aux " \
"méta-données de la vidéo")
log.append(ligne)
for param in parameter:
if param in ligne:
ligne = ligne.replace(param, "")
ligne = ligne.replace("=", "")
ligne = ligne.replace("\n", "")
############################################
# Commenté le 01/09/10 --> voir si tout
# fonctionne malgré tout (commenté pour
# pouvoir lire les tags vidéos correctement)
#ligne = ligne.replace(" ", "")
############################################
############################################
# Le 01/09/10 Essai de réglage de la sortie
# pour les accents dans les tags vidéo
# VOIR SI SYNTAXE PLUS GENERIQUE
ligne = ligne.replace("é", "e")
ligne = ligne.replace("è", "e")
ligne = ligne.replace("ç", "c")
ligne = ligne.replace("à", "a")
ligne = ligne.replace("ù", "u")
ligne = ligne.replace("ä", "a")
ligne = ligne.replace("ü", "u")
ligne = ligne.replace("ö", "o")
############################################
try :
lstValeurs.append(float(ligne))
hashInfo[param] = float(ligne)
except :
lstValeurs.append(str(ligne))
hashInfo[param] = str(ligne)
lstValeurs.append(log)
#lstValeurs.append(hashInfo)
return lstValeurs
def __init__(self, cheminVideo=[], taille=(250,225),
choixWidget=(RATIO, REVENIR, PAS_PRECEDENT_SUIVANT,CURSEUR_SUR_UNE_LIGNE,PAS_PARCOURIR,LIST),
debutFin=(0,0), cheminMPlayer=None, barreTaches=None, facteurLimitant=HAUTEUR,
cheminParcourir=None, parent=None):
"""widget mplayer"""
QDialog.__init__(self, parent)
#=== Paramètres généraux ===#
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowTitle(_(u"Player vidéo"))
#On réduit la marge pour gagner de l'espace
self.setContentsMargins(0,0,0,0)
self.systeme = os.name
### Quand EKD windows est installé, le chemin des dépendances sont ###########
### positionnées dans les variables d'environnement donc pas besoin de #######
### collecter le chemin des ces dépendances ##################################
self.cheminMPlayer = "mplayer"
##############################################################################
# liste de chemins vidéos
if type(cheminVideo) != list :
self.listeVideos=[cheminVideo]
else :
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
self.debutFin = debutFin
# Nom du fichier courant (le self n'est pas encore utile)
txtParDefaut = u"Pas de fichier lu"
if self.listeVideos.__len__()!=0:
self.fichierCourant = [txtParDefaut, self.listeVideos[0]]
else: self.fichierCourant = [txtParDefaut, ""]
# Barre des tâches de la fenêtre
self.barreTaches = barreTaches
# Taille de la vidéo
self.tailleLargeur=taille[0]
self.tailleHauteur=taille[1]
# paramètres des boutons-icones
iconTaille=22
flat=1
# Pour récupérer le temps courant depuis certains cadre
self.temps = 0
self.dureeTimer = 10 # temps en ms
###############################################################################################################################
#Pour être plus précis lors de la lecture, on prend comme unité la miliseconde. ######################
## Il faut donc utiliser une echelle 1000 fois plus grande pour les unités du slider
self.echelle=1000
###############################################################################################################################
# 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
# Chemin sur lequel peut s'ouvrir la boite de dialogue de fichier
# associée au bouton parcourir
self.cheminPourBoutonParcourir = cheminParcourir
self.taille = taille
debug("self.taille avant lecture : %s %s" % (self.taille, type(self.taille)))
#=== Widgets ===#
self.icone_lire=QIcon("Icones" + os.sep + "player_play.png")
self.icone_pause=QIcon("Icones" + os.sep + "player_pause.png")
self.icone_arret=QIcon("Icones" + os.sep + "player_stop.png")
if Mplayer.REVENIR in choixWidget:
self.bout_revenir = QPushButton(u"Revenir")
self.bout_revenir.setIcon(QIcon("Icones" + os.sep + "revenir.png"))
if Mplayer.PARCOURIR in choixWidget:
self.bout_ouvVideo = QPushButton(u"Parcourir...")
if Mplayer.PRECEDENT_SUIVANT in choixWidget:
self.bout_prec = QPushButton(QIcon("Icones" + os.sep + "player_rew.png"),"")
self.bout_prec.setIconSize(QSize(iconTaille, iconTaille))
self.bout_prec.setFlat(flat)
self.bout_suivant = QPushButton(QIcon("Icones" + os.sep + "player_fwd.png"),"")
self.bout_suivant.setIconSize(QSize(iconTaille, iconTaille))
self.bout_suivant.setFlat(flat)
self.LISTW=False
if Mplayer.LIST in choixWidget :
self.LISTW = True
self.listFichiers = QComboBox()
self.listFichiers.hide()
self.setListeVideo()
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 = DisplayVid(self)
# par défaut le widget-cible est noir
color = QColor(0, 0, 0)
self.cibleVideo.setAutoFillBackground(True)
self.cibleVideo.setPalette(QPalette(color))
self.cibleVideo.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.cibleVideo.setFixedHeight(self.taille[1])
self.cibleVideo.setToolTip(self.fichierCourant[0])
#Choix de l'aspect ratio de la vidéo
if Mplayer.RATIO in choixWidget :
self.conf = QGroupBox()
self.conf.setContentsMargins(0,0,0,0)
self.conf.setMinimumSize(QSize(self.tailleLargeur, 0))
self.conf.setObjectName("conf")
self.verticalLayout = QHBoxLayout(self.conf)
self.verticalLayout.setObjectName("verticalLayout")
self.choicenorm = QRadioButton(self.conf)
self.choicenorm.setObjectName("choicenorm")
self.verticalLayout.addWidget(self.choicenorm)
self.choicewide = QRadioButton(self.conf)
self.choicewide.setObjectName("choicewide")
self.verticalLayout.addWidget(self.choicewide)
self.choiceone = QRadioButton(self.conf)
self.choiceone.setObjectName("choiceone")
self.verticalLayout.addWidget(self.choiceone)
self.choicenorm.setText("4:3")
self.choicewide.setText("16:9")
self.choiceone.setText("w:h")
# Checked le ratio de la vidéo
if self.listeVideos.__len__()!=0:
self.changeRatio(self.listeVideos[0])
else :
self.setRatio(4.0/3.0)
if Mplayer.RATIO in choixWidget :
self.choicenorm.setChecked(True)
self.slider = QSlider(Qt.Horizontal)
self.slider.setEnabled(True)
self.mplayerProcess = QProcess(self)
self.timer = QTimer(self)
self.tempsChrono = TracerChrono()
#=== mise-en-page/plan ===#
mhbox = QHBoxLayout()
vbox = QVBoxLayout()
vbox.addWidget(self.cibleVideo)
if Mplayer.RATIO in choixWidget :
vbox.addWidget(self.conf)
hbox = QHBoxLayout()
if Mplayer.REVENIR in choixWidget:
hbox.addWidget(self.bout_revenir)
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)
# Liste fichier dans combobox
if self.LISTW :
hbox = QHBoxLayout()
hbox.addWidget(self.listFichiers)
vbox.addLayout(hbox)
mhbox.addLayout(vbox)
self.setLayout(mhbox)
#=== connexion des widgets à des fonctions ===#
if Mplayer.REVENIR in choixWidget:
self.connect(self.bout_revenir, SIGNAL('clicked()'), SLOT('close()'))
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)
#Ajouté le 08/11/2009 - Liste des fichiers dans une combobox
if self.LISTW :
self.connect(self.listFichiers, SIGNAL('currentIndexChanged(int)'), self.changeVideo)
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)
self.connect(self.cibleVideo, SIGNAL('changeSize'), self.sizeMplayer)
if Mplayer.RATIO in choixWidget :
self.connect(self.choicenorm, SIGNAL("clicked(bool)"), self.defRatio)
self.connect(self.choicewide, SIGNAL("clicked(bool)"), self.defRatio)
self.connect(self.choiceone, SIGNAL("clicked(bool)"), self.defRatio)
def __init__(self, choixCodec, min_range_1, max_range_1, min_range_2, max_range_2, txt1 = _(u"Réglage de la compression : "), txt5 = _(u"Réglage du bitrate vidéo : ")):
'''
Codecs_AvecReglages : Crée un widget avec : 1 slider, 1 bare de progession et un texte explicatif
choixCodec : Nom du codec qui sera utilisé lors de l'enregistrement dans EkdConfig
min_range_1 : Valeur minimale du slider et de la barre
max_range_1 : Valeur maximale du slider et de la barre
min_range_2 : Valeur minimale du slider et de la barre
max_range_2 : Valeur maximale du slider et de la barre
txt1 : Texte intitulé du réglage (compression vidéo)
txt5 : Texte intitulé du réglage (bitrate vidéo)
'''
QWidget.__init__(self)
self.choixCodec = choixCodec
self.idSection = "animation_encodage_general"
# label titre
self.txt1 = txt1
self.txt5 = txt5
self.min_range_2 = min_range_2
self.max_range_2 = max_range_2
#txt1=_(u"Réglage de la compression : ")
self.label_1=QLabel("<center><u>%s</u></center>" % txt1)
# boite de spin pour la compression vidéo
self.spinCompression=QSpinBox() # self car on va récupérer la variable depuis le moteur
self.spinCompression.setRange(min_range_1, max_range_1)
self.label_2=QLabel("<center><u>%s</u></center>" % txt5)
txt6 = _(u'Dimension de la vidéo :')
self.label_3 = QLabel("<center><u>%s</u></center>" % txt6)
self.label_4 = QLabel("<center><u>%s</u></center>" % txt6)
self.label_5 = QLabel("<center><u>%s</u></center>" % txt6)
# Boîte de spin pour le bitrate vidéo
self.spinBitrateVideo=QSpinBox()
self.spinBitrateVideo.setRange(min_range_2, max_range_2)
# Curseur associé à spinCompression
self.curseur_1 = QSlider(Qt.Horizontal)
self.curseur_1.setRange(min_range_1, max_range_1)
self.connect(self.spinCompression,SIGNAL("valueChanged(int)"),self.sauverSpin_1)
self.connect(self.curseur_1, SIGNAL("sliderMoved(int)"), self.curseurBouge_1)
# Curseur associé à spinBitrateVideo
self.curseur_2 = QSlider(Qt.Horizontal)
self.curseur_2.setRange(min_range_2, max_range_2)
self.connect(self.spinBitrateVideo,SIGNAL("valueChanged(int)"),self.sauverSpin_2)
self.connect(self.curseur_2, SIGNAL("sliderMoved(int)"), self.curseurBouge_2)
# Widgets pour la sélection de la résolution
# en sortie pour le 3GP
self.resoSortie3gp = QComboBox()
liste_reso_3gp = [(u'128x96', '128x96'), (u'176x144', '176x144'), (u'352x288', '352x288'), (u'704x576', '704x576')]
for i in liste_reso_3gp: self.resoSortie3gp.addItem(i[0],QVariant(i[1]))
self.connect(self.resoSortie3gp, SIGNAL("activated(int)"), self.changerReglagesResol3gp)
# Widgets pour la sélection de la résolution
# en sortie pour l'AMV
self.resoSortieAMV = QComboBox()
liste_reso_AMV = [(u'128x90', '128x90'), (u'128x128', '128x128'), (u'160x120', '160x120'), (u'208x176', '208x176')]
for i in liste_reso_AMV: self.resoSortieAMV.addItem(i[0],QVariant(i[1]))
self.connect(self.resoSortieAMV, SIGNAL("activated(int)"), self.changerReglagesResolAMV)
# Widgets pour la sélection de la résolution en sortie pour les codecs:
# codecmotionjpeg, codecmpeg2, codech264mpeg4, codech264mpeg4_ext_h264,
# codecdivx4, codecmpeg1, macromediaflashvideo, codecwmv2
self.resoSortieGeneral = QComboBox()
liste_reso_General = [(_(u"Pas de changement (vidéo avec la même taille que l'original)"), u'idem'), (_(u'HD 1080p (16/9): 1920x1080'), u'-vf scale=1920:1080 -aspect 16:9'), (_(u'HD 720p (16/9): 1280x720'), u'-vf scale=1280:720 -aspect 16:9'), (_(u'HD 1080p divisé par deux (16/9): 960x540'), u'-vf scale=960:540 -aspect 16:9'), (_(u'HD 480 (16/9): 852x480'), u'-vf scale=852:480 -aspect 16:9'), (_(u'PAL/SECAM (16/9): 1024x576'), u'-vf scale=1024:576 -aspect 16:9'), (_(u'PAL/SECAM Computer Video (4/3): 768x576'), u'-vf scale=768:576 -aspect 4:3'), (_(u'PAL/SECAM (rapport 1.25): 720x576'), u'-vf scale=720:576'), (_(u'PAL/SECAM (4/3): 384x288'), u'-vf scale=384:288 -aspect 4:3'), (_(u'PAL/SECAM Qualité VCD (rapport 1.22): 352x288'), u'-vf scale=352:288'), (_(u'PAL/SECAM (4/3): 320x240'), u'-vf scale=320:240 -aspect 4:3'), (_(u'NTSC (rapport 1.5): 720x480'), u'-vf scale=720:480'), (_(u'NTSC Computer Video (4/3): 640x480'), u'-vf scale=640:480 -aspect 4:3'), (_(u'NTSC Computer Video (4/3): 512x384'), u'-vf scale=512:384 -aspect 4:3'), (_(u'NTSC SVCD (1/1): 480x480'), u'-vf scale=480:480'), (_(u'NTSC Qualité VCD (rapport 1.46): 352x240'), u'-vf scale=352:240'), (_(u'Affichage WHUXGA (rapport 1.6): 7680x4800'), u'-vf scale=7680:4800'), (_(u'Affichage WHSXGA (rapport 1.56): 6400x4096'), u'-vf scale=6400:4096'), (_(u'Affichage HSXGA (rapport 1.25): 5120x4096'), u'-vf scale=5120:4096'), (_(u'Affichage WQUXGA (rapport 1.6): 3840x2400'), u'-vf scale=3840:2400'), (_(u'Affichage WQSXGA (rapport 1.56): 3200x2048'), u'-vf scale=3200:2048'), (_(u'Affichage QSXGA (rapport 1.25): 2560x2048'), u'-vf scale=2560:2048'), (_(u'Affichage WOXGA (rapport 1.6): 2560x1600'), u'-vf scale=2560:1600'), (_(u'Affichage QXGA (4/3): 2048x1536'), u'-vf scale=2048:1536 -aspect 4:3'), (_(u'Affichage WUXGA (rapport 1.6): 1920x1200'), u'-vf scale=1920:1200'), (_(u'Affichage WSXGA (rapport 1.56): 1600x1024'), u'-vf scale=1600:1024'), (_(u'Affichage WXGA (16/9): 1366x768'), u'-vf scale=1366:768 -aspect 16:9'), (_(u'Affichage SXGA (rapport 1.25): 1280x1024'), u'-vf scale=1280:1024'), (_(u'Affichage UXGA (4/3): 1600x1200'), u'-vf scale=1600:1200 -aspect 4:3'), (_(u'Affichage XGA (4/3): 1024x768'), u'-vf scale=1024:768 -aspect 4:3'), (_(u'Affichage SVGA (4/3): 800x600'), u'-vf scale=800:600 -aspect 4:3'), (_(u'Affichage VEGA (rapport 1.83): 640x350'), u'-vf scale=640:350'), (_(u'Affichage VGA (4/3): 640x480'), u'-vf scale=640:480 -aspect 4:3'), (_(u'Affichage QQVGA (4/3): 160x120'), u'-vf scale=160:120 -aspect 4:3'), (_(u'Smartphone (16/10): 800x480'), u'-vf scale=800:480 -aspect 16:10')]
for i in liste_reso_General: self.resoSortieGeneral.addItem(i[0],QVariant(i[1]))
self.connect(self.resoSortieGeneral, SIGNAL("activated(int)"), self.changerReglagesResolGeneral)
try:
debug( "%s" % EkdConfig.get(self.idSection,self.choixCodec))
self.spinCompression.setValue(int(EkdConfig.get(self.idSection,self.choixCodec)))
except:
debug("Pas de parametre ou mauvais parametre de configuration pour:\n\
DivX4, Codec Motion JPEG, Codec MPEG1, Codec MPEG2 ou Codec WMV2")
#debug( "Pas de paramètre ou mauvais paramètre de configuration pour:\n\
#DivX4, Codec Motion JPEG, Codec MPEG1, Codec MPEG2 ou Codec WMV2")
# Rangement des widgets
vbox = QVBoxLayout(self)
grid=QGridLayout()
# Label pour la compression vidéo
grid.addWidget(self.label_1,1,2)
# Slider de la qualité de la compression
grid.addWidget(self.spinCompression,2,1)
# Curseur associé à spinCompression
grid.addWidget(self.curseur_1,2,2)
# Label pour le bitrate vidéo
grid.addWidget(self.label_2,3,2)
# Slider du bitrate vidéo
grid.addWidget(self.spinBitrateVideo,4,1)
# Curseur associé à spinBitrateVideo
grid.addWidget(self.curseur_2,4,2)
grid.addWidget(self.label_3,5,2)
grid.addWidget(self.resoSortie3gp,6,2)
grid.addWidget(self.label_4,7,2)
grid.addWidget(self.resoSortieAMV,8,2)
grid.addWidget(self.label_5,9,2)
grid.addWidget(self.resoSortieGeneral,10,2)
vbox.addStretch()
vbox.addLayout(grid)
vbox.addStretch()
# On récupère la valeur du bitrate à partir de la configuration
try:
bitrate = EkdConfig.get('animation_encodage_general_bitrate_video',self.choixCodec)
self.spinBitrateVideo.setValue(int(bitrate))
except IndexError:
pass
# On cache certains widgets suivant les codecs choisis dans
# la liste ... et on montre ceux qui doivent être montrés
if self.choixCodec in ['codech264mpeg4', 'codech264mpeg4_ext_h264']:
self.label_1.hide()
self.spinCompression.hide()
self.curseur_1.hide()
self.label_3.hide()
self.resoSortie3gp.hide()
self.label_4.hide()
self.resoSortieAMV.hide()
elif self.choixCodec in ['codecoggtheora', 'codec_vob_ffmpeg']:
self.label_2.hide()
self.spinBitrateVideo.hide()
self.curseur_2.hide()
self.label_3.hide()
self.resoSortie3gp.hide()
self.label_4.hide()
self.resoSortieAMV.hide()
self.label_5.hide()
self.resoSortieGeneral.hide()
elif self.choixCodec in ['codecdivx4', 'codecmotionjpeg', 'codecmpeg1', 'codecmpeg2', 'codecwmv2', 'macromediaflashvideo']:
self.label_3.hide()
self.resoSortie3gp.hide()
self.label_4.hide()
self.resoSortieAMV.hide()
elif self.choixCodec in ['avirawsanscompression', 'codec_hfyu_ffmpeg']:
self.label_1.hide()
self.spinCompression.hide()
self.curseur_1.hide()
self.label_2.hide()
self.spinBitrateVideo.hide()
self.curseur_2.hide()
self.label_3.hide()
self.resoSortie3gp.hide()
self.label_4.hide()
self.resoSortieAMV.hide()
self.label_5.show()
self.resoSortieGeneral.show()
elif self.choixCodec in ['codecxvid']:
self.label_1.hide()
self.spinCompression.hide()
self.curseur_1.hide()
self.label_2.show()
self.spinBitrateVideo.show()
self.curseur_2.show()
self.label_3.hide()
self.resoSortie3gp.hide()
self.label_4.hide()
self.resoSortieAMV.hide()
self.label_5.show()
self.resoSortieGeneral.show()
elif self.choixCodec in ['codec_3GP_ffmpeg']:
self.label_1.hide()
self.spinCompression.hide()
self.curseur_1.hide()
self.label_2.hide()
self.spinBitrateVideo.hide()
self.curseur_2.hide()
self.label_4.hide()
self.resoSortieAMV.hide()
self.label_3.show()
self.resoSortie3gp.show()
self.label_5.hide()
self.resoSortieGeneral.hide()
elif self.choixCodec in ['codec_AMV_ffmpeg']:
self.label_1.hide()
self.spinCompression.hide()
self.curseur_1.hide()
self.label_2.hide()
self.spinBitrateVideo.hide()
self.curseur_2.hide()
self.label_3.hide()
self.resoSortie3gp.hide()
self.label_4.show()
self.resoSortieAMV.show()
self.label_5.hide()
self.resoSortieGeneral.hide()
elif self.choixCodec in ['codec_mov_ffmpeg']:
self.label_1.show()
self.spinCompression.show()
self.curseur_1.show()
self.label_2.hide()
self.spinBitrateVideo.hide()
self.curseur_2.hide()
self.label_3.hide()
self.resoSortie3gp.hide()
self.label_4.hide()
self.resoSortieAMV.hide()
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
commande = None
has_audio = False
debug('\n')
# Si la conversion d'images en vidéo est sélectionné, aucune
# info Mplayer n'est affichée (problème de récup infos par Mplayer)
if self.idCodec in ['mpeg1video', 'mjpeg', 'h263p', 'mpeg4', 'msmpeg4v2', 'ljpeg', 'dv', 'huffyuv', 'mov', 'flv', 'mp4', 'vob']:
# ICI SI LES FICHIERS CHARGES SONT DES IMAGES
a = "###############################"
b = "# Informations sur les images :"
c = "###############################"
infos = '\n'+a+'\n'+b+'\n'+c+'\n'
debug(infos)
self.zoneTexte.append(infos)
import glob
# Le chemin pour l'affichage des infos sur les images ne fonctionnait
# plus après la nouvelle structure des fichiers temporaires
self.recupTempImgAnim = glob.glob(EkdConfig.getTempDir() + os.sep + "*.*")
self.recupTempImgAnim.sort()
# Affichage du chemin (temp) + le poids de chaque image
# --> Une énumération de parcours a été introduite
for parcNb, parcInfIm in enumerate(self.recupTempImgAnim):
debug('* '+str(parcNb+1)+'. '+parcInfIm+' --> '+str(float(os.path.getsize(parcInfIm)/1000))+' ko'+'\n')
self.zoneTexte.append('* '+str(parcNb+1)+'. '+parcInfIm+' --> '+str(float(os.path.getsize(parcInfIm)/1000))+' ko'+'\n')
# Elimination de la dernière image de la liste car car elle
# s'affiche en double ds la fenêtre information de l'encodage
# et aussi ds la console
#self.log = self.log[:len(self.log)-1]
# On définie la longueur de la futur vidéo en divisant le nombre d'image par le
# nombre d'image par seconde (valeurNum ici)
self.ffmpegProcess.setVideoLen(len(self.recupTempImgAnim) / int(self.valeurNum))
# Pour les traitements autres que la transformation des images en vidéo
if self.idCodec not in ['mpeg1video', 'mjpeg', 'h263p', 'mpeg4', 'msmpeg4v2', 'ljpeg', 'dv', 'huffyuv', 'mov', 'flv', 'mp4', 'vob']:
a = "########################"
b = "# Informations MPlayer :"
c = "########################"
infos = '\n'+a+'\n'+b+'\n'+c+'\n'
debug(infos)
######## Ajouté le 24/07/09 ##################################################################
# Utilisation de la classe infovideo (et en particilier la fonction setVideo)
# présents dans gui_modules_animation/infoVideo.py
info = infovideo(self.cheminVideoEntre)
id_filename = 'ID_FILENAME='+self.cheminVideoEntre+'\n'
debug(id_filename)
id_demuxer = 'ID_DEMUXER='+info.demux+'\n'
debug(id_demuxer)
id_video_format = 'ID_VIDEO_FORMAT='+info.videoFormat+'\n'
debug(id_video_format)
id_video_codec = 'ID_VIDEO_CODEC='+info.video_codec+'\n'
debug(id_video_codec)
id_video_bitrate = 'ID_VIDEO_BITRATE='+str(info.videoBitrate)+'\n'
debug(id_video_bitrate)
id_video_largeur = 'ID_VIDEO_WIDTH='+str(info.videoLargeur)+'\n'
debug(id_video_largeur)
id_video_hauteur = 'ID_VIDEO_HEIGHT='+str(info.videoHauteur)+'\n'
debug(id_video_hauteur)
id_img_par_sec = 'ID_VIDEO_FPS='+str(info.imgParSec)+'\n'
debug(id_img_par_sec)
##### Donnée très importante pour la suite du calcul (pour ffmpeg.py et ffmpeg2theora) ####
self.dureeTotaleVideo = float(info.dureeTotaleVideo)
###########################################################################################
id_duree_totale_video = 'ID_LENGTH='+str(info.dureeTotaleVideo)+'\n'
debug(id_duree_totale_video)
id_audio_codec = 'ID_AUDIO_CODEC='+info.audioCodec+'\n'
debug(id_audio_codec)
id_audio_rate = 'ID_AUDIO_RATE='+str(info.audioRate)+'\n'
debug(id_audio_rate)
id_audio_bitrate = 'ID_AUDIO_BITRATE='+str(info.audioBitrate)+'\n'
debug(id_audio_bitrate)
self.zoneTexte.append(infos+id_filename+id_demuxer+id_video_format+id_video_codec+id_video_bitrate+id_video_largeur+id_video_hauteur+id_img_par_sec+id_duree_totale_video+id_audio_codec+id_audio_rate+id_audio_bitrate)
##############################################################################################
## On définie la longueur de la vidéo pour le process
self.ffmpegProcess.setVideoLen(self.dureeTotaleVideo)
if info.audioCodec :
has_audio = True
debug('\n')
a = "############################"
b = "# Informations %s :" %encodeur
c = "############################"
infos = '\n'+a+'\n'+b+'\n'+c+'\n'
debug(infos)
self.zoneTexte.append(infos)
if self.idCodec=='codec_dv_ffmpeg':
self.ffmpegProcess.commandeFfmpegEncodageDv()
elif self.idCodec=='codec_mov_ffmpeg':
#### Enlevé le 09/04/11 ##############################
#self.ffmpegProcess.commandeFfmpegEncodageMov()
######################################################
#### Ajouté/rectifié le 09/04/11 #####################
self.ffmpegProcess.commandeFfmpegEncodageMov(comp = self.valeurNum[0], size = self.valeurNum[1])
######################################################
elif self.idCodec=='codec_hfyu_ffmpeg':
#### Enlevé le 10/04/11 ##############################
#self.ffmpegProcess.commandeFfmpegEncodageHfyu(audio = has_audio)
######################################################
#### Ajouté/rectifié le 10/04/11 #####################
self.ffmpegProcess.commandeFfmpegEncodageHfyu(size = self.valeurNum, audio = has_audio)
######################################################
elif self.idCodec=='codec_vob_ffmpeg':
self.ffmpegProcess.commandeFfmpegEncodageVob(vquantizer = self.valeurNum)
elif self.idCodec=='codec_3GP_ffmpeg':
#### Enlevé le 30/03/11 ##############################
#self.ffmpegProcess.commandeFfmpegEncodage3gp(audio = has_audio)
#### Ajouté/rectifié le 30/03/11 #####################
self.ffmpegProcess.commandeFfmpegEncodage3gp(size = self.valeurNum)
######################################################
elif self.idCodec=='codec_AMV_ffmpeg':
#### Rectifié le 30/03/11 ## Ajout de size ###########
self.ffmpegProcess.commandeFfmpegEncodageAMV(size = self.valeurNum)
######################################################
elif self.idCodec=='idx':
self.ffmpegProcess.commandeFfmpegNbrImgSec(rate = self.valeurNum)
elif self.idCodec in ['mpeg1video', 'mjpeg', 'h263p', 'mpeg4', 'msmpeg4v2', 'ljpeg', 'dv', 'huffyuv', 'mov', 'flv', 'mp4', 'vob']:
self.ffmpegProcess.commandeFfmpegConvertImg(rate = self.valeurNum, size = "%sx%s" % (self.tailleIm[0], self.tailleIm[1]), vcodec = self.idCodec)
# --------------------------------------------------------------------------------- #
# Traitement pour chaque entrée concernant la HD (classique, en dehors du codec Avid DNxHD)
# --------------------------------------------------------------------------------- #
elif self.idCodec in ['hd_1920x1080_mov__pcm_s16be__16/9', 'hd_1280x720_mov__pcm_s16be__16/9', 'hd_1440x1080_mov__pcm_s16be__4/3']:
## FIXME : La taille est récupérée du nom de idCodec (crade)
self.ffmpegProcess.commandeFfmpegConvHD(size = self.idCodec.split("_")[1])
### Ajouté le 19/08/10 (Gestion du codec Avid DNxHD) ################################
# --------------------------------------------------------------------------------- #
# Traitement pour chaque entrée (24) concernant le codec Avid DNxHD pour la HD
# --------------------------------------------------------------------------------- #
elif self.idCodec=='hd_dnxhd_1920x1080_29.97_220_mbs':
## FIXME : Les éléments utiles sont récupérés du nom de idCodec (crade mais utile)
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 1
elif self.idCodec=='hd_dnxhd_1920x1080_29.97_145_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 2
elif self.idCodec=='hd_dnxhd_1920x1080_25_185_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 3
elif self.idCodec=='hd_dnxhd_1920x1080_25_120_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 4
elif self.idCodec=='hd_dnxhd_1920x1080_25_36_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 5
elif self.idCodec=='hd_dnxhd_1920x1080_24_175_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 6
elif self.idCodec=='hd_dnxhd_1920x1080_24_115_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 7
elif self.idCodec=='hd_dnxhd_1920x1080_24_36_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 8
elif self.idCodec=='hd_dnxhd_1920x1080_23.976_175_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 9
elif self.idCodec=='hd_dnxhd_1920x1080_23.976_115_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 10
elif self.idCodec=='hd_dnxhd_1920x1080_23.976_36_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 11
elif self.idCodec=='hd_dnxhd_1920x1080_29.97_220_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 12
elif self.idCodec=='hd_dnxhd_1920x1080_29.97_145_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 13
elif self.idCodec=='hd_dnxhd_1920x1080_29.97_45_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 14
elif self.idCodec=='hd_dnxhd_1280x720_59.94_220_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 15
elif self.idCodec=='hd_dnxhd_1280x720_59.94_145_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 16
elif self.idCodec=='hd_dnxhd_1280x720_50_175_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 17
elif self.idCodec=='hd_dnxhd_1280x720_50_115_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 18
elif self.idCodec=='hd_dnxhd_1280x720_29.97_110_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 19
elif self.idCodec=='hd_dnxhd_1280x720_29.97_75_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 20
elif self.idCodec=='hd_dnxhd_1280x720_25_90_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 21
elif self.idCodec=='hd_dnxhd_1280x720_25_60_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 22
elif self.idCodec=='hd_dnxhd_1280x720_23.976_90_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 23
elif self.idCodec=='hd_dnxhd_1280x720_23.976_60_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 24
#################################################################################
elif self.idCodec=='jpeg': # convertir animation en images
self.ffmpegProcess.commandeFfmpegConvAnimImg()
elif self.idCodec=='extractionaudio':
self.ffmpegProcess.commandeFfmpegSeparation()
elif self.idCodec=='encodage_wav': # encodage de fichiers audio en wav
self.ffmpegProcess.commandeFfmpegEncodageWav()
elif self.idCodec=='conv_en_16_9_ou_4_3': # Convertir vidéo en 16/9 ou 4/3
self.ffmpegProcess.commandeFfmpegConv_16_9_ou_4_3(
ext = os.path.splitext(self.cheminVideoEntre)[1],
size = "%sx%s" % (self.tailleVideo[0], self.tailleVideo[1]),
aspect = self.valeurNum,
audio = has_audio)
# Remonté d'un niveau pour simplifier le code et éviter les répetitions
if commande == None:
commande = self.ffmpegProcess.command
else :
self.ffmpegProcess.command = commande
debug(commande)
self.zoneTexte.append(commande+'\n\n')
self.ffmpegProcess.start()
debug(u"Commande lancée")
self.estLancee = True
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
debug('\n')
# ... pareil pour la concaténation de vidéos ensemble
if self.idCodec=='fusion_video':
pass
# ... pareil pour la concaténation de vidéos + audio(s)
elif self.idCodec in ['fusion_audio_et_video_1', 'fusion_audio_et_video_2']:
pass
# Autrement dans tous les autres cas ...
else:
infos = "\n########################\n"
infos += "# Informations MPlayer :\n"
infos += "########################\n"
debug(infos)
# Utilisation de la classe infovideo (et en particilier la fonction setVideo)
# présents dans gui_modules_animation/infoVideo.py
info = infovideo(self.cheminVideoEntre)
id_filename = 'ID_FILENAME='+self.cheminVideoEntre+'\n'
debug(id_filename)
id_demuxer = 'ID_DEMUXER='+info.demux+'\n'
debug(id_demuxer)
id_video_format = 'ID_VIDEO_FORMAT='+info.videoFormat+'\n'
debug(id_video_format)
id_video_codec = 'ID_VIDEO_CODEC='+info.video_codec+'\n'
debug(id_video_codec)
id_video_bitrate = 'ID_VIDEO_BITRATE='+str(info.videoBitrate)+'\n'
debug(id_video_bitrate)
id_video_largeur = 'ID_VIDEO_WIDTH='+str(info.videoLargeur)+'\n'
debug(id_video_largeur)
id_video_hauteur = 'ID_VIDEO_HEIGHT='+str(info.videoHauteur)+'\n'
debug(id_video_hauteur)
self.id_img_par_sec = 'ID_VIDEO_FPS='+str(info.imgParSec)+'\n'
debug(self.id_img_par_sec)
##### Donnée très importante pour la suite du calcul (uniquement pour ffmpeg.py) ######
#self.dureeTotaleVideo = float(info.dureeTotaleVideo)
#######################################################################################
id_duree_totale_video = 'ID_LENGTH='+str(info.dureeTotaleVideo)+'\n'
debug(id_duree_totale_video)
id_audio_codec = 'ID_AUDIO_CODEC='+info.audioCodec+'\n'
debug(id_audio_codec)
id_audio_rate = 'ID_AUDIO_RATE='+str(info.audioRate)+'\n'
debug(id_audio_rate)
id_audio_bitrate = 'ID_AUDIO_BITRATE='+str(info.audioBitrate)+'\n'
debug(id_audio_bitrate)
self.log.append(infos+id_filename+id_demuxer+id_video_format+id_video_codec+id_video_bitrate+id_video_largeur+id_video_hauteur+self.id_img_par_sec+id_duree_totale_video+id_audio_codec+id_audio_rate+id_audio_bitrate)
##############################################################################################
debug('\n')
infos = "\n############################\n"
infos += "# Informations %s :\n" %encodeur
infos += "############################\n"
debug(infos)
self.log.append(infos)
if self.idCodec in ['dailymotion_sd_4/3', 'dailymotion_sd_16/9', 'dailymotion_HD720p']:
tspl = self.id_img_par_sec.split()
nbrISec =[n.split('=')[1] for n in tspl]
nbrISec = nbrISec[0]
# A une image par seconde, la vidéo chargée n'est pas bien traitrée
# (ou voire pas traitée du tout) Message d'information pour l'utilisateur.
if nbrISec == '1.0':
daily = QMessageBox.information(self, 'Message',
_(u"<p>Le nombre d'image(s) par seconde, dans la vidéo avec laquelle vous avez décidé de travailler, n'est que de 1, vous devez savoir que votre vidéo ne pourra pas être transcodée dans un des trois profils pour Dailymotion.</p><p>A partir de deux images par seconde, cela devient possible (en conséquence, éditez votre vidéo et changez le nombre d'images par seconde). <b>Le traitement demandé ne peut pas avoir lieu.</b></p>"), QMessageBox.Yes)
if daily == QMessageBox.Yes:return
elif self.idCodec=='codech264mpeg4':
if not info.audioCodec:
self.idCodec = "%s_nosound" % self.idCodec
#elif self.idCodec[0]=='bruit':
# Rien à faire, c'est tout se passe ici animation_filtres_video.py
elif self.idCodec=='changement_resolution' and not self.tempsApercu:
reponse = QMessageBox.information(self, 'Message',
_(u"<p>Vous avez décidé de changer la résolution de cette vidéo, sachez avant tout que la vidéo en question sera (en même temps qu'elle est redimensionnée) encodée en <b><font color='red'>Motion JPEG (extension .avi)</font></b>.</p><p>Vous pouvez (si vous le désirez) <b>vous approcher d'une résolution en 16/9ème</b>, pour ce faire vous devez faire un petit calcul ...</p><p>* pour obtenir la valeur de la hauteur comparativement à la valeur de la largeur, vous devez <b>diviser la valeur de la largeur par 1.777</b>, par exemple si votre vidéo de départ est en 640x480, le calcul à faire sera le suivant:</p><p>640 / 1.777, cela vous donnera (à la virgule près) 360.15756893640969, vous devrez enlever les chiffres après la virgule. Pour conclure, votre vidéo fera à l'arrivée 640x360, vous pourrez donc régler <b>Nouvelle largeur</b> à 640 et <b>Nouvelle hauteur</b> à 360.</p><p><b>Si vous décidez de faire les réglages pour obtenir une vidéo en 16/9ème, répondez non</b> à la question qui vous sera posée (pour ainsi pouvoir refaire les réglages), <b>si vous décidez de changer la résolution tout de suite (et avec les valeurs que vous venez de définir), répondez oui</b>.</p><p><b>Voulez-vous changer la résolution tout de suite ?.</b></p>"), QMessageBox.Yes, QMessageBox.No)
if reponse == QMessageBox.No:
return
debug("self.idCodec de mencoder %s" % self.idCodec)
self.mencoderProcess.setCommand(parametres = self.valeurNum, apercu = self.tempsApercu)
self.mencoderProcess.start()
debug(u"Commande lancée")
self.estLancee = True
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
infos = "\n########################\n"
infos += "# Informations MPlayer :\n"
infos += "########################\n"
debug(infos)
# Utilisation de la classe infovideo (et en particilier la fonction setVideo)
# présents dans gui_modules_animation/infoVideo.py
info = infovideo(self.cheminVideoEntre)
id_filename = 'ID_FILENAME='+self.cheminVideoEntre+'\n'
debug(id_filename)
id_demuxer = 'ID_DEMUXER='+info.demux+'\n'
debug(id_demuxer)
id_video_format = 'ID_VIDEO_FORMAT='+info.videoFormat+'\n'
debug(id_video_format)
id_video_codec = 'ID_VIDEO_CODEC='+info.video_codec+'\n'
debug(id_video_codec)
id_video_bitrate = 'ID_VIDEO_BITRATE='+str(info.videoBitrate)+'\n'
debug(id_video_bitrate)
id_video_largeur = 'ID_VIDEO_WIDTH='+str(info.videoLargeur)+'\n'
debug(id_video_largeur)
id_video_hauteur = 'ID_VIDEO_HEIGHT='+str(info.videoHauteur)+'\n'
debug(id_video_hauteur)
id_img_par_sec = 'ID_VIDEO_FPS='+str(info.imgParSec)+'\n'
debug(id_img_par_sec)
##### Donnée très importante pour la suite du calcul (pour ffmpeg.py et ffmpeg2theora) ####
self.dureeTotaleVideo = float(info.dureeTotaleVideo)
###########################################################################################
id_duree_totale_video = 'ID_LENGTH='+str(info.dureeTotaleVideo)+'\n'
debug(id_duree_totale_video)
id_audio_codec = 'ID_AUDIO_CODEC='+info.audioCodec+'\n'
debug(id_audio_codec)
id_audio_rate = 'ID_AUDIO_RATE='+str(info.audioRate)+'\n'
debug(id_audio_rate)
id_audio_bitrate = 'ID_AUDIO_BITRATE='+str(info.audioBitrate)+'\n'
debug(id_audio_bitrate)
self.log.append(infos+id_filename+id_demuxer+id_video_format+id_video_codec+id_video_bitrate+id_video_largeur+id_video_hauteur+id_img_par_sec+id_duree_totale_video+id_audio_codec+id_audio_rate+id_audio_bitrate)
##############################################################################################
infos = "\n############################\n"
infos += "# Informations %s :\n" % encodeur
infos += "############################\n"
debug(infos)
self.log.append(infos)
self.ffmpeg2theoraProcess.setVideoLen(self.dureeTotaleVideo)
if encodeur == 'Ffmpeg2theora':
# mode de canal: on fusionne le canal de sortie normal
# (stdout) et celui des erreurs (stderr)
self.ffmpeg2theoraProcess.setCommand(self.valeurNum)
self.ffmpeg2theoraProcess.start()
debug(u"Commande lancée")
self.estLancee = 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
# On vérifie si on a eu des réponses
if tampon.startsWith("Playing"):
# 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)
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(""))
try:
# Tour de passe-passe pour ne pas avoir de problème d'accents
# Condition pour détection windows
if os.name == 'nt':
self.fichierCourant[1]=unicode(QString(tampon))
# Condition pour détection Linux ou MacOSX
elif os.name in ['posix', 'mac']:
self.fichierCourant[1]=unicode(QString(tampon)).encode("Latin1").decode("UTF8")
except UnicodeEncodeError, e:
debug(e)
self.fichierCourant[1]="?"
self.cibleVideo.setToolTip(self.fichierCourant[1])
if self.barreTaches is not 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 "..."
debug("tampon : %s" % 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:
if resX!=0 or resY!=0:
debug( "ratio : %s - %s" % (self.ratio, type(self.ratio)))
else:
debug("fichier audio")
# réponse à get_time_length : ANS_LENGTH=xx.yy
elif tampon.startsWith("ANS_LENGTH"):
debug("tampon : %s" % 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
## Modifié le 28/05/2009 : On augmente la précision du slider
#self.slider.setMaximum(tempsMax) # déf du domaine de valeur du curseur
self.slider.setMaximum(tempsMax*self.echelle)
# 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
temps = float("%.1f" %self.temps)
if self.debutFin!=(0,0) and self.debutFin[1]==temps:
self.arretMPlayer()
return
self.slider.setValue(tempsCourant*self.echelle)
#############################################################################
self.changerTempsChrono(tempsCourant) # modifier le chrono du bouton
def run(self):
for nb_1, fichier_1 in enumerate(self.cheminVideoEntre):
if self.cancel: break
if self.codec_sortie == "MOV (.mov)":
fps = ' -r '+str(self.nbreImgSec_sortie)
extSortie = '.mov'
vcodec = ' -vcodec mpeg4'
acodec = ' -acodec copy'
qual_video = ' -qscale '+str(self.qualite_sortie) # Adapté le 13/08/2010
elif self.codec_sortie == "MPEG2 (.mpg)":
fps = ' -r 25'
extSortie = '.mpg'
vcodec = ' -vcodec mpeg2video'
acodec = ' -acodec mp2 -ac 1 -ar 22050 -ab 64k'
qual_video = ' -qscale '+str(self.qualite_sortie) # Adapté le 13/08/2010
elif self.codec_sortie == "MPEG1 (.mpg)":
fps = ' -r 25'
extSortie = '.mpg'
vcodec = ' -vcodec mpeg1video'
acodec = ' -acodec mp2 -ac 1 -ar 22050 -ab 64k'
qual_video = ' -qscale '+str(self.qualite_sortie) # Adapté le 13/08/2010
elif self.codec_sortie == "VOB (.vob)":
fps = ' -r '+str(self.nbreImgSec_sortie)
extSortie = '.vob'
vcodec = ' '
acodec = ' -acodec copy'
qual_video = ' -qscale '+str(self.qualite_sortie) # Adapté le 13/08/2010
elif self.codec_sortie == "MPEG4 (.mp4)":
fps = ' -r '+str(self.nbreImgSec_sortie)
extSortie = '.mp4'
vcodec = ' -vcodec mpeg4'
acodec = ' -acodec copy'
qual_video = ' -qscale '+str(self.qualite_sortie) # Adapté le 13/08/2010
elif self.codec_sortie == "WMV2 (.wmv)":
fps = ' -r '+str(self.nbreImgSec_sortie)
extSortie = '.wmv'
vcodec = ' -vcodec wmv2'
acodec = ' -acodec copy'
qual_video = ' -qscale '+str(self.qualite_sortie) # Adapté le 13/08/2010
elif self.codec_sortie == "HFYU (yuv422p) (.avi)":
fps = ' -r '+str(self.nbreImgSec_sortie)
extSortie = '.avi'
vcodec = ' -vcodec huffyuv -pix_fmt yuv422p'
acodec = ' -acodec copy'
qual_video = ' -qscale '+str(self.qualite_sortie) # Adapté le 13/08/2010
elif self.codec_sortie == "MSMPEG 4 version 2 (.avi)":
fps = ' -r '+str(self.nbreImgSec_sortie)
extSortie = '.avi'
vcodec = ' -vcodec msmpeg4v2'
acodec = ' -acodec copy'
qual_video = ' -qscale '+str(self.qualite_sortie) # Adapté le 13/08/2010
elif self.codec_sortie == "Motion JPEG (.avi)":
fps = ' -r '+str(self.nbreImgSec_sortie)
extSortie = '.avi'
vcodec = ' -vcodec mjpeg'
acodec = ' -acodec copy'
qual_video = ' -qscale '+str(self.qualite_sortie) # Adapté le 13/08/2010
elif self.codec_sortie == "FFV1 (FFmpeg) (.avi)":
fps = ' -r '+str(self.nbreImgSec_sortie)
extSortie = '.avi'
vcodec = ' -vcodec ffv1'
acodec = ' -acodec copy'
qual_video = ' -qscale '+str(self.qualite_sortie) # Adapté le 13/08/2010
### Rectification le 14/08/2010 ############################################
elif self.codec_sortie == "Avid DNxHD (.mov)":
# Extension sortie
extSortie = '.mov'
# Codec vidéo pour l'Avid DNxHD
vcodec = ' -vcodec dnxhd'
# Choix du flux audio pour l'Avid DNxHD
if self.son_sortie_DNxHD == "Copie du flux audio": acodec = ' -acodec copy'
elif self.son_sortie_DNxHD == "Flux audio PCM sur 2 canaux (stereo)": acodec = ' -ac 2 -acodec pcm_s16le'
elif self.son_sortie_DNxHD == "Pas de flux audio": acodec = ' -an'
# Les valeurs de qualité de la vidéo ne sont pas conservées
qual_video = ''
# ------------------------ #
# Valeurs particulières
# ------------------------ #
if self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:29.97 Bitrate:220 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 29.97 -b 220000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:29.97 Bitrate:145 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 29.97 -b 145000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:25 Bitrate:185 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 25 -b 185000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:25 Bitrate:120 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 25 -b 120000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:25 Bitrate:36 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 25 -b 36000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:24 Bitrate:175 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 24 -b 175000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:24 Bitrate:115 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 24 -b 115000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:24 Bitrate:36 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 24 -b 36000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:23.976 Bitrate:175 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 23.976 -b 175000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:23.976 Bitrate:115 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 23.976 -b 115000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:23.976 Bitrate:36 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 23.976 -b 36000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:29.97 Bitrate:220 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 29.97 -b 220000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:29.97 Bitrate:145 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 29.97 -b 145000k'
elif self.spec_sortie_DNxHD == "Dimension:1920x1080 Img/sec:29.97 Bitrate:45 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1920'
self.reso_hauteur_sortie = '1080'
# Nbre d'img/sec et bitrate
fps = ' -r 29.97 -b 45000k'
elif self.spec_sortie_DNxHD == "Dimension:1280x720 Img/sec:59.94 Bitrate:220 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1280'
self.reso_hauteur_sortie = '720'
# Nbre d'img/sec et bitrate
fps = ' -r 59.94 -b 220000k'
elif self.spec_sortie_DNxHD == "Dimension:1280x720 Img/sec:59.94 Bitrate:145 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1280'
self.reso_hauteur_sortie = '720'
# Nbre d'img/sec et bitrate
fps = ' -r 59.94 -b 145000k'
elif self.spec_sortie_DNxHD == "Dimension:1280x720 Img/sec:50 Bitrate:175 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1280'
self.reso_hauteur_sortie = '720'
# Nbre d'img/sec et bitrate
fps = ' -r 50 -b 175000k'
elif self.spec_sortie_DNxHD == "Dimension:1280x720 Img/sec:50 Bitrate:115 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1280'
self.reso_hauteur_sortie = '720'
# Nbre d'img/sec et bitrate
fps = ' -r 50 -b 115000k'
elif self.spec_sortie_DNxHD == "Dimension:1280x720 Img/sec:29.97 Bitrate:110 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1280'
self.reso_hauteur_sortie = '720'
# Nbre d'img/sec et bitrate
fps = ' -r 29.97 -b 110000k'
elif self.spec_sortie_DNxHD == "Dimension:1280x720 Img/sec:29.97 Bitrate:75 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1280'
self.reso_hauteur_sortie = '720'
# Nbre d'img/sec et bitrate
fps = ' -r 29.97 -b 75000k'
elif self.spec_sortie_DNxHD == "Dimension:1280x720 Img/sec:25 Bitrate:90 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1280'
self.reso_hauteur_sortie = '720'
# Nbre d'img/sec et bitrate
fps = ' -r 25 -b 90000k'
elif self.spec_sortie_DNxHD == "Dimension:1280x720 Img/sec:25 Bitrate:60 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1280'
self.reso_hauteur_sortie = '720'
# Nbre d'img/sec et bitrate
fps = ' -r 25 -b 60000k'
elif self.spec_sortie_DNxHD == "Dimension:1280x720 Img/sec:23.976 Bitrate:90 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1280'
self.reso_hauteur_sortie = '720'
# Nbre d'img/sec et bitrate
fps = ' -r 23.976 -b 90000k'
elif self.spec_sortie_DNxHD == "Dimension:1280x720 Img/sec:23.976 Bitrate:60 Mb/s":
# Taille largeur x hauteur
self.reso_largeur_sortie = '1280'
self.reso_hauteur_sortie = '720'
# Nbre d'img/sec et bitrate
fps = ' -r 23.976 -b 60000k'
############################################################################
commande = self.cheminFFmpeg+' -i '+"\""+fichier_1+"\""+' -s '+self.reso_largeur_sortie+'x'+self.reso_hauteur_sortie+fps+vcodec+acodec+qual_video+' -y '+"\""+self.enregistrerSortie+'_'+string.zfill(str(nb_1+1), 5)+extSortie+"\""
outputfile = self.enregistrerSortie+'_'+string.zfill(str(nb_1+1), 5)+extSortie
EkdPrint(u'commande %s' % commande)
try:
## Travail avec subprocess
## sp = subprocess.Popen(commande, shell=True, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=os.setsid)
# Travail avec EkdProcess, bien
sp = EkdProcess(commande, outputerr=subprocess.STDOUT)
# Important permet le traitement (!)
self.tampon = sp.stdout.readlines()
except Exception:
debug(u"Erreur dans le lancement de %s" % commande)
# Ca marche mieux avec pourcent calculé comme ça
pourcent=((nb_1+1)*100)/len(self.cheminVideoEntre)
# Emetteur pour la récup des valeurs du pourcentage
self.emit(SIGNAL("increment(int)"), pourcent)
# Emetteur pour (essayer) d'afficher chaque fichier chargé
# (pour info) au bon moment dans la barre de progression
self.emit(SIGNAL("travail_avec_fichier"), fichier_1, outputfile)
debug ("%d "%(nb_1))
self.emit(SIGNAL("fin process"))
def fichierDeTravail(self, fichier_1, out):
self.fichiers_traites.append(out)
debug(u'Fichier chargé: %s' % fichier_1)
