Include additional core headers conditionally

Author: twistedfall

.github/workflows/opencv-rust.yml

@@ -68,9 +68,19 @@ jobs:
           - macos-14
         vcpkg-version:
           - 2025.01.13 # https://github.com/microsoft/vcpkg/releases
+        vcpkg-features-cache-key:
+          - full
+        vcpkg-features:
+          - contrib,nonfree,ade,opencl
+        include:
+          - os-image: windows-2022
+            vcpkg-version: 2025.01.13
+            vcpkg-features-cache-key: min
+            vcpkg-features: contrib
     runs-on: ${{ matrix.os-image }}
     env:
       VCPKG_VERSION: ${{ matrix.vcpkg-version }}
+      VCPKG_FEATURES: ${{ matrix.vcpkg-features }}
       SCCACHE_GHA_ENABLED: "true"
       RUSTC_WRAPPER: "sccache"
     steps:
@@ -80,7 +90,7 @@ jobs:
       - uses: actions/cache@v4
         with:
           path: ~/build
-          key: vcpkg-${{ matrix.vcpkg-version }}-${{ matrix.os-image }}
+          key: vcpkg-${{ matrix.vcpkg-version }}-${{ matrix.os-image }}-${{ matrix.vcpkg-features-cache-key }}
 
       - name: Install dependencies
         run: ci/install.sh

INSTALL.md

@@ -56,7 +56,7 @@ Installing OpenCV is easy through the following sources:
 * from [vcpkg](https://docs.microsoft.com/en-us/cpp/build/vcpkg), also install `llvm` package,
   necessary for building:
   ```shell script
-  vcpkg install llvm opencv4[contrib,nonfree,opencl]
+  vcpkg install llvm opencv4[contrib,nonfree]
   ```
   You most probably want to set environment variable `VCPKGRS_DYNAMIC` to "1" unless you're specifically
   targeting a static build.

build.rs

@@ -1,8 +1,6 @@
 use std::collections::{HashMap, HashSet};
 use std::env;
 use std::ffi::OsStr;
-use std::fs::File;
-use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
 use std::time::Instant;
 
@@ -169,61 +167,131 @@ fn files_with_extension<'e>(dir: &Path, extension: impl AsRef<OsStr> + 'e) -> Re
 	})
 }
 
-fn get_module_header_dir(header_dir: &Path) -> Option<PathBuf> {
-	let mut out = header_dir.join("opencv2.framework/Headers");
-	if out.exists() {
-		return Some(out);
-	}
-	out = header_dir.join("opencv2");
-	if out.exists() {
-		return Some(out);
+mod header {
+	use std::fs::File;
+	use std::io::{BufRead, BufReader};
+	use std::path::{Path, PathBuf};
+	use std::process::Command;
+
+	use semver::Version;
+
+	pub fn get_module_header_dir(header_dir: &Path) -> Option<PathBuf> {
+		let mut out = header_dir.join("opencv2.framework/Headers");
+		if out.is_dir() {
+			return Some(out);
+		}
+		out = header_dir.join("opencv2");
+		if out.is_dir() {
+			return Some(out);
+		}
+		None
 	}
-	None
-}
 
-fn get_version_header(header_dir: &Path) -> Option<PathBuf> {
-	get_module_header_dir(header_dir)
-		.map(|dir| dir.join("core/version.hpp"))
-		.filter(|hdr| hdr.is_file())
-}
+	/// Something like `/usr/include/x86_64-linux-gnu/opencv4/` on newer Debian-derived distros
+	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")
+					.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 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()],
+			);
 
