使用 Python 获取视频属性，无需调用外部软件 [英] Getting video properties with Python without calling external software
问题描述
[更新:] 是的，这是可能的，现在大约 20 个月后.请参阅下面的 Update3！[/更新]
[Update:] Yes, it is possible, now some 20 months later. See Update3 below! [/update]
这真的不可能吗?我所能找到的只是调用 FFmpeg(或其他软件)的变体.我当前的解决方案如下所示，但为了可移植性，我真正想要的是一个纯 Python 的解决方案，它不需要用户安装额外的软件.
Is that really impossible? All I could find were variants of calling FFmpeg (or other software). My current solution is shown below, but what I really would like to get for portability is a Python-only solution that doesn't require users to install additional software.
毕竟，我可以使用 PyQt 的 Phonon 轻松播放视频，但我不能简单地获取诸如视频的尺寸或时长之类的信息?
After all, I can easily play videos using PyQt's Phonon, yet I can't get simply things like dimension or duration of the video?
我的解决方案使用 ffmpy (http://ffmpy.readthedocs.io/en/latest/ffmpy.html )，它是 FFmpeg 和 FFprobe 的包装器(http://trac.ffmpeg.org/wiki/FFprobeTips).比其他产品更流畅，但仍需要额外安装 FFmpeg.
My solution uses ffmpy (http://ffmpy.readthedocs.io/en/latest/ffmpy.html ) which is a wrapper for FFmpeg and FFprobe (http://trac.ffmpeg.org/wiki/FFprobeTips). Smoother than other offerings, yet it still requires an additional FFmpeg installation.
import ffmpy, subprocess, json
ffprobe = ffmpy.FFprobe(global_options="-loglevel quiet -sexagesimal -of json -show_entries stream=width,height,duration -show_entries format=duration -select_streams v:0", inputs={"myvideo.mp4": None})
print("ffprobe.cmd:", ffprobe.cmd) # printout the resulting ffprobe shell command
stdout, stderr = ffprobe.run(stderr=subprocess.PIPE, stdout=subprocess.PIPE)
# std* is byte sequence, but json in Python 3.5.2 requires str
ff0string = str(stdout,'utf-8')
ffinfo = json.loads(ff0string)
print(json.dumps(ffinfo, indent=4)) # pretty print
print("Video Dimensions: {}x{}".format(ffinfo["streams"][0]["width"], ffinfo["streams"][0]["height"]))
print("Streams Duration:", ffinfo["streams"][0]["duration"])
print("Format Duration: ", ffinfo["format"]["duration"])
结果输出:
ffprobe.cmd: ffprobe -loglevel quiet -sexagesimal -of json -show_entries stream=width,height,duration -show_entries format=duration -select_streams v:0 -i myvideo.mp4
{
"streams": [
{
"duration": "0:00:32.033333",
"width": 1920,
"height": 1080
}
],
"programs": [],
"format": {
"duration": "0:00:32.064000"
}
}
Video Dimensions: 1920x1080
Streams Duration: 0:00:32.033333
Format Duration: 0:00:32.064000
更新 经过几天的实验:下面由 Nick 提出的 hachoire 解决方案确实有效，但会给您带来很多麻烦，因为 hachoire 响应太不可预测了.不是我的选择.
UPDATE after several days of experimentation: The hachoire solution as proposed by Nick below does work, but will give you a lot of headaches, as the hachoire responses are too unpredictable. Not my choice.
使用 opencv 编码再简单不过了:
With opencv coding couldn't be any easier:
import cv2
vid = cv2.VideoCapture( picfilename)
height = vid.get(cv2.CAP_PROP_FRAME_HEIGHT) # always 0 in Linux python3
width = vid.get(cv2.CAP_PROP_FRAME_WIDTH) # always 0 in Linux python3
print ("opencv: height:{} width:{}".format( height, width))
问题是它在 Python2 上运行良好，但在 Py3 上运行不正常.引用:重要说明:MacOS 和 Linux 软件包不支持视频相关功能(未使用 FFmpeg 编译)"(https://pypi.python.org/pypi/opencv-python).
The problem is that it works well on Python2 but not on Py3. Quote: "IMPORTANT NOTE: MacOS and Linux packages do not support video related functionality (not compiled with FFmpeg)" (https://pypi.python.org/pypi/opencv-python).
最重要的是，opencv 似乎需要在运行时存在 FFmeg 的二进制包(https://docs.opencv.org/3.3.1/d0/da7/videoio_overview.html).
On top of this it seems that opencv needs the presence of the binary packages of FFmeg at runtime (https://docs.opencv.org/3.3.1/d0/da7/videoio_overview.html).
好吧，如果我无论如何都需要安装 FFmpeg，我可以坚持使用上面显示的原始 ffmpy 示例:-/
Well, if I need an installation of FFmpeg anyway, I can stick to my original ffmpy example shown above :-/
感谢您的帮助.
UPDATE2: master_q(见下文)提议的 MediaInfo.虽然这在我的 Linux 系统上不起作用(请参阅我的评论)，但使用 pymediainfo(MediaInfo 的 py 包装器)的替代方法确实有效.使用起来很简单，但是获取时长、宽度和高度的时间比我最初的 ffprobe 方法要长 4 倍，而且仍然需要外部软件，即 MediaInfo:
UPDATE2: master_q (see below) proposed MediaInfo. While this failed to work on my Linux system (see my comments), the alternative of using pymediainfo, a py wrapper to MediaInfo, did work. It is simple to use, but it takes 4 times longer than my initial ffprobe approach to obtain duration, width and height, and still needs external software, i.e. MediaInfo:
from pymediainfo import MediaInfo
media_info = MediaInfo.parse("myvideofile")
for track in media_info.tracks:
if track.track_type == 'Video':
print("duration (millisec):", track.duration)
print("width, height:", track.width, track.height)
UPDATE3: OpenCV 终于可用于 Python3，并声称可以在 Linux、Win 和 Mac 上运行！这真的很容易，而且我证实不需要外部软件 - 特别是 ffmpeg - ！
UPDATE3: OpenCV is finally available for Python3, and is claimed to run on Linux, Win, and Mac! It makes it really easy, and I verfied that external software - in particular ffmpeg - is NOT needed!
首先通过 Pip 安装 OpenCV:
First install OpenCV via Pip:
pip install opencv-python
在 Python 中运行:
Run in Python:
import cv2
cv2video = cv2.VideoCapture( videofilename)
height = cv2video.get(cv2.CAP_PROP_FRAME_HEIGHT)
width = cv2video.get(cv2.CAP_PROP_FRAME_WIDTH)
print ("Video Dimension: height:{} width:{}".format( height, width))
framecount = cv2video.get(cv2.CAP_PROP_FRAME_COUNT )
frames_per_sec = cv2video.get(cv2.CAP_PROP_FPS)
print("Video duration (sec):", framecount / frames_per_sec)
# equally easy to get this info from images
cv2image = cv2.imread(imagefilename, flags=cv2.IMREAD_COLOR )
height, width, channel = cv2image.shape
print ("Image Dimension: height:{} width:{}".format( height, width))
我还需要视频的第一帧作为图像，并为此使用 ffmpeg 将图像保存在文件系统中.使用 OpenCV 也更容易:
I also needed the first frame of a video as an image, and used ffmpeg for this to save the image in the file system. This also is easier with OpenCV:
hasFrames, cv2image = cv2video.read() # reads 1st frame
cv2.imwrite("myfilename.png", cv2image) # extension defines image type
但更好的是，因为我只需要内存中的图像以供 PyQt5 工具包使用，所以我可以直接将 cv2-image 读入 Qt-image:
But even better, as I need the image only in memory for use in the PyQt5 toolkit, I can directly read the cv2-image into an Qt-image:
bytesPerLine = 3 * width
# my_qt_image = QImage(cv2image, width, height, bytesPerLine, QImage.Format_RGB888) # may give false colors!
my_qt_image = QImage(cv2image.data, width, height, bytesPerLine, QImage.Format_RGB888).rgbSwapped() # correct colors on my systems
由于 OpenCV 是一个庞大的程序，我很担心时间.事实证明，OpenCV 从来没有落后于替代品.我需要大约 100 毫秒来阅读一张幻灯片，其余所有时间加起来不会超过 10 毫秒.
As OpenCV is a huge program, I was concerned about timing. Turned out, OpenCV was never behind the alternatives. I takes some 100ms to read a slide, all the rest combined takes never more than 10ms.
我在 Ubuntu Mate 16.04、18.04 和 19.04 以及两个不同的 Windows 10 Pro 安装上成功地测试了这个.(没有 Mac 可用).我对 OpenCV 非常满意！
I tested this successfully on Ubuntu Mate 16.04, 18.04, and 19.04, and on two different installations of Windows 10 Pro. (Did not have Mac avalable). I am really delighted about OpenCV!
您可以在我的 SlideSorter 程序中看到它的运行情况，该程序允许对图像和视频进行排序、保留排序顺序并以幻灯片形式呈现.可在此处获得:https://sourceforge.net/projects/slidesorter/
You can see it in action in my SlideSorter program, which allows to sort images and videos, preserve sort order, and present as slideshow. Available here: https://sourceforge.net/projects/slidesorter/
推荐答案
好的，在我自己调查之后因为我也需要它，看起来它可以用 hachoir 完成.这是一个代码片段，可以为您提供 hachoir 可以读取的所有元数据:
OK, after investigating this myself because I needed it too, it looks like it can be done with hachoir. Here's a code snippet that can give you all the metadata hachoir can read:
import re
from hachoir.parser import createParser
from hachoir.metadata import extractMetadata
def get_video_metadata(path):
"""
Given a path, returns a dictionary of the video's metadata, as parsed by hachoir.
Keys vary by exact filetype, but for an MP4 file on my machine,
I get the following keys (inside of "Common" subdict):
"Duration", "Image width", "Image height", "Creation date",
"Last modification", "MIME type", "Endianness"
Dict is nested - common keys are inside of a subdict "Common",
which will always exist, but some keys *may* be inside of
video/audio specific stream subdicts, named "Video Stream #1"
or "Audio Stream #1", etc. Not all formats result in this
separation.
:param path: str path to video file
:return: dict of video metadata
"""
if not os.path.exists(path):
raise ValueError("Provided path to video ({}) does not exist".format(path))
parser = createParser(path)
if not parser:
raise RuntimeError("Unable to get metadata from video file")
with parser:
metadata = extractMetadata(parser)
if not metadata:
raise RuntimeError("Unable to get metadata from video file")
metadata_dict = {}
line_matcher = re.compile("-\s(?P<key>.+):\s(?P<value>.+)")
group_key = None # group_key stores which group we're currently in for nesting subkeys
for line in metadata.exportPlaintext(): # this is what hachoir offers for dumping readable information
parts = line_matcher.match(line) #
if not parts: # not all lines have metadata - at least one is a header
if line == "Metadata:": # if it's the generic header, set it to "Common: to match items with multiple streams, so there's always a Common key
group_key = "Common"
else:
group_key = line[:-1] # strip off the trailing colon of the group header and set it to be the current group we add other keys into
metadata_dict[group_key] = {} # initialize the group
continue
if group_key: # if we're inside of a group, then nest this key inside it
metadata_dict[group_key][parts.group("key")] = parts.group("value")
else: # otherwise, put it in the root of the dict
metadata_dict[parts.group("key")] = parts.group("value")
return metadata_dict
这现在似乎对我来说效果很好，不需要额外的安装.键似乎因视频和视频类型而异，因此您需要进行一些检查，而不仅仅是假设存在任何特定键.此代码是为 Python 3 编写的，使用的是 hachoir3 并改编自 hachoir3 文档 - 我还没有调查它是否适用于 Python 2 的 hachoir.
This seems to return good results for me right now and requires no extra installs. The keys seem to vary a decent amount by video and type of video, so you'll need to do some checking and not just assume any particular key is there. This code is written for Python 3 and is using hachoir3 and adapted from hachoir3 documentation - I haven't investigated if it works for hachoir for Python 2.
如果它有用，我还有以下将基于文本的持续时间值转换为秒的方法:
In case it's useful, I also have the following for turning the text-based duration values into seconds:
def length(duration_value):
time_split = re.match("(?P<hours>\d+\shrs)?\s*(?P<minutes>\d+\smin)?\s*(?P<seconds>\d+\ssec)?\s*(?P<ms>\d+\sms)", duration_value) # get the individual time components
fields_and_multipliers = { # multipliers to convert each value to seconds
"hours": 3600,
"minutes": 60,
"seconds": 1,
"ms": 1
}
total_time = 0
for group in fields_and_multipliers: # iterate through each portion of time, multiply until it's in seconds and add to total
if time_split.group(group) is not None: # not all groups will be defined for all videos (eg: "hrs" may be missing)
total_time += float(time_split.group(group).split(" ")[0]) * fields_and_multipliers[group] # get the number from the match and multiply it to make seconds
return total_time
这篇关于使用 Python 获取视频属性，无需调用外部软件的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
