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,14 +1,13 @@
 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;
 
 use binding_generator::handle_running_binding_generator;
 use docs::handle_running_in_docsrs;
 use generator::BindingGenerator;
+use header::IncludePath;
 use library::Library;
 use once_cell::sync::Lazy;
 use semver::{Version, VersionReq};
@@ -21,6 +20,8 @@ pub mod cmake_probe;
 mod docs;
 #[path = "build/generator.rs"]
 mod generator;
+#[path = "build/header.rs"]
+mod header;
 #[path = "build/library.rs"]
 pub mod library;
 
@@ -144,6 +145,8 @@ static SUPPORTED_MODULES: [&str; 73] = [
 	"xstereo",
 ];
 
+static SUPPORTED_INHERENT_FEATURES: [&str; 2] = ["hfloat", "opencl"];
+
 /// The contents of these vars will be present in the debug log, but will not cause the source rebuild
 static DEBUG_ENV_VARS: [&str; 1] = ["PATH"];
 
@@ -169,64 +172,6 @@ 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);
-	}
-	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())
-}
-
-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;
-		}
-		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;
-			}
-		}
-		line.clear();
-	}
-	if let (Some(major), Some(minor), Some(revision)) = (major, minor, revision) {
-		Some(Version::new(major, minor, revision))
-	} else {
-		None
-	}
-}
-
 fn make_modules_and_alises(
 	opencv_dir: &Path,
 	opencv_version: &Version,
@@ -264,13 +209,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 SUPPORTED_INHERENT_FEATURES.contains(&feature.as_str()) {
+			println!("cargo::rustc-cfg=ocvrs_has_inherent_feature_{feature}");
+		}
+	}
 }
 
 fn make_compiler(opencv: &Library, ffi_export_suffix: &str) -> cc::Build {
@@ -374,9 +324,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 SUPPORTED_INHERENT_FEATURES {
 		println!("cargo::rustc-check-cfg=cfg(ocvrs_has_inherent_feature_{inherent_feature})");
 	}
 
@@ -419,10 +367,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| p.get_version_header().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) = opencv_header_dir.find_version() {
 		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 +390,9 @@ 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 = opencv_header_dir
+		.get_module_header_dir()
+		.expect("Can't find OpenCV module header dir");
 	eprintln!(
 		"=== Detected OpenCV module header dir at: {}",
 		opencv_module_header_dir.display()
@@ -452,7 +402,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,8 @@ 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::IncludePath;
+use super::{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 +28,8 @@ 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 = opencv_header_dir
+		.find_version()
 		.ok_or("Can't find the version in the headers")?
 		.to_string();
 	let arg_additional_include_dirs = args.next();

build/header.rs

@@ -0,0 +1,139 @@
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use semver::Version;
+
+pub trait IncludePath {
+	fn get_module_header_dir(&self) -> Option<PathBuf>;
+	fn get_version_header(&self) -> Option<PathBuf>;
+	fn get_config_header(&self) -> Option<PathBuf>;
+	fn find_version(&self) -> Option<Version>;
+	fn find_enabled_features(&self) -> Option<Vec<String>>;
+}
+
+impl IncludePath for Path {
+	fn get_module_header_dir(&self) -> Option<PathBuf> {
+		let mut out = self.join("opencv2.framework/Headers");
+		if out.is_dir() {
+			return Some(out);
+		}
+		out = self.join("opencv2");
+		if out.is_dir() {
+			return Some(out);
+		}
+		None
+	}
+
+	fn get_version_header(&self) -> Option<PathBuf> {
+		self
+			.get_module_header_dir()
+			.map(|dir| dir.join("core/version.hpp"))
+			.filter(|hdr| hdr.is_file())
+	}
+
+	fn get_config_header(&self) -> Option<PathBuf> {
+		self
+			.get_module_header_dir()
+			.map(|dir| dir.join("cvconfig.h"))
+			.filter(|hdr| hdr.is_file())
+	}
+
+	fn find_version(&self) -> Option<Version> {
+		let version_hpp = self.get_version_header()?;
+		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;
+				}
+			}
+			line.clear();
+		}
+		if let (Some(major), Some(minor), Some(revision)) = (major, minor, revision) {
+			Some(Version::new(major, minor, revision))
+		} else {
+			None
+		}
+	}
+
+	fn find_enabled_features(&self) -> Option<Vec<String>> {
+		let config_h = self.get_config_header()?;
+		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();
+		}
+		Some(out)
+	}
+}
+
+/// Something like `/usr/include/x86_64-linux-gnu/opencv4/` on newer Debian-derived distros
+///
+/// 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")
+				.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()],
+		);
+
+	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);
+		}
+	}
+	None
+}

