Improve multilarch directory detection in cross-compilation scenarios

Author: twistedfall

build.rs

@@ -42,6 +42,8 @@ static TARGET_ENV_MSVC: LazyLock<bool> =
 	LazyLock::new(|| env::var("CARGO_CFG_TARGET_ENV").is_ok_and(|target_env| target_env == "msvc"));
 static TARGET_VENDOR_APPLE: LazyLock<bool> =
 	LazyLock::new(|| env::var("CARGO_CFG_TARGET_VENDOR").is_ok_and(|target_vendor| target_vendor == "apple"));
+static TARGET_OS_LINUX: LazyLock<bool> =
+	LazyLock::new(|| env::var("CARGO_CFG_TARGET_OS").is_ok_and(|target_os| target_os == "linux"));
 
 /// Environment vars that affect the build, the source will be rebuilt if those change, the contents of those vars will also
 /// be present in the debug log

build/header.rs

@@ -1,10 +1,13 @@
+use std::env;
 use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
 use semver::Version;
 
+use super::TARGET_OS_LINUX;
+
 pub trait IncludePath {
 	fn get_module_header_dir(&self) -> Option<PathBuf>;
 	fn get_version_header(&self) -> Option<PathBuf>;
@@ -100,42 +103,119 @@ impl IncludePath for Path {
 	}
 }
 
-/// Something like `/usr/include/x86_64-linux-gnu/opencv4/` on newer Debian-derived distros
+const POSSIBLE_MULTIARCHES: &[&str] = &[
+	"x86_64-linux-gnu",
+	"aarch64-linux-gnu",
+	"arm-linux-gnueabihf",
+	"i386-linux-gnu",
+	"arm-linux-gnueabi",
+];
+
+/// When cross-compiling, try to derive the target's multiarch from Cargo's target triple
 ///