-fn get_version_from_headers(header_dir: &Path) -> Option<Version> {
-	let version_hpp = get_version_header(header_dir)?;
-	let mut major = None;
-	let mut minor = None;
-	let mut revision = None;
-	let mut line = String::with_capacity(256);
-	let mut reader = BufReader::new(File::open(version_hpp).ok()?);
-	while let Ok(bytes_read) = reader.read_line(&mut line) {
-		if bytes_read == 0 {
-			break;
+		eprintln!("=== Trying multiarch paths: {try_multiarch:?}");
+
+		for multiarch in try_multiarch {
+			let header_dir = PathBuf::from(format!("/usr/include/{multiarch}/opencv4"));
+			if header_dir.is_dir() {
+				return Some(header_dir);
+			}
 		}
-		if let Some(line) = line.strip_prefix("#define CV_VERSION_") {
-			let mut parts = line.split_whitespace();
-			if let (Some(ver_spec), Some(version)) = (parts.next(), parts.next()) {
-				match ver_spec {
-					"MAJOR" => {
-						major = Some(version.parse().ok()?);
-					}
-					"MINOR" => {
-						minor = Some(version.parse().ok()?);
-					}
-					"REVISION" => {
-						revision = Some(version.parse().ok()?);
+		None
+	}
+
+	pub fn get_version_header(header_dir: &Path) -> Option<PathBuf> {
+		get_module_header_dir(header_dir)
+			.map(|dir| dir.join("core/version.hpp"))
+			.filter(|hdr| hdr.is_file())
+	}
+
+	pub fn get_config_header(header_dir: &Path) -> Option<PathBuf> {
+		get_module_header_dir(header_dir)
+			.map(|dir| dir.join("cvconfig.h"))
+			.filter(|hdr| hdr.is_file())
+	}
+
+	pub fn find_version(header_dir: &Path) -> Option<Version> {
+		let version_hpp = get_version_header(header_dir)?;
+		let mut major = None;
+		let mut minor = None;
+		let mut revision = None;
+		let mut line = String::with_capacity(256);
+		let mut reader = BufReader::new(File::open(version_hpp).ok()?);
+		while let Ok(bytes_read) = reader.read_line(&mut line) {
+			if bytes_read == 0 {
+				break;
+			}
+			if let Some(line) = line.strip_prefix("#define CV_VERSION_") {
+				let mut parts = line.split_whitespace();
+				if let (Some(ver_spec), Some(version)) = (parts.next(), parts.next()) {
+					match ver_spec {
+						"MAJOR" => {
+							major = Some(version.parse().ok()?);
+						}
+						"MINOR" => {
+							minor = Some(version.parse().ok()?);
+						}
+						"REVISION" => {
+							revision = Some(version.parse().ok()?);
+						}
+						_ => {}
 					}
-					_ => {}
+				}
+				if major.is_some() && minor.is_some() && revision.is_some() {
+					break;
 				}
 			}
-			if major.is_some() && minor.is_some() && revision.is_some() {
+			line.clear();
+		}
+		if let (Some(major), Some(minor), Some(revision)) = (major, minor, revision) {
+			Some(Version::new(major, minor, revision))
+		} else {
+			None
+		}
+	}
+
+	pub fn find_enabled_features(header_dir: &Path) -> Option<Vec<String>> {
+		let config_h = get_config_header(header_dir)?;
+		let mut out = Vec::with_capacity(64);
+		let mut line = String::with_capacity(256);
+		let mut reader = BufReader::new(File::open(config_h).ok()?);
+		while let Ok(bytes_read) = reader.read_line(&mut line) {
+			if bytes_read == 0 {
 				break;
 			}
+			if let Some(feature) = line.strip_prefix("#define HAVE_") {
+				out.push(feature.trim().to_lowercase());
+			}
+			line.clear();
 		}
-		line.clear();
-	}
-	if let (Some(major), Some(minor), Some(revision)) = (major, minor, revision) {
-		Some(Version::new(major, minor, revision))
-	} else {
-		None
+		Some(out)
 	}
 }
 
@@ -264,13 +332,18 @@ fn make_modules_and_alises(
 	Ok((modules, aliases))
 }
 
-fn emit_inherent_features(opencv_version: &Version) {
+fn emit_inherent_features(opencv: &Library) {
 	if VersionReq::parse(">=4.10")
 		.expect("Static version requirement")
-		.matches(opencv_version)
+		.matches(&opencv.version)
 	{
 		println!("cargo::rustc-cfg=ocvrs_has_inherent_feature_hfloat");
 	}
+	for feature in &opencv.enabled_features {
+		if feature == "opencl" {
+			println!("cargo::rustc-cfg=ocvrs_has_inherent_feature_opencl");
+		}
+	}
 }
 
 fn make_compiler(opencv: &Library, ffi_export_suffix: &str) -> cc::Build {
@@ -374,9 +447,7 @@ fn main() -> Result<()> {
 	for module in SUPPORTED_MODULES {
 		println!("cargo::rustc-check-cfg=cfg(ocvrs_has_module_{module})");
 	}
-	// MSRV: switch to #[expect] when MSRV is 1.81
-	#[allow(clippy::single_element_loop)]
-	for inherent_feature in ["hfloat"] {
+	for inherent_feature in ["hfloat", "opencl"] {
 		println!("cargo::rustc-check-cfg=cfg(ocvrs_has_inherent_feature_{inherent_feature})");
 	}
 
@@ -419,10 +490,10 @@ fn main() -> Result<()> {
 	let opencv_header_dir = opencv
 		.include_paths
 		.iter()
-		.find(|p| get_version_header(p).is_some())
-		.expect("Discovered OpenCV include paths is empty or contains non-existent paths");
+		.find(|p| header::get_version_header(p).is_some())
+		.expect("Discovered OpenCV include paths do not contain valid OpenCV headers");
 
-	if let Some(header_version) = get_version_from_headers(opencv_header_dir) {
+	if let Some(header_version) = header::find_version(opencv_header_dir) {
 		if header_version != opencv.version {
 			panic!(
 				"OpenCV version from the headers: {header_version} (at {}) must match version of the OpenCV library: {} (include paths: {:?})",
@@ -442,7 +513,7 @@ fn main() -> Result<()> {
 		)
 	}
 
-	let opencv_module_header_dir = get_module_header_dir(opencv_header_dir).expect("Can't find OpenCV module header dir");
+	let opencv_module_header_dir = header::get_module_header_dir(opencv_header_dir).expect("Can't find OpenCV module header dir");
 	eprintln!(
 		"=== Detected OpenCV module header dir at: {}",
 		opencv_module_header_dir.display()
@@ -452,7 +523,7 @@ fn main() -> Result<()> {
 		println!("cargo::rustc-cfg=ocvrs_has_module_{module}");
 	}
 
-	emit_inherent_features(&opencv.version);
+	emit_inherent_features(&opencv);
 
 	setup_rerun()?;
 

build/binding-generator.rs

@@ -5,7 +5,7 @@ use std::path::{Path, PathBuf};
 use opencv_binding_generator::writer::RustNativeBindingWriter;
 use opencv_binding_generator::Generator;
 
-use super::{get_version_from_headers, GenerateFullBindings, Result};
+use super::{header, GenerateFullBindings, Result};
 
 /// Because clang can't be used from multiple threads we run the binding generator helper for each
 /// module as a separate process. Building an additional helper binary from the build script is problematic,
@@ -27,7 +27,7 @@ pub fn run(mut args: impl Iterator<Item = OsString>) -> Result<()> {
 	let out_dir = PathBuf::from(args.next().ok_or("3rd argument must be output dir")?);
 	let module = args.next().ok_or("4th argument must be module name")?;
 	let module = module.to_str().ok_or("Not a valid module name")?;
-	let version = get_version_from_headers(&opencv_header_dir)
+	let version = header::find_version(&opencv_header_dir)
 		.ok_or("Can't find the version in the headers")?
 		.to_string();
 	let arg_additional_include_dirs = args.next();