build/library.rs

@@ -8,7 +8,8 @@ use dunce::canonicalize;
 use semver::Version;
 
 use super::cmake_probe::{CmakeProbe, LinkLib, LinkSearch};
-use super::{get_version_from_headers, Result, MANIFEST_DIR, OUT_DIR, TARGET_VENDOR_APPLE};
+use super::header::IncludePath;
+use super::{header, Result, MANIFEST_DIR, OUT_DIR, TARGET_VENDOR_APPLE};
 
 struct PackageName;
 
@@ -149,12 +150,25 @@ impl Linkage {
 pub struct Library {
 	pub include_paths: Vec<PathBuf>,
 	pub version: Version,
+	pub enabled_features: Vec<String>,
 	pub cargo_metadata: Vec<String>,
 }
 
 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| get_version_from_headers(x.as_ref()))
+		include_paths.into_iter().find_map(|x| x.as_ref().find_version())
+	}
+
+	fn enabled_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_enabled_features())
 	}
 
 	fn process_env_var_list<'a, T: From<&'a str>>(env_list: Option<EnvList<'a>>, sys_list: Vec<T>) -> Vec<T> {
@@ -226,16 +240,20 @@ impl Library {
 			eprintln!("===   link_paths: {link_paths}");
 			eprintln!("===   link_libs: {link_libs}");
 			let mut cargo_metadata = Vec::with_capacity(64);
-			let include_paths: Vec<_> = include_paths.iter().map(PathBuf::from).collect();
+			let include_paths = include_paths.iter().map(PathBuf::from).collect::<Vec<_>>();
 
-			let version = Self::version_from_include_paths(&include_paths).ok_or("Could not OpenCV version from include_paths")?;
+			let version =
+				Self::version_from_include_paths(&include_paths).ok_or("Could not get OpenCV version from include_paths")?;
+			let enabled_features =
+				Self::enabled_features_from_include_paths(&include_paths).ok_or("Could not get OpenCV config from include_paths")?;
 
 			cargo_metadata.extend(Self::process_link_paths(Some(link_paths), vec![]));
 			cargo_metadata.extend(Self::process_link_libs(Some(link_libs), vec![]));
 
 			Ok(Self {
 				include_paths,
 				version,
+				enabled_features,
 				cargo_metadata,
 			})
 		} else {
@@ -302,11 +320,15 @@ impl Library {
 			));
 		}
 
-		let include_paths = Self::process_env_var_list(include_paths, opencv.include_paths);
+		let mut include_paths = Self::process_env_var_list(include_paths, opencv.include_paths);
+		Self::add_multiarch_dir_if_needed(&mut include_paths);
+		let enabled_features =
+			Self::enabled_features_from_include_paths(&include_paths).ok_or("Could not get OpenCV config from include_paths")?;
 
 		Ok(Self {
 			include_paths,
 			version: Version::parse(&opencv.version)?,
+			enabled_features,
 			cargo_metadata,
 		})
 	}
@@ -355,9 +377,15 @@ 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 enabled_features =
+			Self::enabled_features_from_include_paths(&include_paths).ok_or("Could not get OpenCV config from include_paths")?;
+
 		Ok(Self {
-			include_paths: Self::process_env_var_list(include_paths, probe_result.include_paths),
+			include_paths,
 			version: probe_result.version.unwrap_or_else(|| Version::new(0, 0, 0)),
+			enabled_features,
 			cargo_metadata,
 		})
 	}
