# 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 >>> 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 "".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) """ 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") >>> 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 `. :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 `. :rtype: str """ return json.dumps(self.to_data())