python - and - Obtención de la salida en tiempo real de ffmpeg para ser utilizada en la barra de progreso(PyQt4, stdout)

python execute shell command and get output

Question

He mirado una serie de preguntas, pero todavía no puedo resolver esto. Estoy usando PyQt, y espero ejecutar ffmpeg -i file.mp4 file.avi y obtener la salida a medida que se transmite para que pueda crear una barra de progreso.

He visto estas preguntas: ¿Puede ffmpeg mostrar una barra de progreso? captura de stdout en tiempo real desde subproceso

Puedo ver la salida de un comando rsync, usando este código:

import subprocess, time, os, sys

cmd = "rsync -vaz -P source/ dest/"
p, line = True, ''start''


p = subprocess.Popen(cmd,
                     shell=True,
                     bufsize=64,
                     stdin=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE)

for line in p.stdout:
    print("OUTPUT>>> " + str(line.rstrip()))
    p.stdout.flush()

Pero cuando cambio el comando a ffmpeg -i file.mp4 file.avi no recibo salida. Supongo que esto tiene algo que ver con el búfer de salida / salida estándar, pero estoy atascado en cuanto a cómo leer la línea que se ve

frame=   51 fps= 27 q=31.0 Lsize=     769kB time=2.04 bitrate=3092.8kbits/s

Que podría utilizar para averiguar el progreso.

Alguien me puede mostrar un ejemplo de cómo obtener esta información de ffmpeg en python, con o sin el uso de PyQt (si es posible)

EDIT: Terminé yendo con la solución de jlp, mi código se veía así:

#!/usr/bin/python
import pexpect

cmd = ''ffmpeg -i file.MTS file.avi''
thread = pexpect.spawn(cmd)
print "started %s" % cmd
cpl = thread.compile_pattern_list([
    pexpect.EOF,
    "frame= */d+",
    ''(.+)''
])
while True:
    i = thread.expect_list(cpl, timeout=None)
    if i == 0: # EOF
        print "the sub process exited"
        break
    elif i == 1:
        frame_number = thread.match.group(0)
        print frame_number
        thread.close
    elif i == 2:
        #unknown_line = thread.match.group(0)
        #print unknown_line
        pass

Lo que da esta salida:

started ffmpeg -i file.MTS file.avi
frame=   13
frame=   31
frame=   48
frame=   64
frame=   80
frame=   97
frame=  115
frame=  133
frame=  152
frame=  170
frame=  188
frame=  205
frame=  220
frame=  226
the sub process exited

¡Perfecto!

Answer 1

1. Por lo general, no es necesario llamar desde el shell.
2. Sé por experiencia que parte de la salida ffmpeg viene en stderr , no en stdout .

Si todo lo que desea hacer es imprimir la línea de salida, como en el ejemplo anterior, simplemente esto hará:

import subprocess

cmd = ''ffmpeg -i file.mp4 file.avi''
args = cmd.split()

p = subprocess.Popen(args)

Tenga en cuenta que la línea de chat de ffmpeg termina con /r , por lo que se sobrescribirá en la misma línea. Creo que esto significa que no puedes p.stderr las líneas en p.stderr , como lo haces con tu ejemplo rsync. Para crear su propia barra de progreso, entonces, es posible que deba manejar la lectura usted mismo, esto debería comenzar:

p = subprocess.Popen(args, stderr=subprocess.PIPE)

while True:
  chatter = p.stderr.read(1024)
  print("OUTPUT>>> " + chatter.rstrip())

Answer 2

En este caso específico para capturar la salida de estado de ffmpeg (que va a STDERR), esta pregunta SO lo resolvió para mí: FFMPEG y subproceso Pythons

El truco es agregar universal_newlines=True a la llamada subprocess.Popen() , porque la salida de ffmpeg en realidad no tiene buffer pero viene con caracteres de nueva línea.

cmd = "ffmpeg -i in.mp4 -y out.avi"
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,universal_newlines=True)
for line in process.stdout:
    print(line)

También tenga en cuenta que en este ejemplo de código la salida de estado STDERR se redirige directamente a subprocess.STDOUT

Answer 3

Estas respuestas no funcionaron para mí: / Así es como lo hice.

Es de mi proyecto KoalaBeatzHunter .

¡Disfrutar!

def convertMp4ToMp3(mp4f, mp3f, odir, kbps, callback=None, efsize=None):
    """
    mp4f:     mp4 file
    mp3f:     mp3 file
    odir:     output directory
    kbps:     quality in kbps, ex: 320000
    callback: callback() to recieve progress
    efsize:   estimated file size, if there is will callback() with %
    Important:
    communicate() blocks until the child process returns, so the rest of the lines 
    in your loop will only get executed after the child process has finished running. 
    Reading from stderr will block too, unless you read character by character like here.
    """
    cmdf = "ffmpeg -i "+ odir+mp4f +" -f mp3 -ab "+ str(kbps) +" -vn "+ odir+mp3f
    lineAfterCarriage = ''''

    print deleteFile(odir + mp3f)

    child = subprocess.Popen(cmdf, shell=True, stderr=subprocess.PIPE)

    while True:
        char = child.stderr.read(1)
        if char == '''' and child.poll() != None:
            break
        if char != '''':
            # simple print to console
#             sys.stdout.write(char)
#             sys.stdout.flush()
            lineAfterCarriage += char
            if char == ''/r'':
                if callback:
                    size = int(extractFFmpegFileSize(lineAfterCarriage)[0])
                    # kb to bytes
                    size *= 1024
                    if efsize:
                        callback(size, efsize)
                lineAfterCarriage = ''''

