Ubuntu-fr

Doppler

Encoder facilement ses films pour PSP

Hello,

Une petite astuce que l'on doit à Monsieur Müller (aka Zhorglub) et qui simplifie bien la vie.

Éléments requis:
- Une version de ffmpeg qui sache encoder le son en AAC
(soit on compile une version qui peut le faire, soit on a Feisty et on doit juste installer ffmpeg depuis synaptic ou adept, cf: http://doc.ubuntu-fr.org/ffmpeg#ffmpeg_et_le_support_aac )
- python-gtk (dernière version tant qu'à faire)

1 on ouvre son éditeur (gedit, kate etc...) et on colle dans le fichier ce code:

#! /usr/bin/env python
# -*- coding: iso-8859-1 -*-

##############################################
#
# avi2psp est une interface graphique pour convertir une vidéo
# .avi, .ogg, xvid, divx au format MP4 compatible avec la
#  PlayStation Portable de Sony en invoquant ffmpeg
#
#
# Auteur: Dominique Müller (zhorglub CHEZ wanadoo POINT fr)
# Ce programme est soumis à la licence GNU/GPL v2
#
# Nécessite python 2.3 (ou supérieur)
#           module pyGtk 2.4 (paquet Debian python-gtk2)
#           ffmpeg (paquet Debian ffmpeg version CVS)
#           convert (Image Magick) pour les thumbnails
#
# Capture video VLC (video4linux):
#           aoss si vous devez utiliser un wrapper OSS pour ALSA
#           (paquet Debian alsa-oss)
#           VLC (http://www.videolan.org) Paquet Debian vlc
#
# Le script fonctionne avec knoppix 4/kaella 2.1 live-CD
# mais ffmpeg n'étant pas présent sur ces systèmes, il doit
# être installé manuellement
#
# Il peut y avoir des problèmes avec les noms de fichiers comportant
# des caractères accentués, si c'est votre cas:
# Faites dans une console:
#
# export G_FILENAME_ENCODING="iso-8859-1" (ou tout autre encodage)
#
# car gtk+ assume par défaut un encodage UTF-8
# Vous pouvez également rajouter cette ligne dans votre fichier
# ~/.bashrc pour qu'elle soit prise en compte au démarrage
# depuis le shell ou l'intégrer dans un script destiné à lancer
# le programme.
#
# Have fun :)
###############################################
import pygtk
pygtk.require('2.0')
import gtk
import os
import os.path
import gobject


class App:
	def __init__(self):
		self.wnd = gtk.Window(gtk.WINDOW_TOPLEVEL)
		self.wnd.set_title("Conversion Video PSP")
		self.wnd.set_border_width(2)
		
		self.basebox = gtk.VBox(False, 0)
		self.box0 = gtk.HBox(False, 0)
		self.progressbox = gtk.HBox(False, 0)
		self.wnd.add(self.basebox)
		
		self.box1 = gtk.VBox(False, 0)
		self.box2 = gtk.VBox(False, 0)
		self.box3 = gtk.HBox(False, 0)
		self.box4 = gtk.HBox(False, 0)
		self.boxlabel = gtk.VBox(False, 0)
		self.boxradio = gtk.VBox(False, 0)
		self.boxlbl2 = gtk.VBox(True, 0)
		self.boxlbl3 = gtk.VBox(True, 0)
		self.comboboxes = gtk.VBox(False, 0)
		
		self.menu_items = (
		( "/_Options",         None,         None, 0, "<Branch>" ),
		( "/Options/Capturer une video avec  _VLC (video4linux)",    "<control>V", self.capture_video, 0, '<StockItem>', gtk.STOCK_NEW ),
		( "/Options/_Parametres de capture VLC",    "<control>P", self.capture_param, 0, '<StockItem>', gtk.STOCK_PREFERENCES ),
		( "/Options/_Copier la commande vers le presse-papier",    "<control>C", self.copy_to_clipboard, 0, '<StockItem>', gtk.STOCK_COPY ),
		( "/Options/Source audio _WAV",    "<control>W", self.remux_video, 0, '<StockItem>', gtk.STOCK_JUMP_TO ),
		( "/Options/sep1",     None,         None, 0, "<Separator>" ),
		( "/Options/_Quitter",     "<control>Q", gtk.main_quit, 0, '<StockItem>', gtk.STOCK_QUIT ),
		)
		self.menubar = self.get_main_menu(self.wnd)
		self.basebox.pack_start(self.menubar, False, False, 0)
        	self.menubar.show()
		
		
		self.clipboard = gtk.clipboard_get("CLIPBOARD")
		self.copy_sel = False # Par défaut: exécution de la commande
		
	# Variables globales par défaut
		self.smono = "2" # Par défaut le son est en stéréo
		self.extrn_wav = '' # Fichier son externe .wav
		self.capt_file = 'capture.avi'
		self.default_video_device = '/dev/video0'
		self.default_audio_device = '/dev/dsp0'
		self.aoss_chk = False
		self.std_val = 'SECAM'
		self.chn_val = 0
		# Si le fichier ./.avi2psprc existe, on récupère les valeurs
		# sinon --> valeurs par défaut
		f = "./.avi2psprc"
		if os.access(f, os.F_OK):
			h = open(f, 'r')
			null_input = h.readline()
			self.capt_file = h.readline()
			self.capt_file = self.capt_file[:-1]
			self.default_video_device = h.readline()
			self.default_video_device = self.default_video_device[:-1]
			self.default_audio_device = h.readline()
			self.default_audio_device = self.default_audio_device[:-1]
			tmp = h.readline()
			if tmp[:-1] == 'True':
				self.aoss_chk = True
			else:
				self.aoss_chk = False
			self.std_val = h.readline()
			self.std_val = self.std_val[:-1]
			self.chn_val = int(h.readline())
			h.close()
			
		
	# Labels
		lsource = gtk.Label("Source: ")
		self.boxlabel.pack_start(lsource, True, True, 0)
		lsource.show()
		ldest = gtk.Label(" Destination: ")
		self.boxlabel.pack_end(ldest, True, True, 0)
		ldest.show()
		laudiobr = gtk.Label("Audio: ")
		self.boxlbl2.pack_start(laudiobr, True, True, 0)
		laudiobr.show()
		lvideobr = gtk.Label("Video: ")
		self.boxlbl2.pack_start(lvideobr, True, True, 0)
		lvideobr.show()
		laudiobr = gtk.Label(" Kbps")
		self.boxlbl3.pack_start(laudiobr, True, True, 0)
		laudiobr.show()
		lvideobr = gtk.Label(" Kbps")
		self.boxlbl3.pack_start(lvideobr, True, True, 0)
		lvideobr.show()
		lcodec = gtk.Label("Codec:")
		self.boxlbl2.pack_start(lcodec, True, True, 0)
		lcodec.show()
		lcodec = gtk.Label("")
		self.boxlbl3.pack_start(lcodec, True, True, 0)
		lcodec.show()
	# Entries
		self.source = gtk.Entry(max=0)
		self.box1.pack_start(self.source, True, True, 0)
		infobulles = gtk.Tooltips()
		infobulles.set_tip(self.source, "Entrez ou selectionnez le nom du fichier a convertir\nSi vous voulez utiliser deux fichiers separes\npour l'audio et la video, indiquez le fichier video ici\net faites Options --> Source audio WAV pour selectionner l'audio")
		separator = gtk.HSeparator()
		self.box1.pack_start(separator, False, True, 5)
		separator.show()
		self.dest = gtk.Entry(max=0)
		self.dest.set_text("M4V00001.MP4")
		self.box1.pack_start(self.dest, True, True, 0)
		
	# Checkbox mono/stéréo
		laud = gtk.Label(" Audio: ")
		self.box3.pack_start(laud, False, False, 0)
		laud.show()
		self.mono = gtk.CheckButton(" Mono ")
		self.box3.pack_start(self.mono, False, False, 2)
		self.mono.show()
		self.mono.connect("toggled", self.set_mono, None)
		
	# Checkbox audio/copie
		self.acopy = gtk.CheckButton(" Copy ")
		self.box3.pack_start(self.acopy, False, False, 2)
		self.acopy.show()
		infobulles = gtk.Tooltips()
		infobulles.set_tip(self.acopy, "Copier l'audio sans reencodage")
		separator1 = gtk.VSeparator()
		self.box3.pack_start(separator1, False, True, 5)
		separator1.show()
	# Spin volume +
		self.vol_adj = gtk.Adjustment(0.0, 0.0, 300.0, 5.0, 1.0, 0.0)
		self.vol_spin = gtk.SpinButton(self.vol_adj, 0, 0)
		lvol = gtk.Label(" Volume + ")
		self.box3.pack_start(lvol, False, False, 0)
		lvol.show()
		self.box3.pack_start(self.vol_spin, False, False, 0)
		self.vol_spin.show()
		infobulles = gtk.Tooltips()
		infobulles.set_tip(self.vol_spin, "Augmente le volume de la piste audio de n %\nUne valeur trop elevee peut alterer la qualite sonore\ndu projet et causer des dommages auditifs importants\nA utiliser avec moderation! (Max: 300 %)\nInactif si l'option copy est selectionnee ")
		lvol = gtk.Label(" % ")
		self.box3.pack_start(lvol, False, False, 0)
		lvol.show()
	# Cropping	
		separator1 = gtk.VSeparator()
		self.box3.pack_start(separator1, False, True, 5)
		separator1.show()
		self.adj2 = gtk.Adjustment(0.0, 0.0, 100.0, 2.0, 1.0, 0.0)
		self.cropbottom = gtk.SpinButton(self.adj2, 0, 0)
		self.cropbottom.set_wrap(True)
		self.box3.pack_end(self.cropbottom, False, False, 5)
		self.cropbottom.show()
		lcb = gtk.Label(" Bas:")
		self.box3.pack_end(lcb, False, False, 5)
		lcb.show()
		self.adj = gtk.Adjustment(0.0, 0.0, 100.0, 2.0, 1.0, 0.0)
		self.croptop = gtk.SpinButton(self.adj, 0, 0)
		self.croptop.set_wrap(True)
		self.box3.pack_end(self.croptop, False, True, 5)
		self.croptop.show()
		lct = gtk.Label(" Cropping:   Haut:")
		self.box3.pack_end(lct, False, False, 5)
		lct.show()
	# Thumbnail
		lthmb = gtk.Label(" Creer thumbnail (icone) a la position : ")
		self.box4.pack_start(lthmb, False, False, 0)
		lthmb.show()
		# Spins h:m:s --> Minutes
		self.hms2 = gtk.Adjustment(0.0, 0.0, 15.0, 1.0, 1.0, 0.0)
		self.minute = gtk.SpinButton(self.hms2, 0, 0)
		self.minute.set_wrap(True)
		self.box4.pack_start(self.minute, False, True, 5)
		self.minute.show()
		lthmb = gtk.Label(" min ")
		self.box4.pack_start(lthmb, False, False, 0)
		lthmb.show()
		# Spins h:m:s --> Secondes
		self.hms3 = gtk.Adjustment(0.0, 0.0, 59.0, 1.0, 1.0, 0.0)
		self.seconde = gtk.SpinButton(self.hms3, 0, 0)
		self.seconde.set_wrap(True)
		self.box4.pack_start(self.seconde, False, True, 5)
		self.seconde.show()
		lthmb = gtk.Label(" sec ")
		self.box4.pack_start(lthmb, False, False, 0)
		lthmb.show()
	# Boutons
		self.thumb = gtk.Button("  Creer  ")
		self.box4.pack_end(self.thumb, True, False, 0)
		self.thumb.connect("clicked", self.create_thumbnail, None)
		self.thumb.show()
		self.choix_src = gtk.Button()
		self.choix_src.connect("clicked", self.select_src, None)
		boxb2 = xpm_label_box(self.wnd, "info.xpm")
		self.choix_src.add(boxb2)
		boxb2.show()
		self.box2.pack_start(self.choix_src, True, False, 0)
		
		separator1 = gtk.HSeparator()
		self.box2.pack_start(separator1, False, True, 5)
		separator1.show()
		
		self.choix_dest = gtk.Button()
		self.choix_dest.connect("clicked", self.select_dest, None)
		boxb1 = xpm_label_box(self.wnd, "info.xpm")
		self.choix_dest.add(boxb1)
		boxb1.show()
		self.box2.pack_start(self.choix_dest, True, False, 0)
		
		
		self.makeItSo = gtk.Button(None, gtk.STOCK_OK)
		self.makeItSo.connect("clicked", self.exec_comm)
	# Boutons radios
		self.radio = gtk.RadioButton(None, "320x240")
		self.radio.connect("toggled", self.res_set, "320x240")
		self.radio.set_active(True)
		self.boxradio.pack_start(self.radio, True, True, 5)
		self.radio.show()
	
		self.resolution = "320x240" # résolution par défaut
		
		self.radio = gtk.RadioButton(self.radio, "368x208")
		self.radio.connect("toggled", self.res_set, "368x208")
		self.boxradio.pack_start(self.radio, True, True, 5)
		self.radio.show()
		
		self.radio = gtk.RadioButton(self.radio, "400x192")
		self.radio.connect("toggled", self.res_set, "400x192")
		self.boxradio.pack_start(self.radio, True, True, 5)
		self.radio.show()
		
		self.radio = gtk.RadioButton(self.radio, "Original")
		self.radio.connect("toggled", self.res_set, "0")
		self.boxradio.pack_start(self.radio, True, True, 5)
		self.radio.show()
	# Comboboxes
		self.audiobr = gtk.combo_box_new_text()
		self.videobr = gtk.combo_box_new_text()
		self.codec = gtk.combo_box_new_text()
		self.codec.append_text('h264/AVC')
		self.codec.append_text('xvid')
		self.codec.append_text('mpeg4')
		self.codec.append_text('copy')
		self.audiobr.append_text('128')
		self.audiobr.append_text('64')
		self.audiobr.append_text('48')
		self.audiobr.append_text('32')
		self.audiobr.append_text('16')
		self.videobr.append_text('768')
		self.videobr.append_text('512')
		self.videobr.append_text('384')
		self.videobr.set_active(1)
		self.audiobr.set_active(3)
		self.codec.set_active(0)
		self.comboboxes.pack_start(self.audiobr, True, False, 0)
		self.comboboxes.pack_end(self.codec, True, False, 0)
		self.comboboxes.pack_end(self.videobr, True, False, 0)
		self.audiobr.show()
		self.videobr.show()
		self.codec.show()
	# Barre de progression
		self.plabel = gtk.Label("Etat: ")
		self.progressbox.pack_start(self.plabel, False, False, 0)
		self.plabel.show()
		self.pbar = gtk.ProgressBar(None)
		self.pbar.set_text('Conversion en attente')
		#self.pbar.set_fraction(0.62)
		self.pbar.show()
		self.progressbox.pack_start(self.pbar, True, True, 20)
		
	# Pack général
		self.box0.pack_start(self.boxlabel, False, False, 0)
		self.box0.pack_start(self.box1, False, False, 0)
		self.box0.pack_start(self.box2, False, False, 0)
		self.box0.pack_start(self.boxradio, False, False, 20)
		self.box0.pack_start(self.boxlbl2, False, False, 10)
		self.box0.pack_start(self.comboboxes, False, False, 0)
		self.box0.pack_start(self.boxlbl3, False, False, 10)
		self.box0.pack_end(self.makeItSo, True, True, 0)
		
		self.basebox.pack_start(self.box0, False, False, 0)
		separator2 = gtk.HSeparator()
		self.basebox.pack_start(separator2, False, True, 5)
		separator2.show()
		self.basebox.pack_start(self.box3, False, False, 0)
		separator3 = gtk.HSeparator()
		self.basebox.pack_start(separator3, False, True, 5)
		separator3.show()
		self.basebox.pack_start(self.box4, False, False, 0)
		separator4 = gtk.HSeparator()
		self.basebox.pack_start(separator4, False, True, 5)
		separator4.show()
		self.basebox.pack_start(self.progressbox, False, False, 10)
		
		self.source.show()
		self.dest.show()
		self.choix_src.show()
		self.choix_dest.show()
		self.makeItSo.show()
		self.progressbox.show()
		self.basebox.show()
		self.box0.show()
		self.boxlabel.show()
		self.box1.show()
		self.box2.show()
		self.box3.show()
		self.box4.show()
		self.boxradio.show()
		self.boxlbl2.show()
		self.comboboxes.show()
		self.boxlbl3.show()
		self.wnd.show()
		return
	
	# Bon, celle-là, c'est du copier/coller depuis la doc de pyGtk, qu'ils en soient remerciés..
	

	def get_main_menu(self, window):
        	accel_group = gtk.AccelGroup()

        # This function initializes the item factory.
        # Param 1: The type of menu - can be MenuBar, Menu,
        #          or OptionMenu.
        # Param 2: The path of the menu.
        # Param 3: A reference to an AccelGroup. The item factory sets up
        #          the accelerator table while generating menus.
        	item_factory = gtk.ItemFactory(gtk.MenuBar, "<main>", accel_group)

        # This method generates the menu items. Pass to the item factory
        #  the list of menu items
        	item_factory.create_items(self.menu_items)

        # Attach the new accelerator group to the window.
        	window.add_accel_group(accel_group)

        # need to keep a reference to item_factory to prevent its destruction
        	self.item_factory = item_factory
        # Finally, return the actual menu bar created by the item factory.
        	return item_factory.get_widget("<main>")
	
	def select_src(self, w, d):
		self.filew = gtk.FileSelection("Choisir le fichier source")
		self.filew.ok_button.connect("clicked", self.file_ok_sel)
		self.filew.cancel_button.connect("clicked", self.file_cn_sel)
		self.filew.show()
		return
	
	def select_wav(self, w, d):
		self.filew = gtk.FileSelection("Choisir le fichier source audio")
		self.filew.ok_button.connect("clicked", self.wav_ok_sel)
		self.filew.cancel_button.connect("clicked", self.file_cn_sel)
		self.filew.show()
		return
	
	def select_dest(self, w, d):
		self.filew = gtk.FileSelection("Choisir le fichier destination")
		self.filew.ok_button.connect("clicked", self.file_ok_seld)
		self.filew.cancel_button.connect("clicked", self.file_cn_sel)
		self.filew.set_filename(self.dest.get_text())
		self.filew.show()
		return

	def file_ok_sel(self, w):
		self.source.set_text(self.filew.get_filename())
		self.filew.destroy()
		return
	
	def wav_ok_sel(self, w):
		self.source_wav.set_text(self.filew.get_filename())
		self.filew.destroy()
		return
	
	def file_ok_seld(self, w):
		self.dest.set_text(self.filew.get_filename())
		self.filew.destroy()
		return
	
	def file_cn_sel(self, w):
		self.filew.destroy()
		return
	
	def res_set(self, w, data):
		self.resolution = data
		return
	
	def get_active_text(self, combobox):
		model = combobox.get_model()
		active = combobox.get_active()
		if active < 0:
			return None
		return model[active][0]
	
	def create_thumbnail(self, w, d):
		cm = self.minute.get_value_as_int()
		cs = self.seconde.get_value_as_int()
		ct = str(cs + (cm * 60))
		dst = self.dest.get_text()
		dst = dst[:-3] + "gif" # remplacer "gif" par "THM" si encodage direct
		ccmd = "ffmpeg -y -i " + self.source.get_text() + " -ss " + ct + " -f gif -vframes 1 -s 160x120 -an " + dst # remplacer "-f gif" par "-f singlejpeg" si encodage direct
		o = os.system(ccmd)
		if os.access(dst, os.F_OK):						# Conserver cette ligne
			ccmd = "convert " + dst + " " + dst[:-3] + "jpg" 		# Peut-être supprimée si jpeg direct
			o = os.system(ccmd)						# idem
			if os.access(dst[:-3]+'jpg', os.F_OK):				# idem
				ccmd = "rm -f " + dst + "\n"				# idem
				ccmd = ccmd + "mv " + dst[:-3] + "jpg " + dst[:-3] + "THM" # idem
				dst = dst[:-3] + "THM" 					# idem
				o = os.system(ccmd)					# idem
				self.pbar.set_text('Creation de l\'icone '+dst+' a '+ ct +' secondes : complete') # supprimer 1 indentation (tab) mais conserver la ligne
			else: # supprimer
				self.pbar.set_text('La creation de l\'icone a echoue!') # supprimer
		else:
			self.pbar.set_text('La creation de l\'icone a echoue!')
			
		# Commande utilisée: ffmpeg -y -i videofile.avi -f gif -ss value -vframes 1 -s 160x120 -an M4VXXXXX.THM
		#
		# Explication de cette bizarrerie --> -f gif:
		# Sur ma version de ffmpeg je n'ai accès qu'au format gif pour les images, j'encode donc en GIF puis j'utilise
		# convert file.gif file.jpg pour mettre le fichier en jpeg. Cela suppose et implique d'avoir installé Image magick
		# sur votre système. Toutefois, si vous avez une version de ffmpeg qui encode directement en jpeg, vous pouvez
		# sans risque modifier les lignes ci-dessus pour simplifier tout ça!!
		# Ne m'en veuillez pas, je sais que gif n'est pas un format libre et que ça n'est pas bien, même pour
		# un fichier temporaire... ;p
		return
	
	def exec_comm(self, w):
		#
		name = os.path.basename(os.path.splitext(self.source.get_text())[0])
		ccmd = "ffmpeg -y -i " + self.source.get_text() + self.extrn_wav + " -title " + name
		ccmd = ccmd + " -vcodec "
		if self.get_active_text(self.codec) != 'copy':
			if self.get_active_text(self.codec) == 'h264/AVC':
				ccmd = ccmd + "h264 -level 13 -g 250"
			else:
				ccmd = ccmd + self.get_active_text(self.codec)
				if self.get_active_text(self.audiobr) == '128':
					self.audiobr.set_active(1) # Pour les vidéos 'non-h264', le bitrate audio ne doit pas dépasser 64 kbits
					# Ceci corrige une éventuelle saisie erronée en mettant la valeur à 64 kbps
			if self.resolution != "0":
				ccmd = ccmd + " -s " + self.resolution
			ccmd = ccmd + " -r 29.97 -b " + self.get_active_text(self.videobr)
			ct = self.croptop.get_value_as_int()
			cb = self.cropbottom.get_value_as_int()
			if ct != 0:
				ccmd = ccmd + " -croptop " + str(ct)
			if cb != 0:
				ccmd = ccmd + " -cropbottom " + str(cb)
		else:
			ccmd = ccmd + "copy"
		
		if self.acopy.get_active():
			ccmd = ccmd  + " -acodec copy"
		else:
			ccmd = ccmd  + " -acodec aac"
			if self.vol_spin.get_value_as_int() > 0:
				ccmd = ccmd + " -vol " + str(self.vol_spin.get_value_as_int())
			ccmd = ccmd + " -ac " + self.smono + " -ar 24000 -ab " + self.get_active_text(self.audiobr)
		if self.get_active_text(self.codec) != 'h264/AVC':
			ccmd = ccmd + " -f psp "
			
		else:
			ccmd = ccmd + " "
		ccmd = ccmd + self.dest.get_text()
		print ccmd
		if self.copy_sel:
			if not self.clipboard.set_text(ccmd, -1):
				self.pbar.set_text('Copie de la commande ffmpg vers le presse-papier: complete')
				self.copy_sel = False
			else:
				self.pbar.set_text('La commande ne peut pas etre copiee: Echec !')
		else:
			if os.access(self.dest.get_text(), os.F_OK):
				
				if self.ask_ok_cancel("Fichier existant", "\nUn fichier avec le meme nom existe deja.\n\n         Ecraser ?\n") == 1:
					o = os.system('xterm -e ' + ccmd + " &")
		
					self.t1 = gobject.timeout_add(3000, self.gimmick)
					self.t2 = gobject.timeout_add(100, self.gimmick2)
					self.t3 = gobject.timeout_add(4000, self.ffmpeg_activity)
			else:
				o = os.system('xterm -e ' + ccmd + " &")
		
				self.t1 = gobject.timeout_add(3000, self.gimmick)
				self.t2 = gobject.timeout_add(100, self.gimmick2)
				self.t3 = gobject.timeout_add(4000, self.ffmpeg_activity)	
		return
		
	def remux_video(self, w, d):
		self.dialog = gtk.Dialog("Selection Fichier Wav", self.wnd, gtk.DIALOG_DESTROY_WITH_PARENT, None)
		
		hbox = gtk.HBox(False, 0)
		
		self.dialog.vbox.pack_start(hbox, True, True, 0)
		
		label = gtk.Label("   Fichier : ")
		hbox.pack_start(label, True, True, 0)
		label.show()
		self.source_wav = gtk.Entry(max=0)
		self.source_wav.set_text(self.extrn_wav)
		hbox.pack_start(self.source_wav, False, True, 5)
		self.source_wav.show()
		
		infobulles = gtk.Tooltips()
		infobulles.set_tip(self.source_wav, "Le fichier indique sera pris comme source audio\nlors de l'encodage.\nTous les formats audio supportes par ffmpeg sont valides")
		
		self.choix_wav = gtk.Button()
		self.choix_wav.connect("clicked", self.select_wav, None)
		box2 = xpm_label_box(self.dialog, "info.xpm")
		self.choix_wav.add(box2)
		box2.show()
		hbox.pack_start(self.choix_wav, True, False, 0)
		self.choix_wav.show()
		
		makeItSo_cancel = gtk.Button(None, gtk.STOCK_CANCEL)
		makeItSo_cancel.connect("clicked", self.dialogdestroy)
		self.dialog.action_area.pack_start(makeItSo_cancel, False, True, 0)
		makeItSo_cancel.show()
		
		makeItSo_ok = gtk.Button(None, gtk.STOCK_OK)
		makeItSo_ok.connect("clicked", self.set_Ok_destroy)
		self.dialog.action_area.pack_end(makeItSo_ok, False, True, 0)
		makeItSo_ok.show()
		hbox.show()
		
		self.dialog.show()
		
		return
	
	def set_Ok_destroy(self, w):
		if self.source_wav.get_text() == '':
			self.extrn_wav = ''
		else:
			self.extrn_wav = " -i " + self.source_wav.get_text()
		self.dialog.destroy()
		return
	
	def capture_video(self, w, d):
		#os.system('/home/zhorglub/video_grab &')
		ccmd = ''
		if self.aoss_chk:
			ccmd = ccmd + 'aoss '
		ccmd = ccmd + 'vlc v4l:// :v4l-vdev="' + self.default_video_device + '" :v4l-adev="' + self.default_audio_device + '" :v4l-norm='
		if self.std_val == 'SECAM':
			ccmd = ccmd + '2 :v4l-channel='
		elif self.std_val == 'PAL':
			ccmd = ccmd + '0 :v4l-channel='
		elif self.std_val == 'NTSC':
			ccmd = ccmd + '1 :v4l-channel='
		else:
			ccmd = ccmd + '2 :v4l-channel='
		ccmd = ccmd + str(self.chn_val)
		ccmd = ccmd + " :v4l-frequency=-1 --sout \'#transcode{vcodec=mp4v,vb=2048,scale=1}:duplicate{dst=std{access=file,mux=asf,url=\""
		ccmd = ccmd + self.capt_file + "\"}}' &"
		print "Commande pour la capture VLC:\n"
		print ccmd
		os.system(ccmd)
		return
		
	def capture_param(self, w, d):
		self.dialog = gtk.Dialog("Parametres de capture VLC", self.wnd, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, None)
		
		string = """	Vous pouvez modifier ici les parametres par defaut fournis	 
	au programme VLC.
	
	Pour en savoir plus sur VLC: http://www.videolan.org	 	
	La capture utilise les parametres suivants:
		
		Codec video: mp4v 2048 kbps 25 fps
		Audio:	     s16le (PCM 44100 Hz 16 bits)		 
		Container:   asf
	 
		 """
		label = gtk.Label(string)
		self.dialog.vbox.pack_start(label, False, True, 10)
		label.show()
		
		hbox = gtk.HBox(False, 0) # /dev/video /dev/dsp 
		hbox2 = gtk.HBox(False, 0) # aoss checkbox
		hbox3 = gtk.HBox(False, 0) # Entry fichier capture par défaut
		hbox4 = gtk.HBox(False, 0) # standard + canal
		
		label = gtk.Label("  Video ")
		hbox.pack_start(label, False, True, 0)
		label.show()
		
		
		self.devv = gtk.Entry(max=0)
		self.devv.set_text(self.default_video_device)
		hbox.pack_start(self.devv, False, True, 0)
		self.devv.show()
		
		self.deva = gtk.Entry(max=0)
		self.deva.set_text(self.default_audio_device)
		hbox.pack_end(self.deva, False, True, 5)
		self.deva.show()
				
		label = gtk.Label("    Audio ")
		hbox.pack_end(label, False, True, 0)
		label.show()
		

		self.aoss = gtk.CheckButton("Utiliser aoss (Wrapper OSS pour ALSA)")
		hbox2.pack_start(self.aoss, False, False, 2)
		self.aoss.set_active(self.aoss_chk)
		self.aoss.show()
		
		label = gtk.Label("   Fichier de capture: ")
		hbox3.pack_start(label, True, True, 0)
		label.show()
		self.capt = gtk.Entry(max=0)
		self.capt.set_text(self.capt_file)
		hbox3.pack_start(self.capt, False, True, 5)
		self.capt.show()
		
		label = gtk.Label("   Standard: ")
		hbox4.pack_start(label, True, True, 0)
		label.show()
		
		self.standard = gtk.combo_box_new_text()
		self.channel = gtk.combo_box_new_text()
		
		self.standard.append_text('PAL')
		self.standard.append_text('SECAM')
		self.standard.append_text('NTSC')
		if self.std_val == 'SECAM':
			self.standard.set_active(1)
		elif self.std_val == 'PAL':
			self.standard.set_active(0)
		elif self.std_val == 'NTSC':
			self.standard.set_active(2)
		else:
			self.standard.set_active(1)
			
		hbox4.pack_start(self.standard, False, True, 0)
		self.standard.show()
		
		self.channel.append_text('TV')
		self.channel.append_text('Composite')
		self.channel.append_text('S-Video')
		self.channel.set_active(self.chn_val)
		hbox4.pack_end(self.channel, False, True, 0)
		self.channel.show()
		
		label = gtk.Label("   Canal: ")
		hbox4.pack_end(label, True, True, 0)
		label.show()
		
		self.dialog.vbox.pack_start(hbox, True, True, 10)
		self.dialog.vbox.pack_start(hbox2, True, True, 10)
		self.dialog.vbox.pack_start(hbox3, True, True, 10)
		self.dialog.vbox.pack_start(hbox4, True, True, 10)
		
		makeItSo_cancel = gtk.Button(None, gtk.STOCK_CANCEL)
		makeItSo_cancel.connect("clicked", self.dialogdestroy)
		self.dialog.action_area.pack_start(makeItSo_cancel, True, False, 0)
		makeItSo_cancel.show()
		
		makeItSo_ok = gtk.Button(None, gtk.STOCK_SAVE)
		makeItSo_ok.connect("clicked", self.set_saveconfig_destroy)
		self.dialog.action_area.pack_end(makeItSo_ok, False, True, 0)
		makeItSo_ok.show()
				
		infobulles = gtk.Tooltips()
		infobulles.set_tip(makeItSo_ok, "Valider et sauvegarder pour les sessions ulterieures")
		

		makeItSo_valid = gtk.Button(None, gtk.STOCK_OK)
		makeItSo_valid.connect("clicked", self.set_valid_destroy)
		self.dialog.action_area.pack_end(makeItSo_valid, False, True, 0)
		makeItSo_valid.show()
				
		infobulles = gtk.Tooltips()
		infobulles.set_tip(makeItSo_valid, "Valider uniquement pour cette session (pas de sauvegarde)")
		

		hbox.show()
		hbox2.show()
		hbox3.show()
		hbox4.show()
		self.dialog.show()
		return
	
	def set_saveconfig_destroy(self, w):
		self.capt_file = self.capt.get_text()
		self.default_video_device = self.devv.get_text()
		self.default_audio_device = self.deva.get_text()
		self.aoss_chk = self.aoss.get_active()
		self.std_val = self.standard.get_active_text()
		self.chn_val = self.channel.get_active()
		self.dialog.destroy()
		f=open('./.avi2psprc', 'w')
		f.write("# N'éditez pas ce fichier manuellement, utilisez le menu Options --> Paramètres de capture\n")
		f.write(self.capt_file + "\n")
		f.write(self.default_video_device + "\n")
		f.write(self.default_audio_device + "\n")
		f.write(str(self.aoss_chk) + "\n")
		f.write(self.std_val + "\n")
		f.write(str(self.chn_val) + "\n")
		f.close()
		return
	
	def set_valid_destroy(self, w):
		self.capt_file = self.capt.get_text()
		self.default_video_device = self.devv.get_text()
		self.default_audio_device = self.deva.get_text()
		self.aoss_chk = self.aoss.get_active()
		self.std_val = self.standard.get_active_text()
		self.chn_val = self.channel.get_active()
		self.dialog.destroy()
		return
	
	def copy_to_clipboard(self, w, d):
		self.copy_sel = True
		self.exec_comm(w)
		return
	
	def set_mono(self, w, data):
		if w.get_active():
			self.smono = "1"
		else:
			self.smono = "2"
		return
	
	def gimmick(self):
		self.pbar.set_pulse_step(0.05)
		self.pbar.pulse()
		gobject.source_remove(self.t1)
		self.t1 = gobject.timeout_add(50, self.gimmick)
		return
		
	def gimmick2(self):
		self.pbar.set_text('Encodage en cours')
		return True
	
	def ask_ok_cancel(self, title, string):
		self.val = 0
		self.dialog = gtk.Dialog(title, self.wnd, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, None)
		label = gtk.Label(string)
		self.dialog.vbox.pack_start(label, True, True, 0)
		label.show()
		
		makeItSo_cancel = gtk.Button(None, gtk.STOCK_CANCEL)
		makeItSo_cancel.connect("clicked", self.dialogdestroy)
		self.dialog.action_area.pack_start(makeItSo_cancel, True, True, 0)
		makeItSo_cancel.show()
		
		makeItSo_ok = gtk.Button(None, gtk.STOCK_OK)
		makeItSo_ok.connect("clicked", self.setvaltrue)
		self.dialog.action_area.pack_end(makeItSo_ok, True, True, 0)
		makeItSo_ok.show()
		self.dialog.run()
		
		return self.val
	
	def setvaltrue(self, w):
		self.val = 1
		self.dialog.destroy()
		return
	
	def dialogdestroy(self, w):
		self.val = 2
		self.dialog.destroy()
		return
	
	def ffmpeg_activity(self):
		o = os.popen('ps -C ffmpeg')
		s = None
		l = 0
		while s != '':
			ts = len(o.readline())
			if ts != 0:
				l = l + 1
			else:
				break
		o.close()
		if l == 1:
			gobject.source_remove(self.t1)
			gobject.source_remove(self.t2)
			gobject.source_remove(self.t3)
			self.pbar.set_fraction(0.0)
			self.pbar.set_text('Fin de la conversion')
		
		return True

# Remerciement: La fonction suivante provient de l'exemple buttons.py dans la doc pyGtk2.4
# et a été adaptée pour ce programme

def xpm_label_box(parent, xpm_filename):
	# Create box for xpm and label
	box1 = gtk.HBox(False, 0)
	box1.set_border_width(2)

	# Now on to the image stuff
	image = gtk.Image()
	image.set_from_file(xpm_filename)

	# Pack the pixmap and label into the box
	box1.pack_start(image, False, False, 3)

	image.show()
	return box1


def main():
	gtk.main()

if __name__ == "__main__":
	
	root = App()
	main()

2 on sauvegarde ce fichier que l'on nommera avi2psp.py dans le répertoire de son choix.

3 on teste si tout fonctionne bien via la console par la commande :
python /chemindufichier/avi2psp.py

4 on découvre cette interface fort sympathique :

5 il ne reste plus qu'à créer un raccourci dans votre tableau de bord pour que la chose soit absolument conviviale.

6 pour en savoir un peu plus et se tenir au courant d'éventuelles mises à jours du code en fonction des avancées d'ffmpeg par exemple, rendez vous de temps à autre par ici: http://forums.knoppix-fr.org/viewtopic.php?pid=66892

Bon films !

---

L'émancipation des moutons sera l'oeuvre des moutons eux-même... et viva la Jolie Môme !!!

frodon

Re : Encoder facilement ses films pour PSP

J'ai testé ça me donne :

  File "/home/frodon/bin/avi2psp.py", line 82
    self.menubar.show()
    ^
IndentationError: unexpected indent

SInon ca a l'air interessant si j'arrive a le faire marcher.

Alain.g

Re : Encoder facilement ses films pour PSP

@frodon :
Clique sur "citer", et copie le code à  partir de là   (ça sera les vraies tabulations, non remplacées par des espaces)

---

Xubuntu Karmic !

frodon

Re : Encoder facilement ses films pour PSP

Ok mais ligne 82 ça dit bien que c'est a la ligne 82 quand même donc l'essentiel y est.

J'espere que Doppler supporte toujours son script, sinon j'irais chercher une autre solution.

Omnisilver

Re : Encoder facilement ses films pour PSP

Doppler dit que le script est de Zhorglub ... envoies-lui un mail si tu veux lui poser une question, ou poses-la à  la suite du post de Zhorglub sur le forum de knoppix à  mon avis tu auras plus de chance d'avoir ta réponse qu'ici

Alain.g

Re : Encoder facilement ses films pour PSP

Ok mais ligne 82 ça dit bien que c'est a la ligne 82 quand même donc l'essentiel y est.
.

Euh.. tu as pris la peine d'essayer ma solution au moins ? (je l'ai fait et ça fonctionne ;-) )

