Logo Search packages:      
Sourcecode: videoporama version File versions  Download package

mplayer.py

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

# This file is part of Videoporama but it was an new version of the EKD file
# Videoporama is a program to make diaporama export in video file
# Copyright (C) 2007-2010  Olivier Ponchaut <opvg@edpnet.be>

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.


# script grandement inspiré du code c++ de http://doc.qtfr.org/public/2007/qt_mplayer.tar.gz
# merci à IrmatDen

import sys, os
from PyQt4.QtGui import *
from PyQt4.QtCore import *


def getParamVideo(cheminVideoEntre, parameter):
  """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"""
  
  cheminVideoEntre = cheminVideoEntre.encode("UTF8")
  
  # Condition pour détection windows
  if os.name == 'nt':
    recupDonneesVideo = os.popen('mplayer.exe -vo null -ao null -identify -frames 0 '+ "\"" + cheminVideoEntre + "\"").readlines()
  # Condition pour détection Linux ou MacOSX
  elif os.name in ['posix', 'mac']:
    recupDonneesVideo = os.popen('mplayer ' +"\""+ cheminVideoEntre +\
    "\" -vo null -ao null -frames 0 -identify '$@' 2>/dev/null").readlines()
  
  lstValeurs = []
  log = []
  
  for ligne in recupDonneesVideo:
    try:
      # On veut que les caractères non ASCII s'affichent correctement pour les noms de fichiers
      log.append(ligne.decode("UTF8"))
    except UnicodeDecodeError:
      print "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", "")
        ligne = ligne.replace(" ", "")
        lstValeurs.append(float(ligne))
  
  lstValeurs.append(log)
  
  return lstValeurs

def getVideoLength(cheminVideoEntre):
  "Retourne la durée de la vidéo. L'argument doit être de type unicode"
  return getParamVideo(cheminVideoEntre, ["ID_LENGTH"])

def getVideoSize(cheminVideoEntre):
  "Retourne la taille de la vidéo. L'argument doit être de type unicode"
  return getParamVideo(cheminVideoEntre, ["ID_VIDEO_WIDTH", "ID_VIDEO_HEIGHT"])

def getVideoFPS(cheminVideoEntre):
  "Retourne le nombre de trames par seconde de la vidéo. L'argument doit être de type unicode"
  return getParamVideo(cheminVideoEntre, ["ID_VIDEO_FPS"])

def getVideoRatio(cheminVideoEntre):
  "Retourne l'aspect ratio de la vidéo. L'argument doit être de type unicode"
  return getParamVideo(cheminVideoEntre, ["ID_VIDEO_ASPECT"])


00086 class TracerChrono(QWidget):
  """On trace le temps car il ne s'affiche pas bien autrement pour certaines configurations"""
  TAILLE = "0:00:00:000"
  def __init__(self):
    # parent nous permettra d'accéder à la valeur du curseur
    QWidget.__init__(self)
    self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.MinimumExpanding)
    self.raz()
    ######################################################################################
  
  def paintEvent(self, event):
    paint = QPainter()
    paint.begin(self)
    paint.drawText(event.rect(), Qt.AlignCenter, self.num)
    paint.end()
  
  def minimumSizeHint(self):
    "Pour être sûr que le texte du chrono ne soit pas tronqué"
    font = QFont(self.font())
    font.setPointSize(font.pointSize() - 1)
    fm = QFontMetricsF(font)
    ## Modifié le 28/05/2009 : on ajoute de la précision dans la lecture #################
    ##l = fm.width(TracerChrono.TAILLE) + 6.
    l = fm.width(TracerChrono.TAILLE*2) # + 10.
    L = fm.height() + 2.
    return QSize(l, L)
    ######################################################################################
    
00114   def raz(self):
    '''Ajouté le 28/05/2009 : On évite d'avoir à parcourir le code à la recherche de 00:00:00....'''
    self.num = TracerChrono.TAILLE

00118 class DisplayVid(QWidget) :

  def resizeEvent(self,event) :
    QWidget.resizeEvent(self,event)
    self.emit(SIGNAL("changeSize"))

00124 class Mplayer(QDialog):
  
  REVENIR, PAS_PRECEDENT_SUIVANT, PRECEDENT_SUIVANT, CURSEUR_SUR_UNE_LIGNE,\
    CURSEUR_A_PART, PARCOURIR, PAS_PARCOURIR = range(7)
  
  HAUTEUR, LARGEUR = range(2)
  
