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)