---

Xubuntu Karmic !

frodon

Re : Encoder facilement ses films pour PSP

Desole Alain je vien de comprendre, je pensai que tu me disait cela pour poster mon error log. Oui c'est vrai que python utilise les tab pour detecter le branchements conditionels.
Je teste ca des que je peux.

Sinon ce script marche pour quelqu un ?
SI oui avec le ffmpeg des depots ou celui de medibuntu ?

Dernière modification par frodon (Le 10/12/2007, à 11:28)

Alain.g

Re : Encoder facilement ses films pour PSP

Il doit falloir la version Medibuntu (à  moins de compiler soi-même)

Sinon je n'ai jamais essayé ce script, je n'ai pas de PSP (je sais que c'est une console de jeux, mais je ne sais même pas à  quoi elle ressemble !)

Dernière modification par Alain.g (Le 10/12/2007, à 15:04)

---

Xubuntu Karmic !

jerome33

Re : Encoder facilement ses films pour PSP

En fait il y a des espaces en trop sur cette ligne 82.

jerome33

Re : Encoder facilement ses films pour PSP

Chez moi ça marche mais le fichier est 4 fois plus petit au détriment du son et de la taille de l'image. Pour la taille pas de problème vu l'écran de la PSP, mais le son ça craint un peu, surtout que j'ai testé sur un concert.

Alain.g

Re : Encoder facilement ses films pour PSP

mais le son ça craint un peu, surtout que j'ai testé sur un concert.

à‡a doit dépendre uniquement de la qualité que tu choisis. Par défaut, c'est sur 32kbps, donc effectivement très médiocre.
Mais tu peux choisir 64 ou même 128

---

Xubuntu Karmic !

frodon

Re : Encoder facilement ses films pour PSP

Voila la commande générée ainsi que son résultat une fois mise dans la console :

ffmpeg -y -i /***/***/**********.avi -title ******* -vcodec h264 -level 13 -g 250 -s 320x240 -r 29.97 -b 512 -acodec aac -ac 2 -ar 24000 -ab 32 /***/*****/M4V00001.mp4
ffmpeg: No match.

Quelqu'un a une idée, j'utlise la version ffmeg de medibuntu pour gutsy.

Dernière modification par frodon (Le 11/12/2007, à 21:56)

dekans

Re : Encoder facilement ses films pour PSP

la résolution de l'écran de la PSP c'est 480*272
Mais en AVC ce n'est peut etre pas géré par les firmwares officiels.

---

dekans@jabber.kubuntu-fr.org

frodon

Re : Encoder facilement ses films pour PSP

la résolution de l'écran de la PSP c'est 480*272
Mais en AVC ce n'est peut etre pas géré par les firmwares officiels.

Oui mais la j'ai ce probleme quelque soit la resolution, donc j'ai pas encore eu le loisir de tester ca sur la psp malheureusement.

frodon

Re : Encoder facilement ses films pour PSP

Je suis le seul pour qui cette solution ne marche pas ?

@jerome33, ça semble marcher chez toi pourrais tu nous donner quelque détails sur ton système et sur ce que tu as installé pour que cela marche ?

Merci

Dernière modification par frodon (Le 14/12/2007, à 11:46)

fazerick

Re : Encoder facilement ses films pour PSP

j'utilise pspvc trouvé sur ce forum, il est nikel, plus joli et efficace avec un choix de la qualité
http://doc.kubuntu-fr.org/psp

---

sous (k)(x)ubuntu depuis 2 an et heureux avec ce systeme :)
http://lxde.free.fr

