Ubuntu-fr

Désolé en ce moment j'ai pas trop le temps de répondre ou de m'occuper du projet.

@freewee : je pourrais te donner une explication rapide mais si tu es novice tu comprendrais pas tout et tu serais dégouté. Donc tu vas devoir patienter un peu, le temps que je me remette dedans et que je simplifie un peu l'installation.

Par contre je peux répondre à tes questions :
- ça ne pose pas de problème que tu utilises les pilotes propriétaires;
- il te faudra les librairies OpenGL et les paquets de développement pour la compilation;
- les applications compatibles 3D sont toutes les applications supportant le Quad-Buffer d'OpenGL nativement ... c'est-à-dire pas grand chose pour le moment. Mais il y a quelques lecteurs de vidéos (Bino, mplayer entre autres), des visionneurs d'images, quelques jeux. Su le wiki la liste des logiciels compatibles est à peu près à jour je crois.
- les mkv 3D sont lisibles avec Bino (et surement avec mplayer) par contres tu peux oublier les Blu-Ray 3D pour le moment : les Blu-Ray sont déjà difficilement lisibles alors en 3D ...

Mais ne t'inquiète pas, tu y arriveras

Et bien si, il est compatible ! Avec le pilote propriétaire il suffit de rajouter une ligne dans le fichier /etc/xorg.conf. Et si il supporte l'HDMI 3D alors il faut relire les messages de jean un peu plus haut

Normalement tout marche à peu près, il faut juste que je prenne un peu de temps pour tout remettre en forme, faire des instructions d'installation etc ... Mais en ce moment j'ai pas vraiment le temps, j'ai pas mal de choses à faire pour la fac ... et il me reste moins de 3 semaines ^^ Après ça ira mieux. J'espère.

Est-ce que tu as téléchargé le firmware ?

Je viens d'accepter une modification sur github venant de PKN_zeta (ça faisait longtemps ). Normalement la compilation devrait marcher correctement !

Est-ce que tu utilises le pilote propriétaire ou le pilote libre (nouveau) ? L'option "Stereo 10" ne marche que pour le pilote propriétaire !

Si tu utilises le pilote libre tu vas devoir utiliser une résolution personnalisée qui activera la stéréoscopie.

Dès que je serai en vacances je m'occuperais de remettre au propre le driver et la doc, promis

Bonjour à tous, et bonne année !

En ce moment j'ai pas trop le temps d'avancer sur glQuadBufferEmu. Je travaille sur un jeu en OpenGL pour mes études donc je peux pas repousser, faut que je le finisse à temps et c'est un projet assez conséquent. Par contre j'apprends plein de choses en OpenGL ça devrait beaucoup me servir quand j'aurais un peu de temps pour me remettre sur glQuadBufferEmu. Il reste pas tant que ça a faire pour avoir quelque chose de correct !

Désolé pour tout ceux qui attendent que j'avance ... Mais je vais vraiment essayer de prendre quelques heures pour faire un peu de ménage (supprimer les trucs qui servent plus) et compléter un peu les différents points essentiels.

Allez perdez pas espoir

Bonjour à tous !

Comme je l'ai déjà dit j'ai pas le temps de bosser de manière directe sur glQuadBufferEmu puisque j'ai un projet scolaire à finir. Par contre, je travaille indirectement puisque j’acquiers des connaissances en OpenGL. Du coups, dès la fin des cours (mi-mars) je serai capable d'améliorer le driver très rapidement !

Bon, là je me suis répété, je vous avais déjà dit tout ça. Sauf que je viens d'intégrer la Stéréoscopie dans mon projet de fin d'année (qui est un jeu de foot en OpenGL) et je suis très satisfait ! En quelques heures seulement j'ai juste modifié ma gestion de caméra pour pouvoir facilement calculer des vues légèrement différentes (voir ici : http://paulbourke.net/stereographics/stereorender/) et pouvoir les afficher comme si y'avait un carte graphique QUAD-BUFFER. Et voilà, glQuadBufferEmu a fait le reste !

Aucun problème à l'affichage, glQuadBufferEmu a pas bronché. Pourtant mon jeu est en OpenGL 3.1 alors que quand j'ai écrit glQuadBufferEmu je connaissais à peine l'OpenGL 2.1 ! Quand je vois à quel point glQuadBufferEmu est déjà stable ça me donne encore plus envie de continuer et d'aller jusqu'au bout pour proposer quelque chose de parfait !!!

Attendez-moi, d'ici un mois c'est reparti

Je l'ai pas mal pris Au contraire, c'est pas tout les jours qu'on me compare à Jésus

Ok ça marche. Je serais sur IRC toute la journée aujourd'hui