A continuación, necesitas 3 funciones más para implementarlo.

def executeShellCommand(cmd):
    p = Popen(cmd , shell=True, stdout=PIPE, stderr=PIPE)
    out, err = p.communicate()
    return out.rstrip(), err.rstrip(), p.returncode

def getFFmpegFileDurationInSeconds(filename):
    cmd = "ffmpeg -i "+ filename +" 2>&1 | grep ''Duration'' | cut -d '' '' -f 4 | sed s/,//"
    time = executeShellCommand(cmd)[0]
    h = int(time[0:2])
    m = int(time[3:5])
    s = int(time[6:8])
    ms = int(time[9:11])
    ts = (h * 60 * 60) + (m * 60) + s + (ms/60)
    return ts

def estimateFFmpegMp4toMp3NewFileSizeInBytes(duration, kbps):
    """
    * Very close but not exact.
    duration: current file duration in seconds
    kbps: quality in kbps, ex: 320000
    Ex:
        estim.:    12,200,000
        real:      12,215,118
    """
    return ((kbps * duration) / 8)

Y finalmente lo haces:

# get new mp3 estimated size
secs = utls.getFFmpegFileDurationInSeconds(filename)
efsize = utls.estimateFFmpegMp4toMp3NewFileSizeInBytes(secs, 320000)
print efsize

utls.convertMp4ToMp3("AwesomeKoalaBeat.mp4", "AwesomeKoalaBeat.mp3",
                "../../tmp/", 320000, utls.callbackPrint, efsize)

Espero que esto ayude!

Answer 4

La única manera que he encontrado para obtener retroalimentación / salida dinámica de un proceso secundario es usar algo como pexpect:

#! /usr/bin/python

import pexpect

cmd = "foo.sh"
thread = pexpect.spawn(cmd)
print "started %s" % cmd
cpl = thread.compile_pattern_list([pexpect.EOF,
                                   ''waited (/d+)''])
while True:
    i = thread.expect_list(cpl, timeout=None)
    if i == 0: # EOF
        print "the sub process exited"
        break
    elif i == 1:
        waited_time = thread.match.group(1)
        print "the sub process waited %d seconds" % int(waited_time)
thread.close()

el subproceso llamado foo.sh solo espera un tiempo aleatorio entre 10 y 20 segundos, aquí está el código para ello:

#! /bin/sh

n=5
while [ $n -gt 0 ]; do
    ns=`date +%N`
    p=`expr $ns % 10 + 10`
    sleep $p
    echo waited $p
    n=`expr $n - 1`
done

Querrá usar alguna expresión regular que coincida con la salida que está obteniendo de ffmpeg y haga algún tipo de cálculo para mostrar la barra de progreso, pero al menos obtendrá la salida sin buffer de ffmpeg.

Answer 5

Si tiene la duración (que también puede obtener de la salida FFMPEG), puede calcular el progreso leyendo la salida del tiempo transcurrido (tiempo) durante la codificación.

Un ejemplo simple:

  pipe = subprocess.Popen(
        cmd,
        stderr=subprocess.PIPE,
        close_fds=True
  )
  fcntl.fcntl(
        pipe.stderr.fileno(),
        fcntl.F_SETFL,
        fcntl.fcntl(pipe.stderr.fileno(), fcntl.F_GETFL) | os.O_NONBLOCK,
  )
   while True:
            readx = select.select([pipe.stderr.fileno()], [], [])[0]

            if readx: 
                chunk = pipe.stderr.read()

                if not chunk:
                    break

                result = re.search(r''/stime=(?P<time>/S+) '', chunk)
                elapsed_time = float(result.groupdict()[''time''])

                # Assuming you have the duration in seconds
                progress = (elapsed_time / duration) * 100

                # Do something with progress here
                callback(progress)

        time.sleep(10)

Answer 6

También puede hacerlo de manera bastante clara con el QProcess de PyQt4 (como se pregunta en la pregunta original) conectando una ranura del QProcess a un QTextEdit o lo que sea. Todavía soy bastante nuevo en python y pyqt pero aquí es cómo me las arreglé para hacerlo:

import sys
from PyQt4 import QtCore, QtGui

class ffmpegBatch(QtGui.QWidget):
    def __init__(self):
        super(ffmpegBatch, self).__init__()
        self.initUI()

    def initUI(self):
        layout = QtGui.QVBoxLayout()
        self.edit = QtGui.QTextEdit()
        self.edit.setGeometry(300, 300, 300, 300)
        run = QtGui.QPushButton("Run process")

        layout.addWidget(self.edit)
        layout.addWidget(run)

        self.setLayout(layout)

        run.clicked.connect(self.run)

    def run(self):
        # your commandline whatnot here, I just used this for demonstration
        cmd = "systeminfo"

        proc = QtCore.QProcess(self)
        proc.setProcessChannelMode(proc.MergedChannels)
        proc.start(cmd)
        proc.readyReadStandardOutput.connect(lambda: self.readStdOutput(proc))


    def readStdOutput(self, proc):
        self.edit.append(QtCore.QString(proc.readAllStandardOutput()))

def main():
    app = QtGui.QApplication(sys.argv)
    ex = ffmpegBatch()
    ex.show()
    sys.exit(app.exec_())

if __name__ == ''__main__'':
    main()