@@ -397,8 +425,6 @@ impl Library {
 
 		let version = Self::version_from_include_paths(&opencv_include_paths);
 
-		let include_paths = Self::process_env_var_list(include_paths, opencv_include_paths);
-
 		let mut cargo_metadata = opencv.cargo_metadata;
 
 		if link_paths.as_ref().is_some_and(|lp| !lp.is_extend()) {
@@ -411,9 +437,15 @@ 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 enabled_features =
+			Self::enabled_features_from_include_paths(&include_paths).ok_or("Could not get OpenCV config from include_paths")?;
+
 		Ok(Self {
 			include_paths,
 			version: version.unwrap_or_else(|| Version::new(0, 0, 0)),
+			enabled_features,
 			cargo_metadata,
 		})
 	}

ci/install-macos-vcpkg.sh

@@ -2,40 +2,8 @@
 
 set -xeu
 
-if [[ "${VCPKG_VERSION:-}" == "" ]]; then
-	echo "Must set VCPKG_VERSION environment var"
-	exit 1
-fi
-
-export VCPKG_ROOT="$HOME/build/vcpkg"
-if [[ -e "$VCPKG_ROOT" && ! -e "$VCPKG_ROOT/.git" ]]; then
-	rm -rf "$VCPKG_ROOT"
-fi
-if [ ! -e "$VCPKG_ROOT" ]; then
-	git clone https://github.com/Microsoft/vcpkg.git "$VCPKG_ROOT"
-fi
-pushd "$VCPKG_ROOT"
-git fetch --all --prune --tags
-git status
-git checkout .
-git checkout "$VCPKG_VERSION"
-./bootstrap-vcpkg.sh -disableMetrics
-#./vcpkg integrate install
-echo "set(VCPKG_BUILD_TYPE release)" >> triplets/arm64-osx.cmake
-echo "set(VCPKG_BUILD_TYPE release)" >> triplets/x64-osx.cmake
 export VCPKG_DEFAULT_TRIPLET=arm64-osx
-(
-	set +e
-	which cmake
-	cmake --version
-	if ! ./vcpkg install --clean-after-build --recurse "opencv[contrib,nonfree,ade,opencl]"; then
-		for log in "$VCPKG_ROOT/buildtrees"/**/*out.log; do
-			echo "=== $log"
-			cat "$log"
-		done
-		exit 1
-	fi
-)
-# remove build artifacts to save CI cache space
-rm -rf "$VCPKG_ROOT/downloads" "$VCPKG_ROOT/buildtrees" "$VCPKG_ROOT/packages"
-popd
+
+script_dir="$(dirname "$(readlink -f "$BASH_SOURCE")")"
+
+. "$script_dir/install-vcpkg.sh"

ci/install-ubuntu-vcpkg.sh

@@ -2,11 +2,6 @@
 
 set -xeu
 
-if [[ "${VCPKG_VERSION:-}" == "" ]]; then
-	echo "Must set VCPKG_VERSION environment var"
-	exit 1
-fi
-
 sudo apt-get update
 sudo apt-get install -y \
 	autoconf \
@@ -38,36 +33,8 @@ sudo apt-get install -y \
 	unzip \
 	zip
 
-export VCPKG_ROOT="$HOME/build/vcpkg"
-export VCPKG_DISABLE_METRICS=1
-if [[ -e "$VCPKG_ROOT" && ! -e "$VCPKG_ROOT/.git" ]]; then
-	rm -rf "$VCPKG_ROOT"
-fi
-if [ ! -e "$VCPKG_ROOT" ]; then
-	git clone https://github.com/Microsoft/vcpkg.git "$VCPKG_ROOT"
-fi
-pushd "$VCPKG_ROOT"
-git fetch --all --prune --tags
-git status
-git checkout .
-git checkout "$VCPKG_VERSION"
-./bootstrap-vcpkg.sh -disableMetrics
-#./vcpkg integrate install
-echo "set(VCPKG_BUILD_TYPE release)" >> triplets/x64-linux.cmake
 export VCPKG_DEFAULT_TRIPLET=x64-linux
-#./vcpkg install llvm  # takes very long time
-(
-	set +e
-	which cmake
-	cmake --version
-	if ! ./vcpkg install --clean-after-build --recurse "opencv[contrib,nonfree,ade,opencl]"; then
-		for log in "$VCPKG_ROOT/buildtrees"/**/*-{out,err}.log; do
-			echo "=== $log"
-			cat "$log"
-		done
-		exit 1
-	fi
-)
-# remove build artifacts to save CI cache space
-rm -rf "$VCPKG_ROOT/downloads" "$VCPKG_ROOT/buildtrees" "$VCPKG_ROOT/packages"
-popd
+
+script_dir="$(dirname "$(readlink -f "$BASH_SOURCE")")"
+
+. "$script_dir/install-vcpkg.sh"

ci/install-vcpkg.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+set -xeu
+
+export VCPKG_ROOT="$HOME/build/vcpkg"
+export VCPKG_DISABLE_METRICS=1
+if [[ -e "$VCPKG_ROOT" && ! -e "$VCPKG_ROOT/.git" ]]; then
+	rm -rf "$VCPKG_ROOT"
+fi
+if [ ! -e "$VCPKG_ROOT" ]; then
+	git clone https://github.com/Microsoft/vcpkg.git "$VCPKG_ROOT"
+fi
+pushd "$VCPKG_ROOT"
+git fetch --all --prune --tags
+git status
+git checkout .
+git checkout "$VCPKG_VERSION"
+./bootstrap-vcpkg.sh -disableMetrics
+#./vcpkg integrate install
+echo "set(VCPKG_BUILD_TYPE release)" >> triplets/x64-linux.cmake
+echo "set(VCPKG_BUILD_TYPE release)" >> triplets/arm64-osx.cmake
+echo "set(VCPKG_BUILD_TYPE release)" >> triplets/x64-osx.cmake
+echo "set(VCPKG_BUILD_TYPE release)" >> triplets/x64-windows.cmake
+echo "set(VCPKG_BUILD_TYPE release)" >> triplets/x64-windows-static.cmake
+echo "set(VCPKG_BUILD_TYPE release)" >> triplets/x86-windows.cmake
+echo "set(VCPKG_BUILD_TYPE release)" >> triplets/community/x64-windows-static-md.cmake
+#./vcpkg install llvm  # takes very long time
+(
+	set +e
+	which cmake
+	cmake --version
+	if ! ./vcpkg install --clean-after-build --recurse "opencv4[$VCPKG_FEATURES]"; then
+		for log in "$VCPKG_ROOT/buildtrees"/**/*-{out,err}.log; do
+			echo "=== $log"
+			cat "$log"
+		done
+		exit 1
+	fi
+)
+# remove build artifacts to save CI cache space
+rm -rf "$VCPKG_ROOT/downloads" "$VCPKG_ROOT/buildtrees" "$VCPKG_ROOT/packages"
+popd

ci/install-windows-vcpkg.sh

@@ -2,45 +2,11 @@
 
 set -xeu
 
-# remove system vcpkg
-rm -rf "$VCPKG_INSTALLATION_ROOT"
-
 # install llvm from choco in place of vcpkg to speed things up
 choco install -y llvm --version "$CHOCO_LLVM_VERSION"
 
-export VCPKG_ROOT="$HOME/build/vcpkg"
-export VCPKG_DISABLE_METRICS=1
-if [[ -e "$VCPKG_ROOT" && ! -e "$VCPKG_ROOT/.git" ]]; then
-	rm -rf "$VCPKG_ROOT"
-fi
-if [ ! -e "$VCPKG_ROOT" ]; then
-	git clone https://github.com/Microsoft/vcpkg.git "$VCPKG_ROOT"
-fi
-pushd "$VCPKG_ROOT"
-git fetch --all --prune --tags
-git status
-git checkout .
-git checkout "$VCPKG_VERSION"
-./bootstrap-vcpkg.sh -disableMetrics
-#./vcpkg integrate install
-echo "set(VCPKG_BUILD_TYPE release)" >> triplets/x64-windows.cmake
-echo "set(VCPKG_BUILD_TYPE release)" >> triplets/x64-windows-static.cmake
-echo "set(VCPKG_BUILD_TYPE release)" >> triplets/x86-windows.cmake
-echo "set(VCPKG_BUILD_TYPE release)" >> triplets/community/x64-windows-static-md.cmake
 export VCPKG_DEFAULT_TRIPLET=x64-windows
-#./vcpkg install llvm  # takes very long time
-(
-	set +e
-	which cmake
-	cmake --version
-	if ! ./vcpkg install --clean-after-build --recurse "opencv[contrib,nonfree,ade,opencl]"; then
-		for log in "$VCPKG_ROOT/buildtrees"/**/*out.log; do
-			echo "=== $log"
-			cat "$log"
-		done
-		exit 1
-	fi
-)
-# remove build artifacts to save CI cache space
-rm -rf "$VCPKG_ROOT/downloads" "$VCPKG_ROOT/buildtrees" "$VCPKG_ROOT/packages"
-popd
+
+script_dir="$(dirname "$(readlink -f "$BASH_SOURCE")")"
+
+. "$script_dir/install-vcpkg.sh"

examples/opencl.rs

@@ -1,19 +1,21 @@
-use std::{env, time};
+use opencv::Result;
 
-use opencv::core::{Device, Size, UMat, Vector};
-use opencv::prelude::*;
-use opencv::{core, imgcodecs, imgproc, Result};
+#[cfg(ocvrs_has_inherent_feature_opencl)]
+fn main() -> Result<()> {
+	use std::{env, time};
 
-opencv::not_opencv_branch_34! {
-	use opencv::core::AccessFlag::ACCESS_READ;
-}
-opencv::opencv_branch_34! {
-	use opencv::core::ACCESS_READ;
-}
+	use opencv::core::{Device, Size, UMat, Vector};
+	use opencv::prelude::*;
+	use opencv::{core, imgcodecs, imgproc};
 
-const ITERATIONS: usize = 100;
+	opencv::not_opencv_branch_34! {
+		use opencv::core::AccessFlag::ACCESS_READ;
+	}
+	opencv::opencv_branch_34! {
+		use opencv::core::ACCESS_READ;
+	}
 
-fn main() -> Result<()> {
+	const ITERATIONS: usize = 100;
 	let img_file = env::args().nth(1).expect("Please supply image file name");
 	let opencl_have = core::have_opencl()?;
 	if opencl_have {
@@ -74,3 +76,10 @@ fn main() -> Result<()> {
 	}
 	Ok(())
 }
+
+#[cfg(not(ocvrs_has_inherent_feature_opencl))]
+fn main() -> Result<()> {
+	eprintln!("This example requires that OpenCV is build with OpenCL support:");
+	eprintln!("{}", opencv::core::get_build_information()?);
+	Ok(())
+}

src_cpp/core.hpp

@@ -1,11 +1,15 @@
 #include "ocvrs_common.hpp"
 #include <opencv2/core/affine.hpp>
-#include <opencv2/core/directx.hpp>
-#include <opencv2/core/ocl.hpp>
-#include <opencv2/core/va_intel.hpp>
+#ifdef HAVE_OPENCL
+	#include <opencv2/core/ocl.hpp>
+	// opengl.hpp, va_intel.hpp and directx.hpp unconditionally include ocl.hpp thus it needs to be within ifdef HAVE_OPENCL
+	#ifdef HAVE_OPENGL
+		#include <opencv2/core/opengl.hpp>
+	#endif
+	#include <opencv2/core/va_intel.hpp>
+	#include <opencv2/core/directx.hpp>
+#endif
 #include <opencv2/core/cuda.hpp>
-#include <opencv2/core/opengl.hpp>
-#include <opencv2/core/directx.hpp>
 #if (CV_VERSION_MAJOR == 3 && CV_VERSION_MINOR == 4 && CV_VERSION_REVISION >= 4) /* 3.4.4+ */ \
 	|| (CV_VERSION_MAJOR == 4) /* 4.0+ */ \
 	|| (CV_VERSION_MAJOR == 5) /* 5.0+ */

src_cpp/ocvrs_common.hpp

@@ -1,10 +1,11 @@
 #ifndef __OCVRS_COMMON_HPP__
 #define __OCVRS_COMMON_HPP__
 
-#if defined(_WIN32) || defined(_WIN64) || defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__) \
- || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__)
-	#define OCVRS_TARGET_OS_WINDOWS
-#endif
+#include <memory>
+#include <opencv2/cvconfig.h>
+// defining HAVE_VA starts to rely on <va/va.h> for VADisplay and VASurfaceID instead of OpenCV stubs, and we stop generating
+// bindings for the functions that use them
+#undef HAVE_VA
 
 #define CV_COLLECT_IMPL_DATA
 #ifdef OCVRS_PARSING_HEADERS
@@ -15,9 +16,13 @@
 	#define OCVRS_FFI_EXPORT_SUFFIX
 #endif
 
-#include <memory>
 #include <opencv2/core.hpp>
 
+#if defined(_WIN32) || defined(_WIN64) || defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__) \
+ || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__)
+	#define OCVRS_TARGET_OS_WINDOWS
+#endif
+
 #define OCVRS_ONLY_DEPENDENT_TYPES
 
 #define OCVRS_HANDLE(code, msg, return_name) Err(code, msg, return_name)

tests/opencl.rs

@@ -2,6 +2,7 @@ use opencv::{core, Result};
 
 #[test]
 fn convert_type_str() -> Result<()> {
+	#[cfg(ocvrs_has_inherent_feature_opencl)]
 	if core::have_opencl()? {
 		// this function writes to buf argument and returns it
 		let mut test = "test".to_string();