00131   def __init__(self, VideoporamaInstance, cheminVideo=[], taille=(250,225),
      choixWidget=(REVENIR, PAS_PRECEDENT_SUIVANT,CURSEUR_SUR_UNE_LIGNE,PAS_PARCOURIR),
      debutFin=(0,0), cheminMPlayer=None, barreTaches=None, facteurLimitant=HAUTEUR,
00134       cheminParcourir=None, parent=None):
    
00136     """widget mplayer"""
    QDialog.__init__(self, parent)
    self.VideoporamaInstance=VideoporamaInstance
    
    #=== Paramètres généraux ===#
    self.setAttribute(Qt.WA_DeleteOnClose)
    
    self.systeme = os.name
    
    # système d'exploitation
    if self.systeme in ['posix', 'mac'] : #and not cheminMPlayer:
      self.cheminMPlayer=cheminMPlayer+os.sep+"mplayer"  # moteur de lecture mplayer
    else : # windows à priori
      self.cheminMPlayer=cheminMPlayer+os.sep+"mplayer.exe" # avec le *.exe
    
    # liste de chemins vidéos
    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 = self.VideoporamaInstance.qtapp.translate("MPlayerDlg","No file")
    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]
    
    # Drapeau pour afficher plus de boutons
    plusBoutons = choixWidget[0]
    
    # Drapeau pour mettre le curseur à part
    curseurAPart = choixWidget[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
    ###############################################################################################################################
    
    ## Ajouté le 28/05/2009 : 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

    print "self.taille avant lecture :", self.taille, type(self.taille)
    
    #=== Widgets ===#
    
    self.icone_lire=QIcon("icons" + os.sep + "player_play.png")
    self.icone_pause=QIcon("icons" + os.sep + "player_pause.png")
    self.icone_arret=QIcon("icons" + os.sep + "player_stop.png")
    
    ###### Rajouté le 31/03/09 ################################################################
    if Mplayer.REVENIR in choixWidget:
      self.bout_revenir = QPushButton(self.VideoporamaInstance.qtapp.translate("MPlayerDlg","Back ..."))
      self.bout_revenir.setIcon(QIcon("Icones" + os.sep + "revenir.png"))
    ###########################################################################################
    
    if Mplayer.PARCOURIR in choixWidget:
      self.bout_ouvVideo = QPushButton(self.VideoporamaInstance.qtapp.translate("MPlayerDlg","Browse ..."))
      
    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.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
    self.conf = QGroupBox()
    sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
    sizePolicy.setHorizontalStretch(0)
    sizePolicy.setVerticalStretch(0)
    sizePolicy.setHeightForWidth(self.conf.sizePolicy().hasHeightForWidth())
    self.conf.setSizePolicy(sizePolicy)
    self.conf.setMinimumSize(QSize(70, 0))
    self.conf.setMaximumSize(QSize(70, 16777215))
    self.conf.setObjectName("conf")
    self.verticalLayout = QVBoxLayout(self.conf)
    self.verticalLayout.setMargin(0)
    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)
    spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
    self.verticalLayout.addItem(spacerItem)
    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)
      self.choicenorm.setChecked(True)

    self.slider = QSlider(Qt.Horizontal)
    # Modifié le 27/05/2009 : qualification du bug en question
    #self.slider.setEnabled(False) # évite un bogue
    self.slider.setEnabled(True)
    #self.slider.setSingleStep(self.echelle)
    
    self.mplayerProcess = QProcess(self)
    
    self.timer = QTimer(self)
    
    self.tempsChrono = TracerChrono()
    
    #=== mise-en-page/plan ===#
    mhbox = QHBoxLayout()
    vbox = QVBoxLayout()
    vbox.addWidget(self.cibleVideo)
    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)
    mhbox.addLayout(vbox)
    mhbox.addWidget(self.conf)
    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)
    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)
    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 defRatio(self, state=0) :
    if state :
      if self.choicenorm.isChecked() :
        self.setRatio(4.0/3.0)
      if self.choicewide.isChecked() :
        self.setRatio(16.0/9.0)
      if self.choiceone.isChecked() :
        dim=getVideoSize(unicode(self.listeVideos[0]))
        self.setRatio(dim[0]/dim[1])
      self.defRatio()
    else :
      self.adjustSize()

  def setRatio(self,ratio) :
    self.ratio = ratio
    self.sizeMplayer()
    
  def changeRatio(self,video) :
    rv = getVideoRatio(video)
    if rv[0]==0.0 and type(rv[1])==float :
      rat = rv[1]
    else :
      rat = rv[0]

    if rat > 1.7 :
      self.choicewide.setChecked(True)
      self.setRatio(16.0/9.0)
    elif rat > 1.3 and rat <= 1.7 :
      self.choicenorm.setChecked(True)
      self.setRatio(4.0/3.0)
    elif rat < 1.3 and rat != 0.0 :
      self.choiceone.setChecked(True)
      dim=getVideoSize(video)
      self.setRatio(dim[0]/dim[1])
    else :
      self.choicenorm.setChecked(True)
      self.setRatio(4.0/3.0)
      
  def sizeMplayer(self) :
    self.cibleVideo.setFixedHeight(int(self.cibleVideo.width()/self.ratio))

