ifm3d-ffmpeg 8.1.2.post1__py3-none-win_amd64.whl

ifm3d_ffmpeg/BUILD_INFO.json

@@ -0,0 +1,26 @@
+{
+  "avcodec_major": 62,
+  "avutil_major": 60,
+  "build_revision": 1,
+  "bundled_non_system_dependencies": [],
+  "distribution_version": "8.1.2.post1",
+  "embedded_dependencies": [
+    "winpthreads"
+  ],
+  "ffmpeg_version": "8.1.2",
+  "libraries": {
+    "avcodec": "avcodec-62.dll",
+    "avutil": "avutil-60.dll"
+  },
+  "license_files": [
+    "licenses/COPYING.LGPLv2.1",
+    "licenses/COPYING.LGPLv3",
+    "licenses/LICENSE.md",
+    "licenses/winpthreads-COPYING"
+  ],
+  "platform": "windows-x64",
+  "schema_version": 1,
+  "source_date_epoch": 1781664417,
+  "source_sha256": "464beb5e7bf0c311e68b45ae2f04e9cc2af88851abb4082231742a74d97b524c",
+  "wheel_tag": "py3-none-win_amd64"
+}

ifm3d_ffmpeg/__init__.py

@@ -0,0 +1,13 @@
+"""Package-local FFmpeg H.264 decoder libraries for ifm3d."""
+
+from ._loader import abi_info, activate, lib_files, lib_path, version
+
+__version__ = str(abi_info()["distribution_version"])
+__all__ = [
+    "__version__",
+    "version",
+    "abi_info",
+    "lib_path",
+    "lib_files",
+    "activate",
+]

ifm3d_ffmpeg/_loader.py

