diff options
Diffstat (limited to 'python/servo/platform')
| -rw-r--r-- | python/servo/platform/base.py | 15 | ||||
| -rw-r--r-- | python/servo/platform/build_target.py | 372 | ||||
| -rw-r--r-- | python/servo/platform/linux.py | 7 | ||||
| -rw-r--r-- | python/servo/platform/macos.py | 18 | ||||
| -rw-r--r-- | python/servo/platform/windows.py | 23 |
5 files changed, 408 insertions, 27 deletions
diff --git a/python/servo/platform/base.py b/python/servo/platform/base.py index 3cfbd09b618..6fb2f535f4e 100644 --- a/python/servo/platform/base.py +++ b/python/servo/platform/base.py @@ -12,6 +12,8 @@ import shutil import subprocess from typing import Optional +from .build_target import BuildTarget + class Base: def __init__(self, triple: str): @@ -21,7 +23,7 @@ class Base: self.is_linux = False self.is_macos = False - def gstreamer_root(self, _cross_compilation_target: Optional[str]) -> Optional[str]: + def gstreamer_root(self, target: BuildTarget) -> Optional[str]: raise NotImplementedError("Do not know how to get GStreamer path for platform.") def executable_suffix(self) -> str: @@ -30,13 +32,13 @@ class Base: def _platform_bootstrap(self, _force: bool) -> bool: raise NotImplementedError("Bootstrap installation detection not yet available.") - def _platform_bootstrap_gstreamer(self, _force: bool) -> bool: + def _platform_bootstrap_gstreamer(self, _target: BuildTarget, _force: bool) -> bool: raise NotImplementedError( "GStreamer bootstrap support is not yet available for your OS." ) - def is_gstreamer_installed(self, cross_compilation_target: Optional[str]) -> bool: - gstreamer_root = self.gstreamer_root(cross_compilation_target) + def is_gstreamer_installed(self, target: BuildTarget) -> bool: + gstreamer_root = self.gstreamer_root(target) if gstreamer_root: pkg_config = os.path.join(gstreamer_root, "bin", "pkg-config") else: @@ -100,8 +102,9 @@ class Base: return False def bootstrap_gstreamer(self, force: bool): - if not self._platform_bootstrap_gstreamer(force): - root = self.gstreamer_root(None) + target = BuildTarget.from_triple(self.triple) + if not self._platform_bootstrap_gstreamer(target, force): + root = self.gstreamer_root(target) if root: print(f"GStreamer found at: {root}") else: diff --git a/python/servo/platform/build_target.py b/python/servo/platform/build_target.py new file mode 100644 index 00000000000..bf795386b5a --- /dev/null +++ b/python/servo/platform/build_target.py @@ -0,0 +1,372 @@ +# Copyright 2024 The Servo Project Developers. See the COPYRIGHT +# file at the top-level directory of this distribution. +# +# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +# option. This file may not be copied, modified, or distributed +# except according to those terms. + +import errno +import json +import os +import pathlib +import platform +import shutil +import subprocess +import sys + +from os import path +from packaging.version import parse as parse_version +from typing import Any, Dict, Optional + +import servo.platform + + +class BuildTarget(object): + def __init__(self, target_triple: str): + self.target_triple = target_triple + + @staticmethod + def from_triple(target_triple: Optional[str]) -> 'BuildTarget': + host_triple = servo.platform.host_triple() + if target_triple: + if 'android' in target_triple: + return AndroidTarget(target_triple) + elif 'ohos' in target_triple: + return OpenHarmonyTarget(target_triple) + elif target_triple != host_triple: + raise Exception(f"Unknown build target {target_triple}") + return BuildTarget(host_triple) + + def triple(self) -> str: + return self.target_triple + + def binary_name(self) -> str: + return f"servo{servo.platform.get().executable_suffix()}" + + def configure_build_environment(self, env: Dict[str, str], config: Dict[str, Any], topdir: pathlib.Path): + pass + + def is_cross_build(self) -> bool: + return False + + def needs_packaging(self) -> bool: + return False + + +class CrossBuildTarget(BuildTarget): + def is_cross_build(self) -> bool: + return True + + +class AndroidTarget(CrossBuildTarget): + def ndk_configuration(self) -> Dict[str, str]: + target = self.triple() + config = {} + if target == "armv7-linux-androideabi": + config["platform"] = "android-30" + config["target"] = target + config["toolchain_prefix"] = "arm-linux-androideabi" + config["arch"] = "arm" + config["lib"] = "armeabi-v7a" + config["toolchain_name"] = "armv7a-linux-androideabi30" + elif target == "aarch64-linux-android": + config["platform"] = "android-30" + config["target"] = target + config["toolchain_prefix"] = target + config["arch"] = "arm64" + config["lib"] = "arm64-v8a" + config["toolchain_name"] = "aarch64-linux-androideabi30" + elif target == "i686-linux-android": + # https://github.com/jemalloc/jemalloc/issues/1279 + config["platform"] = "android-30" + config["target"] = target + config["toolchain_prefix"] = target + config["arch"] = "x86" + config["lib"] = "x86" + config["toolchain_name"] = "i686-linux-android30" + elif target == "x86_64-linux-android": + config["platform"] = "android-30" + config["target"] = target + config["toolchain_prefix"] = target + config["arch"] = "x86_64" + config["lib"] = "x86_64" + config["toolchain_name"] = "x86_64-linux-android30" + else: + raise Exception(f"Unknown android target {target}") + + return config + + def configure_build_environment(self, env: Dict[str, str], config: Dict[str, Any], topdir: pathlib.Path): + # Paths to Android build tools: + if config["android"]["sdk"]: + env["ANDROID_SDK_ROOT"] = config["android"]["sdk"] + if config["android"]["ndk"]: + env["ANDROID_NDK_ROOT"] = config["android"]["ndk"] + + toolchains = path.join(topdir, "android-toolchains") + for kind in ["sdk", "ndk"]: + default = os.path.join(toolchains, kind) + if os.path.isdir(default): + env.setdefault(f"ANDROID_{kind.upper()}_ROOT", default) + + if "IN_NIX_SHELL" in env and ("ANDROID_NDK_ROOT" not in env or "ANDROID_SDK_ROOT" not in env): + print("Please set SERVO_ANDROID_BUILD=1 when starting the Nix shell to include the Android SDK/NDK.") + sys.exit(1) + if "ANDROID_NDK_ROOT" not in env: + print("Please set the ANDROID_NDK_ROOT environment variable.") + sys.exit(1) + if "ANDROID_SDK_ROOT" not in env: + print("Please set the ANDROID_SDK_ROOT environment variable.") + sys.exit(1) + + ndk_configuration = self.ndk_configuration() + android_platform = ndk_configuration["platform"] + android_toolchain_name = ndk_configuration["toolchain_name"] + android_lib = ndk_configuration["lib"] + + android_api = android_platform.replace('android-', '') + + # Check if the NDK version is 26 + if not os.path.isfile(path.join(env["ANDROID_NDK_ROOT"], 'source.properties')): + print("ANDROID_NDK should have file `source.properties`.") + print("The environment variable ANDROID_NDK_ROOT may be set at a wrong path.") + sys.exit(1) + with open(path.join(env["ANDROID_NDK_ROOT"], 'source.properties'), encoding="utf8") as ndk_properties: + lines = ndk_properties.readlines() + if lines[1].split(' = ')[1].split('.')[0] != '26': + print("Servo currently only supports NDK r26c.") + sys.exit(1) + + # Android builds also require having the gcc bits on the PATH and various INCLUDE + # path munging if you do not want to install a standalone NDK. See: + # https://dxr.mozilla.org/mozilla-central/source/build/autoconf/android.m4#139-161 + os_type = platform.system().lower() + if os_type not in ["linux", "darwin"]: + raise Exception("Android cross builds are only supported on Linux and macOS.") + + cpu_type = platform.machine().lower() + host_suffix = "unknown" + if cpu_type in ["i386", "i486", "i686", "i768", "x86"]: + host_suffix = "x86" + elif cpu_type in ["x86_64", "x86-64", "x64", "amd64"]: + host_suffix = "x86_64" + host = os_type + "-" + host_suffix + + host_cc = env.get('HOST_CC') or shutil.which("clang") + host_cxx = env.get('HOST_CXX') or shutil.which("clang++") + + llvm_toolchain = path.join(env['ANDROID_NDK_ROOT'], "toolchains", "llvm", "prebuilt", host) + env['PATH'] = (env['PATH'] + ':' + path.join(llvm_toolchain, "bin")) + + def to_ndk_bin(prog): + return path.join(llvm_toolchain, "bin", prog) + + # This workaround is due to an issue in the x86_64 Android NDK that introduces + # an undefined reference to the symbol '__extendsftf2'. + # See https://github.com/termux/termux-packages/issues/8029#issuecomment-1369150244 + if "x86_64" in self.triple(): + libclangrt_filename = subprocess.run( + [to_ndk_bin(f"x86_64-linux-android{android_api}-clang"), "--print-libgcc-file-name"], + check=True, + capture_output=True, + encoding="utf8" + ).stdout + env['RUSTFLAGS'] = env.get('RUSTFLAGS', "") + env["RUSTFLAGS"] += f"-C link-arg={libclangrt_filename}" + + env["RUST_TARGET"] = self.triple() + env['HOST_CC'] = host_cc + env['HOST_CXX'] = host_cxx + env['HOST_CFLAGS'] = '' + env['HOST_CXXFLAGS'] = '' + env['TARGET_CC'] = to_ndk_bin("clang") + env['TARGET_CPP'] = to_ndk_bin("clang") + " -E" + env['TARGET_CXX'] = to_ndk_bin("clang++") + + env['TARGET_AR'] = to_ndk_bin("llvm-ar") + env['TARGET_RANLIB'] = to_ndk_bin("llvm-ranlib") + env['TARGET_OBJCOPY'] = to_ndk_bin("llvm-objcopy") + env['TARGET_YASM'] = to_ndk_bin("yasm") + env['TARGET_STRIP'] = to_ndk_bin("llvm-strip") + env['RUST_FONTCONFIG_DLOPEN'] = "on" + + env["LIBCLANG_PATH"] = path.join(llvm_toolchain, "lib") + env["CLANG_PATH"] = to_ndk_bin("clang") + + # A cheat-sheet for some of the build errors caused by getting the search path wrong... + # + # fatal error: 'limits' file not found + # -- add -I cxx_include + # unknown type name '__locale_t' (when running bindgen in mozjs_sys) + # -- add -isystem sysroot_include + # error: use of undeclared identifier 'UINTMAX_C' + # -- add -D__STDC_CONSTANT_MACROS + # + # Also worth remembering: autoconf uses C for its configuration, + # even for C++ builds, so the C flags need to line up with the C++ flags. + env['TARGET_CFLAGS'] = "--target=" + android_toolchain_name + env['TARGET_CXXFLAGS'] = "--target=" + android_toolchain_name + + # These two variables are needed for the mozjs compilation. + env['ANDROID_API_LEVEL'] = android_api + env["ANDROID_NDK_HOME"] = env["ANDROID_NDK_ROOT"] + + # The two variables set below are passed by our custom + # support/android/toolchain.cmake to the NDK's CMake toolchain file + env["ANDROID_ABI"] = android_lib + env["ANDROID_PLATFORM"] = android_platform + env["NDK_CMAKE_TOOLCHAIN_FILE"] = path.join( + env['ANDROID_NDK_ROOT'], "build", "cmake", "android.toolchain.cmake") + env["CMAKE_TOOLCHAIN_FILE"] = path.join(topdir, "support", "android", "toolchain.cmake") + + # Set output dir for gradle aar files + env["AAR_OUT_DIR"] = path.join(topdir, "target", "android", "aar") + if not os.path.exists(env['AAR_OUT_DIR']): + os.makedirs(env['AAR_OUT_DIR']) + + env['TARGET_PKG_CONFIG_SYSROOT_DIR'] = path.join(llvm_toolchain, 'sysroot') + + def binary_name(self) -> str: + return "libservoshell.so" + + def is_cross_build(self) -> bool: + return True + + def needs_packaging(self) -> bool: + return True + + +class OpenHarmonyTarget(CrossBuildTarget): + def configure_build_environment(self, env: Dict[str, str], config: Dict[str, Any], topdir: pathlib.Path): + # Paths to OpenHarmony SDK and build tools: + # Note: `OHOS_SDK_NATIVE` is the CMake variable name the `hvigor` build-system + # uses for the native directory of the SDK, so we use the same name to be consistent. + if "OHOS_SDK_NATIVE" not in env and config["ohos"]["ndk"]: + env["OHOS_SDK_NATIVE"] = config["ohos"]["ndk"] + + if "OHOS_SDK_NATIVE" not in env: + print("Please set the OHOS_SDK_NATIVE environment variable to the location of the `native` directory " + "in the OpenHarmony SDK.") + sys.exit(1) + + ndk_root = pathlib.Path(env["OHOS_SDK_NATIVE"]) + + if not ndk_root.is_dir(): + print(f"OHOS_SDK_NATIVE is not set to a valid directory: `{ndk_root}`") + sys.exit(1) + + ndk_root = ndk_root.resolve() + package_info = ndk_root.joinpath("oh-uni-package.json") + try: + with open(package_info) as meta_file: + meta = json.load(meta_file) + ohos_api_version = int(meta['apiVersion']) + ohos_sdk_version = parse_version(meta['version']) + if ohos_sdk_version < parse_version('4.0'): + print("Warning: mach build currently assumes at least the OpenHarmony 4.0 SDK is used.") + print(f"Info: The OpenHarmony SDK {ohos_sdk_version} is targeting API-level {ohos_api_version}") + except Exception as e: + print(f"Failed to read metadata information from {package_info}") + print(f"Exception: {e}") + + # The OpenHarmony SDK for Windows hosts currently does not contain a libclang shared library, + # which is required by `bindgen` (see issue + # https://gitee.com/openharmony/third_party_llvm-project/issues/I8H50W). Using upstream `clang` is currently + # also not easily possible, since `libcxx` support still needs to be upstreamed ( + # https://github.com/llvm/llvm-project/pull/73114). + os_type = platform.system().lower() + if os_type not in ["linux", "darwin"]: + raise Exception("OpenHarmony builds are currently only supported on Linux and macOS Hosts.") + + llvm_toolchain = ndk_root.joinpath("llvm") + llvm_bin = llvm_toolchain.joinpath("bin") + ohos_sysroot = ndk_root.joinpath("sysroot") + if not (llvm_toolchain.is_dir() and llvm_bin.is_dir()): + print(f"Expected to find `llvm` and `llvm/bin` folder under $OHOS_SDK_NATIVE at `{llvm_toolchain}`") + sys.exit(1) + if not ohos_sysroot.is_dir(): + print(f"Could not find OpenHarmony sysroot in {ndk_root}") + sys.exit(1) + + # Note: We don't use the `<target_triple>-clang` wrappers on purpose, since + # a) the OH 4.0 SDK does not have them yet AND + # b) the wrappers in the newer SDKs are bash scripts, which can cause problems + # on windows, depending on how the wrapper is called. + # Instead, we ensure that all the necessary flags for the c-compiler are set + # via environment variables such as `TARGET_CFLAGS`. + def to_sdk_llvm_bin(prog: str): + if sys.platform == 'win32': + prog = prog + '.exe' + llvm_prog = llvm_bin.joinpath(prog) + if not llvm_prog.is_file(): + raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), llvm_prog) + return str(llvm_bin.joinpath(prog)) + + # CC and CXX should already be set to appropriate host compilers by `build_env()` + env['HOST_CC'] = env['CC'] + env['HOST_CXX'] = env['CXX'] + env['TARGET_AR'] = to_sdk_llvm_bin("llvm-ar") + env['TARGET_RANLIB'] = to_sdk_llvm_bin("llvm-ranlib") + env['TARGET_READELF'] = to_sdk_llvm_bin("llvm-readelf") + env['TARGET_OBJCOPY'] = to_sdk_llvm_bin("llvm-objcopy") + env['TARGET_STRIP'] = to_sdk_llvm_bin("llvm-strip") + + target_triple = self.triple() + rust_target_triple = str(target_triple).replace('-', '_') + ndk_clang = to_sdk_llvm_bin(f"{target_triple}-clang") + ndk_clangxx = to_sdk_llvm_bin(f"{target_triple}-clang++") + env[f'CC_{rust_target_triple}'] = ndk_clang + env[f'CXX_{rust_target_triple}'] = ndk_clangxx + # The clang target name is different from the LLVM target name + clang_target_triple = str(target_triple).replace('-unknown-', '-') + clang_target_triple_underscore = clang_target_triple.replace('-', '_') + env[f'CC_{clang_target_triple_underscore}'] = ndk_clang + env[f'CXX_{clang_target_triple_underscore}'] = ndk_clangxx + # rustc linker + env[f'CARGO_TARGET_{rust_target_triple.upper()}_LINKER'] = ndk_clang + # We could also use a cross-compile wrapper + env["RUSTFLAGS"] += f' -Clink-arg=--target={clang_target_triple}' + env["RUSTFLAGS"] += f' -Clink-arg=--sysroot={ohos_sysroot}' + + env['HOST_CFLAGS'] = '' + env['HOST_CXXFLAGS'] = '' + ohos_cflags = ['-D__MUSL__', f' --target={clang_target_triple}', f' --sysroot={ohos_sysroot}'] + if clang_target_triple.startswith('armv7-'): + ohos_cflags.extend(['-march=armv7-a', '-mfloat-abi=softfp', '-mtune=generic-armv7-a', '-mthumb']) + ohos_cflags_str = " ".join(ohos_cflags) + env['TARGET_CFLAGS'] = ohos_cflags_str + env['TARGET_CPPFLAGS'] = '-D__MUSL__' + env['TARGET_CXXFLAGS'] = ohos_cflags_str + + # CMake related flags + cmake_toolchain_file = ndk_root.joinpath("build", "cmake", "ohos.toolchain.cmake") + if cmake_toolchain_file.is_file(): + env[f'CMAKE_TOOLCHAIN_FILE_{rust_target_triple}'] = str(cmake_toolchain_file) + else: + print( + f"Warning: Failed to find the OpenHarmony CMake Toolchain file - Expected it at {cmake_toolchain_file}") + env[f'CMAKE_C_COMPILER_{rust_target_triple}'] = ndk_clang + env[f'CMAKE_CXX_COMPILER_{rust_target_triple}'] = ndk_clangxx + + # pkg-config + pkg_config_path = '{}:{}'.format(str(ohos_sysroot.joinpath("usr", "lib", "pkgconfig")), + str(ohos_sysroot.joinpath("usr", "share", "pkgconfig"))) + env[f'PKG_CONFIG_SYSROOT_DIR_{rust_target_triple}'] = str(ohos_sysroot) + env[f'PKG_CONFIG_PATH_{rust_target_triple}'] = pkg_config_path + + # bindgen / libclang-sys + env["LIBCLANG_PATH"] = path.join(llvm_toolchain, "lib") + env["CLANG_PATH"] = ndk_clangxx + env[f'CXXSTDLIB_{clang_target_triple_underscore}'] = "c++" + bindgen_extra_clangs_args_var = f'BINDGEN_EXTRA_CLANG_ARGS_{rust_target_triple}' + bindgen_extra_clangs_args = env.get(bindgen_extra_clangs_args_var, "") + bindgen_extra_clangs_args = bindgen_extra_clangs_args + " " + ohos_cflags_str + env[bindgen_extra_clangs_args_var] = bindgen_extra_clangs_args + + def binary_name(self) -> str: + return "libservoshell.so" + + def needs_packaging(self) -> bool: + return True diff --git a/python/servo/platform/linux.py b/python/servo/platform/linux.py index 6ed34ee9892..1397a4f16de 100644 --- a/python/servo/platform/linux.py +++ b/python/servo/platform/linux.py @@ -7,12 +7,13 @@ # option. This file may not be copied, modified, or distributed # except according to those terms. +import distro import os import subprocess from typing import Optional, Tuple -import distro from .base import Base +from .build_target import BuildTarget # Please keep these in sync with the packages on the wiki, using the instructions below # https://github.com/servo/servo/wiki/Building @@ -211,10 +212,10 @@ class Linux(Base): raise EnvironmentError("Installation of dependencies failed.") return True - def gstreamer_root(self, cross_compilation_target: Optional[str]) -> Optional[str]: + def gstreamer_root(self, _target: BuildTarget) -> Optional[str]: return None - def _platform_bootstrap_gstreamer(self, _force: bool) -> bool: + def _platform_bootstrap_gstreamer(self, _target: BuildTarget, _force: bool) -> bool: raise EnvironmentError( "Bootstrapping GStreamer on Linux is not supported. " + "Please install it using your distribution package manager.") diff --git a/python/servo/platform/macos.py b/python/servo/platform/macos.py index de20fe35ad5..a1655dc613e 100644 --- a/python/servo/platform/macos.py +++ b/python/servo/platform/macos.py @@ -14,6 +14,7 @@ from typing import Optional from .. import util from .base import Base +from .build_target import BuildTarget URL_BASE = "https://github.com/servo/servo-build-deps/releases/download/macOS" GSTREAMER_PLUGIN_VERSION = "1.22.3" @@ -27,15 +28,15 @@ class MacOS(Base): super().__init__(*args, **kwargs) self.is_macos = True - def gstreamer_root(self, cross_compilation_target: Optional[str]) -> Optional[str]: + def gstreamer_root(self, target: BuildTarget) -> Optional[str]: # We do not support building with gstreamer while cross-compiling on MacOS. - if cross_compilation_target or not os.path.exists(GSTREAMER_ROOT): + if target.is_cross_build() or not os.path.exists(GSTREAMER_ROOT): return None return GSTREAMER_ROOT - def is_gstreamer_installed(self, cross_compilation_target: Optional[str]) -> bool: + def is_gstreamer_installed(self, target: BuildTarget) -> bool: # Servo only supports the official GStreamer distribution on MacOS. - return not cross_compilation_target and os.path.exists(GSTREAMER_ROOT) + return not target.is_cross_build() and os.path.exists(GSTREAMER_ROOT) def _platform_bootstrap(self, _force: bool) -> bool: installed_something = False @@ -49,11 +50,12 @@ class MacOS(Base): except subprocess.CalledProcessError as e: print("Could not run homebrew. Is it installed?") raise e - installed_something |= self._platform_bootstrap_gstreamer(False) + target = BuildTarget.from_triple(None) + installed_something |= self._platform_bootstrap_gstreamer(target, False) return installed_something - def _platform_bootstrap_gstreamer(self, force: bool) -> bool: - if not force and self.is_gstreamer_installed(cross_compilation_target=None): + def _platform_bootstrap_gstreamer(self, target: BuildTarget, force: bool) -> bool: + if not force and self.is_gstreamer_installed(target): return False with tempfile.TemporaryDirectory() as temp_dir: @@ -78,5 +80,5 @@ class MacOS(Base): ] ) - assert self.is_gstreamer_installed(cross_compilation_target=None) + assert self.is_gstreamer_installed(target) return True diff --git a/python/servo/platform/windows.py b/python/servo/platform/windows.py index dced63a8fb5..52b7d4f0a2c 100644 --- a/python/servo/platform/windows.py +++ b/python/servo/platform/windows.py @@ -14,8 +14,10 @@ from typing import Optional import urllib import zipfile -from .. import util +from servo import util + from .base import Base +from .build_target import BuildTarget DEPS_URL = "https://github.com/servo/servo-build-deps/releases/download/msvc-deps" DEPENDENCIES = { @@ -57,7 +59,7 @@ class Windows(Base): else: print("done") - def _platform_bootstrap(self, force: bool = False) -> bool: + def _platform_bootstrap(self, force: bool) -> bool: installed_something = self.passive_bootstrap() try: @@ -77,7 +79,8 @@ class Windows(Base): print("Could not run chocolatey. Follow manual build setup instructions.") raise e - installed_something |= self._platform_bootstrap_gstreamer(force) + target = BuildTarget.from_triple(None) + installed_something |= self._platform_bootstrap_gstreamer(target, force) return installed_something def passive_bootstrap(self) -> bool: @@ -103,8 +106,8 @@ class Windows(Base): return True - def gstreamer_root(self, cross_compilation_target: Optional[str]) -> Optional[str]: - build_target_triple = cross_compilation_target or self.triple + def gstreamer_root(self, target: BuildTarget) -> Optional[str]: + build_target_triple = target.triple() gst_arch_names = { "x86_64": "X86_64", "x86": "X86", @@ -132,11 +135,11 @@ class Windows(Base): return None - def is_gstreamer_installed(self, cross_compilation_target: Optional[str]) -> bool: - return self.gstreamer_root(cross_compilation_target) is not None + def is_gstreamer_installed(self, target: BuildTarget) -> bool: + return self.gstreamer_root(target) is not None - def _platform_bootstrap_gstreamer(self, force: bool) -> bool: - if not force and self.is_gstreamer_installed(cross_compilation_target=None): + def _platform_bootstrap_gstreamer(self, target: BuildTarget, force: bool) -> bool: + if not force and self.is_gstreamer_installed(target): return False if "x86_64" not in self.triple: @@ -171,5 +174,5 @@ class Windows(Base): "msiexec.exe", "-ArgumentList", f"@({quoted_arguments})", ").ExitCode" ]) - assert self.is_gstreamer_installed(cross_compilation_target=None) + assert self.is_gstreamer_installed(target) return True |