Generación de películas desde python sin guardar fotogramas individuales en archivos

Después de parchear ffmpeg (ver comentarios de Joe Kington a mi pregunta), pude obtener PNG de tubería a ffmpeg de la siguiente manera:

import subprocess
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

outf = 'test.avi'
rate = 1

cmdstring = ('local/bin/ffmpeg',
             '-r', '%d' % rate,
             '-f','image2pipe',
             '-vcodec', 'png',
             '-i', 'pipe:', outf
             )
p = subprocess.Popen(cmdstring, stdin=subprocess.PIPE)

plt.figure()
frames = 10
for i in range(frames):
    plt.imshow(np.random.randn(100,100))
    plt.savefig(p.stdin, format='png')

No funcionaría sin el parche , que modifica trivialmente dos archivos y agrega libavcodec/png_parser.c. Tuve que aplicar manualmente el parche a libavcodec/Makefile. Por último, eliminé '-number' de Makefile para obtener las páginas de manual para construir. Con opciones de compilación,

FFmpeg version 0.6.1, Copyright (c) 2000-2010 the FFmpeg developers
  built on Nov 30 2010 20:42:02 with gcc 4.2.1 (Apple Inc. build 5664)
  configuration: --prefix=/Users/paul/local_test --enable-gpl --enable-postproc --enable-swscale --enable-libxvid --enable-libx264 --enable-nonfree --mandir=/Users/paul/local_test/share/man --enable-shared --enable-pthreads --disable-indevs --cc=/usr/bin/gcc-4.2 --arch=x86_64 --extra-cflags=-I/opt/local/include --extra-ldflags=-L/opt/local/lib
  libavutil     50.15. 1 / 50.15. 1
  libavcodec    52.72. 2 / 52.72. 2
  libavformat   52.64. 2 / 52.64. 2
  libavdevice   52. 2. 0 / 52. 2. 0
  libswscale     0.11. 0 /  0.11. 0
  libpostproc   51. 2. 0 / 51. 2. 0

La conversión a formatos de imagen es bastante lenta y agrega dependencias. Después de mirar estas páginas y otras, lo conseguí trabajando con buffers raw sin codificar usando mencoder (solución ffmpeg todavía se desea).

Detalles en: http://vokicodder.blogspot.com/2011/02/numpy-arrays-to-video.html

import subprocess

import numpy as np

class VideoSink(object) :

    def __init__( self, size, filename="output", rate=10, byteorder="bgra" ) :
            self.size = size
            cmdstring  = ('mencoder',
                    '/dev/stdin',
                    '-demuxer', 'rawvideo',
                    '-rawvideo', 'w=%i:h=%i'%size[::-1]+":fps=%i:format=%s"%(rate,byteorder),
                    '-o', filename+'.avi',
                    '-ovc', 'lavc',
                    )
            self.p = subprocess.Popen(cmdstring, stdin=subprocess.PIPE, shell=False)

    def run(self, image) :
            assert image.shape == self.size
            self.p.stdin.write(image.tostring())
    def close(self) :
            self.p.stdin.close()

Tengo algunas buenas aceleraciones.

Estas son realmente grandes respuestas. Aquí hay otra sugerencia. @user621442 es correcto que el cuello de botella es típicamente la escritura de la imagen, por lo que si está escribiendo archivos PNG en su compresor de video, será bastante lento (incluso si los está enviando a través de una tubería en lugar de escribir en el disco). Encontré una solución usando pure ffmpeg, que personalmente encuentro más fácil de usar que matplotlib.animación o mencoder.

También, en mi caso, quería guardar la imagen en un eje, en lugar de guardar todas las etiquetas de marca, título de la figura, fondo de la figura, etc. Básicamente quería hacer una película / animación usando el código matplotlib, pero no que "pareciera un gráfico". He incluido ese código aquí, pero puede hacer gráficos estándar y canalizarlos a ffmpeg en su lugar si lo desea.

import matplotlib.pyplot as plt
import subprocess

# create a figure window that is the exact size of the image
# 400x500 pixels in my case
# don't draw any axis stuff ... thanks to @Joe Kington for this trick
# https://stackoverflow.com/questions/14908576/how-to-remove-frame-from-matplotlib-pyplot-figure-vs-matplotlib-figure-frame
f = plt.figure(frameon=False, figsize=(4, 5), dpi=100)
canvas_width, canvas_height = f.canvas.get_width_height()
ax = f.add_axes([0, 0, 1, 1])
ax.axis('off')

def update(frame):
    # your matplotlib code goes here

# Open an ffmpeg process
outf = 'ffmpeg.mp4'
cmdstring = ('ffmpeg', 
    '-y', '-r', '30', # overwrite, 30fps
    '-s', '%dx%d' % (canvas_width, canvas_height), # size of image string
    '-pix_fmt', 'argb', # format
    '-f', 'rawvideo',  '-i', '-', # tell ffmpeg to expect raw video from the pipe
    '-vcodec', 'mpeg4', outf) # output encoding
p = subprocess.Popen(cmdstring, stdin=subprocess.PIPE)

# Draw 1000 frames and write to the pipe
for frame in range(1000):
    # draw the frame
    update(frame)
    plt.draw()

    # extract the image as an ARGB string
    string = f.canvas.tostring_argb()

    # write to pipe
    p.stdin.write(string)

# Finish up
p.communicate()

¡Esto es genial! Yo quería hacer lo mismo. Pero, nunca pude compilar la fuente ffmpeg parcheada (0.6.1) en Vista con MINGW32+MSYS+pr enviroment... png_parser.c produjo Error1 durante la compilación.

Entonces, se me ocurrió una solución jpeg para esto usando PIL. Solo pon tu ffmpeg.exe en la misma carpeta que este script. Esto debería funcionar con ffmpeg sin el parche bajo Windows. Tuve que usar stdin.escribir método en lugar del método de comunicación que se recomienda en el oficial documentación sobre subproceso. Tenga en cuenta que la opción 2nd-vcodec especifica el códec de codificación. El tubo está cerrado por p. stdin.cerca().

import subprocess
import numpy as np
from PIL import Image

rate = 1
outf = 'test.avi'

cmdstring = ('ffmpeg.exe',
             '-y',
             '-r', '%d' % rate,
             '-f','image2pipe',
             '-vcodec', 'mjpeg',
             '-i', 'pipe:', 
             '-vcodec', 'libxvid',
             outf
             )
p = subprocess.Popen(cmdstring, stdin=subprocess.PIPE, shell=False)

for i in range(10):
    im = Image.fromarray(np.uint8(np.random.randn(100,100)))
    p.stdin.write(im.tostring('jpeg','L'))
    #p.communicate(im.tostring('jpeg','L'))

p.stdin.close()