Ça c'est pas très grave, j'ai passé plus d'un an à développer des logiciels stéréo sans aucun matos 3D. Bon maintenant je suis bien équipé, je peux tester presque toutes les technos

Ça marche nickel Bon, la qualité est quand même limite quand y'a du noir, mais ça marche, je vais enfin pouvoir regarder mon épisode de Castle x)

Par contre là il me manque une ou deux petites choses avant de pouvoir poster le code. Mais ça arrive

Bon, alors, ça marche, j'arrive à télécharger les vidéos avec pluzzdl.

Par contre j'ai pas trop bien réussi à l'intégrer dans pluzzdl donc je vais mettre les morceaux de code modifiés ici comme ça le développeur principal (je sais même pas qui c'est ^^) de pluzzdl pourra l'intégrer comme il le voudra.

Donc il faut ajouter ces 3 lignes dans le init de la classe PluzzDL:

#utilisation du lien mobile
args = re.findall( "/(([0-9]{4})/S([0-9]{2})/J([0-9]{1})/([0-9]*)-([0-9]{6,8}))-", self.pageInfos )[0]
mobile_link = "http://medias2.francetv.fr//catchup-mobile/france-dom-tom/non-token/non-drm/m3u8/%s.m3u8" %(args[0])
downloader = PluzzDLM3U8(mobile_link, self.nomFichier, self.navigateur, self.stopDownloadEvent, self.progressFnct )

J'ai aucune idée de ou l'ajouter ... il faudrait que quand aucune autre vidéo n'est disponible (ou utilisable, comme actuellement) ça utilise la vidéo mobile. Et avec le code actuel c'est pas facile à faire. J'aurais bien fait les modifications nécessaires moi même mais y'a beaucoup de chose de changer donc je pense pas que ce soit à moi de le faire (c'est la première fois que je vous aide).

Maintenant le code de la classe PluzzDLM3U8 :

class PluzzDLM3U8( object ):
	"""
	Telechargement des liens m3u8
	"""

	def __init__( self, m3u8URL, nomFichier, navigateur, stopDownloadEvent, progressFnct ):
		self.m3u8URL           = m3u8URL
		self.nomFichier        = nomFichier
		self.navigateur        = navigateur
		self.stopDownloadEvent = stopDownloadEvent
		self.progressFnct      = progressFnct

		self.historique        = Historique()

		self.nomFichierFinal   = "%s.mkv" %( self.nomFichier[ : -3 ] )

	def ouvrirNouvelleVideo( self ):
		"""
		Creer une nouvelle video
		"""
		try :
			# Ouverture du fichier
			self.fichierVideo = open( self.nomFichier, "wb" )
		except :
			logger.critical( "Impossible d'écrire dans le répertoire %s" %( os.getcwd() ) )
			sys.exit( -1 )
		# Ajout de l'en-tête
		#	Fait dans creerMKV

	def ouvrirVideoExistante( self ):
		"""
		Ouvre une video existante
		"""
		try :
			# Ouverture du fichier
			self.fichierVideo = open( self.nomFichier, "a+b" )
		except :
			logger.critical( "Impossible d'écrire dans le répertoire %s" %( os.getcwd() ) )
			sys.exit( -1 )

	def creerMKV( self ):
		"""
		Creer un mkv a partir de la video existante (cree l'en-tete de la video)
		"""
		logger.info( "Création du fichier MKV (vidéo finale) ; veuillez attendre quelques instants" )
		try:
			commande = "ffmpeg -i %s -vcodec copy -acodec copy %s 1>/dev/null 2>/dev/null" %( self.nomFichier, self.nomFichierFinal )
			os.system( commande )
			os.remove( self.nomFichier )
			logger.info( "Fin !" )
		except:
			logger.error( "Impossible de créer la vidéo finale" )
			sys.exit( -1 )

	def telecharger( self ):

		if( re.match( "http://ftvodhd-i.akamaihd.net/[^\.]+", self.m3u8URL ) ):
			# Recupere le fichier master.m3u8
			self.m3u8 = self.navigateur.getFichier( self.m3u8URL )
			# Recupere le lien avec le plus gros bitrate (toujours 1205000 ?)
			try:
				self.listeFragmentsURL = re.findall( "http://ftvodhd-i\.akamaihd.net/.+?index_2_av\.m3u8.+", self.m3u8 )[ 0 ]
			except:
				logger.critical( "Impossible de trouver le lien vers la liste des fragments" )
				sys.exit( -1 )

			# Recupere la liste des fragments
			self.listeFragmentsPage = self.navigateur.getFichier( self.listeFragmentsURL )

			# Extrait l'URL de tous les fragments
			self.listeFragments = re.findall( "http://ftvodhd-i.akamaihd.net.+", self.listeFragmentsPage )

			# Nombre de fragments
			self.nbFragMax = float( len( self.listeFragments ) )
			logger.debug( "Nombre de fragments : %d" %( self.nbFragMax ) )
		else: # mobile
			quality = M3U(self.m3u8URL, self.navigateur)

			max_bandwith_val = -1
			max_bandwith_url = ""

			for f in quality.files:
				try:
					s = f.options['EXT-X-STREAM-INF'].split(',')
					b = s[1].split('=')
					if b[0] == 'BANDWIDTH':
						bandwidth = int(b[1])
				except:
					bandwidth = 0

				if bandwidth >= max_bandwith_val:
					max_bandwith_url = quality.getURL(f.name)
					max_bandwith_val = bandwidth

			self.listeFragmentsURL = max_bandwith_url
			#print max_bandwith_url


		#
		# Creation de la video
		#
		self.premierFragment    = 1
		self.telechargementFini = False
		video = self.historique.getVideo( self.listeFragmentsURL )
		# Si la video est dans l'historique
		if( video is not None ):
			# Si la video existe sur le disque
			if( os.path.exists( self.nomFichier ) or os.path.exists( self.nomFichierFinal ) ):
				if( video.finie ):
					logger.info( "La vidéo a déjà été entièrement téléchargée" )
					if( not os.path.exists( self.nomFichierFinal ) ):
						self.creerMKV()
					sys.exit( 0 )
				else:
					self.ouvrirVideoExistante()
					self.premierFragment = video.fragments
					logger.info( "Reprise du téléchargement de la vidéo au fragment %d" %( video.fragments ) )
			else:
				self.ouvrirNouvelleVideo()
				logger.info( "Impossible de reprendre le téléchargement de la vidéo, le fichier %s n'existe pas" %( self.nomFichier ) )
		else: # Si la video n'est pas dans l'historique
			self.ouvrirNouvelleVideo()

		# Ajout des fragments
		logger.info( "Début du téléchargement des fragments" )
		try:
			if( re.match( "http://ftvodhd-i.akamaihd.net/[^\.]+", self.m3u8URL ) ):
				i = self.premierFragment
				while( i <= self.nbFragMax and not self.stopDownloadEvent.isSet() ):
					frag = self.navigateur.getFichier( self.listeFragments[ i - 1 ] )
					self.fichierVideo.write( frag )
					# Affichage de la progression
					self.progressFnct( min( int( ( i / self.nbFragMax ) * 100 ), 100 ) )
					i += 1
				if( i == self.nbFragMax + 1 ):
					self.progressFnct( 100 )
					self.telechargementFini = True
					logger.info( "Fin du téléchargement" )
					self.creerMKV()
			else:
				playlist = M3U(max_bandwith_url, self.navigateur)
				i = 0
				for f in playlist.files:
					#print playlist.getURL(f.name)
					#print f.options

					frag = self.navigateur.getFichier(playlist.getURL(f.name))
					self.fichierVideo.write( frag )
					++i

				logger.info( "Fin du téléchargement" )
				self.creerMKV()

		except KeyboardInterrupt:
			logger.info( "Interruption clavier" )
		except:
			logger.critical( "Erreur inconnue" )
		finally :
			# Ajout dans l'historique
			self.historique.ajouter( Video( lien = self.listeFragmentsURL, fragments = i, finie = self.telechargementFini ) )
			# Fermeture du fichier
			self.fichierVideo.close()

Donc c'est un peu le bordel parce que j'ai préféré laisser l'ancien code pour le moment (en mettant plusieurs conditions). D'abord je sais pas à quoi ressemble le fichier master.m3u8 donc je voulais pas trop supprimer de code pour eviter de casser des choses qui marche actuellement. Si quelqu'un me donne un master.m3u8 je pourrais faire les modifications nécessaires pour fusionner les 2 codes (et donc enlever toutes les conditions). Ensuite j'ai utilisé plusieurs autres classes que j'avais faite en travaillant en local, pour tester plus rapidement. Et quand j'ai vu le code de PluzzDL j'ai bien vu que c'était pas la bonne solution puisqu'aucune autre classe de téléchargement n'utilise des classe extérieure pour les téléchargement.

Donc voilà le code de mes classes, dans lesquelles j'utilise des iterateurs, je trouvais que c'était assez sympa de les utiliser dans ce contexte :

#!/usr/bin/env python
# -*- coding:Utf-8 -*-

from Navigateur import Navigateur
import StringIO

class M3U_file:
	def __init__(self, name, ext):
		self.name = name
		self.options = ext

	def __str__(self):
		return self.name

class M3U_iterator:
	def __init__(self, data):
		self.buf = StringIO.StringIO(data)

	def __next_line(self):
		l = self.buf.readline()

		if l == "":
			raise StopIteration

		return l.rstrip('\n\r')

	def next(self):
		l = self.__next_line()


		while l[0] == '#':
			ext = {}

			try:
				s = l.split(':')
				ext[s[0].lstrip('#')] = s[1]
			except:
				pass

			l = self.__next_line()

		return M3U_file(l, ext)


	def __iter__(self):
		return self

class M3U:
	def __init__(self, url, navigateur):
		splited = url.split('/')
		self.m3u = splited[-1]
		splited[-1] = ""
		self.basedir = '/'.join(splited)

		data = navigateur.getFichier(url)

		self.files = M3U_iterator(data)

	def getURL(self, filename):
		return self.basedir + filename

Je suis bien au courant que ce que j'ai fait aura besoin de beaucoup de modifications pour être intégrer avec les normes du projet, alors ne vous genez pas. J'ai trouvé une solution, je l'ai implémenté à ma façon et je l'ai partagé. A vous d'adapter selon vos habitudes

Et si vous voulez, je peux faire des modifications moi même si vous me dites ce que je dois faire

Ah oui c'est vrai j'ai oublié de préciser quand même que jchb était mon partenaire de la nuit pour cette découverte formidable
D'ailleurs c'est lui qui a eu l'idée de regarder les liens des vidéos de l'appli mobile.

Je vais en profiter pour vous faire un compte rendu de l'application mobile, comme promis.

Pour commencer l'application télécharge un fichier zip contenant un fichier JSON par chaine. Chaque fichier contient la liste des programmes disponibles en replay et pour chaque programme disponible il y a le lien vers la playlist m3u.
Voilà le lien du fichier :  http://webservices.francetelevisions.fr … x_main.zip
Normalement y'a un espèce de timestamp en paramètre pour ce zip mais je pense que c'est plus pour empêcher la mise en cache.

Je précise que je n'utilise pas cette archive dans mon code. J'ai trouvé une correspondance entre les liens c'est plus simple. Sinon il faudrait télécharger l'archive, ouvrir les fichier JSON un par un et les parcourir en essayant de trouver la correspondance entre le lien à télécharger et le programme dans le JSON.

Retour à l'application. Quand on clique sur un programme, l'application récupère le fichier m3u globale qui contient 4 playlist m3u, chacune ayant des fragments de différentes qualités (bande-passante). Les quatre qualités sont 150k, 240k, 440k et 840k. Exemple : http://medias2.francetv.fr/catchup-mobi … 21119.m3u8

Là on voit clairement quelque chose de connu à la fin : m3u8/2012/S47/J1/72780286-20121119.m3u8
Donc ce morceau je le récupère (regex powaaa) dans le getInfosOeuvre.php qui est toujours appelé au chargement de PluzzDL.

L'appli sélectionne la playlist (surement en déterminant la bande-passante disponible en se basant sur la vitesse de téléchargement du zip) et la récupère. La playlist spécifique pour la qualité a la même adresse de base que la playlist globale, en gros ils rajoute juste la qualité après la date : 72780286-20121119-840k.m3u8 Par exemple : http://medias2.francetv.fr/catchup-mobi … -840k.m3u8

Dans mon cas je sélectionne toujours la playlist ayant la plus haute bande-passante, sans utiliser de REGEX comme c'était avant sur le master.m3u. Ce qui est bien c'est que si le master.m3u a la même syntaxe que les m3u mobile alors on peut simplifier le code en supprimant la condition permettant l'expression régulière pour trouver la meilleure qualité pour ftvod, mon code utilise la playlist globale et lit chaque sous playlist et les options associés pour determiner celle qui a la meilleure qualité.

Finalement l'application récupère les fragments et les lis directement. Les fragments sont placés dans un sous dossier portant le nom de la playlist et sont nommé comme les playlist en ajoutant le numéro du fragment à la fin : 72780286-20121119-840k/72780286-20121119-0.ts Petit exemple : http://medias2.francetv.fr/catchup-mobi … 21119-0.ts

De mon côté je télécharge les fragments et je met tout dans le même fichier et à la fin je lance ffmpeg pour convertir en mkv pour que ce soit lisible : là j'ai rien inventé hein ^^ J'ai juste repris le code déjà existant dans pluzzdl.

Voilà, j'espère que c'était clair ^^

La seule hypothèse que j'utilise c'est qu'on peut trouver le nom de la playlist (via une regex uniquement) dans le getInfosOeuvres.php ... ce qui est toujours le cas normalement. Tout les reste fonctionne comme l'application pluzz du coups même si ils font des (petits) changements ça devrait pas tout casser.