open-source-mirrors
/
bazarr
mirror of https://github.com/morpheus65535/bazarr
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
bazarr/libs/pymediainfo/__init__.py

529 lines
21 KiB
Raw Permalink Blame History

# vim: set fileencoding=utf-8 :
"""
This module is a wrapper around the MediaInfo library.
"""
import ctypes
import json
import os
import pathlib
import re
import sys
import warnings
import xml.etree.ElementTree as ET
from typing import Any, Dict, List, Optional, Tuple, Union
try:
from importlib import metadata
except ImportError:
import importlib_metadata as metadata # type: ignore
try:
__version__ = metadata.version("pymediainfo")
except metadata.PackageNotFoundError:
__version__ = ""
class Track:
"""
An object associated with a media file track.
Each :class:`Track` attribute corresponds to attributes parsed from MediaInfo's output.
All attributes are lower case. Attributes that are present several times such as `Duration`
yield a second attribute starting with `other_` which is a list of all alternative
attribute values.
When a non-existing attribute is accessed, `None` is returned.
Example:
>>> t = mi.tracks[0]
>>> t
<Track track_id='None', track_type='General'>
>>> t.duration
3000
>>> t.other_duration
['3 s 0 ms', '3 s 0 ms', '3 s 0 ms',
'00:00:03.000', '00:00:03.000']
>>> type(t.non_existing)
NoneType
All available attributes can be obtained by calling :func:`to_data`.
"""
def __eq__(self, other): # type: ignore
return self.__dict__ == other.__dict__
def __getattribute__(self, name): # type: ignore
try:
return object.__getattribute__(self, name)
except AttributeError:
pass
return None
def __getstate__(self): # type: ignore
return self.__dict__
def __setstate__(self, state): # type: ignore
self.__dict__ = state
def __init__(self, xml_dom_fragment: ET.Element):
self.track_type = xml_dom_fragment.attrib["type"]
repeated_attributes = []
for elem in xml_dom_fragment:
node_name = elem.tag.lower().strip().strip("_")
if node_name == "id":
node_name = "track_id"
node_value = elem.text
if getattr(self, node_name) is None:
setattr(self, node_name, node_value)
else:
other_node_name = f"other_{node_name}"
repeated_attributes.append((node_name, other_node_name))
if getattr(self, other_node_name) is None:
setattr(self, other_node_name, [node_value])
else:
getattr(self, other_node_name).append(node_value)
for primary_key, other_key in repeated_attributes:
try:
# Attempt to convert the main value to int
# Usually, if an attribute is repeated, one of its value
# is an int and others are human-readable formats
setattr(self, primary_key, int(getattr(self, primary_key)))
except ValueError:
# If it fails, try to find a secondary value
# that is an int and swap it with the main value
for other_value in getattr(self, other_key):
try:
current = getattr(self, primary_key)
# Set the main value to an int
setattr(self, primary_key, int(other_value))
# Append its previous value to other values
getattr(self, other_key).append(current)
break
except ValueError:
pass
def __repr__(self): # type: ignore
return "<Track track_id='{}', track_type='{}'>".format(self.track_id, self.track_type)
def to_data(self) -> Dict[str, Any]:
"""
Returns a dict representation of the track attributes.
Example:
>>> sorted(track.to_data().keys())[:3]
['codec', 'codec_extensions_usually_used', 'codec_url']
>>> t.to_data()["file_size"]
5988
:rtype: dict
"""
return self.__dict__
class MediaInfo:
"""
An object containing information about a media file.
:class:`MediaInfo` objects can be created by directly calling code from
libmediainfo (in this case, the library must be present on the system):
>>> pymediainfo.MediaInfo.parse("/path/to/file.mp4")
Alternatively, objects may be created from MediaInfo's XML output.
Such output can be obtained using the ``XML`` output format on versions older than v17.10
and the ``OLDXML`` format on newer versions.
Using such an XML file, we can create a :class:`MediaInfo` object:
>>> with open("output.xml") as f:
... mi = pymediainfo.MediaInfo(f.read())
:param str xml: XML output obtained from MediaInfo.
:param str encoding_errors: option to pass to :func:`str.encode`'s `errors`
parameter before parsing `xml`.
:raises xml.etree.ElementTree.ParseError: if passed invalid XML.
:var tracks: A list of :py:class:`Track` objects which the media file contains.
For instance:
>>> mi = pymediainfo.MediaInfo.parse("/path/to/file.mp4")
>>> for t in mi.tracks:
... print(t)
<Track track_id='None', track_type='General'>
<Track track_id='1', track_type='Text'>
"""
def __eq__(self, other): # type: ignore
return self.tracks == other.tracks
def __init__(self, xml: str, encoding_errors: str = "strict"):
xml_dom = ET.fromstring(xml.encode("utf-8", encoding_errors))
self.tracks = []
# This is the case for libmediainfo < 18.03
# https://github.com/sbraz/pymediainfo/issues/57
# https://github.com/MediaArea/MediaInfoLib/commit/575a9a32e6960ea34adb3bc982c64edfa06e95eb
if xml_dom.tag == "File":
xpath = "track"
else:
xpath = "File/track"
for xml_track in xml_dom.iterfind(xpath):
self.tracks.append(Track(xml_track))
def _tracks(self, track_type: str) -> List[Track]:
return [track for track in self.tracks if track.track_type == track_type]
@property
def general_tracks(self) -> List[Track]:
"""
:return: All :class:`Track`\\s of type ``General``.
:rtype: list of :class:`Track`\\s
"""
return self._tracks("General")
@property
def video_tracks(self) -> List[Track]:
"""
:return: All :class:`Track`\\s of type ``Video``.
:rtype: list of :class:`Track`\\s
"""
return self._tracks("Video")
@property
def audio_tracks(self) -> List[Track]:
"""
:return: All :class:`Track`\\s of type ``Audio``.
:rtype: list of :class:`Track`\\s
"""
return self._tracks("Audio")
@property
def text_tracks(self) -> List[Track]:
"""
:return: All :class:`Track`\\s of type ``Text``.
:rtype: list of :class:`Track`\\s
"""
return self._tracks("Text")
@property
def other_tracks(self) -> List[Track]:
"""
:return: All :class:`Track`\\s of type ``Other``.
:rtype: list of :class:`Track`\\s
"""
return self._tracks("Other")
@property
def image_tracks(self) -> List[Track]:
"""
:return: All :class:`Track`\\s of type ``Image``.
:rtype: list of :class:`Track`\\s
"""
return self._tracks("Image")
@property
def menu_tracks(self) -> List[Track]:
"""
:return: All :class:`Track`\\s of type ``Menu``.
:rtype: list of :class:`Track`\\s
"""
return self._tracks("Menu")
@staticmethod
def _normalize_filename(filename: Any) -> Any:
if hasattr(os, "PathLike") and isinstance(filename, os.PathLike):
return os.fspath(filename)
if pathlib is not None and isinstance(filename, pathlib.PurePath):
return str(filename)
return filename
@classmethod
def _define_library_prototypes(cls, lib: Any) -> Any:
lib.MediaInfo_Inform.restype = ctypes.c_wchar_p
lib.MediaInfo_New.argtypes = []
lib.MediaInfo_New.restype = ctypes.c_void_p
lib.MediaInfo_Option.argtypes = [
ctypes.c_void_p,
ctypes.c_wchar_p,
ctypes.c_wchar_p,
]
lib.MediaInfo_Option.restype = ctypes.c_wchar_p
lib.MediaInfo_Inform.argtypes = [ctypes.c_void_p, ctypes.c_size_t]
lib.MediaInfo_Inform.restype = ctypes.c_wchar_p
lib.MediaInfo_Open.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p]
lib.MediaInfo_Open.restype = ctypes.c_size_t
lib.MediaInfo_Open_Buffer_Init.argtypes = [
ctypes.c_void_p,
ctypes.c_uint64,
ctypes.c_uint64,
]
lib.MediaInfo_Open_Buffer_Init.restype = ctypes.c_size_t
lib.MediaInfo_Open_Buffer_Continue.argtypes = [
ctypes.c_void_p,
ctypes.c_char_p,
ctypes.c_size_t,
]
lib.MediaInfo_Open_Buffer_Continue.restype = ctypes.c_size_t
lib.MediaInfo_Open_Buffer_Continue_GoTo_Get.argtypes = [ctypes.c_void_p]
lib.MediaInfo_Open_Buffer_Continue_GoTo_Get.restype = ctypes.c_uint64
lib.MediaInfo_Open_Buffer_Finalize.argtypes = [ctypes.c_void_p]
lib.MediaInfo_Open_Buffer_Finalize.restype = ctypes.c_size_t
lib.MediaInfo_Delete.argtypes = [ctypes.c_void_p]
lib.MediaInfo_Delete.restype = None
lib.MediaInfo_Close.argtypes = [ctypes.c_void_p]
lib.MediaInfo_Close.restype = None
@staticmethod
def _get_library_paths(os_is_nt: bool) -> Tuple[str]:
if os_is_nt:
library_paths = ("MediaInfo.dll",)
elif sys.platform == "darwin":
library_paths = ("libmediainfo.0.dylib", "libmediainfo.dylib")
else:
library_paths = ("libmediainfo.so.0",)
script_dir = os.path.dirname(__file__)
# Look for the library file in the script folder
for library in library_paths:
absolute_library_path = os.path.join(script_dir, library)
if os.path.isfile(absolute_library_path):
# If we find it, don't try any other filename
library_paths = (absolute_library_path,)
break
return library_paths
@classmethod
def _get_library(
cls,
library_file: Optional[str] = None,
) -> Tuple[Any, Any, str, Tuple[int, ...]]:
os_is_nt = os.name in ("nt", "dos", "os2", "ce")
if os_is_nt:
lib_type = ctypes.WinDLL # type: ignore
else:
lib_type = ctypes.CDLL
if library_file is None:
library_paths = cls._get_library_paths(os_is_nt)
else:
library_paths = (library_file,)
exceptions = []
for library_path in library_paths:
try:
lib = lib_type(library_path)
cls._define_library_prototypes(lib)
# Without a handle, there might be problems when using concurrent threads
# https://github.com/sbraz/pymediainfo/issues/76#issuecomment-574759621
handle = lib.MediaInfo_New()
version = lib.MediaInfo_Option(handle, "Info_Version", "")
match = re.search(r"^MediaInfoLib - v(\S+)", version)
if match:
lib_version_str = match.group(1)
lib_version = tuple(int(_) for _ in lib_version_str.split("."))
else:
raise RuntimeError("Could not determine library version")
return (lib, handle, lib_version_str, lib_version)
except OSError as exc:
exceptions.append(str(exc))
raise OSError(
"Failed to load library from {} - {}".format(
", ".join(library_paths), ", ".join(exceptions)
)
)
@classmethod
def can_parse(cls, library_file: Optional[str] = None) -> bool:
"""
Checks whether media files can be analyzed using libmediainfo.
:param str library_file: path to the libmediainfo library, this should only be used if
the library cannot be auto-detected.
:rtype: bool
"""
try:
lib, handle = cls._get_library(library_file)[:2]
lib.MediaInfo_Close(handle)
lib.MediaInfo_Delete(handle)
return True
except Exception: # pylint: disable=broad-except
return False
@classmethod
def parse(
# pylint: disable=too-many-statements
# pylint: disable=too-many-branches, too-many-locals, too-many-arguments
cls,
filename: Any,
library_file: Optional[str] = None,
cover_data: bool = False,
encoding_errors: str = "strict",
parse_speed: float = 0.5,
full: bool = True,
legacy_stream_display: bool = False,
mediainfo_options: Optional[Dict[str, str]] = None,
output: Optional[str] = None,
) -> Union[str, "MediaInfo"]:
"""
Analyze a media file using libmediainfo.
.. note::
Because of the way the underlying library works, this method should not
be called simultaneously from multiple threads *with different arguments*.
Doing so will cause inconsistencies or failures by changing
library options that are shared across threads.
:param filename: path to the media file or file-like object which will be analyzed.
A URL can also be used if libmediainfo was compiled
with CURL support.
:param str library_file: path to the libmediainfo library, this should only be used if
the library cannot be auto-detected.
:param bool cover_data: whether to retrieve cover data as base64.
:param str encoding_errors: option to pass to :func:`str.encode`'s `errors`
parameter before parsing MediaInfo's XML output.
:param float parse_speed: passed to the library as `ParseSpeed`,
this option takes values between 0 and 1.
A higher value will yield more precise results in some cases
but will also increase parsing time.
:param bool full: display additional tags, including computer-readable values
for sizes and durations, corresponds to the CLI's ``--Full``/``-f`` parameter.
:param bool legacy_stream_display: display additional information about streams.
:param dict mediainfo_options: additional options that will be passed to the
`MediaInfo_Option` function, for example: ``{"Language": "raw"}``.
Do not use this parameter when running the method simultaneously from multiple threads,
it will trigger a reset of all options which will cause inconsistencies or failures.
:param str output: custom output format for MediaInfo, corresponds to the CLI's
``--Output`` parameter. Setting this causes the method to
return a `str` instead of a :class:`MediaInfo` object.
Useful values include:
* the empty `str` ``""`` (corresponds to the default
text output, obtained when running ``mediainfo`` with no
additional parameters)
* ``"XML"``
* ``"JSON"``
* ``%``-delimited templates (see ``mediainfo --Info-Parameters``)
:type filename: str or pathlib.Path or os.PathLike or file-like object.
:rtype: str if `output` is set.
:rtype: :class:`MediaInfo` otherwise.
:raises FileNotFoundError: if passed a non-existent file.
:raises ValueError: if passed a file-like object opened in text mode.
:raises OSError: if the library file could not be loaded.
:raises RuntimeError: if parsing fails, this should not
happen unless libmediainfo itself fails.
Examples:
>>> pymediainfo.MediaInfo.parse("tests/data/sample.mkv")
<pymediainfo.MediaInfo object at 0x7fa83a3db240>
>>> import json
>>> mi = pymediainfo.MediaInfo.parse("tests/data/sample.mkv",
... output="JSON")
>>> json.loads(mi)["media"]["track"][0]
{'@type': 'General', 'TextCount': '1', 'FileExtension': 'mkv',
'FileSize': '5904', … }
"""
lib, handle, lib_version_str, lib_version = cls._get_library(library_file)
# The XML option was renamed starting with version 17.10
if lib_version >= (17, 10):
xml_option = "OLDXML"
else:
xml_option = "XML"
# Cover_Data is not extracted by default since version 18.03
# See https://github.com/MediaArea/MediaInfoLib/commit/d8fd88a1
if lib_version >= (18, 3):
lib.MediaInfo_Option(handle, "Cover_Data", "base64" if cover_data else "")
lib.MediaInfo_Option(handle, "CharSet", "UTF-8")
lib.MediaInfo_Option(handle, "Inform", xml_option if output is None else output)
lib.MediaInfo_Option(handle, "Complete", "1" if full else "")
lib.MediaInfo_Option(handle, "ParseSpeed", str(parse_speed))
lib.MediaInfo_Option(handle, "LegacyStreamDisplay", "1" if legacy_stream_display else "")
if mediainfo_options is not None:
if lib_version < (19, 9):
warnings.warn(
"This version of MediaInfo (v{}) does not support resetting all "
"options to their default values, passing it custom options is not recommended "
"and may result in unpredictable behavior, see "
"https://github.com/MediaArea/MediaInfoLib/issues/1128".format(lib_version_str),
RuntimeWarning,
)
for option_name, option_value in mediainfo_options.items():
lib.MediaInfo_Option(handle, option_name, option_value)
try:
filename.seek(0, 2)
file_size = filename.tell()
filename.seek(0)
except AttributeError: # filename is not a file-like object
file_size = None
if file_size is not None: # We have a file-like object, use the buffer protocol:
# Some file-like objects do not have a mode
if "b" not in getattr(filename, "mode", "b"):
raise ValueError("File should be opened in binary mode")
lib.MediaInfo_Open_Buffer_Init(handle, file_size, 0)
while True:
buffer = filename.read(64 * 1024)
if buffer:
# https://github.com/MediaArea/MediaInfoLib/blob/v20.09/Source/MediaInfo/File__Analyze.h#L1429
# 4th bit = finished
if lib.MediaInfo_Open_Buffer_Continue(handle, buffer, len(buffer)) & 0x08:
break
# Ask MediaInfo if we need to seek
seek = lib.MediaInfo_Open_Buffer_Continue_GoTo_Get(handle)
# https://github.com/MediaArea/MediaInfoLib/blob/v20.09/Source/MediaInfoDLL/MediaInfoJNI.cpp#L127
if seek != ctypes.c_uint64(-1).value:
filename.seek(seek)
# Inform MediaInfo we have sought
lib.MediaInfo_Open_Buffer_Init(handle, file_size, filename.tell())
else:
break
lib.MediaInfo_Open_Buffer_Finalize(handle)
else: # We have a filename, simply pass it:
filename = cls._normalize_filename(filename)
# If an error occured
if lib.MediaInfo_Open(handle, filename) == 0:
lib.MediaInfo_Close(handle)
lib.MediaInfo_Delete(handle)
# If filename doesn't look like a URL and doesn't exist
if "://" not in filename and not os.path.exists(filename):
raise FileNotFoundError(filename)
# We ran into another kind of error
raise RuntimeError(
"An error occured while opening {}" " with libmediainfo".format(filename)
)
info: str = lib.MediaInfo_Inform(handle, 0)
# Reset all options to their defaults so that they aren't
# retained when the parse method is called several times
# https://github.com/MediaArea/MediaInfoLib/issues/1128
# Do not call it when it is not required because it breaks threads
# https://github.com/sbraz/pymediainfo/issues/76#issuecomment-575245093
if mediainfo_options is not None and lib_version >= (19, 9):
lib.MediaInfo_Option(handle, "Reset", "")
# Delete the handle
lib.MediaInfo_Close(handle)
lib.MediaInfo_Delete(handle)
if output is None:
return cls(info, encoding_errors)
return info
def to_data(self) -> Dict[str, Any]:
"""
Returns a dict representation of the object's :py:class:`Tracks <Track>`.
:rtype: dict
"""
return {"tracks": [_.to_data() for _ in self.tracks]}
def to_json(self) -> str:
"""
Returns a JSON representation of the object's :py:class:`Tracks <Track>`.
:rtype: str
"""
return json.dumps(self.to_data())
Reference in new issue View Git Blame Copy Permalink