@@ -0,0 +1,160 @@
+"""Strict discovery for the FFmpeg libraries bundled in a release wheel."""
+
+from __future__ import annotations
+
+import json
+import ctypes
+import os
+import platform
+import re
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+_VERSION_RE = re.compile(r"^[0-9]+\.[0-9]+\.[0-9]+$")
+_PLATFORMS = {"linux-x64", "linux-aarch64", "windows-x64"}
+_REQUIRED_KEYS = {
+    "schema_version",
+    "ffmpeg_version",
+    "build_revision",
+    "distribution_version",
+    "platform",
+    "wheel_tag",
+    "source_sha256",
+    "source_date_epoch",
+    "avcodec_major",
+    "avutil_major",
+    "libraries",
+    "bundled_non_system_dependencies",
+    "embedded_dependencies",
+    "license_files",
+}
+_DLL_DIRECTORY_HANDLES: list[Any] = []
+_LIBRARY_HANDLES: list[Any] = []
+
+
+def _host_platform() -> str:
+    machine = platform.machine().lower()
+    if sys.platform == "win32" and machine in {"amd64", "x86_64"}:
+        return "windows-x64"
+    if sys.platform == "linux" and machine in {"amd64", "x86_64"}:
+        return "linux-x64"
+    if sys.platform == "linux" and machine in {"aarch64", "arm64"}:
+        return "linux-aarch64"
+    raise RuntimeError(
+        f"unsupported host for ifm3d-ffmpeg: {sys.platform}/{platform.machine()}"
+    )
+
+
+def _load_metadata() -> Dict[str, Any]:
+    path = Path(__file__).with_name("BUILD_INFO.json")
+    try:
+        metadata = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError as exc:
+        raise RuntimeError(f"required wheel metadata is missing: {path}") from exc
+    except (OSError, json.JSONDecodeError) as exc:
+        raise RuntimeError(f"required wheel metadata is invalid: {exc}") from exc
+    if not isinstance(metadata, dict) or set(metadata) != _REQUIRED_KEYS:
+        raise RuntimeError("wheel metadata fields are incomplete or unexpected")
+    version = metadata["ffmpeg_version"]
+    revision = metadata["build_revision"]
+    package_platform = metadata["platform"]
+    if (
+        metadata["schema_version"] != 1
+        or not isinstance(version, str)
+        or not _VERSION_RE.fullmatch(version)
+        or not isinstance(revision, int)
+        or revision < 1
+        or package_platform not in _PLATFORMS
+        or metadata["distribution_version"] != f"{version}.post{revision}"
+        or not re.fullmatch(r"[0-9a-f]{64}", str(metadata["source_sha256"]))
+        or not isinstance(metadata["source_date_epoch"], int)
+        or not isinstance(metadata["avcodec_major"], int)
+        or not isinstance(metadata["avutil_major"], int)
+        or not isinstance(metadata["bundled_non_system_dependencies"], list)
+        or metadata["bundled_non_system_dependencies"]
+        or not isinstance(metadata["embedded_dependencies"], list)
+    ):
+        raise RuntimeError("wheel metadata values are invalid")
+    if package_platform != _host_platform():
+        raise RuntimeError(
+            f"wheel targets {package_platform}, but host is {_host_platform()}"
+        )
+    libraries = metadata["libraries"]
+    if not isinstance(libraries, dict) or set(libraries) != {"avcodec", "avutil"}:
+        raise RuntimeError("wheel metadata library map is invalid")
+    expected = (
+        {
+            "avcodec": f"avcodec-{metadata['avcodec_major']}.dll",
+            "avutil": f"avutil-{metadata['avutil_major']}.dll",
+        }
+        if package_platform == "windows-x64"
+        else {
+            "avcodec": f"libavcodec.so.{metadata['avcodec_major']}",
+            "avutil": f"libavutil.so.{metadata['avutil_major']}",
+        }
+    )
+    if libraries != expected:
+        raise RuntimeError("wheel library names do not match ABI metadata")
+    expected_embedded = (
+        {"winpthreads"} if package_platform == "windows-x64" else set()
+    )
+    embedded_dependencies = metadata["embedded_dependencies"]
+    if (
+        len(embedded_dependencies) != len(set(embedded_dependencies))
+        or set(embedded_dependencies) != expected_embedded
+    ):
+        raise RuntimeError("wheel dependency metadata is invalid")
+    return metadata
+
+
+def version() -> str:
+    """Return the exact upstream FFmpeg version."""
+    return str(_load_metadata()["ffmpeg_version"])
+
+
+def abi_info() -> Dict[str, Any]:
+    """Return a copy of the validated build and ABI metadata."""
+    return dict(_load_metadata())
+
+
+def lib_path() -> Path:
+    """Return the package-local runtime library directory."""
+    path = Path(__file__).with_name("lib")
+    if not path.is_dir():
+        raise RuntimeError(f"required wheel library directory is missing: {path}")
+    return path
+
+
+def lib_files() -> Dict[str, Path]:
+    """Return exact metadata-matching avcodec and avutil runtime paths."""
+    metadata = _load_metadata()
+    libraries = metadata["libraries"]
+    assert isinstance(libraries, dict)
+    result = {name: lib_path() / str(filename) for name, filename in libraries.items()}
+    missing = [str(path) for path in result.values() if not path.is_file()]
+    if missing:
+        raise RuntimeError(f"required wheel libraries are missing: {missing}")
+    return result
+
+
+def activate() -> Dict[str, Path]:
+    """Make bundled libraries discoverable before ifm3d loads bare ABI names."""
+    files = lib_files()
+    if _LIBRARY_HANDLES:
+        return files
+    new_handles: list[Any] = []
+    if _host_platform() == "windows-x64":
+        directory_handle = os.add_dll_directory(str(lib_path()))
+        try:
+            new_handles.append(ctypes.WinDLL(str(files["avutil"])))
+            new_handles.append(ctypes.WinDLL(str(files["avcodec"])))
+        except Exception:
+            directory_handle.close()
+            raise
+        _DLL_DIRECTORY_HANDLES.append(directory_handle)
+    else:
+        new_handles.append(ctypes.CDLL(str(files["avutil"]), mode=ctypes.RTLD_GLOBAL))
+        new_handles.append(ctypes.CDLL(str(files["avcodec"]), mode=ctypes.RTLD_GLOBAL))
+    _LIBRARY_HANDLES.extend(new_handles)
+    return files