00383   def ouvrirVideo(self):
    """Ouverture de la boîte de dialogue de fichiers"""
    txt = self.VideoporamaInstance.qtapp.translate("MPlayerDlg","Video files")
    if self.cheminPourBoutonParcourir: 
      chemin = self.cheminPourBoutonParcourir

    else:
      chemin = os.path.expanduser('~')

    liste=QFileDialog.getOpenFileNames(None, self.VideoporamaInstance.qtapp.translate("MPlayerDlg","Open"), chemin, "%s (*.avi *.mpg *.mpeg *.mjpeg *.flv *.mp4 *.ogg)\n*" %txt)
    if not liste: return
    self.listeVideos = liste
    self.changeRatio(unicode(self.listeVideos[0]))

    chemin = unicode(self.listeVideos[0])

  
00400   def demarrerMPlayer(self):
    """démarrage de mplayer avec les arguments choisis"""
    if self.estLue:
      return True
    
    args = QStringList()  # Liste Qt qui contiendra les options de mplayer
          # Ajout d'options à liste: args << "-option"
    
    # mplayer fonctionnera comme un terminal dans ce script
    args << "-slave"
    # on ne veut pas avoir des commentaires sans grand intérêt
    args << "-quiet"

    # Sous linux, aucun driver n'a été nécessaire et pas de manip pour Wid :)
    if self.systeme=='posix':
      # try - except?
      # la fenêtre de mplayer restera attaché à la fenêtre
      # wid prend en valeur le nombre identifiant le widget (celui qui contiendra la vidéo)
      args << "-wid" << QString.number(self.cibleVideo.winId()) # Objet QString car args est une liste de ch de caractères
      settings = QSettings()
      videoOutput = settings.value("vo", QVariant('')).toString()
      if videoOutput:
        args << '-vo' << videoOutput
      
    # Sous windows
    else:
      # reinterpret_cast<qlonglong> obligatoire, winId() ne se laissant pas convertir gentiment ;)
      args << "-wid" << self.cibleVideo.winId().__hex__()
      args << "-vo" << "directx:noaccel"
      #args << "-vo" << "gl" # alternative

    # chemin de la vidéo
    args << self.listeVideos
    
    if PYQT_VERSION_STR >= "4.1.0":
      # mode de canal: on fusionne le canal de sortie normal (stdout) et celui des erreurs (stderr)
      self.mplayerProcess.setProcessChannelMode(QProcess.MergedChannels)
    # démarrage de mplayer (en tenant compte des arguments définis ci-dessus) 
    # comme un nouveau processus
    self.mplayerProcess.start(self.cheminMPlayer, args)
    # au cas où mplayer ne démarrerait pas au bout de 3 sec (ex. problème de codec)
    if not self.mplayerProcess.waitForStarted(3000):
      QMessageBox.critical(self, self.VideoporamaInstance.qtapp.translate("MPlayerDlg","Warning"), self.VideoporamaInstance.qtapp.translate("MPlayerDlg","Error when starting mplayer"))
      return False
    
    # donne le temps toutes les x secondes
    self.timer.start(self.dureeTimer)
    
    self.estLue = True
    
    return True
  
00452   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
      
      #print "tampon :", tampon
      
      # 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:
          print 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 "..."
        print "tampon :",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:
          print "ratio :", self.ratio, type(self.ratio)
        else:
          print "fichier audio"
      
      # réponse à get_time_length : ANS_LENGTH=xx.yy
      elif tampon.startsWith("ANS_LENGTH"):
        print "tampon :",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
        #print "self.temps", self.temps, type(self.temps)
        #print "self.debutFin", self.debutFin[1], type(self.debutFin[1])
        temps = float("%.1f" %self.temps)
        #print "temps", temps, type(temps), '\n'
        if self.debutFin!=(0,0) and self.debutFin[1]==temps:
          self.arretMPlayer()
          return
        ## Modifié le 28/05/2009 : On augmente la précision du slider ###############
        #self.slider.setValue(tempsCourant) # aller au temps courant
        self.slider.setValue(tempsCourant*self.echelle)
        #############################################################################
        self.changerTempsChrono(tempsCourant) # modifier le chrono du bouton
  
  