-/// https://wiki.debian.org/Multiarch/Implementation
-pub fn get_multiarch_header_dir() -> Option<PathBuf> {
-	let try_multiarch = Command::new("dpkg-architecture")
-		.args(["--query", "DEB_TARGET_MULTIARCH"])
-		.output()
-		.inspect_err(|e| eprintln!("=== Failed to get DEB_TARGET_MULTIARCH: {e}"))
-		.ok()
-		.or_else(|| {
-			Command::new("cc")
-				.arg("-print-multiarch")
+/// https://doc.rust-lang.org/reference/conditional-compilation.html#target_arch
+/// https://wiki.debian.org/Multiarch/Tuples#Architectures_in_Debian
+fn target_linux_multiarch_from_cargo() -> Option<&'static str> {
+	let target_arch = env::var("CARGO_CFG_TARGET_ARCH").ok()?;
+	let target_abi = env::var("CARGO_CFG_TARGET_ABI").ok()?;
+	match (target_arch.as_str(), target_abi.as_str()) {
+		("x86", _) => Some("i386-linux-gnu"),
+		("x86_64", _) => Some("x86_64-linux-gnu"),
+		("aarch64", _) => Some("aarch64-linux-gnu"),
+		("arm", "eabihf") => Some("arm-linux-gnueabihf"),
+		("arm", _) => Some("arm-linux-gnueabi"),
+		_ => None,
+	}
+}
+
+fn target_linux_multiarch_from_path(cmake_dir: &Path) -> Option<&str> {
+	cmake_dir.components().rev().find_map(|comp| {
+		comp
+			.as_os_str()
+			.to_str()
+			.filter(|comp_str| POSSIBLE_MULTIARCHES.contains(comp_str))
+	})
+}
+
+pub fn get_multiarch_header_dirs(non_multiarch_include_dirs: &[PathBuf]) -> Vec<PathBuf> {
+	let mut try_multiarches = vec![];
+
+	try_multiarches.extend(
+		(*TARGET_OS_LINUX)
+			.then(target_linux_multiarch_from_cargo)
+			.flatten()
+			.map(|s| s.to_string())
+			.inspect(|target_arch| eprintln!("=== Detected target multiarch from Cargo target: {target_arch}")),
+	);
+	try_multiarches.extend(
+		env::var_os("OpenCV_DIR")
+			.and_then(|d| target_linux_multiarch_from_path(&PathBuf::from(d)).map(|s| s.to_string()))
+			.inspect(|target_arch| eprintln!("=== Detected target multiarch from cmake OpenCV_DIR: {target_arch}")),
+	);
+	if try_multiarches.is_empty() {
+		// Fallback to detecting the host's multiarch
+		try_multiarches.extend(
+			Command::new("dpkg-architecture")
+				.args(["--query", "DEB_TARGET_MULTIARCH"])
 				.output()
-				.inspect_err(|e| eprintln!("=== Failed to get -print-multiarch: {e}"))
+				.inspect_err(|e| eprintln!("=== Failed to query DEB_TARGET_MULTIARCH: {e}"))
 				.ok()
-		})
-		.and_then(|output| String::from_utf8(output.stdout).ok())
-		.map_or_else(
-			|| {
-				eprintln!("=== Failed to get DEB_TARGET_MULTIARCH, trying common multiarch paths");
-				vec![
-					"x86_64-linux-gnu".to_string(),
-					"aarch64-linux-gnu".to_string(),
-					"arm-linux-gnueabihf".to_string(),
-				]
-			},
-			|multiarch| vec![multiarch.trim().to_string()],
+				.or_else(|| {
+					Command::new("cc")
+						.arg("-print-multiarch")
+						.output()
+						.inspect_err(|e| eprintln!("=== Failed to get -print-multiarch: {e}"))
+						.ok()
+				})
+				.and_then(|output| String::from_utf8(output.stdout).ok())
+				.map_or_else(
+					|| {
+						eprintln!("=== Failed to detect multiarch path, trying common paths");
+						POSSIBLE_MULTIARCHES.iter().map(|s| s.to_string()).collect::<Vec<_>>()
+					},
+					|multiarch| vec![multiarch.trim().to_string()],
+				),
 		);
+	};
 
-	eprintln!("=== Trying multiarch paths: {try_multiarch:?}");
+	eprintln!("=== Trying multiarches: {try_multiarches:?}");
 
-	for multiarch in try_multiarch {
-		let header_dir = PathBuf::from(format!("/usr/include/{multiarch}/opencv4"));
-		if header_dir.is_dir() {
-			return Some(header_dir);
+	let mut out = Vec::with_capacity(non_multiarch_include_dirs.len());
+	for multiarch in try_multiarches {
+		for non_multiarch_include_dir in non_multiarch_include_dirs {
+			if let Some(multiarch_include_dir) = add_multiarch_dir_before_opencv4(non_multiarch_include_dir, &multiarch) {
+				if multiarch_include_dir.is_dir() {
+					out.push(multiarch_include_dir);
+				}
+			} else if let Some(multiarch_include_dir) = add_multiarch_dir_after_include(non_multiarch_include_dir, &multiarch) {
+				if multiarch_include_dir.is_dir() {
+					out.push(multiarch_include_dir);
+				}
+			}
 		}
 	}
-	None
+	eprintln!("=== Found multiarch header dirs: {out:?}");
+	out
+}
+
+/// Finds the "opencv4" component in the path and inserts the multiarch directory before it
+///
+/// This works starting with OpenCV 4.0.0
+fn add_multiarch_dir_before_opencv4(path: &Path, multiarch: &str) -> Option<PathBuf> {
+	let opencv4_idx = path
+		.components()
+		.position(|comp| comp.as_os_str().to_str().is_some_and(|s| s == "opencv4"))?;
+	let mut comps = path.components();
+	let mut out = PathBuf::with_capacity(path.as_os_str().len() + multiarch.len() + 1);
+	out.extend((&mut comps).take(opencv4_idx));
+	out.push(multiarch);
+	out.extend(comps);
+	Some(out)
+}
+
+/// Finds the "include" component in the path and inserts the multiarch directory after it
+///
+/// This works starting for OpenCV 3.4 as it doesn't have the "opencv4" component
+fn add_multiarch_dir_after_include(path: &Path, multiarch: &str) -> Option<PathBuf> {
+	path.ends_with("include").then(|| path.join(multiarch))
 }

build/library.rs

@@ -181,20 +181,21 @@ pub struct Library {
 }
 
 impl Library {
-	fn add_multiarch_dir_if_needed(include_paths: &mut Vec<PathBuf>) {
-		if include_paths.iter().all(|p| p.get_config_header().is_none()) {
-			if let Some(multiarch_include_path) = header::get_multiarch_header_dir() {
-				include_paths.push(multiarch_include_path);
-			}
-		}
-	}
-
 	fn version_from_include_paths(include_paths: impl IntoIterator<Item = impl AsRef<Path>>) -> Option<Version> {
 		include_paths.into_iter().find_map(|x| x.as_ref().find_version())
 	}
 
-	fn inherent_features_from_include_paths(include_paths: impl IntoIterator<Item = impl AsRef<Path>>) -> Option<Vec<String>> {
-		include_paths.into_iter().find_map(|x| x.as_ref().find_inherent_features())
+	fn inherent_features_from_include_paths(include_paths: &[PathBuf]) -> Option<Vec<String>> {
+		include_paths.iter().find_map(|x| x.find_inherent_features()).or_else(|| {
+			// Check the multiarch header directories if no `cvconfig.h` found in the provided include paths
+			//
+			// On the newer Debian-derived distros the `cvconfig.h` is located in the multiarch include directory, it won't be reported
+			// by pkg-config/cmake/vcpkg. It looks like `/usr/include/x86_64-linux-gnu/opencv4/` and contains architecture specific
+			// headers: https://wiki.debian.org/Multiarch/Implementation
+			header::get_multiarch_header_dirs(include_paths)
+				.into_iter()
+				.find_map(|x| x.find_inherent_features())
+		})
 	}
 
 	fn process_env_var_list<'a, T: From<&'a str>>(env_list: Option<EnvList<'a>>, sys_list: Vec<T>) -> Vec<T> {
@@ -215,8 +216,9 @@ impl Library {
 		Self::process_env_var_list(link_paths, sys_link_paths)
 			.into_iter()
 			.flat_map(move |search| {
-				iter::once(search.clone())
-					.chain((*TARGET_VENDOR_APPLE && search.0 != Linkage::Framework).then(|| LinkSearch(Linkage::Framework, search.1)))
+				iter::once(search.clone()).chain(
+					(*TARGET_VENDOR_APPLE && search.0 != Linkage::Framework).then_some(LinkSearch(Linkage::Framework, search.1)),
+				)
 			})
 			.inspect(|s| eprintln!("=== Link search path: {s:?}"))
 			.map(|search| search.emit_cargo_rustc_link_search())
@@ -348,8 +350,7 @@ impl Library {
 			));
 		}
 
-		let mut include_paths = Self::process_env_var_list(include_paths, opencv.include_paths);
-		Self::add_multiarch_dir_if_needed(&mut include_paths);
+		let include_paths = Self::process_env_var_list(include_paths, opencv.include_paths);
 		let inherent_features =
 			Self::inherent_features_from_include_paths(&include_paths).ok_or("Could not get OpenCV config from include_paths")?;
 
@@ -408,8 +409,7 @@ impl Library {
 		cargo_metadata.extend(Self::process_link_paths(link_paths, probe_result.link_paths));
 		cargo_metadata.extend(Self::process_link_libs(link_libs, probe_result.link_libs));
 
-		let mut include_paths = Self::process_env_var_list(include_paths, probe_result.include_paths);
-		Self::add_multiarch_dir_if_needed(&mut include_paths);
+		let include_paths = Self::process_env_var_list(include_paths, probe_result.include_paths);
 		let inherent_features =
 			Self::inherent_features_from_include_paths(&include_paths).ok_or("Could not get OpenCV config from include_paths")?;
 
@@ -468,8 +468,7 @@ impl Library {
 		}
 		cargo_metadata.extend(Self::process_link_libs(link_libs, vec![]));
 
-		let mut include_paths = Self::process_env_var_list(include_paths, opencv_include_paths);
-		Self::add_multiarch_dir_if_needed(&mut include_paths);
+		let include_paths = Self::process_env_var_list(include_paths, opencv_include_paths);
 		let inherent_features =
 			Self::inherent_features_from_include_paths(&include_paths).ok_or("Could not get OpenCV config from include_paths")?;