从 ffmpeg 获取实时输出以在进度条中使用（PyQt4，stdout）

Question

我已经查看了很多问题，但仍然无法完全弄清楚。我正在使用 PyQt，并且希望运行 ffmpeg -i file.mp4 file.avi 并在流式传输时获取输出，以便我可以创建进度条。

我看过这些问题： ffmpeg可以显示进度条吗？ 从子进程实时捕获标准

输出我能够看到rsync 命令，使用以下代码：

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()

但是当我将命令更改为 ffmpeg -i file.mp4 file.avi 时，我没有收到任何输出。我猜这与标准输出/输出缓冲有关，但我对如何读取看起来像

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

我可以用来找出进度的行感到困惑。

有人可以向我展示一个如何将此信息从 ffmpeg 获取到 python 的示例，无论是否使用 PyQt（如果可能）

---

编辑： 我最终采用了 jlp 的解决方案，我的代码如下所示：

#!/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

给出了以下输出：

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

完美！

Answer 1

在这种捕获 ffmpeg 状态输出（进入 STDERR）的特定情况下，这个问题为我解决了这个问题： FFMPEG 和 Python 子进程

技巧是将 universal_newlines=True 添加到 subprocess.Popen() 调用中，因为ffmpeg 的输出实际上是无缓冲的，但带有换行符。

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)

另请注意，在此代码示例中，STDERR 状态输出直接重定向到 subprocess.STDOUT

Answer 2

我发现从子进程获取动态反馈/输出的唯一方法是使用类似 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()

被调用的子进程 foo.sh 只是等待 10 到 20 秒之间的随机时间，下面是它的代码：

#! /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

您将需要使用一些与从 ffmpeg 获得的输出相匹配的正则表达式，并对其进行某种计算以显示进度条，但这至少会为您提供来自 ffmpeg 的无缓冲输出。

Answer 3

1. 通常不需要从 shell 调用。
2. 根据经验，我知道 ffmpeg 输出的一部分来自 stderr，而不是 stdout。

如果您只想打印输出行，就像上面的示例一样，那么只需这样做：

import subprocess

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

p = subprocess.Popen(args)

请注意，ffmpeg chat 的行以 \r 终止，因此它将覆盖同一条线！我认为这意味着您无法像处理 rsync 示例那样迭代 p.stderr 中的行。要构建自己的进度条，您可能需要自己处理阅读，这应该可以帮助您开始：

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

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

Answer 4

我编写了一个专用包，为您提供了 Python 中 ffmpeg 进度的生成器函数： ffmpeg-进度产量。

只需运行：

pip3 install ffmpeg-progress-yield

然后，只需执行：

from ffmpeg_progress_yield import FfmpegProgress

cmd = [
    "ffmpeg", "-i", "test/test.mp4", "-c:v", "libx264", "-vf", "scale=1920x1080", "-preset", "fast", "-f", "null", "/dev/null",
]

ff = FfmpegProgress(cmd)
for progress in ff.run_command_with_progress():
    print(f"{progress}/100")

请注意，这仅适用于预先知道持续时间的输入文件。

Answer 5

这个答案对我不起作用：/这是我的做法。

它来自我的项目 KoalaBeatzHunter。

享受！

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 = ''

接下来，您还需要 3 个函数来实现它。

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)

最后你做到了：

# 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)

希望这会有所帮助！

Answer 6

您还可以使用 PyQt4 的 QProcess（如原始问题中所要求的）通过将 QProcess 中的插槽连接到 QTextEdit 或其他内容来非常清楚地完成此操作。我对 python 和 pyqt 还很陌生，但我是这样做的：

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()

Answer 7

ffmpeg-python github 上有一个示例 - 对于 Windows 机器（使用 unix 套接字），不能开箱即用... https://github.com/kkroening/ffmpeg-python/blob/master/examples/show_progress.py

一个简单的（IMO，更好...:)）视频转换器脚本，带有进度（ffmpeg-python 和 tq​​dm_rich）：
https://gist.github.com/pbouill/fddf767221b47f83c97d7813c03569c4

无需覆盖 sys.stdout/stderr，然后像某些 tqdm 文档建议的那样恢复以获取子进程输出/拦截控制台输出（https://github.com/tqdm/tqdm/blob/master/examples/ redirect_print.py）。

只需通过提供输入文件路径来创建视频转换器实例：

vc = VideoConverter(input_path=pathlib.Path('./path/to/my/file'))
vc.convert()

如果未提供输出路径，则输出视频将放置在与输入文件相同的目录中，并附加“-converted.mp4”。您也可以调整输出/转换 kwargs...默认情况下它使用：

class VideoConverter:
    FF_OUTPUT_KWARGS = {
        'vcodec': 'libx265',
        'crf': 35 
    }
    ...

例如，

vc = VideoConverter(
    input_path=pathlib.Path('./path/to/my/input_file.mp4'), 
    output_path=pathlib.Path('./path/to/my/output_file.mp4')),
    output_kwargs={
        'crf': 30,
        'vcodec': 'libx264'
    }
)
vc.convert()

您可以通过在调用“转换”时提供进度指标选择来基于视频时间的进度报告或基于帧的进度报告：

class VideoConverter:
    ...
    class ProgressMetric(Enum):
            FRAMES = auto()
            TIME = auto()
    ...

vc.convert(self, progress_metric = VideoConverter.ProgressMetric.TIME)

您可以转换所有内容在脚本目录中，只需调用：（

VideoConverter.convert_all()

也可以指定输入目录、输出目录、output_kwargs 作为此函数的关键字参数）

希望这有帮助！

Answer 8

如果您有持续时间（也可以从 FFMPEG 输出中获取），您可以通过在编码时读取经过的时间（时间）输出来计算进度。

一个简单的例子：

  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 9

在我看来，通过使用 ffmpeg 的 -progress url (global) 选项，解决方案实际上很简单：

ffmpeg -progress progress.log -i file.mp4 file.avi

文件 progress.log 将附加实时进度信息（更新周期​​使用 -stats_period 选项设置）。

该信息将如下所示：

frame=584
fps=52.40
stream_0_0_q=0.0
bitrate=N/A
total_size=762
out_time_us=0
out_time_ms=0
out_time=00:00:00.000000
dup_frames=0
drop_frames=0
speed=   0x
progress=continue

根据此信息，可以计算进度。

程序员博客中有更详细的示例