00555   def sonderTempsActuel(self):
    """envoie le temps correspondant à la position de la vidéo dans le tampon"""
    self.mplayerProcess.write("get_time_pos\n")
  
00559   def changerTempsCurseur(self, pos):
    """change la partie de la vidéo qui sera lue"""
    # on arrête le temps pendant le changement de position de la vidéo 
    # sinon le curseur ne bouge plus
    self.timer.stop()
    self.mplayerProcess.write("seek " + str(pos/self.echelle) + " 2\n") 

    #self.mplayerProcess.write(QString("seek " + QString.number(pos) + " 2\n").toUtf8()) # anciennement
    self.timer.start()
    self.estLue, self.estEnPause = True, False
    self.bout_LectPause.setIcon(self.icone_pause)
    
  
00572   def changerTempsChrono(self,nvTemps):
    """affichage du temps sous la forme h:mm:ss:ms dans un bouton"""
    temps0 = QTime(0, 0, 0)
    ## Modifié le 28/05/2009 : On augemente la précision, on ajoute les milisecondes au lieu des secondes #####
    #temps = temps0.addSecs(nvTemps)
    temps = temps0.addMSecs(nvTemps*self.echelle)
    ###########################################################################################################
    mn = str(temps.minute()).zfill(2)
    s = str(temps.second()).zfill(2)
    ms = str(temps.msec()).zfill(3)
    chrono = str(temps.hour())+':'+mn+':'+s+':'+ms
    self.tempsChrono.num = chrono
    self.tempsChrono.repaint()
    ###########################################################################################################
  
  
00588   def precedent(self):
    """affiche la vidéo précédente"""
    if self.estLue:
      self.mplayerProcess.write("pt_step -1\n")
      self.estEnPause = False
      self.bout_LectPause.setIcon(self.icone_pause)
  
  
00596   def suivant(self):
    """affiche la vidéo suivante"""
    if self.estLue:
      self.mplayerProcess.write("pt_step 1\n")
      self.estEnPause = False
      self.bout_LectPause.setIcon(self.icone_pause)
  
  
00604   def lectPause(self):
    """lecture/pause de la vidéo avec mplayer"""
    if not self.estLue:
      if not self.demarrerMPlayer(): # lecture de la vidéo
        return # au cas où mplayer ne démarrerait pas au bout de 3 sec (ex. problème de codec)
      self.estLue, self.estEnPause = True, False
      self.bout_LectPause.setIcon(self.icone_pause)
      self.slider.setEnabled(True) # évite un bogue
      if self.debutFin!=(0,0) and self.debutFin[0]!= 0:
        self.mplayerProcess.write("seek " + str(self.debutFin[0]) + " 2\n")
    elif self.estLue and not self.estEnPause: # lecture -> pause
      self.mplayerProcess.write("pause\n")
      self.timer.stop()
      self.bout_LectPause.setIcon(self.icone_lire)
      self.slider.setEnabled(True) # évite un bogue
      self.estLue, self.estEnPause = True, True
    elif self.estLue and self.estEnPause: # pause -> lecture
      # prévoir le cas où mplayer ne se mettrait pas en pause au bout de 3 sec
      self.timer.start()
      self.bout_LectPause.setIcon(self.icone_pause)
      self.slider.setEnabled(True) # évite un bogue
      self.estLue, self.estEnPause = True, False
  
  
00628   def arretMPlayer(self):
    """"Arrete la lecture de la vidéo et réinitialise les icones et variables"""
    if self.mplayerProcess.state() == QProcess.NotRunning: # ajouté pour ne pas avoir de bogue à la fin de la lecture de la vidéo.
          return True
    
    self.mplayerProcess.write("quit\n") # arrêt de la vidéo
    
    # au cas où mplayer ne s'arrêterait pas au bout de 3 sec
    if not self.mplayerProcess.waitForFinished(3000):
      QMessageBox.critical(self, self.VideoporamaInstance.qtapp.translate("MPlayerDlg","Warning"), self.VideoporamaInstance.qtapp.translate("MPlayerDlg","Error when stoping mplayer"))
      return False
    
    self.slider.setEnabled(False) # évite un bogue
    #self.slider.setEnabled(True)
    
    #self.tempsChrono.num = "0:00:00"
    self.tempsChrono.raz()

    self.tempsChrono.repaint()
    self.slider.setValue(0)
    self.estLue, self.estEnPause = False, False
    self.bout_LectPause.setIcon(self.icone_lire)
    return True
  
00652   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:
      print "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()



Generated by  Doxygen 1.6.0   Back to index