def afficherAide(self): """ Boîte de dialogue de l'aide du cadre Image > Renommer """ # Nouvelle fenêtre d'aide messageAide=EkdAide(parent=self) messageAide.setText(tr(u"<p><b>Vous pouvez ici renommer un lot d'images. Pour information (et ce dans l'onglet Réglages), vous pouvez choisir un ordre spécifique dans le classement de vos images (les deux derniers choix dans la liste font référence aux données EXIF des photographies numériques).</b></p><p>Dans l'onglet <b>'Images sources'</b> cliquez sur le bouton <b>Ajouter</b>, une boîte de dialogue apparaît, sur la partie gauche sélectionnez le répertoire (au besoin dépliez les sous-répertoires), allez chercher vos image(s). Si vous voulez sélectionner plusieurs images d'un coup, maintenez la touche <b>CTRL</b> (ou <b>SHIFT</b>) du clavier enfoncée (tout en sélectionnant vos images), cliquez sur <b>Ajouter</b>.<p></p>Dans l'onglet <b>'Réglages'</b> faites les réglages du <b>'Traitement à partir de l'image (numéro)'</b> et du <b>'Nombre de chiffres après le nom de l'image' <font color='red'>(la plupart du temps les valeurs par défaut suffisent)</font></b></p>.<p>Une fois tout ceci fait, cliquez sur le bouton <b>'Renommer'</b>, sélectionnez le répertoire de sauvegarde, indiquez votre <b>'Nom de fichier'</b>, cliquez sur le bouton <b>'Enregistrer'</b>.</p><p>Après le traitement vous pouvez immédiatement voir l'affichage du résultat avant et après renommage des fichiers par l'onglet <b>'Infos'</b>.</p>")) messageAide.show()
def afficherAide(self): """Boîte de dialogue de l'aide du cadre Image > Informations (txt ou Exif)""" # Gestion de l'aide via EkdAide messageAide=EkdAide(parent=self) messageAide.setText(_(u"<p><b>Vous pouvez ici afficher les informations (en format texte) d'images et/ou les informations EXIF (Exchangeable Image File Format) de prises de vues d'appareils photographiques numériques. Vous pouvez de même exporter ces informations sous forme de fichier html (en vue d'être publié sur internet, par exemple).</b></p><p><b>Voici une défintion de EXIF selon Wikipédia: 'L’Exchangeable image file format ou Exif est une spécification de format de fichier pour les images utilisées par les appareils photographiques numériques.</b></p><p><b>Les balises de métadonnées définies dans le format Exif standard couvrent un large éventail de données, dont:<br><ol><li>Information de la date et de l’heure. Les appareils numériques enregistrent la date et l’heure de la prise de vue et l’insèrent dans les métadonnées.</li><li>Les réglages de l’appareil. Cela comprend des informations statiques telles que la marque et le modèle de l’appareil et des informations variables telles que l’orientation, l’ouverture, la vitesse d’obturation, la longueur de focale, la sensibilité ... .</li><li>Description et information des droits d’auteur.'</b></li></ol></p><p><b><font color='green'>Attention: comme vous pouvez le constater, les boutons 'Sauver infos (.txt)' et 'Sauver Exif (.html)' sont dans un premier temps grisés (ils deviendront actifs dès lors que vous aurez chargé une image).</font></b></p><p>Dans l'onglet <b>'Image source'</b> cliquez sur le bouton <b>Ajouter</b>, une boîte de dialogue apparaît, sur la partie gauche sélectionnez le répertoire (au besoin dépliez les sous-répertoires), allez chercher votre/vos image(s). Si vous voulez sélectionner plusieurs images d'un coup, maintenez la touche <b>CTRL</b> (ou <b>SHIFT</b>) du clavier enfoncée (tout en sélectionnant vos images), cliquez sur <b>Ajouter</b>.</p><p>Vous avez maintenant la possibilité de consulter les informations sur l'image dans les onglets <b>'Infos Texte'</b> et/ou <b>'Infos Exif'</b>. <b><font color='red'>Il faut savoir que les informations délivrées sont celles de l'image que vous aurez sélectionné dans l'onglet Image(s) source</font></b></p><p>Vous pouvez sauvegarder les informations texte et/ou EXIF (suivant l'image/photo chargée), pour ce faire cliquez sur le bouton <b>'Sauver infos (.txt)'</b> ou <b>'Sauver Exif (.html)'</b>, dans la boîte de dialogue sélectionnez le répertoire de sauvegarde, indiquez votre <b>'Nom de fichier'</b>, cliquez sur le bouton <b>'Enregistrer'</b>. <b><font color='red'>De même ici les informations qui seront enregistrées seront celles de l'image sélectionnée dans l'onglet Image(s) source.</font></b></p>")) messageAide.show()
def afficherAide(self): """Boîte de dialogue de l'aide""" # Utilisation de EkdAide messageAide=EkdAide(parent=self) messageAide.setText(tr(u"<p><b>Vous allez ici superposer des images avec un canal alpha (transparence) sur d'autres images sans canal alpha (ces dernières sont en quelque sorte l'arrière-plan). Vous avez aussi ici la possibilité de travailler avec un arrière-plan composé d'une seule image, en cas de travail en plan fixe (le programme duplique lui-même les images).</b></p><p><b>Voilà la définition que donne Wikipédia du terme compositing (c'est le terme exact): 'La composition (en anglais compositing) est un ensemble de méthodes numériques consistant à mélanger plusieurs sources d’images pour en faire un plan unique qui sera intégré dans le montage. Pour un film d'animation, il s'agit de l'étape finale de fabrication qui consiste à assembler toutes les couches des décors, des personnages et à réaliser les effets de caméra, à animer certains déplacements, et effets spéciaux. En cinéma de prise de vue réel, il consiste surtout à réaliser des effets spéciaux et à truquer des vidéos. C'est l'un des derniers maillons de la chaîne de l'image dans la réalisation d'un film.<br>Les sources peuvent être des images numérisées de cinéma, de dessin, de vidéo, des images numériques (dessin, 3D, effets spéciaux).'<br>Source: http://fr.wikipedia.org/wiki/Compositing</b></p><p>Dans l'onglet <b>'Image(s) avec canal alpha'</b> cliquez sur le bouton <b>Ajouter</b>, une boîte de dialogue apparaît, sur la partie gauche sélectionnez le répertoire (au besoin dépliez les sous-répertoires), allez chercher vos image(s). Passez maintenant dans l'onglet <b>'Image(s) sans canal alpha'</b> cliquez sur le bouton <b>Ajouter</b>, une boîte de dialogue apparaît, sur la partie gauche sélectionnez le répertoire (au besoin dépliez les sous-répertoires), allez chercher vos image(s). Si vous voulez sélectionner plusieurs images d'un coup, maintenez la touche <b>CTRL</b> (ou <b>SHIFT</b>) du clavier enfoncée (tout en sélectionnant vos images).</p><p>Dans <b>'Réglages'</b> faites les réglages du <b>'Traitement à partir de l'image (numéro)'</b> et du <b>'Nombre de chiffres après le nom de l'image' <font color='red'>(la plupart du temps les valeurs par défaut suffisent)</font></b>. Cliquez sur le bouton <b>'Voir le résultat'</b> vous voyez à ce moment là, le résultat du compositing entre la dernière image du lot de votre premier groupe d'image (images avec transparence) et la première image du lot de votre second groupe d'image (images sans transparence), s'afficher dans une nouvelle fenêtre.</p>Pour finir cliquez sur le bouton <b>'Appliquer et sauver'</b>, entrez le titre de votre futur compositing (après <b>'Nom de fichier'</b>) dans cette dernière boîte (vous aurez évidemment pris soin de sélectionner le répertoire de destination de votre compositing). Cliquez sur le bouton <b>'Enregistrer'</b>.<p>Si vous faites un clic droit de la souris (sur l'image) dans l'onglet <b>Image(s) après traitement</b>, vous accédez à des paramètres vous permettant différents affichages de la dite image. De même dans cet onglet vous pouvez lancer la visualisation des images par le bouton <b>Lancer le diaporama</b> (le bouton violet avec une flèche blanche vers la droite).</p><p>L'onglet <b>'Infos'</b> vous permet de voir le filtre utilisé, les image(s) chargée(s) et les image(s) convertie(s).</p>")) messageAide.show()
def afficherAide(self): """Boîte de dialogue de l'aide""" # Nouvelle fenêtre d'aide messageAide=EkdAide(parent=self) messageAide.setText(tr(u"<p><b>Vous pouvez ici changer la résolution (c'est à dire la taille, plus précisément la largeur et la hauteur) des images.</b></p><p><b>Dans l'onglet 'Réglages' il est possible de redimensionner les images en tenant compte du ratio, c'est à dire des proportions de chaque image (là on ne donne que la largeur, EKD se changeant de calculer la hauteur ; cela permet de ne pas déformer les images lors du changement de résolution), mais aussi de définir soi-même la taille de chaque image (en changeant à la fois la largeur et la hauteur).</b></p><p>Dans l'onglet <b>'Image(s) source'</b> cliquez sur le bouton <b>Ajouter</b>, une boîte de dialogue apparaît, sur la partie gauche sélectionnez le répertoire (au besoin dépliez les sous-répertoires), allez chercher vos image(s). Si vous voulez sélectionner plusieurs images d'un coup, maintenez la touche <b>CTRL</b> (ou <b>SHIFT</b>) du clavier enfoncée (tout en sélectionnant vos images), cliquez sur <b>Ajouter</b>.</p><p>Dans l'onglet <b>'Réglages'</b> faites les réglages du <b>'Traitement à partir de l'image (numéro)'</b> et du <b>'Nombre de chiffres après le nom de l'image' <font color='red'>(la plupart du temps les valeurs par défaut suffisent)</font></b>, ensuite sélectionnez votre <b>'Type'</b> (<b>Redimensionner en tenant compte des proportions</b> ou <b>Redimensionner sans tenir compte des proportions</b>), faites les réglages par rapport au <b>'Type'</b> choisi (vous pouvez voir en temps réel la taille de la première image du lot changer à mesure que vous réglez la <b>nouvelle largeur</b> et/ou la <b>nouvelle hauteur</b>).</p><p>En complément, vous pouvez cliquer sur le bouton <b>'Voir le résultat'</b>, vous voyez à ce moment là le résultat de vos réglages s'afficher dans une nouvelle fenêtre (particulièrement utile pour voir les déformations dues au redimensionnement pour <b>Redimensionner sans tenir compte des proportions</b>).</p><p>Une fois tout ceci fait, cliquez sur le bouton <b>'Appliquer et sauver'</b>, sélectionnez le répertoire de sauvegarde, indiquez votre <b>'Nom de fichier'</b>, cliquez sur le bouton <b>'Enregistrer'</b>.</p><p>Si vous faites un clic droit de la souris (sur l'image) dans l'onglet <b>'Images après traitement'</b>, vous accédez à des paramètres vous permettant différents affichages de la dite image. De même dans cet onglet vous pouvez lancer la visualisation des images par le bouton <b>Lancer le diaporama</b> (le bouton violet avec une flèche blanche vers la droite).</p><p>L'onglet <b>'Infos'</b> vous permet de voir les image(s) chargée(s), les image(s) convertie(s) et la nouvelle résolution des images.</p>")) messageAide.show()
def afficherAide(self): "Boîte de dialogue de l'aide" messageAide = EkdAide(parent=self) messageAide.setText(_(u"<p><b>Ici vous pouvez ajouter du texte, des cadres ou des petites images comme des logos sur des images. Cela peut être utile pour <i>signer</i> ou indiquer la provenance d'un lot d'images (avant par exemple de les diffuser sur internet).</b></p><p><b>De nombreux réglages vous sont proposés (dans l'onglet 'Réglage') afin d'inscrire et disposer comme bon vous semble du texte sur un lot d'images.</b></p>\ \ <p>Dans l'onglet <b>Image(s) source</b> cliquez sur le bouton <b>Ajouter</b>, une boîte de dialogue apparaît, sur la partie gauche sélectionnez le répertoire (au besoin dépliez les sous-répertoires), allez chercher vos image(s). Si vous voulez sélectionner plusieurs images d'un coup, maintenez la touche <b>CTRL</b> (ou <b>SHIFT</b>) du clavier enfoncée (tout en sélectionnant vos images), cliquez sur <b>Ajouter</b>. Toujours dans l'onglet <b>Image(s) source</b> sélectionnez une des miniatures.</p><p>Allez maintenant dans l'onglet <b>Réglages</b>, l'image de la miniature que vous venez de sélectionner est affichée. Vous pouvez zoomer ou dézoomer l'image avec le bouton du milieu de la souris. Dans cet onglet <b>Réglages</b> (et sur la droite), vous voyez toute une série de boutons (qui correspondent aux différentes actions que vous pouvez effectuer sur l'image ou sur le texte que vous allez écrire sur cette image). Nous allons maintenant, simplement ajouter un texte, pour ce faire cliquez sur le bouton <b>Ajouter texte</b>, la boîte de dialogue <b>Texte sur images - Ajouter texte</b> apparaît, avant d'écrire quoi que ce soit (dans le champ réservé à cet effet), faites le choix de la <b>Police</b>, de la <b>Taille</b> et de la <b>Couleur</b>, écrivez maintenant votre texte, une fois fait, cliquez sur le bouton <b>OK</b>. Vérifiez que votre texte ne dépasse pas de l'image (si cela est la cas, double-cliquez sur le texte en question, la boîte de dialogue de saisie va réapparaître) et faites ce qu'il faut ... . Vous pouvez positionner le texte sur l'image en bougeant le cadre où se trouve le texte avec la souris. Vous pouvez si vous le désirez ajouter une boîte (par le bouton <b>Ajouter Boîte</b>). Pour choisir le contour de la boîte, faites un clic droit dessus, un menu vous permettra de choisir le contour que vous désirez. En ce qui concerne la taille de la boîte, il est possible de régler la taille de celle-ci en pressant simultanément les touches <b>Shift</b> et <b>Flèche droite (ou gauche)</b> pour changer la taille en largeur, <b>Shift</b> et <b>Flèche haut (ou bas)</b> pour changer la taille en hauteur (pas besoin d'utiliser la souris pour changer la taille). Vous pouvez ajouter une image (par le bouton <b>Ajouter Image</b>), sélectionnez le chemin de votre image (puis l'image elle-même) dans la boîte de dialogue <b>Ouvrir des images</b>, cliquez sur le bouton <b>Ouvrir</b>. Certaines actions peuvent être effectuées (comme Copier, Couper, Coller, Effacer) par les boutons juste en dessous de <b>Ajouter Image</b> (positionnez votre souris sur ces boutons et il vous sera indiqué à quoi ils correspondent). Vous pouvez déplacer les éléments un à un dans la scène en cliquant dessus et en déplaçant la souris sans relacher le clic gauche (vu précédemment). Vous pouvez aussi déplacer plusieurs éléments en même temps comme expliqué précédemment mais en 'dessinant' au préalable un rectangle qui les englobera (bouton gauche de la souris maintenu en la déplaçant). L'ordre d'affichage des éléments peut-être modifié au moyen des boutons <b>Monter</b> et <b>Descendre</b>.</p><p>Sélectionnez votre format d'image (PNG, JPEG, BMP, TIFF ou PPM), c'est à dire votre extension d'image, dans la liste déroulante (tout en bas) prévue à cet effet. Dans le cas d'une sélection JPEG, n'oubliez pas de régler la <b>Qualité de l'image</b>.</p><p>Une fois tout ceci fait, cliquez sur le bouton <b>Appliquer</b>, sélectionnez le répertoire de sauvegarde, indiquez votre <b>Nom de fichier</b>, cliquez sur le bouton <b>Enregistrer</b>.</p><p>Si vous faites un clic droit de la souris (sur l'image) dans l'onglet <b>Visualisation des images créées</b>, vous accédez à des paramètres vous permettant différents affichages de la dite image. De même dans cet onglet vous pouvez lancer la visualisation des images par le bouton <b>Lancer le diaporama</b> (le bouton violet avec une flèche blanche vers la droite).</p><p>L'onglet <b>Infos</b> vous permet de voir le filtre utilisé, les image(s) chargée(s) et les image(s) convertie(s).</p>")) messageAide.show()
def afficherAide(self): """Boîte de dialogue de l'aide""" # ATTENTION _ a été mis à la place de tr car le script de mise à jour gettext (mise_a_jour_gettext.py) # ne fonctionne pas pour ekdDoc.pot avec les clés --keyword donc les nouvelles lignes vides encore # non traduites de la doc se retrouveront dans ekd.pot au lieu de ekdDoc.pot # Utilisation de EkdAide messageAide=EkdAide(parent=self) messageAide.setText(_(u"<p><b>Vous pouvez ici changer/transformer le format des images (et par là même en changer leur extension). En ce qui concerne le JPEG, vous pourrez sélectionner deux types d'extension (jpeg ou jpg), toujours pour le JPEG, vous aurez aussi la possiblité de régler la qualité (c'est à dire la compression).</b></p><p><b>Les formats pris en compte sont: JPEG, PNG, GIF, BMP, PPM, TIFF et TIF.</b></p><p>Dans l'onglet <b>'Images sources'</b> cliquez sur le bouton <b>Ajouter</b>, une boîte de dialogue apparaît, sur la partie gauche sélectionnez le répertoire (au besoin dépliez les sous-répertoires), allez chercher vos image(s). Si vous voulez sélectionner plusieurs images d'un coup, maintenez la touche <b>CTRL</b> (ou <b>SHIFT</b>) du clavier enfoncée (tout en sélectionnant vos images), cliquez sur <b>Ajouter</b>.</p><p>Dans l'onglet <b>'Réglages'</b> faites les réglages du <b>'Traitement à partir de l'image (numéro)'</b> et du <b>'Nombre de chiffres après le nom de l'image' <font color='red'>(la plupart du temps les valeurs par défaut suffisent)</b></font>, ensuite choisissez votre <b>'Type de format après traitement'</b> et réglez la <b>'Qualité'</b> (disponible uniquement si vous avez sélectionné une image JPEG en sortie). Cliquez sur le bouton <b>'Voir le résultat'</b> (vous voyez à ce moment le résultat de vos réglages sur la première image du lot s'afficher dans une nouvelle fenêtre).</p></p><p>Une fois tout ceci fait, cliquez sur le bouton <b>'Appliquer'</b>, sélectionnez le répertoire de sauvegarde, indiquez votre <b>'Nom de fichier'</b>, cliquez sur le bouton <b>'Enregistrer'</b>.</p><p>Si vous faites un clic droit de la souris (sur l'image) dans l'onglet <b>Image(s) après traitement</b>, vous accédez à des paramètres vous permettant différents affichages de la dite image. De même dans cet onglet vous pouvez lancer la visualisation des images par le bouton <b>Lancer le diaporama</b> (le bouton violet avec une flèche blanche vers la droite).</p><p>L'onglet <b>'Infos'</b> vous permet de voir le filtre utilisé, les image(s) chargée(s) et les image(s) convertie(s).</p>")) messageAide.show()
def afficherAide(self): """Boîte de dialogue de l'aide""" messageAide=EkdAide(parent=self) messageAide.setText(tr(u"<h3><center>Lire des vidéos</center></h3><p>Vous allez ici pouvoir lire une ou plusieurs vidéo(s).</p><p>Cliquez sur le bouton 'Parcourir...', dans la boîte de dialogue allez chercher votre (ou vos) vidéo(s) ... et cliquez sur le bouton juste à droite (la flèche blanche vers la droite).</p><p>Pour sélectionner plusieurs vidéos (dans la boîte de dialogue), maintenez la touche CTRL du clavier enfoncée (pour une sélection individuelle) ou bien SHIFT (pour une sélection groupée) ... tout en sélectionnant vos fichiers.</p><p>Pour certaines opérations précises, vous pouvez utiliser les raccourcis claviers suivants (pour que ces raccourcis soient opérationnels, n'oubliez pas de mettre le pointeur de votre souris sur la fenêtre de lecture):</p><h4><ul>** Les touches Alt Gr avec [ et Alt Gr avec ] diminuent/accélèrent la vitesse courante de lecture de 10% (avec la touche backspace, on revient à une vitesse de lecture normale).</ul></h4><h4><ul>** Les touches Shift avec 0 augmentent le volume et les touches Shift avec 9 diminuent le volume (pour le son). Attention pour le 0 et le 9, ce sont les chiffres à gauche du clavier (pas les touches du pavé numérique).</ul></h4><h4><ul>** Avec la touche q (ou Echap) on arrête la lecture.</ul></h4>")) messageAide.show()
class MusiqueSon_normalize(Base):
# -----------------------------------
# Cadre accueillant les widgets de :
# Musique-Son >> Encodage
# -----------------------------------
def __init__(self, parent):
# -------------------------------
# Parametres généraux du widget
# -------------------------------
self.config=EkdConfig
self.parent = parent
#=== Identifiant de la classe ===#
self.idSection = "son_normaliser_convertir_musique_ou_son"
super(MusiqueSon_normalize, self).__init__(None, None, None, 'vbox') # Base module de animation
self.setTitle(_(u"Normaliser et convertir un fichier audio"))
self.printSection()
#------------------------------------------------------------------------
# TabWidget pour les réglages et pour l'écoute du résultat
#------------------------------------------------------------------------
extFormat=[]
for fmt in self.parent.soxSuppFormat :
extFormat.append("*."+fmt)
# Widget standard de sélection de fichier audio dans le tab standard
self.selectionAudioFile = SelectWidget(extensions = extFormat, mode="texte", audio = True)
# Onglets
self.tab.insertTab(0,self.selectionAudioFile, _(u'Son(s) source'))
self.connect(self.selectionAudioFile,SIGNAL("fileSelected"),self.synchroFiles)
self.connect(self.selectionAudioFile, SIGNAL("pictureChanged(int)"), self.synchroFiles)
## ---------------------------------------------------------------------
# Variables pour la fonction tampon
## ---------------------------------------------------------------------
self.typeEntree = "audio" # Défini le type de fichier source.
self.typeSortie = "audio" # Défini le type de fichier de sortie.
self.sourceEntrees = self.selectionAudioFile # Fait le lien avec le sélecteur de fichier source.
# -------------------------------------------------------------------
# Sélection et affichage des fichiers à joindre : "Fichiers audio source"
# -------------------------------------------------------------------
reglage = QWidget()
regVLayout = QVBoxLayout(reglage)
self.selectionFile = choixSonSortieWidget(self.parent.soxSuppFormat, parent=self)
regVLayout.addWidget(self.selectionFile)
niveau = QGroupBox(_(u"Choix du niveau"))
self.choix1 = QRadioButton(_(u"- 3 dB"))
self.choix2 = QRadioButton(_(u"- 6 dB"))
self.choix3 = QRadioButton(_(u"- 9 dB"))
self.choix1.setChecked(True)
nivLayout = QHBoxLayout()
nivLayout.addWidget(self.choix1)
nivLayout.addWidget(self.choix2)
nivLayout.addWidget(self.choix3)
niveau.setLayout(nivLayout)
regVLayout.addWidget(niveau)
mode = QGroupBox(_(u"Choix du mode de normalisation"))
self.choixm1 = QRadioButton(_(u"Standard"))
self.choixm2 = QRadioButton(_(u"Individuel"))
self.choixm3 = QRadioButton(_(u"Balancé"))
self.choixm1.setChecked(True)
modeLayout = QHBoxLayout()
modeLayout.addWidget(self.choixm1)
modeLayout.addWidget(self.choixm2)
modeLayout.addWidget(self.choixm3)
mode.setLayout(modeLayout)
regVLayout.addWidget(mode)
regVLayout.addStretch()
self.tab.addTab(reglage,_(u"Réglage"))
#------------------------------------------------------------------------
# Ecoute du résultat
#------------------------------------------------------------------------
#=== Widgets mplayer ===#
widget = QWidget()
vboxMplayer = QVBoxLayout(widget)
vboxMplayer.addStretch()
hbox = QHBoxLayout()
vboxMplayer.addLayout(hbox)
hbox.addStretch()
self.mplayer=Mplayer(taille=(300,270), facteurLimitant=Mplayer.LARGEUR,
choixWidget=(Mplayer.PAS_PRECEDENT_SUIVANT,Mplayer.CURSEUR_A_PART))
self.mplayer.setAudio(True)
hbox.addWidget(self.mplayer)
hbox.addStretch()
vboxMplayer.addStretch()
self.mplayer.setEnabled(False)
self.tab.addTab(widget, _(u"Son créé"))
### pour les infos supplémentaires
self.addLog()
# -------------------------------------------------------------------
# widgets du bas : ligne + boutons Aide et Appliquer
# -------------------------------------------------------------------
def synchroFiles(self):
if len(self.selectionAudioFile.getFiles()) > 0 :
self.boutApp.setEnabled(True)
else :
self.boutApp.setEnabled(False)
def endProcess(self, sortie) :
self.mplayer.setEnabled(True)
self.mplayer.listeVideos = [sortie]
self.tab.setCurrentIndex(1)
self.infoLog(None, None, self.selectionAudioFile.getFile(), sortie)
def afficherAide(self):
""" Boîte de dialogue de l'aide """
self.aide = EkdAide(550,400,self)
self.aide.setText(_(u"<p><b>Ici vous pouvez normaliser des fichiers audio, c'est à dire ajuster leur volume sonore. Voici une définition selon Wikipédia de la normalisation audio:<br>http://fr.wikipedia.org/wiki/Normalisation_audio</b></p><p>Dans l'onglet <b>Son(s) source</b> cliquez sur le bouton <b>Ajouter</b>, une boîte de dialogue apparaît, sur la partie gauche sélectionnez le répertoire (au besoin dépliez les sous-répertoires), allez chercher la/les fichiers(s) audio. Si vous voulez sélectionner plusieurs fichiers audio d'un coup, maintenez la touche <b>CTRL</b> (ou <b>SHIFT</b>) du clavier enfoncée (tout en sélectionnant vos fichiers audio), cliquez sur <b>Ajouter</b>.</p><p>Vous pouvez dès lors sélectionner un fichier audio dans la liste et le lire (par le bouton juste à la droite de cette liste). De même si vous le désirez, vous pouvez obtenir des informations complètes sur le fichier audio sélectionné, et ce par le bouton <b>Infos</b> (en bas).</p><p>Dans l'onglet <b>Réglages</b> sélectionnez le <b>Format du fichier de sortie</b>, et s'il le faut <b>Réglage expert</b> et faites éventuellement le réglage de la <b>Qualité d'encodage</b>, puis réglez le <b>Choix du niveau</b> et le <b>Choix du mode de normalisation</b>.</p><p>Une fois tout ceci fait, cliquez sur le bouton <b>Appliquer</b>, sélectionnez le répertoire de sauvegarde, indiquez votre <b>Nom de fichier</b>, cliquez sur le bouton <b>Enregistrer</b> et attendez le temps de la conversion. A la fin du traitement cliquez sur le bouton <b>Fermer</b> de la fenêtre <b>Affichage de la progression</b>.</p><p>Dans l'onglet <b>Son créé</b> vous pouvez lire le résultat.</p><p>L'onglet <b>Infos</b> vous permet de voir les fichiers audio chargés (avec leurs chemins exacts) avant et après conversion.</p>"))
self.aide.show()
def appliquer(self):
""" appelle la boite de dialogue de sélection de fichier à sauver """
suffixSortie = u"."+self.selectionFile.getFileExt()
saveDialog = EkdSaveDialog(self, mode="audio", suffix=suffixSortie, title=_(u"Sauver"))
cheminAudioSorti = saveDialog.getFile()
if not cheminAudioSorti: return
# récupération du chemin des fichiers audio source
cheminAudioSource=self.selectionAudioFile.getFile()
# suffix du fichier actif
suffix=os.path.splitext(cheminAudioSource)[1]
if suffix == u".mp3" or suffix == u".MP3" :
chemin = u"-t mp3 \""+cheminAudioSource+u"\""
elif suffix == u".ogg" or suffix == u".OGG" :
chemin = u"-t ogg \""+cheminAudioSource+u"\""
elif suffix == u".mp2" or suffix == u".MP2" :
chemin = u"-t mp2 \""+cheminAudioSource+u"\""
elif suffix == u".flac" or suffix == u".FLAC" :
chemin = u"-t flac \""+cheminAudioSource+u"\""
else :
chemin = u"\""+cheminAudioSource+u"\""
# Définition des options
if self.choix1.isChecked() :
db = " -3 "
if self.choix2.isChecked() :
db = " -6 "
if self.choix3.isChecked() :
db = " -9 "
if self.choixm1.isChecked() :
mde = ""
if self.choixm2.isChecked() :
mde = "-i"
if self.choixm3.isChecked() :
mde = "-b"
option = "norm "+mde+db
if self.selectionFile.reglageExp.getExpertState() :
regExp = self.selectionFile.reglageExp.getC()
else :
regExp = u""
# Encodage
self.process = SoxProcess(chemin, cheminAudioSorti, 1, u"", u""+regExp, option, self.parent)
self.process.setSignal(u"Input",u"In:")
self.process.show()
self.process.run()
self.connect(self.process,SIGNAL("endProcess"),self.endProcess)
def load(self) :
self.selectionAudioFile.loadFileLocation(self.idSection)
self.selectionFile.reglageExp.loadConfig(self.idSection)
self.choix1.setChecked(int(EkdConfig.get(self.idSection, 'choix1')))
self.choix2.setChecked(int(EkdConfig.get(self.idSection, 'choix2')))
self.choix3.setChecked(int(EkdConfig.get(self.idSection, 'choix3')))
self.choixm1.setChecked(int(EkdConfig.get(self.idSection, 'choixm1')))
self.choixm2.setChecked(int(EkdConfig.get(self.idSection, 'choixm2')))
self.choixm3.setChecked(int(EkdConfig.get(self.idSection, 'choixm3')))
def save(self) :
self.selectionAudioFile.saveFileLocation(self.idSection)
self.selectionFile.reglageExp.saveConfig(self.idSection)
EkdConfig.set(self.idSection, u'choix1', unicode(int(self.choix1.isChecked())))
EkdConfig.set(self.idSection, u'choix2', unicode(int(self.choix2.isChecked())))
EkdConfig.set(self.idSection, u'choix3', unicode(int(self.choix3.isChecked())))
EkdConfig.set(self.idSection, u'choixm1', unicode(int(self.choixm1.isChecked())))
EkdConfig.set(self.idSection, u'choixm2', unicode(int(self.choixm2.isChecked())))
EkdConfig.set(self.idSection, u'choixm3', unicode(int(self.choixm3.isChecked())))
class MusiqueSon_Join(Base):
# -----------------------------------
# Cadre accueillant les widgets de :
# Musique-Son >> Encodage
# -----------------------------------
def __init__(self, parent):
#=== Variable de configuration ===#
self.config=EkdConfig
self.parent = parent
#=== Identifiant de la classe ===#
self.idSection = "son_joindre_multiple_fichier_audio"
super(MusiqueSon_Join, self).__init__(None, None, None, 'vbox') # module de animation
self.setTitle(_(u"Joindre plusieurs fichiers audio"))
self.printSection()
#------------------------------------------------------------------------
# TabWidget pour les réglages et pour l'écoute du résultat
#------------------------------------------------------------------------
extFormat=[]
for fmt in self.parent.soxSuppFormat :
extFormat.append("*."+fmt)
# Widget standard de sélection de fichier audio dans le tab standard
self.selectionAudioFile = SelectWidget(extensions = extFormat, mode="texte", audio = True)
# Onglets
self.tab.insertTab(0,self.selectionAudioFile, _(u'Son(s) source'))
self.connect(self.selectionAudioFile,SIGNAL("fileSelected"),self.synchroFiles)
self.connect(self.selectionAudioFile, SIGNAL("pictureChanged(int)"), self.synchroFiles)
## ---------------------------------------------------------------------
# Variables pour la fonction tampon
## ---------------------------------------------------------------------
self.typeEntree = "audio" # Défini le type de fichier source.
self.typeSortie = "audio" # Défini le type de fichier de sortie.
self.sourceEntrees = self.selectionAudioFile # Fait le lien avec le sélecteur de fichier source.
# -------------------------------------------------------------------
# Sélection et affichage des fichiers à joindre : "Fichiers audio source"
# -------------------------------------------------------------------
self.selectionFile = selectJoinMultipleSound(exp=1, parent=self)
self.tab.addTab(self.selectionFile,_(u"Réglage"))
#------------------------------------------------------------------------
# Ecoute du résultat
#------------------------------------------------------------------------
#=== Widgets mplayer ===#
widget = QWidget()
vboxMplayer = QVBoxLayout(widget)
vboxMplayer.addStretch()
hbox = QHBoxLayout()
vboxMplayer.addLayout(hbox)
hbox.addStretch()
self.mplayer=Mplayer(taille=(300,270), facteurLimitant=Mplayer.LARGEUR,
choixWidget=(Mplayer.PAS_PRECEDENT_SUIVANT,Mplayer.CURSEUR_A_PART))#
self.mplayer.setAudio(True)
hbox.addWidget(self.mplayer)
hbox.addStretch()
vboxMplayer.addStretch()
self.mplayer.setEnabled(False)
self.tab.addTab(widget, _(u"Son créé"))
### report d'informations à la fin du process
self.addLog()
# -------------------------------------------------------------------
# widgets du bas : ligne + boutons Aide et Appliquer
# -------------------------------------------------------------------
# Aide
def synchroFiles(self):
'''
# On utilise la nouvelle interface de récupération des fichiers audio
'''
chemins = self.selectionAudioFile.getFiles()
self.selectionFile.addSoundAction(chemins)
self.selectionFile.delFile(chemins)
def encodAudioWav(self, nfile, cheminAudioSource, cheminAudioSorti) :
""" Joindre et encoder les fichiers audio """
if self.selectionFile.choixFormatAudio.reglageExp.getExpertState() :
regExp = self.selectionFile.choixFormatAudio.reglageExp.getC()
else :
regExp = u""
self.process = soxProcessMulti(cheminAudioSource, cheminAudioSorti, regExp, self.parent)
self.process.show()
self.process.run()
self.connect(self.process,SIGNAL("endProcess"),self.endProcess)
def endProcess(self, sortie) :
self.mplayer.setEnabled(True)
self.mplayer.listeVideos = sortie
self.tab.setCurrentIndex(2)
### Info sur le traitement effectué.
self.infoLog(None, None, self.selectionFile.getListFile(), sortie)
def afficherAide(self):
""" Boîte de dialogue de l'aide """
self.aide = EkdAide(550,400,self)
self.aide.setText(_(u"<p><b>Ce module permet de joindre plusieurs fichiers son à la suite dans un fichier de sortie. EKD peut assembler des fichiers audio de diférentes nature (extensions).</b></p><p><b>Il est à noter ici que vous bénéficiez d'un traitement par lot, c'est à dire que tous les fichiers que vous allez charger seront traités (et pas seulement le fichier sélectionné).</b></p><p>Dans l'onglet <b>Son(s) source</b> cliquez sur le bouton <b>Ajouter</b>, une boîte de dialogue apparaît, sur la partie gauche sélectionnez le répertoire (au besoin dépliez les sous-répertoires), allez chercher la/les fichiers(s) audio. Si vous voulez sélectionner plusieurs fichiers audio d'un coup, maintenez la touche <b>CTRL</b> (ou <b>SHIFT</b>) du clavier enfoncée (tout en sélectionnant vos fichiers audio), cliquez sur <b>Ajouter</b>.</p><p>Vous pouvez dès lors sélectionner un fichier audio dans la liste et le lire (par le bouton juste à la droite de cette liste). De même si vous le désirez, vous pouvez obtenir des informations complètes sur le fichier audio sélectionné, et ce par le bouton <b>Infos</b> (en bas).</p><p>Dans l'onglet <b>Réglages</b> sélectionnez le <b>Format du fichier de sortie</b>, et s'il le faut <b>Réglage expert</b> et faites éventuellement le réglage de la <b>Qualité d'encodage</b>. Dans ce même onglet vous pouvez changer l'ordre de montage des fichiers et ce en remontant ou en redéscendant (par les flèches haut et bas) dans la <b>Liste des fichiers à joindre</b>. Pour information les fichiers apparaissant en haut de la liste sont ceux qui seront au début du montage.</p><p>Une fois tout ceci fait, cliquez sur le bouton <b>Appliquer</b>, sélectionnez le répertoire de sauvegarde, indiquez votre <b>Nom de fichier</b>, cliquez sur le bouton <b>Enregistrer</b> et attendez le temps de la conversion. A la fin du traitement cliquez sur le bouton <b>Fermer</b> de la fenêtre <b>Affichage de la progression</b>.</p><p>Dans l'onglet <b>Son créé</b> vous pouvez lire le résultat.</p><p>L'onglet <b>Infos</b> vous permet de voir les fichiers audio chargés (avec leurs chemins exacts) avant et après conversion.</p>"))
self.aide.show()
def appliquer(self):
""" appelle la boite de dialogue de sélection de fichier à sauver """
#=== Détermination des chemins d'entrée et sortie ===#
# récupération du chemin du fichier audio de destination (à l'exception de l'extension)
suffixSortie = u"."+self.selectionFile.getFileExt()
saveDialog = EkdSaveDialog(self, mode="audio", suffix=suffixSortie, title=_(u"Sauver"))
self.cheminAudioSorti = saveDialog.getFile()
if not self.cheminAudioSorti: return
# récupération du nombre de fichier audio à joindre
nfile = self.selectionFile.getNumFile()
# Encodage
self.encodAudioWav(nfile, self.selectionFile.getListFile(), self.cheminAudioSorti)
def load(self) :
self.selectionAudioFile.loadFileLocation(self.idSection)
self.selectionFile.choixFormatAudio.reglageExp.loadConfig(self.idSection)
files = eval(EkdConfig.get(self.idSection, 'ordre'))
#print "[Debug] Chargement des fichiers |",files,"| de la section :",idsection
self.selectionFile.setListSource(files)
def save(self) :
self.selectionAudioFile.saveFileLocation(self.idSection)
self.selectionFile.choixFormatAudio.reglageExp.saveConfig(self.idSection)
files = self.selectionFile.getListFile()
if files != None :
EkdConfig.set(self.idSection, u'ordre', files)
def afficherAide(self,msg=None):
""" Boîte de dialogue de l'aide"""
if not msg: _(u"Message d'aide")
message=EkdAide(parent=self)
message.setText(msg)
message.show()
class MusiqueSon_decoupe(Animation_MontagVideoDecoupUneVideo):
"""Class pour la découpe de fichier son. Class dérivée de celle permettant de découper une vidéo dans le module animation"""
# -----------------------------------
# Cadre accueillant les widgets de :
# Musique-Son >> Encodage
# -----------------------------------
def __init__(self, parent):
super(MusiqueSon_decoupe, self).__init__(parent)
# Vérification des possibilités de Sox pour l'encodage
self.setTitle(_(u"Découpe de musiques et de sons"))
self.parent = parent
# -------------------------------
# Divergeances par rapport à la class Musique Son_decoupe
# -------------------------------
self.idSection = "son_decoupe_musiques_et_sons"
# -------------------------------------------------------------------
# Boîte de groupe : "Fichier audio source"
# -------------------------------------------------------------------
self.radioSource.setText(_(u"Fichier son source"))
self.radioConvert.setText(_(u"Son final"))
self.mplayer.cibleVideo.hide()
self.mplayer.conf.hide()
self.mplayer.setToolTip(_(u"La lecture du fichier audio est nécessaire pour achever la sélection d'une zone de la piste audio"))
self.boutExtractionSon.hide()
### Option de fade in / fade out sur le son decoupe
hlbox = QHBoxLayout()
self.fadeIn = QCheckBox(_(u"Fade in"))
self.fadeIn.setDisabled(True)
self.fadeInTime = QDoubleSpinBox()
self.fadeInTime.setDecimals(3)
self.fadeInTime.setRange(0.500, 5.000)
self.fadeInTime.setValue(1.000)
self.fadeInTime.setDisabled(True)
self.fadeOut = QCheckBox(_(u"Fade out"))
self.fadeOut.setDisabled(True)
self.fadeOutTime = QDoubleSpinBox()
self.fadeOutTime.setDecimals(3)
self.fadeOutTime.setRange(0.500, 5.000)
self.fadeOutTime.setValue(1.000)
self.fadeOutTime.setDisabled(True)
self.boutMarqFinSelect_max.setToolTip(_(u"Marquer la fin de la sélection au temps maximum (t=\"la durée de la piste audio\")"))
hlbox.addStretch(100)
hlbox.addWidget(self.fadeIn)
hlbox.addWidget(self.fadeInTime)
hlbox.addStretch(20)
hlbox.addWidget(self.fadeOut)
hlbox.addWidget(self.fadeOutTime)
hlbox.addStretch(100)
self.layoutReglage.insertLayout(3,hlbox)
### Pour n'activer les QDoubleSpinBox que lorsque les QCheckBox correspondantes
### sont activees.
self.connect(self.fadeIn, SIGNAL("stateChanged(int)"), self.fadeInTime.setEnabled)
self.connect(self.fadeOut, SIGNAL("stateChanged(int)"), self.fadeOutTime.setEnabled)
### Zone de selection du format de sortie de fichier
hbox = QHBoxLayout()
# Utilisation du widget choixSonSortieWidget
self.choixFormatAudio = choixSonSortieWidget(self.parent.soxSuppFormat, parent=self)
extFormat=[]
for fmt in self.parent.soxSuppFormat :
extFormat.append("*."+fmt)
hbox.addWidget(self.choixFormatAudio)
self.layoutReglage.insertLayout(0,hbox)
#-------------------------------------------------------------------
# Modification de la nouvelle interface d'ajout des videos pour l'adapter aux fichiers son
self.afficheurVideoSource=SelectWidget(extensions = extFormat, mode="texte", audio = True)
# Onglets
self.tab.removeTab(0)
self.indexVideoSource = self.tab.insertTab(0,self.afficheurVideoSource, _(u'Son(s) source'))
self.connect(self.afficheurVideoSource,SIGNAL("fileSelected"),self.getFile)
self.connect(self.afficheurVideoSource, SIGNAL("pictureChanged(int)"), self.getFile)
#--------------------------------------------------------------------
self.tab.setCurrentIndex(0)
## ---------------------------------------------------------------------
# Variables pour la fonction tampon
## ---------------------------------------------------------------------
self.typeEntree = "audio" # Défini le type de fichier source.
self.typeSortie = "audio" # Défini le type de fichier de sortie.
self.sourceEntrees = self.afficheurVideoSource # Fait le lien avec le sélecteur de fichier source.
def getFile(self):
'''
# Modifié par rapport à la fonction getFile de la class decoupe_video
On utilise la nouvelle interface de récupération des fichiers sources slectionnés
'''
self.chemin = unicode(self.afficheurVideoSource.getFile())
if not self.chemin:
### Desactive les options si pas de fichier d'entree introduit.
self.fadeIn.setDisabled(True)
self.fadeInTime.setDisabled(True)
self.fadeOut.setDisabled(True)
self.fadeOutTime.setDisabled(True)
return
# Affichage du chemin + nom de fichier dans la ligne d'édition
self.mplayer.setEnabled(True)
self.mplayer.listeVideos = [self.chemin]
self.radioSource.setChecked(True)
self.radioSource.setEnabled(True)
self.radioConvert.setChecked(False)
self.radioApercu.setChecked(False)
self.fadeIn.setEnabled(True)
self.fadeOut.setEnabled(True)
self.miseAZeroSelect()
# les boutons de marquage apparaissent
self.frameMarque.setEnabled(True)
def afficherAide(self):
""" Boîte de dialogue de l'aide """
self.aide = EkdAide(550,280,self)
self.aide.setText(_(u"""<p><b>Vous pouvez ici découper un fichier audio et ainsi en garder uniquement la partie qui vous intéresse.</b></p><p><font color='green'>Ce cadre est assez différent des autres, vous avez tout d'abord la zone d'écoute audio, comprenant les boutons marche, arrêt et le compteur, la glissière de défilement, la zone d'affichage de la découpe (les parties découpées seront affichées en vert), les boutons début/fin de sélection, remise à zéro, à la doite de ce dernier bouton, vous avez trois minuscules boutons contenant +, = et - (ils servent à accélérer ou diminuer la vitesse de lecture du fichier audio), une première case à cocher <b>Fade in</b> (qui peut appliquer un effet de fondu au début de la découpe du son), juste à la droite, le réglage du fondu, une deuxième case à cocher <b>Fade out</b> (qui peut appliquer un effet de fondu à la fin de la découpe du son), le réglage du fondu correspondant, puis les choix d'écoute <b>Fichier son source</b>, <b>aperçu</b> et <b>Son final</b>.</font></p><p><b>Tout ce qui vient de vous être décrit se trouve dans l'onglet Réglages</b>.</p><p>Dans l'onglet <b>Son(s) source</b> cliquez sur le bouton <b>Ajouter</b>, une boîte de dialogue apparaît, sur la partie gauche sélectionnez le répertoire (au besoin dépliez les sous-répertoires), allez chercher la/les fichier(s) audio. Si vous voulez sélectionner plusieurs fichiers audio d'un coup, maintenez la touche <b>CTRL</b> (ou <b>SHIFT</b>) du clavier enfoncée (tout en sélectionnant vos fichiers), cliquez sur <b>Ajouter</b>.</p><p>Vous pouvez dès lors sélectionner un fichier audio dans la liste et l'écouter (par le bouton juste à la droite de cette liste). De même si vous le désirez, vous pouvez obtenir des informations complètes sur le fichier audio sélectionné, et ce par le bouton <b>Infos</b> (en bas).</p><p>Dans l'onglet <b>Réglages</b>, lancez l'écoute du fichier audio (par le bouton avec la flèche orientée vers la droite <b>La lecture du fichier audio est nécessaire ...</b>), pour la vitesse de lecture, profitez des boutons + ou - pour augmenter ou diminuer la vitesse de lecture <b>(plus vous diminuez la vitesse de lecture, plus la découpe pourra se faire de façon précise)</b>, cliquez ensuite sur le bouton <b>Marquer le début de la sélection</b> ou <b>Marquer le début de la sélection au temps minimum (t=0)</b> (pour sélectionner le fichier audio à son tout début), laissez jouer (écoutez la musique ou le son) et cliquez sur le bouton <b>Marquer la fin de la sélection</b> au moment propice (ou <b>Marquer la fin de la sélection au temps maximum t="la durée du fichier audio"</b> pour garder le dit fichier audio jusqu'à la fin).</p><p><font color='blue'>Sachez que vous pouvez revenir aux paramètres par défaut en cliquant sur le bouton <b>Remettre à zéro les paramètres</b> (les deux flèches vertes inversées), vous devrez alors rejouer le fichier audio et recommencer vos différentes sélections.</font></p><p>Cliquez sur le bouton <b>Appliquer</b>, sélectionnez le répertoire de sauvegarde de votre fichier audio, entrez le <b>Nom de Fichier</b> dans le champ de texte réservé à cet effet ... cliquez sur le bouton <b>Enregistrer</b> et attendez le temps de la conversion. A la fin du traitement cliquez sur le bouton <b>Fermer</b> de la fenêtre <b>Affichage de la progression</b>.</p><p>Vous pouvez visionner votre fichier audio (avant la conversion) en sélectionnant <b>Fichier son source</b>, après la conversion <b>Son final</b>.</p><p>L'onglet <b>Infos</b> vous permet de voir les fichiers audio chargés (avec leurs chemins exacts) avant et après conversion.</p>"""))
self.aide.show()
def tempsToHMSMS(self,sec) :
"""Fonction de conversion du temps en seconde vers le temps en HH:MM:SS.MSE"""
heure = int(sec/3600.0)
minute = int((sec-heure*3600.0)/60.0)
seconde = int(sec-heure*3600.0-minute*60.0)
millisec = int((sec-heure*3600.0-minute*60.0-seconde)*1000.0)
return u"%02d:%02d:%02d.%d" % (heure, minute, seconde, millisec)
def appliquer(self):
"""Découpage du fichier son"""
# suffix du fichier actif
suffix=os.path.splitext(self.chemin)[1]
if suffix == u".mp3" or suffix == u".MP3" :
chemin = u"-t mp3 \""+self.chemin+u"\""
elif suffix == u".ogg" or suffix == u".OGG" :
chemin = u"-t ogg \""+self.chemin+u"\""
elif suffix == u".mp2" or suffix == u".MP2" :
chemin = u"-t mp2 \""+self.chemin+u"\""
elif suffix == u".flac" or suffix == u".FLAC" :
chemin = u"-t flac \""+self.chemin+u"\""
else :
chemin = u"\""+self.chemin+u"\""
suffixSortie = u".%s" % (self.parent.soxSuppFormat[self.choixFormatAudio.formatSound.currentIndex()])
saveDialog = EkdSaveDialog(self, os.path.expanduser(self.repSortieProv()), suffixSortie, _(u"Sauver"))
self.fichierSortie = saveDialog.getFile()
if not self.fichierSortie: return
tempsDebut = self.tempsToHMSMS(self.valeurDebut)
dureeSelection = self.tempsToHMSMS(self.valeurFin - self.valeurDebut)
if (self.fadeIn.isChecked() and self.fadeIn.isEnabled()) or \
(self.fadeOut.isChecked() and self.fadeOut.isEnabled()):
if self.fadeIn.isChecked() and self.fadeIn.isEnabled() :
fadeIn = u"00:00:0%f" % (self.fadeInTime.value())
else :
fadeIn = u"00:00:00.000"
if self.fadeOut.isChecked() and self.fadeOut.isEnabled() :
fadeOut = u"00:00:0%f" % (self.fadeOutTime.value())
else :
fadeOut = u"00:00:00.000"
fadeOption = u"fade %s %s %s" % (fadeIn, dureeSelection, fadeOut)
else :
fadeOption = u""
### Pour le debugage
print "extension :", suffix, type(suffix)
print "début : ", self.valeurDebut
print "fin : ", self.valeurFin
print "temps début formaté : ", dureeSelection
print "durée : ", dureeSelection
print "Input file : ", chemin
print "Fichier de sortie : ", self.fichierSortie
print u"option : trim %s %s" %(tempsDebut, dureeSelection)
if self.choixFormatAudio.reglageExp.getExpertState() :
optSortie = self.choixFormatAudio.reglageExp.getC()
else :
optSortie = u""
### Encodage avec le module soxProcess
self.process = SoxProcess(chemin, self.fichierSortie, 1, u"", optSortie, u"trim %s %s %s" %(tempsDebut, dureeSelection, fadeOption))
self.process.setSignal("Input","In:")
self.process.show()
self.process.run()
self.connect(self.process,SIGNAL("endProcess"),self.endProcess)
def endProcess(self, sortie) :
"""Actions à réaliser lors de la fin du processus d'encodage si celui-ci se termine correctement"""
self.radioSource.setEnabled(True)
self.radioConvert.setEnabled(True)
### Info sur le traitement effectué.
self.infoLog(None, None, self.chemin, self.fichierSortie)
def load(self) :
self.loadFiles()
self.choixFormatAudio.reglageExp.loadConfig(self.idSection)
def save(self) :
self.saveFiles()
self.choixFormatAudio.reglageExp.saveConfig(self.idSection)
def afficherAide(self):
"""Boîte de dialogue de l'aide du cadre"""
message = EkdAide(parent=self)
message.setText(_(u"Message d'aide à compléter")) ### TODO : Définir le texte d'aide à afficher
message.show()
class Videoporama_Main(Base) : #OK QT4
def __init__(self, verifsformats, parent=None):
super(Videoporama_Main, self).__init__(boite='vbox', titre=_(u"Diaporama d'images en vidéo"))
#=== Drapeaux ===#
# Une conversion (même partielle) a-t-elle eu lieu après le chargement des images? (1: vrai)
# Est-ce que des images sources ont été modifiées? (c'est-à-dire ajoutées ou supprimées)
self.modifImageSource = 0
# Fonction appelant la fenêtre principale
self.mainWindowFrameGeometry = parent.frameGeometry
layout = QVBoxLayout()
self.tabW=QTabWidget()
self.afficheurImgSource=SelectWidget(geometrie = self.mainWindowFrameGeometry)
self.dicoTab = {}
self.dicoTab['images']=self.add(self.afficheurImgSource, _(u'Image(s) source(s)'))
self.idSection = 'videoporama'
## ---------------------------------------------------------------------
# Variables pour la fonction tampon
## ---------------------------------------------------------------------
self.typeEntree = "image" # Défini le type de fichier source.
self.typeSortie = "video" # Défini le type de fichier de sortie.
self.sourceEntrees = self.afficheurImgSource # Fait le lien avec le sélecteur de fichier source.
#=== Widget réglages videoporama ===#
self.vid_widg=vid_widg(verifsformats, parent) # Class vid_widg est dans videoporama_widget.py
self.add(self.vid_widg,_(u"Réglages"))
self.addPreview(light=True)
self.addLog()
#----------------------------------------------------------------------------------------------------
# Signal de présence d'images dans ler widget de sélection -> modifie le statut des boutons d'action
#----------------------------------------------------------------------------------------------------
self.connect(self.afficheurImgSource, SIGNAL("pictureChanged(int)"), self.modifBoutonsAction)
def saveprj(self, url) :
self.vid_widg.saveprojet(url)
def loadprj(self,url) :
self.vid_widg.affichedata(url,n=1,disp=self.afficheurImgSource)
if self.vid_widg.timeline.columnCount() > 0 :
self.boutApp.setEnabled(1)
def load(self) :
print "Diaporama"
def save(self) :
print "Diaporama"
def empty(self) :
self.afficheurImgSource.toutSupprimer()
def modifBoutonsAction(self, i):
"""On active ou désactive les boutons d'action selon s'il y a des images ou pas dans le widget de sélection
Transfert et synchronisation des images vers la timeline de videoporama"""
self.boutApp.setEnabled(i)
if i :
self.modifImageSource = 1
lfiles=self.afficheurImgSource.getFiles()
tlfiles=self.vid_widg.getFilesList()
z=0
for F in tlfiles :
if F in lfiles :
lfiles.remove(F)
z+=1
else :
self.vid_widg.delete(z)
self.vid_widg.add2(lfiles)
else :
self.modifImageSource = 0
self.vid_widg.empty()
def appliquer(self) :
""" Démarrage du processus d'encodage des images en diaporama vidéo"""
format=self.vid_widg.data.getElementsByTagName('outputf')[0].childNodes[0].nodeValue
filter=u"."+self.vid_widg.verifsformats[5][int(format)][2]
print "DEBUG : Format du fichier : ", format, "Filter : ", filter
# XXX Check that the output directory is correctly set.
saveDialog = EkdSaveDialog(self, mode="video", suffix=filter, title=_(u"Sauver"))
self.outputfile = saveDialog.getFile()
if not self.outputfile : return
self.vid_widg.updatexml(self.vid_widg.data,"outputfile",self.outputfile)
self.vid_widg.process()
self.connect(self.vid_widg.prc, SIGNAL("resProcess"), self.activideo)
def activideo(self,ofile, image=None, video=None, audio=None, sortie=None) :
""" visualisation de la video finalisée """
self.mplayer.listeVideos = [ofile]
self.mplayer.setEnabled(True)
self.tabW.setCurrentIndex(2)
self.infoLog(image, video, audio, sortie)
def afficherAide(self) :
""" Boîte de dialogue d'aide """
self.aide = EkdAide(600,700,self)
self.aide.setText(_(u"<p><b>Le module diaporama permet de créer des fichiers vidéo de diaporama à partir d'images fixes. Selon la définition de Wikipédia: 'Un diaporama est un spectacle de projection de diapositives ; par extension on entend par ce terme toute suite d'images ou de documents reliés par des effets et, sur lesquels il est possible de mettre du son.'. Source:<br>http://fr.wikipedia.org/wiki/Diaporama</b></p>\
<p>La composition d'un diaporama se passe en 5 étapes principales : \
<ol> \
<li>Sélection des images sources : Ceci est réalisé dans l'onglet \"Image(s) source(s))\".</li> \
<li>Définition de l'ordre d'apparition des images dans le diaporama : Cette opération se fait dans l'onglet \"réglages\". L'ordre d'apparition des images est celui de la ligne du temps dans laquelle se retrouve les miniatures des images à traiter. Pour changer l'ordre, il suffit de sélectionner l'image à déplacer et de la déplacer au moyen des icônes avec les flèches gauche ou droite.</li> \
<li>Réglages sur le montage : Cette étape est réalisée dans le premier onglet de la zone d'option (onglet \"Options du montage\"). Il faut alors définir le format d'image, la résolution de la vidéo de sortie, le format et l'éventuelle bande son (fichier) à ajouter au montage.</li> \
<li>Réglages spécifiques par image : Ces réglages sont réalisés dans les 3 derniers onglets de la zone de réglage (\"Image\", \"Texte\" et \"Zoom et survol\"). Pour changer les réglages d'une image, il faut d'abord la sélectionner dans la ligne du temps. L'image sélectionnée est alors affichée dans la zone de prévisualisation. Dans l'onglet \"Image\" il est possible de définir le temps d'affichage de l'image dans le diaporama (en seconde), d'ajouter une couleur ou une image de fond (pour les images orientées en portrait) et de défini l'effet de transition qui sera effectué entre l'image sélectionnée et l'image suivante. Dans l'onglet \"Texte\", il est possible d'ajouter un ou plusieurs texte(s) sur l'image et enfin dans l'onglet \"Zoom et survol\" il est possible de définir les caractéristiques d'un survol de l'image de départ entre une sélection dans l'image (appelée image de départ) et une autre sélection (appelée image de fin).</li> \
<li>Pour réaliser le montage, il reste à appuyer sur le bouton \"Appliquer\" et attendre la fin e l'encodage. Le résultat peut ensuite être visualisé dans l'onglet \"Vidéo créée\".</li></ol><\p> \
<p>Une aide plus détaillée sur ce module est également disponible dans le répertoire ekd/videoporama/help</p>"))
self.aide.show()