[Source] Génération d'une vidéo à partir d'une collection d'images

[sopsag]

Je me suis penché sur la question et j'ai trouvé plein d'info sur ce forum () mais finalement rien qui ne fonctionne.

J'ai continué à explorer la piste pymedia et finalement j'ai obtenu un code qui tourne et que je poste ici.

Malgré tout, le résultat est assez décevant car pymedia semble loin d'être mûr...
(voir les limitations dans le descriptif du code)

Je vais peut être me tourner vers wx.media... (mais j'ai l'impression qu'il n'y a pas d'encodeur)

Voici donc le bébé, aussi documenté que possible :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#!/usr/bin/python
# -*- coding: latin-1 -*-
 
'''
##############################################################
#  Génération d'une vidéo à partir d'une collection d'images.
##############################################################
 
Librairies utilisées :
======================
 
pymedia
--------
 A télécharger ici : http://pymedia.org
 La version pour python 2.5 est ici : http://pymedia.org/downloads/pymedia-1.3.7.3.win32-py2.5.exe
 (Ce lien ne figure pas sur la page des téléchargements)
 
PIL
----
 A télécharger ici : http://www.pythonware.com/products/pil/index.htm
 (Penser à choisir la version pour python 2.5 !)
 PIL permet de lire pratiquement tous les formats d'image.
 
 
Limitations :
==============
 - A l'heure où j'écris ce code, il n'y pas de version supérieure à python 2.5 qui soit supportée par pymedia.
 
 - Il semblerait que pymedia ajoute une image grise à la fin de la vidéo.
 
 - Le format de vidéo généré est mpeg1 car je n'ai pas réussi à faire fonctionner correctement les autres codecs.
   Lors de mes essais, j'ai pu constater que l'encodeur atteint vite ses limites :
   pour une résolution supérieure à 800x800 et/ou au delà d'une cinquantaine d'images, l'encodeur rend l'âme...
 
 - PIL fournit les binaires pour l'environnement win32.
   Il faut recompiler les sources soi-même pour un autre environnement.
 
 - enfin, pour la petite histoire, le code d'exemple (http://pymedia.org/tut/src/make_video.py.html)
   que j'ai retrouvé sur beaucoup de forums est buggé, il faut écrire : "fw.write( d.data )".
'''
 
from PIL import Image
 
def BuildVideo ( images,output_filename,size ):
    '''Construit une vidéo à partir de la liste d'images.
       images          : liste des noms de fichiers des images
       output_filename : nom de la video (attention à l'extension)
       size            : (largeur,hauteur) en pixels de la vidéo générée
       Les paramètres du codec sont ceux trouvés dans les tutoriels de pymedia.
       '''
    import pymedia.video.vcodec as vcodec
    params = {'type'            : 0,
              'gop_size'        : 12,
              # frame rate = frame_rate/frame_rate_base : ici = 24 im/sec
              # attention : tous les frame rate ne sont pas supportés
              'frame_rate'      : 2400,
              'frame_rate_base' : 100,
              'max_b_frames'    : 0,
              'height'          : size[1],
              'width'           : size[0],
              'deinterlace'     : 0,
              'bitrate'         : 2700000,
              'id'              : vcodec.getCodecID( 'mpeg1video' ) }
    encoder = vcodec.Encoder( params ) # créé une instance d'encodeur
    output = open( output_filename,'wb' ) # créé le fichier de sortie
    for im in images :
        print '+',im
        # recupère l'image sous forme d'une string raw
        bitmap    = Image.open( im ).resize( size ).tostring()
        # en fait une frame rgb
        frame_rgb = vcodec.VFrame( vcodec.formats.PIX_FMT_RGB24,size,( bitmap,None,None ))
        # la convertit en frame yuv (l'encodeur n'accepte pas directement du rgb)
        frame_yuv = frame_rgb.convert( vcodec.formats.PIX_FMT_YUV420P )
        # encode la frame
        encoded   = encoder.encode( frame_yuv )
        # ajoute la frame encodée au fichier
        output.write( encoded.data )
    # ferme le fichier de sortie
    output.close()
 
if __name__ == '__main__':
    import os,sys
    # affiche quelques infos à transmettre en cas de problème...
    print 'Python %d.%d.%d (%s)'%tuple(list(sys.version_info[0:3])+[sys.executable])
    print 'Construit une video a partir des images presentes dans ce repertoire.'
    # génère la liste des images (il y a bien d'autres formats reconnus par PIL)
    images = filter( lambda f : f[-4:] in ['.jpg','.bmp','.png'] , os.listdir('.'))
    # lance la génération
    BuildVideo( images , 'movie.mpeg',(640,480) )

(la coloration syntaxique ne semble pas gérer les triples quote de python...)

[afranck64]

Bonsoir,

Merci [sopsag] ça fait un bout que je cherche un exemple fonctionnel de pymedia.viodeo c'est génial.

@+ et bon code

[afranck64]

Bonsoir,
J'ai un bricolé pour faire une version de BuildVideo qui prend entre la durée de la vidéo que l'on veut produire.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
def BuildVideo ( images,output_filename,size,time=60 ):
    '''Construit une vidéo à partir de la liste d'images.
       images          : liste des noms de fichiers des images
       output_filename : nom de la video (attention à l'extension)
       size            : (largeur,hauteur) en pixels de la vidéo générée
       Les paramètres du codec sont ceux trouvés dans les tutoriels de pymedia.
       '''
    nb_images = 1
    if len(images)>1:
        nb_images = len(images)
    elif nb_images>=time: 
        frame_rate_base = 1567641600/nb_images
        frame_rate = frame_rate_base*nb_images/time
        rate = frame_rate/frame_rate_base
        params = {
                  'type'            : 0,
                  'gop_size'        : 12,
                  # frame rate = frame_rate/frame_rate_base : ici déterminer par la duree et le nb d'images
                  # attention : tous les frames rate ne sont pas supportés
                  'frame_rate'      : frame_rate_base*nb_images/time,
                  'frame_rate_base' : frame_rate_base,
                  'max_b_frames'    : 0,
                  'height'          : size[1],
                  'width'           : size[0],
                  'deinterlace'     : 0,
                  'bitrate'         : 2700000,
                  'id'              : vcodec.getCodecID( 'mpeg1video' ) }
 
        #Lorsqu'il y a peu d'images cela pose quelques problèmes
    else:
        rate = 1
        params = {
                  # frame rate = frame_rate/frame_rate_base : ici = 1 im/sec
                  # attention : tous les frame rate ne sont pas supportés
                  'frame_rate'      : 1,
                  'frame_rate_base' : 1,
                  'max_b_frames'    : 0,
                  'height'          : size[1],
                  'width'           : size[0],
                  'deinterlace'     : 0,
                  'bitrate'         : 2700000,
                  'id'              : vcodec.getCodecID( 'mpeg1video' ) }
 
        tmp = [images[0]]
        for i in range(time):
            pos = i*nb_images/time
            tmp.append(images[pos])
        images = tmp
 
    encoder = vcodec.Encoder( params ) # créé une instance d'encodeur
    output = open( output_filename,'wb' ) # créé le fichier de sortie
 
    for i,im in enumerate(images) :
        # recupère l'image sous forme d'une string raw
        bitmap    = Image.open( im ).resize( size ).tostring()
        # en fait une frame rgb
        frame_rgb = vcodec.VFrame( vcodec.formats.PIX_FMT_RGB24,size,( bitmap,None,None ))
        f = frame_rgb
        # la convertit en frame yuv (l'encodeur n'accepte pas directement du rgb)
        frame_yuv = frame_rgb.convert( vcodec.formats.PIX_FMT_YUV420P )
        # encode la frame
        encoded   = encoder.encode( frame_yuv )
        # ajoute la frame encodée au fichier
        output.write( encoded.data )
    # ferme le fichier de sortie
    output.close()

Mais un problème demeure: Lorsque je lis la vidéo produite, les indices de temps restent figés à 00:00 tout au long. As-tu une idée?

[sopsag]

Depuis cette aventure, je suis passé à Python 2.6 qui n'est pas supporté par Pymedia...
Du coup, je suis à la recherche d'une autre lib équivalente, mais qui soit toujours maintenue.
Si tu en connais, ça m’intéresse !

[Guigui_]

T'as essayé avec un binaire dispo ici ( http://www.lfd.uci.edu/~gohlke/pythonlibs/ ) ? (ce qui ne veut pas dire que la lib soit encore maintenue)

[sopsag]

Wah ! p'taing ! Guigui_, c'est de la folie toute pure ton lien !
Je n'ai pas encore fini d'éplucher toutes les libs, mais je me régale d'avance...
Par exemple je vois PyMedia pour Python 2.6 et 2.7...
Ça résout plein d'autres problèmes que j'avais par ailleurs !
(mais d'où ça sort ? je croyais que ce n'était plus maintenu...)

Merci !

[Guigui_]

Tu peux remercier Tyrtamos qui l'avait déjà mis ce lien auparavant sur le forum
En tout cas, il m'a permis de passer à la version 2.7 de Python plutôt que prévu