jerome33

Re : Encoder facilement ses films pour PSP

Chez moi ffmpeg était déjà  installé, donc je n'ai eu qu'à  rendre le script executable et ça a marché. j'ai juste eu à  corriger la syntaxe de la ligne 82 pour enlever des espaces en trop, comme indiqué au début du post. Mais visiblement ton souci viens plutà´t de ffmpeg... Je vois que tu as donné tout un chemin pour le titre de sortie. Laisse le titre par défaut pour voir. J'ai du mal à  saisir le "no match".

frodon

Re : Encoder facilement ses films pour PSP

j'utilise pspvc trouvé sur ce forum, il est nikel, plus joli et efficace avec un choix de la qualité
http://doc.kubuntu-fr.org/psp

Merci mais pspvc n'est pas une solution qui m'intéresse, c'est une apps externe et j'évite d'en installer surtout quand je ne peut pas juger de manière objective de la qualité du soft et des lib qu il installe surtout quand ce n'est pas nécessaire (ffmpeg et mencoder marche tres bien).
Au fait pspvc il utilise ffmpeg comme ce script donc pour les différences de rapidité j'y crois pas trop vu que c'est le même encodeur.

@Jerome merci je vais tester ca, en effet pour le titre et la ligne 82 ça peut être le problème, sinon pour ffmpeg il était déjà  installe aussi.

