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,3 +1,4 @@
+use std::env;
 use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
@@ -100,42 +101,117 @@ 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_linux_multiarch_from_cargo()
+			.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

@@ -10,7 +10,7 @@ use semver::Version;
 use super::cmake_probe::CmakeProbe;
 use super::header::IncludePath;
 use super::path_ext::{LibraryKind, PathExt};
-use super::{header, Result, MANIFEST_DIR, OUT_DIR, TARGET_VENDOR_APPLE};
+use super::{header, Result, MANIFEST_DIR, OUT_DIR, TARGET_OS_LINUX, TARGET_VENDOR_APPLE};
 
 struct PackageName;
 
@@ -181,11 +181,18 @@ pub struct Library {
 }
 
 impl Library {
+	/// Adds the multiarch 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
 	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);
-			}
+		if *TARGET_OS_LINUX && include_paths.iter().all(|p| p.get_config_header().is_none()) {
+			include_paths.extend(
+				header::get_multiarch_header_dirs(include_paths)
+					.into_iter()
+					.filter(|p| p.get_config_header().is_some()),
+			);
 		}
 	}