Dernière modification par frodon (Le 14/12/2007, à 14:27)

frodon

Re : Encoder facilement ses films pour PSP

Toujours la meme erreur, je comprend pas ce qui est different chez moi, il doit certainement me manquer une lib de codec.

EDIT: bon j'ai laisse tombe, j'ai installe la preview de avidemux 2.4 et l'option psp marche tres bien.

Dernière modification par frodon (Le 18/12/2007, à 15:36)

Syrion

Re : Encoder facilement ses films pour PSP

Hé, les petits pirantins !
La PSP ne supporte la résolution max (480x272) que pour les disques UMD. Si vous faites ça avec une vidéeo sur le memory stick, il faut downgrader avec un firmware illégal ....
Donc avec le firmware officiel, la PSP lira des vidéos au maximum en 368x208 si elle ne sont pas en UMD. Tout ça parceque Sony-la-malice voulait favoriser l'UMD. Ce qui ne sert à rien, c'est un format mort.

Dernière modification par Syrion (Le 11/03/2008, à 23:18)

---

Ubuntu 22.04.4 amd64 sur Dell XPS 7590 15"
Ubuntu Server 20.04.4 Eeepc 1215P
Ubuntu 22.04.1 sur Ryzen 5 5600X, 32Go DDR4-3600, NVidia RTX 3060Ti

requiem

Re : Encoder facilement ses films pour PSP

Syrion, il est tout à fait possible de lire des vidéos en 480x272 avec un firmware officiel récent.

---

Le problème avec Linux, ce n'est pas Linux, c'est le linuxien

Lo_pescofi

Re : Encoder facilement ses films pour PSP

Super !
C'est tout à fait ce que je cherchais. Il fonctionne avec mon lecteur mp4.
C'est un SONY NWZ-S615F et ça faisait plusieurs jour que je cherchais une config qui marche avec AVIDEMUX et autres prog en tout genre.

Merci encore

PS : par contre j'ai eu du mal a obtenir un fichier correct même en faisant "Citer"
- pas de fichier complet obtenu
- il a fallut que je remplace à la main les
&quot; &lt; &gt et &amp; respectivement en " < > et &
-plus quelques Pb d'espace  au lieu de Tab

Je pense qu'il serait bien de déposer le fichier pour qu'on puisse le télécharger ...
et pourquoi pas un paquet pour la prochaine sortie d'ubuntu ?

Dernière modification par Lo_pescofi (Le 23/03/2008, à 17:26)

mydoom666

Re : Encoder facilement ses films pour PSP

Bonjour

WinFF (GUI de ffmpeg) permet la même chose non ?

Lo_pescofi

Re : Encoder facilement ses films pour PSP

Bonjour

WinFF (GUI de ffmpeg) permet la même chose non ?

http://i49.servimg.com/u/f49/11/19/52/01/24030810.png

Chez moi WinFF ( la dernière version v0.33) ne marche pas ... vu que le script python me convient, j'ai pas cherché pourquoi.
Cependant, WinFF semble disposer de plus de possibilités.

Merci tout de même.