Initial implementation of video_probe (Rust)

Core modules:
- probe.rs: ffprobe execution logic
- parser.rs: JSON parsing logic
- output.rs: Output formatting
- lib.rs: Library interface
- main.rs: CLI entry point

Features:
- Extract video metadata using ffprobe
- Parse video/audio/subtitle streams
- Save to JSON file
- Console summary output

Documentation:
- Added QUICKSTART.md
- Added ENVIRONMENT_SETUP_REPORT.md

target/debug/build/anyhow-24ec003b790501cc/build_script_build-24ec003b790501cc.d

@@ -0,0 +1,5 @@
+/Users/accusys/video_yolo_player/target/debug/build/anyhow-24ec003b790501cc/build_script_build-24ec003b790501cc.d: /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/anyhow-1.0.102/build.rs
+
+/Users/accusys/video_yolo_player/target/debug/build/anyhow-24ec003b790501cc/build_script_build-24ec003b790501cc: /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/anyhow-1.0.102/build.rs
+
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/anyhow-1.0.102/build.rs:

target/debug/build/anyhow-40fe6c014f4e8bb6/invoked.timestamp

@@ -0,0 +1 @@
+This file has an mtime of when this was started.

target/debug/build/anyhow-40fe6c014f4e8bb6/output

@@ -0,0 +1,7 @@
+cargo:rerun-if-changed=src/nightly.rs
+cargo:rerun-if-env-changed=RUSTC_BOOTSTRAP
+cargo:rustc-check-cfg=cfg(anyhow_build_probe)
+cargo:rustc-check-cfg=cfg(anyhow_nightly_testing)
+cargo:rustc-check-cfg=cfg(anyhow_no_clippy_format_args)
+cargo:rustc-check-cfg=cfg(anyhow_no_core_error)
+cargo:rustc-check-cfg=cfg(error_generic_member_access)

target/debug/build/anyhow-40fe6c014f4e8bb6/root-output

@@ -0,0 +1 @@
+/Users/accusys/video_yolo_player/target/debug/build/anyhow-40fe6c014f4e8bb6/out

target/debug/build/clang-sys-455eaadebd7fcdd4/invoked.timestamp

@@ -0,0 +1 @@
+This file has an mtime of when this was started.

target/debug/build/clang-sys-455eaadebd7fcdd4/output

@@ -0,0 +1,2 @@
+cargo:rustc-link-search=/Library/Developer/CommandLineTools/usr/lib
+cargo:rustc-link-lib=dylib=clang

target/debug/build/clang-sys-455eaadebd7fcdd4/root-output

@@ -0,0 +1 @@
+/Users/accusys/video_yolo_player/target/debug/build/clang-sys-455eaadebd7fcdd4/out

target/debug/build/clang-sys-97c996220bfdd113/build_script_build-97c996220bfdd113.d

@@ -0,0 +1,9 @@
+/Users/accusys/video_yolo_player/target/debug/build/clang-sys-97c996220bfdd113/build_script_build-97c996220bfdd113.d: /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build/macros.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build/common.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build/dynamic.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build/static.rs
+
+/Users/accusys/video_yolo_player/target/debug/build/clang-sys-97c996220bfdd113/build_script_build-97c996220bfdd113: /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build/macros.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build/common.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build/dynamic.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build/static.rs
+
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build/macros.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build/common.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build/dynamic.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/clang-sys-1.8.1/build/static.rs:

target/debug/build/libc-d9e23ff9305bfd93/build_script_build-d9e23ff9305bfd93.d

@@ -0,0 +1,5 @@
+/Users/accusys/video_yolo_player/target/debug/build/libc-d9e23ff9305bfd93/build_script_build-d9e23ff9305bfd93.d: /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libc-0.2.182/build.rs
+
+/Users/accusys/video_yolo_player/target/debug/build/libc-d9e23ff9305bfd93/build_script_build-d9e23ff9305bfd93: /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libc-0.2.182/build.rs
+
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libc-0.2.182/build.rs:

target/debug/build/libc-fcd50b7bda3a60e8/invoked.timestamp

@@ -0,0 +1 @@
+This file has an mtime of when this was started.

target/debug/build/libc-fcd50b7bda3a60e8/output

@@ -0,0 +1,25 @@
+cargo:rerun-if-changed=build.rs
+cargo:rerun-if-env-changed=RUST_LIBC_UNSTABLE_FREEBSD_VERSION
+cargo:rustc-cfg=freebsd12
+cargo:rerun-if-env-changed=RUST_LIBC_UNSTABLE_MUSL_V1_2_3
+cargo:rerun-if-env-changed=RUST_LIBC_UNSTABLE_LINUX_TIME_BITS64
+cargo:rerun-if-env-changed=RUST_LIBC_UNSTABLE_GNU_FILE_OFFSET_BITS
+cargo:rerun-if-env-changed=RUST_LIBC_UNSTABLE_GNU_TIME_BITS
+cargo:rustc-check-cfg=cfg(emscripten_old_stat_abi)
+cargo:rustc-check-cfg=cfg(espidf_time32)
+cargo:rustc-check-cfg=cfg(freebsd10)
+cargo:rustc-check-cfg=cfg(freebsd11)
+cargo:rustc-check-cfg=cfg(freebsd12)
+cargo:rustc-check-cfg=cfg(freebsd13)
+cargo:rustc-check-cfg=cfg(freebsd14)
+cargo:rustc-check-cfg=cfg(freebsd15)
+cargo:rustc-check-cfg=cfg(gnu_file_offset_bits64)
+cargo:rustc-check-cfg=cfg(gnu_time_bits64)
+cargo:rustc-check-cfg=cfg(libc_deny_warnings)
+cargo:rustc-check-cfg=cfg(linux_time_bits64)
+cargo:rustc-check-cfg=cfg(musl_v1_2_3)
+cargo:rustc-check-cfg=cfg(musl32_time64)
+cargo:rustc-check-cfg=cfg(vxworks_lt_25_09)
+cargo:rustc-check-cfg=cfg(target_os,values("switch","aix","ohos","hurd","rtems","visionos","nuttx","cygwin","qurt"))
+cargo:rustc-check-cfg=cfg(target_env,values("illumos","wasi","aix","ohos","nto71_iosock","nto80"))
+cargo:rustc-check-cfg=cfg(target_arch,values("loongarch64","mips32r6","mips64r6","csky"))

target/debug/build/libc-fcd50b7bda3a60e8/root-output

@@ -0,0 +1 @@
+/Users/accusys/video_yolo_player/target/debug/build/libc-fcd50b7bda3a60e8/out

target/debug/build/num-traits-151c990202d10603/build_script_build-151c990202d10603.d

@@ -0,0 +1,5 @@
+/Users/accusys/video_yolo_player/target/debug/build/num-traits-151c990202d10603/build_script_build-151c990202d10603.d: /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-traits-0.2.19/build.rs
+
+/Users/accusys/video_yolo_player/target/debug/build/num-traits-151c990202d10603/build_script_build-151c990202d10603: /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-traits-0.2.19/build.rs
+
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-traits-0.2.19/build.rs:

target/debug/build/num-traits-da6afca2f0b36689/invoked.timestamp

@@ -0,0 +1 @@
+This file has an mtime of when this was started.

target/debug/build/num-traits-da6afca2f0b36689/output

@@ -0,0 +1,3 @@
+cargo:rustc-check-cfg=cfg(has_total_cmp)
+cargo:rustc-cfg=has_total_cmp
+cargo:rerun-if-changed=build.rs

target/debug/build/num-traits-da6afca2f0b36689/root-output

@@ -0,0 +1 @@
+/Users/accusys/video_yolo_player/target/debug/build/num-traits-da6afca2f0b36689/out

target/debug/build/opencv-4e105b5546afc119/invoked.timestamp

@@ -0,0 +1 @@
+This file has an mtime of when this was started.

target/debug/build/opencv-4e105b5546afc119/out/flag_check.cpp

@@ -0,0 +1 @@
+int main(void) { return 0; }

target/debug/build/opencv-4e105b5546afc119/out/highgui.cpp

@@ -0,0 +1,457 @@
+#include "ocvrs_common.hpp"
+#include <opencv2/highgui.hpp>
+#include "highgui_types.hpp"
+
+extern "C" {
+void cv_addText_const_MatR_const_StringR_Point_const_QtFontR(const cv::Mat* img, const char* text, cv::Point* org, const cv::QtFont* font, ResultVoid* ocvrs_return) {
+	try {
+		cv::addText(*img, std::string(text), *org, *font);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_addText_const_MatR_const_StringR_Point_const_StringR(const cv::Mat* img, const char* text, cv::Point* org, const char* nameFont, ResultVoid* ocvrs_return) {
+	try {
+		cv::addText(*img, std::string(text), *org, std::string(nameFont));
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_addText_const_MatR_const_StringR_Point_const_StringR_int_Scalar_int_int_int(const cv::Mat* img, const char* text, cv::Point* org, const char* nameFont, int pointSize, cv::Scalar* color, int weight, int style, int spacing, ResultVoid* ocvrs_return) {
+	try {
+		cv::addText(*img, std::string(text), *org, std::string(nameFont), pointSize, *color, weight, style, spacing);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_createButton_const_StringR_ButtonCallback_voidX(const char* bar_name, cv::ButtonCallback on_change, void* userdata, Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::createButton(std::string(bar_name), on_change, userdata);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_createButton_const_StringR_ButtonCallback_voidX_int_bool(const char* bar_name, cv::ButtonCallback on_change, void* userdata, int type, bool initial_button_state, Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::createButton(std::string(bar_name), on_change, userdata, type, initial_button_state);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_createTrackbar_const_StringR_const_StringR_intX_int_TrackbarCallback_voidX(const char* trackbarname, const char* winname, int* value, int count, cv::TrackbarCallback onChange, void* userdata, Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::createTrackbar(std::string(trackbarname), std::string(winname), value, count, onChange, userdata);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_currentUIFramework(Result<void*>* ocvrs_return) {
+	try {
+		const std::string ret = cv::currentUIFramework();
+		Ok(ocvrs_create_string(ret.c_str()), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_destroyAllWindows(ResultVoid* ocvrs_return) {
+	try {
+		cv::destroyAllWindows();
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_destroyWindow_const_StringR(const char* winname, ResultVoid* ocvrs_return) {
+	try {
+		cv::destroyWindow(std::string(winname));
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_displayOverlay_const_StringR_const_StringR(const char* winname, const char* text, ResultVoid* ocvrs_return) {
+	try {
+		cv::displayOverlay(std::string(winname), std::string(text));
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_displayOverlay_const_StringR_const_StringR_int(const char* winname, const char* text, int delayms, ResultVoid* ocvrs_return) {
+	try {
+		cv::displayOverlay(std::string(winname), std::string(text), delayms);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_displayStatusBar_const_StringR_const_StringR(const char* winname, const char* text, ResultVoid* ocvrs_return) {
+	try {
+		cv::displayStatusBar(std::string(winname), std::string(text));
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_displayStatusBar_const_StringR_const_StringR_int(const char* winname, const char* text, int delayms, ResultVoid* ocvrs_return) {
+	try {
+		cv::displayStatusBar(std::string(winname), std::string(text), delayms);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_fontQt_const_StringR(const char* nameFont, Result<cv::QtFont*>* ocvrs_return) {
+	try {
+		cv::QtFont ret = cv::fontQt(std::string(nameFont));
+		Ok(new cv::QtFont(ret), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_fontQt_const_StringR_int_Scalar_int_int_int(const char* nameFont, int pointSize, cv::Scalar* color, int weight, int style, int spacing, Result<cv::QtFont*>* ocvrs_return) {
+	try {
+		cv::QtFont ret = cv::fontQt(std::string(nameFont), pointSize, *color, weight, style, spacing);
+		Ok(new cv::QtFont(ret), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_getMouseWheelDelta_int(int flags, Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::getMouseWheelDelta(flags);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_getTrackbarPos_const_StringR_const_StringR(const char* trackbarname, const char* winname, Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::getTrackbarPos(std::string(trackbarname), std::string(winname));
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_getWindowImageRect_const_StringR(const char* winname, Result<cv::Rect>* ocvrs_return) {
+	try {
+		cv::Rect ret = cv::getWindowImageRect(std::string(winname));
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_getWindowProperty_const_StringR_int(const char* winname, int prop_id, Result<double>* ocvrs_return) {
+	try {
+		double ret = cv::getWindowProperty(std::string(winname), prop_id);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_imshow_const_StringR_const__InputArrayR(const char* winname, const cv::_InputArray* mat, ResultVoid* ocvrs_return) {
+	try {
+		cv::imshow(std::string(winname), *mat);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_loadWindowParameters_const_StringR(const char* windowName, ResultVoid* ocvrs_return) {
+	try {
+		cv::loadWindowParameters(std::string(windowName));
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_moveWindow_const_StringR_int_int(const char* winname, int x, int y, ResultVoid* ocvrs_return) {
+	try {
+		cv::moveWindow(std::string(winname), x, y);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_namedWindow_const_StringR(const char* winname, ResultVoid* ocvrs_return) {
+	try {
+		cv::namedWindow(std::string(winname));
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_namedWindow_const_StringR_int(const char* winname, int flags, ResultVoid* ocvrs_return) {
+	try {
+		cv::namedWindow(std::string(winname), flags);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_pollKey(Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::pollKey();
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_resizeWindow_const_StringR_const_SizeR(const char* winname, const cv::Size* size, ResultVoid* ocvrs_return) {
+	try {
+		cv::resizeWindow(std::string(winname), *size);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_resizeWindow_const_StringR_int_int(const char* winname, int width, int height, ResultVoid* ocvrs_return) {
+	try {
+		cv::resizeWindow(std::string(winname), width, height);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_saveWindowParameters_const_StringR(const char* windowName, ResultVoid* ocvrs_return) {
+	try {
+		cv::saveWindowParameters(std::string(windowName));
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_selectROI_const_StringR_const__InputArrayR(const char* windowName, const cv::_InputArray* img, Result<cv::Rect>* ocvrs_return) {
+	try {
+		cv::Rect ret = cv::selectROI(std::string(windowName), *img);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_selectROI_const_StringR_const__InputArrayR_bool_bool_bool(const char* windowName, const cv::_InputArray* img, bool showCrosshair, bool fromCenter, bool printNotice, Result<cv::Rect>* ocvrs_return) {
+	try {
+		cv::Rect ret = cv::selectROI(std::string(windowName), *img, showCrosshair, fromCenter, printNotice);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_selectROI_const__InputArrayR(const cv::_InputArray* img, Result<cv::Rect>* ocvrs_return) {
+	try {
+		cv::Rect ret = cv::selectROI(*img);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_selectROI_const__InputArrayR_bool_bool_bool(const cv::_InputArray* img, bool showCrosshair, bool fromCenter, bool printNotice, Result<cv::Rect>* ocvrs_return) {
+	try {
+		cv::Rect ret = cv::selectROI(*img, showCrosshair, fromCenter, printNotice);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_selectROIs_const_StringR_const__InputArrayR_vectorLRectGR(const char* windowName, const cv::_InputArray* img, std::vector<cv::Rect>* boundingBoxes, ResultVoid* ocvrs_return) {
+	try {
+		cv::selectROIs(std::string(windowName), *img, *boundingBoxes);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_selectROIs_const_StringR_const__InputArrayR_vectorLRectGR_bool_bool_bool(const char* windowName, const cv::_InputArray* img, std::vector<cv::Rect>* boundingBoxes, bool showCrosshair, bool fromCenter, bool printNotice, ResultVoid* ocvrs_return) {
+	try {
+		cv::selectROIs(std::string(windowName), *img, *boundingBoxes, showCrosshair, fromCenter, printNotice);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_setMouseCallback_const_StringR_MouseCallback_voidX(const char* winname, cv::MouseCallback onMouse, void* userdata, ResultVoid* ocvrs_return) {
+	try {
+		cv::setMouseCallback(std::string(winname), onMouse, userdata);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_setOpenGlContext_const_StringR(const char* winname, ResultVoid* ocvrs_return) {
+	try {
+		cv::setOpenGlContext(std::string(winname));
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_setOpenGlDrawCallback_const_StringR_OpenGlDrawCallback_voidX(const char* winname, cv::OpenGlDrawCallback onOpenGlDraw, void* userdata, ResultVoid* ocvrs_return) {
+	try {
+		cv::setOpenGlDrawCallback(std::string(winname), onOpenGlDraw, userdata);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_setTrackbarMax_const_StringR_const_StringR_int(const char* trackbarname, const char* winname, int maxval, ResultVoid* ocvrs_return) {
+	try {
+		cv::setTrackbarMax(std::string(trackbarname), std::string(winname), maxval);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_setTrackbarMin_const_StringR_const_StringR_int(const char* trackbarname, const char* winname, int minval, ResultVoid* ocvrs_return) {
+	try {
+		cv::setTrackbarMin(std::string(trackbarname), std::string(winname), minval);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_setTrackbarPos_const_StringR_const_StringR_int(const char* trackbarname, const char* winname, int pos, ResultVoid* ocvrs_return) {
+	try {
+		cv::setTrackbarPos(std::string(trackbarname), std::string(winname), pos);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_setWindowProperty_const_StringR_int_double(const char* winname, int prop_id, double prop_value, ResultVoid* ocvrs_return) {
+	try {
+		cv::setWindowProperty(std::string(winname), prop_id, prop_value);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_setWindowTitle_const_StringR_const_StringR(const char* winname, const char* title, ResultVoid* ocvrs_return) {
+	try {
+		cv::setWindowTitle(std::string(winname), std::string(title));
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_startLoop_int__X__int__charXX__int_charXX(int (*pt2Func)(int, char**), int argc, char** argv, Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::startLoop(pt2Func, argc, argv);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_startWindowThread(Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::startWindowThread();
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_stopLoop(ResultVoid* ocvrs_return) {
+	try {
+		cv::stopLoop();
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_updateWindow_const_StringR(const char* winname, ResultVoid* ocvrs_return) {
+	try {
+		cv::updateWindow(std::string(winname));
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_waitKey(Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::waitKey();
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_waitKeyEx(Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::waitKeyEx();
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_waitKeyEx_int(int delay, Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::waitKeyEx(delay);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_waitKey_int(int delay, Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::waitKey(delay);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+cv::QtFont* cv_QtFont_defaultNew_const() {
+		cv::QtFont* ret = new cv::QtFont();
+		return ret;
+}
+
+void* cv_QtFont_propNameFont_const(const cv::QtFont* instance) {
+		const char* ret = instance->nameFont;
+		return ocvrs_create_string(ret);
+}
+
+void cv_QtFont_propColor_const(const cv::QtFont* instance, cv::Scalar* ocvrs_return) {
+		cv::Scalar ret = instance->color;
+		*ocvrs_return = ret;
+}
+
+void cv_QtFont_propColor_const_Scalar(cv::QtFont* instance, const cv::Scalar* val) {
+		instance->color = *val;
+}
+
+int cv_QtFont_propFont_face_const(const cv::QtFont* instance) {
+		int ret = instance->font_face;
+		return ret;
+}
+
+void cv_QtFont_propFont_face_const_int(cv::QtFont* instance, const int val) {
+		instance->font_face = val;
+}
+
+const int* cv_QtFont_propAscii_const(const cv::QtFont* instance) {
+		const int* ret = instance->ascii;
+		return ret;
+}
+
+const int* cv_QtFont_propGreek_const(const cv::QtFont* instance) {
+		const int* ret = instance->greek;
+		return ret;
+}
+
+const int* cv_QtFont_propCyrillic_const(const cv::QtFont* instance) {
+		const int* ret = instance->cyrillic;
+		return ret;
+}
+
+float cv_QtFont_propHscale_const(const cv::QtFont* instance) {
+		float ret = instance->hscale;
+		return ret;
+}
+
+void cv_QtFont_propHscale_const_float(cv::QtFont* instance, const float val) {
+		instance->hscale = val;
+}
+
+float cv_QtFont_propVscale_const(const cv::QtFont* instance) {
+		float ret = instance->vscale;
+		return ret;
+}
+
+void cv_QtFont_propVscale_const_float(cv::QtFont* instance, const float val) {
+		instance->vscale = val;
+}
+
+float cv_QtFont_propShear_const(const cv::QtFont* instance) {
+		float ret = instance->shear;
+		return ret;
+}
+
+void cv_QtFont_propShear_const_float(cv::QtFont* instance, const float val) {
+		instance->shear = val;
+}
+
+int cv_QtFont_propThickness_const(const cv::QtFont* instance) {
+		int ret = instance->thickness;
+		return ret;
+}
+
+void cv_QtFont_propThickness_const_int(cv::QtFont* instance, const int val) {
+		instance->thickness = val;
+}
+
+float cv_QtFont_propDx_const(const cv::QtFont* instance) {
+		float ret = instance->dx;
+		return ret;
+}
+
+void cv_QtFont_propDx_const_float(cv::QtFont* instance, const float val) {
+		instance->dx = val;
+}
+
+int cv_QtFont_propLine_type_const(const cv::QtFont* instance) {
+		int ret = instance->line_type;
+		return ret;
+}
+
+void cv_QtFont_propLine_type_const_int(cv::QtFont* instance, const int val) {
+		instance->line_type = val;
+}
+
+void cv_QtFont_delete(cv::QtFont* instance) {
+		delete instance;
+}
+
+}

target/debug/build/opencv-4e105b5546afc119/out/imgproc_types.hpp

@@ -0,0 +1,123 @@
+extern "C" {
+	const cv::CLAHE* cv_PtrLcv_CLAHEG_getInnerPtr_const(const cv::Ptr<cv::CLAHE>* instance) {
+			return instance->get();
+	}
+
+	cv::CLAHE* cv_PtrLcv_CLAHEG_getInnerPtrMut(cv::Ptr<cv::CLAHE>* instance) {
+			return instance->get();
+	}
+
+	cv::Ptr<cv::CLAHE>* cv_PtrLcv_CLAHEG_new_null_const() {
+			return new cv::Ptr<cv::CLAHE>();
+	}
+
+	void cv_PtrLcv_CLAHEG_delete(cv::Ptr<cv::CLAHE>* instance) {
+			delete instance;
+	}
+
+	cv::Ptr<cv::Algorithm>* cv_PtrLcv_CLAHEG_to_PtrOfAlgorithm(cv::Ptr<cv::CLAHE>* instance) {
+			return new cv::Ptr<cv::Algorithm>(instance->dynamicCast<cv::Algorithm>());
+	}
+
+}
+
+extern "C" {
+	const cv::GeneralizedHough* cv_PtrLcv_GeneralizedHoughG_getInnerPtr_const(const cv::Ptr<cv::GeneralizedHough>* instance) {
+			return instance->get();
+	}
+
+	cv::GeneralizedHough* cv_PtrLcv_GeneralizedHoughG_getInnerPtrMut(cv::Ptr<cv::GeneralizedHough>* instance) {
+			return instance->get();
+	}
+
+	cv::Ptr<cv::GeneralizedHough>* cv_PtrLcv_GeneralizedHoughG_new_null_const() {
+			return new cv::Ptr<cv::GeneralizedHough>();
+	}
+
+	void cv_PtrLcv_GeneralizedHoughG_delete(cv::Ptr<cv::GeneralizedHough>* instance) {
+			delete instance;
+	}
+
+	cv::Ptr<cv::Algorithm>* cv_PtrLcv_GeneralizedHoughG_to_PtrOfAlgorithm(cv::Ptr<cv::GeneralizedHough>* instance) {
+			return new cv::Ptr<cv::Algorithm>(instance->dynamicCast<cv::Algorithm>());
+	}
+
+}
+
+extern "C" {
+	const cv::GeneralizedHoughBallard* cv_PtrLcv_GeneralizedHoughBallardG_getInnerPtr_const(const cv::Ptr<cv::GeneralizedHoughBallard>* instance) {
+			return instance->get();
+	}
+
+	cv::GeneralizedHoughBallard* cv_PtrLcv_GeneralizedHoughBallardG_getInnerPtrMut(cv::Ptr<cv::GeneralizedHoughBallard>* instance) {
+			return instance->get();
+	}
+
+	cv::Ptr<cv::GeneralizedHoughBallard>* cv_PtrLcv_GeneralizedHoughBallardG_new_null_const() {
+			return new cv::Ptr<cv::GeneralizedHoughBallard>();
+	}
+
+	void cv_PtrLcv_GeneralizedHoughBallardG_delete(cv::Ptr<cv::GeneralizedHoughBallard>* instance) {
+			delete instance;
+	}
+
+	cv::Ptr<cv::Algorithm>* cv_PtrLcv_GeneralizedHoughBallardG_to_PtrOfAlgorithm(cv::Ptr<cv::GeneralizedHoughBallard>* instance) {
+			return new cv::Ptr<cv::Algorithm>(instance->dynamicCast<cv::Algorithm>());
+	}
+
+	cv::Ptr<cv::GeneralizedHough>* cv_PtrLcv_GeneralizedHoughBallardG_to_PtrOfGeneralizedHough(cv::Ptr<cv::GeneralizedHoughBallard>* instance) {
+			return new cv::Ptr<cv::GeneralizedHough>(instance->dynamicCast<cv::GeneralizedHough>());
+	}
+
+}
+
+extern "C" {
+	const cv::GeneralizedHoughGuil* cv_PtrLcv_GeneralizedHoughGuilG_getInnerPtr_const(const cv::Ptr<cv::GeneralizedHoughGuil>* instance) {
+			return instance->get();
+	}
+
+	cv::GeneralizedHoughGuil* cv_PtrLcv_GeneralizedHoughGuilG_getInnerPtrMut(cv::Ptr<cv::GeneralizedHoughGuil>* instance) {
+			return instance->get();
+	}
+
+	cv::Ptr<cv::GeneralizedHoughGuil>* cv_PtrLcv_GeneralizedHoughGuilG_new_null_const() {
+			return new cv::Ptr<cv::GeneralizedHoughGuil>();
+	}
+
+	void cv_PtrLcv_GeneralizedHoughGuilG_delete(cv::Ptr<cv::GeneralizedHoughGuil>* instance) {
+			delete instance;
+	}
+
+	cv::Ptr<cv::Algorithm>* cv_PtrLcv_GeneralizedHoughGuilG_to_PtrOfAlgorithm(cv::Ptr<cv::GeneralizedHoughGuil>* instance) {
+			return new cv::Ptr<cv::Algorithm>(instance->dynamicCast<cv::Algorithm>());
+	}
+
+	cv::Ptr<cv::GeneralizedHough>* cv_PtrLcv_GeneralizedHoughGuilG_to_PtrOfGeneralizedHough(cv::Ptr<cv::GeneralizedHoughGuil>* instance) {
+			return new cv::Ptr<cv::GeneralizedHough>(instance->dynamicCast<cv::GeneralizedHough>());
+	}
+
+}
+
+extern "C" {
+	const cv::LineSegmentDetector* cv_PtrLcv_LineSegmentDetectorG_getInnerPtr_const(const cv::Ptr<cv::LineSegmentDetector>* instance) {
+			return instance->get();
+	}
+
+	cv::LineSegmentDetector* cv_PtrLcv_LineSegmentDetectorG_getInnerPtrMut(cv::Ptr<cv::LineSegmentDetector>* instance) {
+			return instance->get();
+	}
+
+	cv::Ptr<cv::LineSegmentDetector>* cv_PtrLcv_LineSegmentDetectorG_new_null_const() {
+			return new cv::Ptr<cv::LineSegmentDetector>();
+	}
+
+	void cv_PtrLcv_LineSegmentDetectorG_delete(cv::Ptr<cv::LineSegmentDetector>* instance) {
+			delete instance;
+	}
+
+	cv::Ptr<cv::Algorithm>* cv_PtrLcv_LineSegmentDetectorG_to_PtrOfAlgorithm(cv::Ptr<cv::LineSegmentDetector>* instance) {
+			return new cv::Ptr<cv::Algorithm>(instance->dynamicCast<cv::Algorithm>());
+	}
+
+}
+

target/debug/build/opencv-4e105b5546afc119/out/opencv/hub.rs

@@ -0,0 +1,25 @@
+include!(concat!(env!("OUT_DIR"), "/opencv/core.rs"));
+include!(concat!(env!("OUT_DIR"), "/opencv/dnn.rs"));
+include!(concat!(env!("OUT_DIR"), "/opencv/highgui.rs"));
+include!(concat!(env!("OUT_DIR"), "/opencv/imgproc.rs"));
+include!(concat!(env!("OUT_DIR"), "/opencv/videoio.rs"));
+pub mod types {
+	include!(concat!(env!("OUT_DIR"), "/opencv/types.rs"));
+}
+#[doc(hidden)]
+pub mod sys {
+	include!(concat!(env!("OUT_DIR"), "/opencv/sys.rs"));
+}
+pub mod hub_prelude {
+	pub use super::core::prelude::*;
+	pub use super::dnn::prelude::*;
+	pub use super::highgui::prelude::*;
+	pub use super::imgproc::prelude::*;
+	pub use super::videoio::prelude::*;
+}
+
+mod ffi_exports {
+	use crate::mod_prelude_sys::*;
+	#[unsafe(no_mangle)] unsafe extern "C" fn ocvrs_create_string_0_98_1(s: *const c_char) -> *mut String { unsafe { crate::templ::ocvrs_create_string(s) } }
+	#[unsafe(no_mangle)] unsafe extern "C" fn ocvrs_create_byte_string_0_98_1(v: *const u8, len: size_t) -> *mut Vec<u8> { unsafe { crate::templ::ocvrs_create_byte_string(v, len) } }
+}

target/debug/build/opencv-4e105b5546afc119/out/videoio.cpp

@@ -0,0 +1,453 @@
+#include "videoio.hpp"
+#include "videoio_types.hpp"
+
+extern "C" {
+void cv_videoio_registry_getBackendName_VideoCaptureAPIs(cv::VideoCaptureAPIs api, Result<void*>* ocvrs_return) {
+	try {
+		cv::String ret = cv::videoio_registry::getBackendName(api);
+		Ok(ocvrs_create_string(ret.c_str()), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_videoio_registry_getBackends(Result<std::vector<cv::VideoCaptureAPIs>*>* ocvrs_return) {
+	try {
+		std::vector<cv::VideoCaptureAPIs> ret = cv::videoio_registry::getBackends();
+		Ok(new std::vector<cv::VideoCaptureAPIs>(ret), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_videoio_registry_getCameraBackendPluginVersion_VideoCaptureAPIs_intR_intR(cv::VideoCaptureAPIs api, int* version_ABI, int* version_API, Result<void*>* ocvrs_return) {
+	try {
+		std::string ret = cv::videoio_registry::getCameraBackendPluginVersion(api, *version_ABI, *version_API);
+		Ok(ocvrs_create_string(ret.c_str()), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_videoio_registry_getCameraBackends(Result<std::vector<cv::VideoCaptureAPIs>*>* ocvrs_return) {
+	try {
+		std::vector<cv::VideoCaptureAPIs> ret = cv::videoio_registry::getCameraBackends();
+		Ok(new std::vector<cv::VideoCaptureAPIs>(ret), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_videoio_registry_getStreamBackendPluginVersion_VideoCaptureAPIs_intR_intR(cv::VideoCaptureAPIs api, int* version_ABI, int* version_API, Result<void*>* ocvrs_return) {
+	try {
+		std::string ret = cv::videoio_registry::getStreamBackendPluginVersion(api, *version_ABI, *version_API);
+		Ok(ocvrs_create_string(ret.c_str()), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_videoio_registry_getStreamBackends(Result<std::vector<cv::VideoCaptureAPIs>*>* ocvrs_return) {
+	try {
+		std::vector<cv::VideoCaptureAPIs> ret = cv::videoio_registry::getStreamBackends();
+		Ok(new std::vector<cv::VideoCaptureAPIs>(ret), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_videoio_registry_getStreamBufferedBackendPluginVersion_VideoCaptureAPIs_intR_intR(cv::VideoCaptureAPIs api, int* version_ABI, int* version_API, Result<void*>* ocvrs_return) {
+	try {
+		std::string ret = cv::videoio_registry::getStreamBufferedBackendPluginVersion(api, *version_ABI, *version_API);
+		Ok(ocvrs_create_string(ret.c_str()), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_videoio_registry_getStreamBufferedBackends(Result<std::vector<cv::VideoCaptureAPIs>*>* ocvrs_return) {
+	try {
+		std::vector<cv::VideoCaptureAPIs> ret = cv::videoio_registry::getStreamBufferedBackends();
+		Ok(new std::vector<cv::VideoCaptureAPIs>(ret), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_videoio_registry_getWriterBackendPluginVersion_VideoCaptureAPIs_intR_intR(cv::VideoCaptureAPIs api, int* version_ABI, int* version_API, Result<void*>* ocvrs_return) {
+	try {
+		std::string ret = cv::videoio_registry::getWriterBackendPluginVersion(api, *version_ABI, *version_API);
+		Ok(ocvrs_create_string(ret.c_str()), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_videoio_registry_getWriterBackends(Result<std::vector<cv::VideoCaptureAPIs>*>* ocvrs_return) {
+	try {
+		std::vector<cv::VideoCaptureAPIs> ret = cv::videoio_registry::getWriterBackends();
+		Ok(new std::vector<cv::VideoCaptureAPIs>(ret), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_videoio_registry_hasBackend_VideoCaptureAPIs(cv::VideoCaptureAPIs api, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = cv::videoio_registry::hasBackend(api);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_videoio_registry_isBackendBuiltIn_VideoCaptureAPIs(cv::VideoCaptureAPIs api, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = cv::videoio_registry::isBackendBuiltIn(api);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_IStreamReader_read_charX_long_long(cv::IStreamReader* instance, void** buffer, long long size, Result<long long>* ocvrs_return) {
+	try {
+		std::unique_ptr<char[]> buffer_out = std::make_unique<char[]>(1024);
+		long long ret = instance->read(buffer_out.get(), size);
+		*buffer = ocvrs_create_string(buffer_out.get());
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_IStreamReader_seek_long_long_int(cv::IStreamReader* instance, long long offset, int origin, Result<long long>* ocvrs_return) {
+	try {
+		long long ret = instance->seek(offset, origin);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_IStreamReader_delete(cv::IStreamReader* instance) {
+		delete instance;
+}
+
+void cv_VideoCapture_VideoCapture(Result<cv::VideoCapture*>* ocvrs_return) {
+	try {
+		cv::VideoCapture* ret = new cv::VideoCapture();
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_VideoCapture_const_StringR_int(const char* filename, int apiPreference, Result<cv::VideoCapture*>* ocvrs_return) {
+	try {
+		cv::VideoCapture* ret = new cv::VideoCapture(std::string(filename), apiPreference);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_VideoCapture_const_StringR(const char* filename, Result<cv::VideoCapture*>* ocvrs_return) {
+	try {
+		cv::VideoCapture* ret = new cv::VideoCapture(std::string(filename));
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_VideoCapture_const_StringR_int_const_vectorLintGR(const char* filename, int apiPreference, const std::vector<int>* params, Result<cv::VideoCapture*>* ocvrs_return) {
+	try {
+		cv::VideoCapture* ret = new cv::VideoCapture(std::string(filename), apiPreference, *params);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_VideoCapture_int_int(int index, int apiPreference, Result<cv::VideoCapture*>* ocvrs_return) {
+	try {
+		cv::VideoCapture* ret = new cv::VideoCapture(index, apiPreference);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_VideoCapture_int(int index, Result<cv::VideoCapture*>* ocvrs_return) {
+	try {
+		cv::VideoCapture* ret = new cv::VideoCapture(index);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_VideoCapture_int_int_const_vectorLintGR(int index, int apiPreference, const std::vector<int>* params, Result<cv::VideoCapture*>* ocvrs_return) {
+	try {
+		cv::VideoCapture* ret = new cv::VideoCapture(index, apiPreference, *params);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_VideoCapture_const_PtrLIStreamReaderGR_int_const_vectorLintGR(const cv::Ptr<cv::IStreamReader>* source, int apiPreference, const std::vector<int>* params, Result<cv::VideoCapture*>* ocvrs_return) {
+	try {
+		cv::VideoCapture* ret = new cv::VideoCapture(*source, apiPreference, *params);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_open_const_StringR_int(cv::VideoCapture* instance, const char* filename, int apiPreference, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(std::string(filename), apiPreference);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_open_const_StringR(cv::VideoCapture* instance, const char* filename, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(std::string(filename));
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_open_const_StringR_int_const_vectorLintGR(cv::VideoCapture* instance, const char* filename, int apiPreference, const std::vector<int>* params, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(std::string(filename), apiPreference, *params);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_open_int_int(cv::VideoCapture* instance, int index, int apiPreference, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(index, apiPreference);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_open_int(cv::VideoCapture* instance, int index, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(index);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_open_int_int_const_vectorLintGR(cv::VideoCapture* instance, int index, int apiPreference, const std::vector<int>* params, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(index, apiPreference, *params);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_open_const_PtrLIStreamReaderGR_int_const_vectorLintGR(cv::VideoCapture* instance, const cv::Ptr<cv::IStreamReader>* source, int apiPreference, const std::vector<int>* params, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(*source, apiPreference, *params);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_isOpened_const(const cv::VideoCapture* instance, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->isOpened();
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_release(cv::VideoCapture* instance, ResultVoid* ocvrs_return) {
+	try {
+		instance->release();
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_grab(cv::VideoCapture* instance, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->grab();
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_retrieve_const__OutputArrayR_int(cv::VideoCapture* instance, const cv::_OutputArray* image, int flag, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->retrieve(*image, flag);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_retrieve_const__OutputArrayR(cv::VideoCapture* instance, const cv::_OutputArray* image, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->retrieve(*image);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_read_const__OutputArrayR(cv::VideoCapture* instance, const cv::_OutputArray* image, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->read(*image);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_set_int_double(cv::VideoCapture* instance, int propId, double value, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->set(propId, value);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_get_const_int(const cv::VideoCapture* instance, int propId, Result<double>* ocvrs_return) {
+	try {
+		double ret = instance->get(propId);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_getBackendName_const(const cv::VideoCapture* instance, Result<void*>* ocvrs_return) {
+	try {
+		cv::String ret = instance->getBackendName();
+		Ok(ocvrs_create_string(ret.c_str()), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_setExceptionMode_bool(cv::VideoCapture* instance, bool enable, ResultVoid* ocvrs_return) {
+	try {
+		instance->setExceptionMode(enable);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_getExceptionMode_const(const cv::VideoCapture* instance, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->getExceptionMode();
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_waitAny_const_vectorLVideoCaptureGR_vectorLintGR_int64_t(const std::vector<cv::VideoCapture>* streams, std::vector<int>* readyIndex, int64_t timeoutNs, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = cv::VideoCapture::waitAny(*streams, *readyIndex, timeoutNs);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_waitAny_const_vectorLVideoCaptureGR_vectorLintGR(const std::vector<cv::VideoCapture>* streams, std::vector<int>* readyIndex, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = cv::VideoCapture::waitAny(*streams, *readyIndex);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoCapture_delete(cv::VideoCapture* instance) {
+		delete instance;
+}
+
+void cv_VideoWriter_VideoWriter(Result<cv::VideoWriter*>* ocvrs_return) {
+	try {
+		cv::VideoWriter* ret = new cv::VideoWriter();
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_VideoWriter_const_StringR_int_double_Size_bool(const char* filename, int fourcc, double fps, cv::Size* frameSize, bool isColor, Result<cv::VideoWriter*>* ocvrs_return) {
+	try {
+		cv::VideoWriter* ret = new cv::VideoWriter(std::string(filename), fourcc, fps, *frameSize, isColor);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_VideoWriter_const_StringR_int_double_Size(const char* filename, int fourcc, double fps, cv::Size* frameSize, Result<cv::VideoWriter*>* ocvrs_return) {
+	try {
+		cv::VideoWriter* ret = new cv::VideoWriter(std::string(filename), fourcc, fps, *frameSize);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_VideoWriter_const_StringR_int_int_double_Size_bool(const char* filename, int apiPreference, int fourcc, double fps, cv::Size* frameSize, bool isColor, Result<cv::VideoWriter*>* ocvrs_return) {
+	try {
+		cv::VideoWriter* ret = new cv::VideoWriter(std::string(filename), apiPreference, fourcc, fps, *frameSize, isColor);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_VideoWriter_const_StringR_int_int_double_Size(const char* filename, int apiPreference, int fourcc, double fps, cv::Size* frameSize, Result<cv::VideoWriter*>* ocvrs_return) {
+	try {
+		cv::VideoWriter* ret = new cv::VideoWriter(std::string(filename), apiPreference, fourcc, fps, *frameSize);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_VideoWriter_const_StringR_int_double_const_SizeR_const_vectorLintGR(const char* filename, int fourcc, double fps, const cv::Size* frameSize, const std::vector<int>* params, Result<cv::VideoWriter*>* ocvrs_return) {
+	try {
+		cv::VideoWriter* ret = new cv::VideoWriter(std::string(filename), fourcc, fps, *frameSize, *params);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_VideoWriter_const_StringR_int_int_double_const_SizeR_const_vectorLintGR(const char* filename, int apiPreference, int fourcc, double fps, const cv::Size* frameSize, const std::vector<int>* params, Result<cv::VideoWriter*>* ocvrs_return) {
+	try {
+		cv::VideoWriter* ret = new cv::VideoWriter(std::string(filename), apiPreference, fourcc, fps, *frameSize, *params);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_open_const_StringR_int_double_Size_bool(cv::VideoWriter* instance, const char* filename, int fourcc, double fps, cv::Size* frameSize, bool isColor, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(std::string(filename), fourcc, fps, *frameSize, isColor);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_open_const_StringR_int_double_Size(cv::VideoWriter* instance, const char* filename, int fourcc, double fps, cv::Size* frameSize, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(std::string(filename), fourcc, fps, *frameSize);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_open_const_StringR_int_int_double_Size_bool(cv::VideoWriter* instance, const char* filename, int apiPreference, int fourcc, double fps, cv::Size* frameSize, bool isColor, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(std::string(filename), apiPreference, fourcc, fps, *frameSize, isColor);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_open_const_StringR_int_int_double_Size(cv::VideoWriter* instance, const char* filename, int apiPreference, int fourcc, double fps, cv::Size* frameSize, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(std::string(filename), apiPreference, fourcc, fps, *frameSize);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_open_const_StringR_int_double_const_SizeR_const_vectorLintGR(cv::VideoWriter* instance, const char* filename, int fourcc, double fps, const cv::Size* frameSize, const std::vector<int>* params, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(std::string(filename), fourcc, fps, *frameSize, *params);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_open_const_StringR_int_int_double_const_SizeR_const_vectorLintGR(cv::VideoWriter* instance, const char* filename, int apiPreference, int fourcc, double fps, const cv::Size* frameSize, const std::vector<int>* params, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->open(std::string(filename), apiPreference, fourcc, fps, *frameSize, *params);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_isOpened_const(const cv::VideoWriter* instance, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->isOpened();
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_release(cv::VideoWriter* instance, ResultVoid* ocvrs_return) {
+	try {
+		instance->release();
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_write_const__InputArrayR(cv::VideoWriter* instance, const cv::_InputArray* image, ResultVoid* ocvrs_return) {
+	try {
+		instance->write(*image);
+		Ok(ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_set_int_double(cv::VideoWriter* instance, int propId, double value, Result<bool>* ocvrs_return) {
+	try {
+		bool ret = instance->set(propId, value);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_get_const_int(const cv::VideoWriter* instance, int propId, Result<double>* ocvrs_return) {
+	try {
+		double ret = instance->get(propId);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_fourcc_char_char_char_char(char c1, char c2, char c3, char c4, Result<int>* ocvrs_return) {
+	try {
+		int ret = cv::VideoWriter::fourcc(c1, c2, c3, c4);
+		Ok(ret, ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_getBackendName_const(const cv::VideoWriter* instance, Result<void*>* ocvrs_return) {
+	try {
+		cv::String ret = instance->getBackendName();
+		Ok(ocvrs_create_string(ret.c_str()), ocvrs_return);
+	} OCVRS_CATCH(ocvrs_return);
+}
+
+void cv_VideoWriter_delete(cv::VideoWriter* instance) {
+		delete instance;
+}
+
+}

target/debug/build/opencv-4e105b5546afc119/out/videoio_types.hpp

@@ -0,0 +1,103 @@
+extern "C" {
+	const cv::IStreamReader* cv_PtrLcv_IStreamReaderG_getInnerPtr_const(const cv::Ptr<cv::IStreamReader>* instance) {
+			return instance->get();
+	}
+
+	cv::IStreamReader* cv_PtrLcv_IStreamReaderG_getInnerPtrMut(cv::Ptr<cv::IStreamReader>* instance) {
+			return instance->get();
+	}
+
+	cv::Ptr<cv::IStreamReader>* cv_PtrLcv_IStreamReaderG_new_null_const() {
+			return new cv::Ptr<cv::IStreamReader>();
+	}
+
+	void cv_PtrLcv_IStreamReaderG_delete(cv::Ptr<cv::IStreamReader>* instance) {
+			delete instance;
+	}
+
+}
+
+extern "C" {
+	std::vector<cv::VideoCaptureAPIs>* std_vectorLcv_VideoCaptureAPIsG_new_const() {
+			std::vector<cv::VideoCaptureAPIs>* ret = new std::vector<cv::VideoCaptureAPIs>();
+			return ret;
+	}
+
+	void std_vectorLcv_VideoCaptureAPIsG_delete(std::vector<cv::VideoCaptureAPIs>* instance) {
+			delete instance;
+	}
+
+	size_t std_vectorLcv_VideoCaptureAPIsG_len_const(const std::vector<cv::VideoCaptureAPIs>* instance) {
+			size_t ret = instance->size();
+			return ret;
+	}
+
+	bool std_vectorLcv_VideoCaptureAPIsG_isEmpty_const(const std::vector<cv::VideoCaptureAPIs>* instance) {
+			bool ret = instance->empty();
+			return ret;
+	}
+
+	size_t std_vectorLcv_VideoCaptureAPIsG_capacity_const(const std::vector<cv::VideoCaptureAPIs>* instance) {
+			size_t ret = instance->capacity();
+			return ret;
+	}
+
+	void std_vectorLcv_VideoCaptureAPIsG_shrinkToFit(std::vector<cv::VideoCaptureAPIs>* instance) {
+			instance->shrink_to_fit();
+	}
+
+	void std_vectorLcv_VideoCaptureAPIsG_reserve_size_t(std::vector<cv::VideoCaptureAPIs>* instance, size_t additional) {
+			instance->reserve(instance->size() + additional);
+	}
+
+	void std_vectorLcv_VideoCaptureAPIsG_remove_size_t(std::vector<cv::VideoCaptureAPIs>* instance, size_t index) {
+			instance->erase(instance->begin() + index);
+	}
+
+	void std_vectorLcv_VideoCaptureAPIsG_swap_size_t_size_t(std::vector<cv::VideoCaptureAPIs>* instance, size_t index1, size_t index2) {
+			std::swap((*instance)[index1], (*instance)[index2]);
+	}
+
+	void std_vectorLcv_VideoCaptureAPIsG_clear(std::vector<cv::VideoCaptureAPIs>* instance) {
+			instance->clear();
+	}
+
+	void std_vectorLcv_VideoCaptureAPIsG_push_const_VideoCaptureAPIs(std::vector<cv::VideoCaptureAPIs>* instance, const cv::VideoCaptureAPIs val) {
+			instance->push_back(val);
+	}
+
+	void std_vectorLcv_VideoCaptureAPIsG_insert_size_t_const_VideoCaptureAPIs(std::vector<cv::VideoCaptureAPIs>* instance, size_t index, const cv::VideoCaptureAPIs val) {
+			instance->insert(instance->begin() + index, val);
+	}
+
+	void std_vectorLcv_VideoCaptureAPIsG_get_const_size_t(const std::vector<cv::VideoCaptureAPIs>* instance, size_t index, cv::VideoCaptureAPIs* ocvrs_return) {
+			cv::VideoCaptureAPIs ret = (*instance)[index];
+			*ocvrs_return = ret;
+	}
+
+	void std_vectorLcv_VideoCaptureAPIsG_set_size_t_const_VideoCaptureAPIs(std::vector<cv::VideoCaptureAPIs>* instance, size_t index, const cv::VideoCaptureAPIs val) {
+			(*instance)[index] = val;
+	}
+
+	std::vector<cv::VideoCaptureAPIs>* std_vectorLcv_VideoCaptureAPIsG_clone_const(const std::vector<cv::VideoCaptureAPIs>* instance) {
+			std::vector<cv::VideoCaptureAPIs> ret = std::vector<cv::VideoCaptureAPIs>(*instance);
+			return new std::vector<cv::VideoCaptureAPIs>(ret);
+	}
+
+	const cv::VideoCaptureAPIs* std_vectorLcv_VideoCaptureAPIsG_data_const(const std::vector<cv::VideoCaptureAPIs>* instance) {
+			const cv::VideoCaptureAPIs* ret = instance->data();
+			return ret;
+	}
+
+	cv::VideoCaptureAPIs* std_vectorLcv_VideoCaptureAPIsG_dataMut(std::vector<cv::VideoCaptureAPIs>* instance) {
+			cv::VideoCaptureAPIs* ret = instance->data();
+			return ret;
+	}
+
+	std::vector<cv::VideoCaptureAPIs>* cv_fromSlice_const_const_VideoCaptureAPIsX_size_t(const cv::VideoCaptureAPIs* data, size_t len) {
+			return new std::vector<cv::VideoCaptureAPIs>(data, data + len);
+	}
+
+}
+
+

target/debug/build/opencv-4e105b5546afc119/output

@@ -0,0 +1,499 @@
+cargo::rustc-check-cfg=cfg(ocvrs_opencv_branch_34)
+cargo::rustc-check-cfg=cfg(ocvrs_opencv_branch_4)
+cargo::rustc-check-cfg=cfg(ocvrs_opencv_branch_5)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_3d)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_alphamat)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_aruco)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_aruco_detector)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_barcode)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_bgsegm)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_bioinspired)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_calib)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_calib3d)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_ccalib)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_core)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_cudaarithm)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_cudabgsegm)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_cudacodec)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_cudafeatures2d)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_cudafilters)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_cudaimgproc)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_cudalegacy)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_cudaobjdetect)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_cudaoptflow)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_cudastereo)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_cudawarping)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_cvv)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_dnn)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_dnn_superres)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_dpm)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_face)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_features)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_features2d)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_flann)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_freetype)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_fuzzy)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_gapi)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_hdf)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_hfs)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_highgui)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_img_hash)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_imgcodecs)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_imgproc)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_intensity_transform)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_line_descriptor)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_mcc)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_ml)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_objdetect)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_optflow)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_ovis)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_phase_unwrapping)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_photo)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_plot)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_quality)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_rapid)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_rgbd)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_saliency)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_sfm)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_shape)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_signal)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_stereo)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_stitching)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_structured_light)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_superres)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_surface_matching)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_text)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_tracking)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_video)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_videoio)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_videostab)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_viz)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_wechat_qrcode)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_xfeatures2d)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_ximgproc)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_xobjdetect)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_xphoto)
+cargo::rustc-check-cfg=cfg(ocvrs_has_module_xstereo)
+cargo::rustc-check-cfg=cfg(ocvrs_has_inherent_feature_opencl)
+cargo::rustc-check-cfg=cfg(ocvrs_has_inherent_feature_cuda)
+cargo::rustc-check-cfg=cfg(ocvrs_has_inherent_feature_hfloat)
+cargo::rustc-check-cfg=cfg(ocvrs_has_inherent_feature_algorithm_hint)
+cargo:rerun-if-env-changed=OPENCV4_NO_PKG_CONFIG
+cargo:rerun-if-env-changed=PKG_CONFIG_aarch64-apple-darwin
+cargo:rerun-if-env-changed=PKG_CONFIG_aarch64_apple_darwin
+cargo:rerun-if-env-changed=HOST_PKG_CONFIG
+cargo:rerun-if-env-changed=PKG_CONFIG
+cargo:rerun-if-env-changed=OPENCV4_STATIC
+cargo:rerun-if-env-changed=OPENCV4_DYNAMIC
+cargo:rerun-if-env-changed=PKG_CONFIG_ALL_STATIC
+cargo:rerun-if-env-changed=PKG_CONFIG_ALL_DYNAMIC
+cargo:rerun-if-env-changed=PKG_CONFIG_PATH_aarch64-apple-darwin
+cargo:rerun-if-env-changed=PKG_CONFIG_PATH_aarch64_apple_darwin
+cargo:rerun-if-env-changed=HOST_PKG_CONFIG_PATH
+cargo:rerun-if-env-changed=PKG_CONFIG_PATH
+cargo:rerun-if-env-changed=PKG_CONFIG_LIBDIR_aarch64-apple-darwin
+cargo:rerun-if-env-changed=PKG_CONFIG_LIBDIR_aarch64_apple_darwin
+cargo:rerun-if-env-changed=HOST_PKG_CONFIG_LIBDIR
+cargo:rerun-if-env-changed=PKG_CONFIG_LIBDIR
+cargo:rerun-if-env-changed=PKG_CONFIG_SYSROOT_DIR_aarch64-apple-darwin
+cargo:rerun-if-env-changed=PKG_CONFIG_SYSROOT_DIR_aarch64_apple_darwin
+cargo:rerun-if-env-changed=HOST_PKG_CONFIG_SYSROOT_DIR
+cargo:rerun-if-env-changed=PKG_CONFIG_SYSROOT_DIR
+cargo:rerun-if-env-changed=OPENCV4_STATIC
+cargo:rerun-if-env-changed=OPENCV4_DYNAMIC
+cargo:rerun-if-env-changed=PKG_CONFIG_ALL_STATIC
+cargo:rerun-if-env-changed=PKG_CONFIG_ALL_DYNAMIC
+cargo:rerun-if-env-changed=PKG_CONFIG_aarch64-apple-darwin
+cargo:rerun-if-env-changed=PKG_CONFIG_aarch64_apple_darwin
+cargo:rerun-if-env-changed=HOST_PKG_CONFIG
+cargo:rerun-if-env-changed=PKG_CONFIG
+cargo:rerun-if-env-changed=OPENCV4_STATIC
+cargo:rerun-if-env-changed=OPENCV4_DYNAMIC
+cargo:rerun-if-env-changed=PKG_CONFIG_ALL_STATIC
+cargo:rerun-if-env-changed=PKG_CONFIG_ALL_DYNAMIC
+cargo:rerun-if-env-changed=PKG_CONFIG_PATH_aarch64-apple-darwin
+cargo:rerun-if-env-changed=PKG_CONFIG_PATH_aarch64_apple_darwin
+cargo:rerun-if-env-changed=HOST_PKG_CONFIG_PATH
+cargo:rerun-if-env-changed=PKG_CONFIG_PATH
+cargo:rerun-if-env-changed=PKG_CONFIG_LIBDIR_aarch64-apple-darwin
+cargo:rerun-if-env-changed=PKG_CONFIG_LIBDIR_aarch64_apple_darwin
+cargo:rerun-if-env-changed=HOST_PKG_CONFIG_LIBDIR
+cargo:rerun-if-env-changed=PKG_CONFIG_LIBDIR
+cargo:rerun-if-env-changed=PKG_CONFIG_SYSROOT_DIR_aarch64-apple-darwin
+cargo:rerun-if-env-changed=PKG_CONFIG_SYSROOT_DIR_aarch64_apple_darwin
+cargo:rerun-if-env-changed=HOST_PKG_CONFIG_SYSROOT_DIR
+cargo:rerun-if-env-changed=PKG_CONFIG_SYSROOT_DIR
+cargo::rustc-cfg=ocvrs_opencv_branch_4
+cargo::rustc-cfg=ocvrs_has_inherent_feature_opencl
+cargo::rustc-cfg=ocvrs_has_inherent_feature_hfloat
+cargo::rustc-cfg=ocvrs_has_inherent_feature_algorithm_hint
+cargo::rustc-cfg=ocvrs_has_module_core
+cargo::rustc-cfg=ocvrs_has_module_dnn
+cargo::rustc-cfg=ocvrs_has_module_highgui
+cargo::rustc-cfg=ocvrs_has_module_imgproc
+cargo::rustc-cfg=ocvrs_has_module_videoio
+cargo::rerun-if-env-changed=OPENCV_PACKAGE_NAME
+cargo::rerun-if-env-changed=OPENCV_PKGCONFIG_NAME
+cargo::rerun-if-env-changed=OPENCV_CMAKE_NAME
+cargo::rerun-if-env-changed=OPENCV_CMAKE_BIN
+cargo::rerun-if-env-changed=OPENCV_VCPKG_NAME
+cargo::rerun-if-env-changed=OPENCV_LINK_LIBS
+cargo::rerun-if-env-changed=OPENCV_LINK_PATHS
+cargo::rerun-if-env-changed=OPENCV_INCLUDE_PATHS
+cargo::rerun-if-env-changed=OPENCV_DISABLE_PROBES
+cargo::rerun-if-env-changed=OPENCV_MSVC_CRT
+cargo::rerun-if-env-changed=OPENCV_CMAKE_TOOLCHAIN_FILE
+cargo::rerun-if-env-changed=OPENCV_CMAKE_ARGS
+cargo::rerun-if-env-changed=CMAKE_PREFIX_PATH
+cargo::rerun-if-env-changed=OpenCV_DIR
+cargo::rerun-if-env-changed=PKG_CONFIG_PATH
+cargo::rerun-if-env-changed=VCPKG_ROOT
+cargo::rerun-if-env-changed=VCPKGRS_DYNAMIC
+cargo::rerun-if-env-changed=VCPKGRS_TRIPLET
+cargo::rerun-if-env-changed=OCVRS_DOCS_GENERATE_DIR
+cargo::rerun-if-env-changed=DOCS_RS
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/bioinspired.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/gapi.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/tracking.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/face.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/sfm.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/hdf.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/xfeatures2d.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/photo.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/alphamat.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/ccalib.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/dnn.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/videoio.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/stitching.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/manual-core.cpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/core.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/ocvrs_common.hpp
+cargo::rerun-if-changed=/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp/aruco.hpp
+cargo::rerun-if-changed=Cargo.toml
+OPT_LEVEL = Some(0)
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+TARGET = Some(aarch64-apple-darwin)
+CARGO_ENCODED_RUSTFLAGS = Some()
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXX_aarch64-apple-darwin
+CXX_aarch64-apple-darwin = None
+cargo:rerun-if-env-changed=CXX_aarch64_apple_darwin
+CXX_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=HOST_CXX
+HOST_CXX = None
+cargo:rerun-if-env-changed=CXX
+CXX = None
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+RUSTC_WRAPPER = None
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+DEBUG = Some(true)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+OUT_DIR = Some(/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out)
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+TARGET = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET
+MACOSX_DEPLOYMENT_TARGET = None
+HOST = Some(aarch64-apple-darwin)
+cargo:rerun-if-env-changed=CXXFLAGS
+CXXFLAGS = None
+cargo:rerun-if-env-changed=HOST_CXXFLAGS
+HOST_CXXFLAGS = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64_apple_darwin
+CXXFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=CXXFLAGS_aarch64-apple-darwin
+CXXFLAGS_aarch64-apple-darwin = None
+exit status: 0
+exit status: 0
+exit status: 0
+exit status: 0
+exit status: 0
+exit status: 0
+cargo:rerun-if-env-changed=AR_aarch64-apple-darwin
+AR_aarch64-apple-darwin = None
+cargo:rerun-if-env-changed=AR_aarch64_apple_darwin
+AR_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=HOST_AR
+HOST_AR = None
+cargo:rerun-if-env-changed=AR
+AR = None
+cargo:rerun-if-env-changed=ARFLAGS
+ARFLAGS = None
+cargo:rerun-if-env-changed=HOST_ARFLAGS
+HOST_ARFLAGS = None
+cargo:rerun-if-env-changed=ARFLAGS_aarch64_apple_darwin
+ARFLAGS_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=ARFLAGS_aarch64-apple-darwin
+ARFLAGS_aarch64-apple-darwin = None
+cargo:rustc-link-lib=static=ocvrs
+cargo:rustc-link-search=native=/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out
+cargo:rerun-if-env-changed=CXXSTDLIB_aarch64-apple-darwin
+CXXSTDLIB_aarch64-apple-darwin = None
+cargo:rerun-if-env-changed=CXXSTDLIB_aarch64_apple_darwin
+CXXSTDLIB_aarch64_apple_darwin = None
+cargo:rerun-if-env-changed=HOST_CXXSTDLIB
+HOST_CXXSTDLIB = None
+cargo:rerun-if-env-changed=CXXSTDLIB
+CXXSTDLIB = None
+cargo:rustc-link-lib=c++
+cargo::rustc-link-search=/opt/homebrew/opt/opencv/lib
+cargo::rustc-link-search=framework=/opt/homebrew/opt/opencv/lib
+cargo::rustc-link-lib=opencv_gapi
+cargo::rustc-link-lib=opencv_stitching
+cargo::rustc-link-lib=opencv_alphamat
+cargo::rustc-link-lib=opencv_aruco
+cargo::rustc-link-lib=opencv_bgsegm
+cargo::rustc-link-lib=opencv_bioinspired
+cargo::rustc-link-lib=opencv_ccalib
+cargo::rustc-link-lib=opencv_dnn_objdetect
+cargo::rustc-link-lib=opencv_dnn_superres
+cargo::rustc-link-lib=opencv_dpm
+cargo::rustc-link-lib=opencv_face
+cargo::rustc-link-lib=opencv_freetype
+cargo::rustc-link-lib=opencv_fuzzy
+cargo::rustc-link-lib=opencv_hfs
+cargo::rustc-link-lib=opencv_img_hash
+cargo::rustc-link-lib=opencv_intensity_transform
+cargo::rustc-link-lib=opencv_line_descriptor
+cargo::rustc-link-lib=opencv_mcc
+cargo::rustc-link-lib=opencv_quality
+cargo::rustc-link-lib=opencv_rapid
+cargo::rustc-link-lib=opencv_reg
+cargo::rustc-link-lib=opencv_rgbd
+cargo::rustc-link-lib=opencv_saliency
+cargo::rustc-link-lib=opencv_sfm
+cargo::rustc-link-lib=opencv_signal
+cargo::rustc-link-lib=opencv_stereo
+cargo::rustc-link-lib=opencv_structured_light
+cargo::rustc-link-lib=opencv_phase_unwrapping
+cargo::rustc-link-lib=opencv_superres
+cargo::rustc-link-lib=opencv_optflow
+cargo::rustc-link-lib=opencv_surface_matching
+cargo::rustc-link-lib=opencv_tracking
+cargo::rustc-link-lib=opencv_highgui
+cargo::rustc-link-lib=opencv_datasets
+cargo::rustc-link-lib=opencv_text
+cargo::rustc-link-lib=opencv_plot
+cargo::rustc-link-lib=opencv_videostab
+cargo::rustc-link-lib=opencv_videoio
+cargo::rustc-link-lib=opencv_viz
+cargo::rustc-link-lib=opencv_wechat_qrcode
+cargo::rustc-link-lib=opencv_xfeatures2d
+cargo::rustc-link-lib=opencv_shape
+cargo::rustc-link-lib=opencv_ml
+cargo::rustc-link-lib=opencv_ximgproc
+cargo::rustc-link-lib=opencv_video
+cargo::rustc-link-lib=opencv_xobjdetect
+cargo::rustc-link-lib=opencv_objdetect
+cargo::rustc-link-lib=opencv_calib3d
+cargo::rustc-link-lib=opencv_imgcodecs
+cargo::rustc-link-lib=opencv_features2d
+cargo::rustc-link-lib=opencv_dnn
+cargo::rustc-link-lib=opencv_flann
+cargo::rustc-link-lib=opencv_xphoto
+cargo::rustc-link-lib=opencv_photo
+cargo::rustc-link-lib=opencv_imgproc
+cargo::rustc-link-lib=opencv_core

target/debug/build/opencv-4e105b5546afc119/root-output

@@ -0,0 +1 @@
+/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out

target/debug/build/opencv-4e105b5546afc119/stderr

@@ -0,0 +1,264 @@
+=== Crate version: 0.98.1
+=== Environment configuration:
+===   OPENCV_PACKAGE_NAME = None
+===   OPENCV_PKGCONFIG_NAME = None
+===   OPENCV_CMAKE_NAME = None
+===   OPENCV_CMAKE_BIN = None
+===   OPENCV_VCPKG_NAME = None
+===   OPENCV_LINK_LIBS = None
+===   OPENCV_LINK_PATHS = None
+===   OPENCV_INCLUDE_PATHS = None
+===   OPENCV_DISABLE_PROBES = None
+===   OPENCV_MSVC_CRT = None
+===   OPENCV_CMAKE_TOOLCHAIN_FILE = None
+===   OPENCV_CMAKE_ARGS = None
+===   CMAKE_PREFIX_PATH = None
+===   OpenCV_DIR = None
+===   PKG_CONFIG_PATH = None
+===   VCPKG_ROOT = None
+===   VCPKGRS_DYNAMIC = None
+===   VCPKGRS_TRIPLET = None
+===   OCVRS_DOCS_GENERATE_DIR = None
+===   DOCS_RS = None
+===   PATH = Some("/opt/homebrew/bin:/Users/accusys/.cargo/bin:/usr/bin:/bin:/usr/sbin:/sbin")
+=== Enabled features:
+===   DNN
+===   HIGHGUI
+===   IMGPROC
+===   VIDEOIO
+=== Detected probe priority boost based on environment vars: pkg_config: false, cmake: false, vcpkg: false
+=== Probing the OpenCV library in the following order: environment, pkg_config, cmake, vcpkg_cmake, vcpkg
+=== Can't probe using: environment, continuing with other methods because: Some environment variables are missing
+=== Probing OpenCV library using pkg_config
+=== Link search path: LinkSearch(Default, "/opt/homebrew/opt/opencv/lib")
+=== Link search path: LinkSearch(Framework, "/opt/homebrew/opt/opencv/lib")
+=== Linking to library: LinkLib(Default, "opencv_gapi")
+=== Linking to library: LinkLib(Default, "opencv_stitching")
+=== Linking to library: LinkLib(Default, "opencv_alphamat")
+=== Linking to library: LinkLib(Default, "opencv_aruco")
+=== Linking to library: LinkLib(Default, "opencv_bgsegm")
+=== Linking to library: LinkLib(Default, "opencv_bioinspired")
+=== Linking to library: LinkLib(Default, "opencv_ccalib")
+=== Linking to library: LinkLib(Default, "opencv_dnn_objdetect")
+=== Linking to library: LinkLib(Default, "opencv_dnn_superres")
+=== Linking to library: LinkLib(Default, "opencv_dpm")
+=== Linking to library: LinkLib(Default, "opencv_face")
+=== Linking to library: LinkLib(Default, "opencv_freetype")
+=== Linking to library: LinkLib(Default, "opencv_fuzzy")
+=== Linking to library: LinkLib(Default, "opencv_hfs")
+=== Linking to library: LinkLib(Default, "opencv_img_hash")
+=== Linking to library: LinkLib(Default, "opencv_intensity_transform")
+=== Linking to library: LinkLib(Default, "opencv_line_descriptor")
+=== Linking to library: LinkLib(Default, "opencv_mcc")
+=== Linking to library: LinkLib(Default, "opencv_quality")
+=== Linking to library: LinkLib(Default, "opencv_rapid")
+=== Linking to library: LinkLib(Default, "opencv_reg")
+=== Linking to library: LinkLib(Default, "opencv_rgbd")
+=== Linking to library: LinkLib(Default, "opencv_saliency")
+=== Linking to library: LinkLib(Default, "opencv_sfm")
+=== Linking to library: LinkLib(Default, "opencv_signal")
+=== Linking to library: LinkLib(Default, "opencv_stereo")
+=== Linking to library: LinkLib(Default, "opencv_structured_light")
+=== Linking to library: LinkLib(Default, "opencv_phase_unwrapping")
+=== Linking to library: LinkLib(Default, "opencv_superres")
+=== Linking to library: LinkLib(Default, "opencv_optflow")
+=== Linking to library: LinkLib(Default, "opencv_surface_matching")
+=== Linking to library: LinkLib(Default, "opencv_tracking")
+=== Linking to library: LinkLib(Default, "opencv_highgui")
+=== Linking to library: LinkLib(Default, "opencv_datasets")
+=== Linking to library: LinkLib(Default, "opencv_text")
+=== Linking to library: LinkLib(Default, "opencv_plot")
+=== Linking to library: LinkLib(Default, "opencv_videostab")
+=== Linking to library: LinkLib(Default, "opencv_videoio")
+=== Linking to library: LinkLib(Default, "opencv_viz")
+=== Linking to library: LinkLib(Default, "opencv_wechat_qrcode")
+=== Linking to library: LinkLib(Default, "opencv_xfeatures2d")
+=== Linking to library: LinkLib(Default, "opencv_shape")
+=== Linking to library: LinkLib(Default, "opencv_ml")
+=== Linking to library: LinkLib(Default, "opencv_ximgproc")
+=== Linking to library: LinkLib(Default, "opencv_video")
+=== Linking to library: LinkLib(Default, "opencv_xobjdetect")
+=== Linking to library: LinkLib(Default, "opencv_objdetect")
+=== Linking to library: LinkLib(Default, "opencv_calib3d")
+=== Linking to library: LinkLib(Default, "opencv_imgcodecs")
+=== Linking to library: LinkLib(Default, "opencv_features2d")
+=== Linking to library: LinkLib(Default, "opencv_dnn")
+=== Linking to library: LinkLib(Default, "opencv_flann")
+=== Linking to library: LinkLib(Default, "opencv_xphoto")
+=== Linking to library: LinkLib(Default, "opencv_photo")
+=== Linking to library: LinkLib(Default, "opencv_imgproc")
+=== Linking to library: LinkLib(Default, "opencv_core")
+=== Successfully probed using: pkg_config
+=== OpenCV library configuration: Library {
+    include_paths: [
+        "/opt/homebrew/opt/opencv/include/opencv4",
+    ],
+    version: Version {
+        major: 4,
+        minor: 13,
+        patch: 0,
+    },
+    inherent_features: [
+        "eigen",
+        "openjpeg",
+        "jpeg",
+        "opencl",
+        "opencl_static",
+        "openexr",
+        "png",
+        "pthread",
+        "pthreads_pf",
+        "tbb",
+        "tiff",
+        "lapack",
+    ],
+    cargo_metadata: [
+        "cargo::rustc-link-search=/opt/homebrew/opt/opencv/lib",
+        "cargo::rustc-link-search=framework=/opt/homebrew/opt/opencv/lib",
+        "cargo::rustc-link-lib=opencv_gapi",
+        "cargo::rustc-link-lib=opencv_stitching",
+        "cargo::rustc-link-lib=opencv_alphamat",
+        "cargo::rustc-link-lib=opencv_aruco",
+        "cargo::rustc-link-lib=opencv_bgsegm",
+        "cargo::rustc-link-lib=opencv_bioinspired",
+        "cargo::rustc-link-lib=opencv_ccalib",
+        "cargo::rustc-link-lib=opencv_dnn_objdetect",
+        "cargo::rustc-link-lib=opencv_dnn_superres",
+        "cargo::rustc-link-lib=opencv_dpm",
+        "cargo::rustc-link-lib=opencv_face",
+        "cargo::rustc-link-lib=opencv_freetype",
+        "cargo::rustc-link-lib=opencv_fuzzy",
+        "cargo::rustc-link-lib=opencv_hfs",
+        "cargo::rustc-link-lib=opencv_img_hash",
+        "cargo::rustc-link-lib=opencv_intensity_transform",
+        "cargo::rustc-link-lib=opencv_line_descriptor",
+        "cargo::rustc-link-lib=opencv_mcc",
+        "cargo::rustc-link-lib=opencv_quality",
+        "cargo::rustc-link-lib=opencv_rapid",
+        "cargo::rustc-link-lib=opencv_reg",
+        "cargo::rustc-link-lib=opencv_rgbd",
+        "cargo::rustc-link-lib=opencv_saliency",
+        "cargo::rustc-link-lib=opencv_sfm",
+        "cargo::rustc-link-lib=opencv_signal",
+        "cargo::rustc-link-lib=opencv_stereo",
+        "cargo::rustc-link-lib=opencv_structured_light",
+        "cargo::rustc-link-lib=opencv_phase_unwrapping",
+        "cargo::rustc-link-lib=opencv_superres",
+        "cargo::rustc-link-lib=opencv_optflow",
+        "cargo::rustc-link-lib=opencv_surface_matching",
+        "cargo::rustc-link-lib=opencv_tracking",
+        "cargo::rustc-link-lib=opencv_highgui",
+        "cargo::rustc-link-lib=opencv_datasets",
+        "cargo::rustc-link-lib=opencv_text",
+        "cargo::rustc-link-lib=opencv_plot",
+        "cargo::rustc-link-lib=opencv_videostab",
+        "cargo::rustc-link-lib=opencv_videoio",
+        "cargo::rustc-link-lib=opencv_viz",
+        "cargo::rustc-link-lib=opencv_wechat_qrcode",
+        "cargo::rustc-link-lib=opencv_xfeatures2d",
+        "cargo::rustc-link-lib=opencv_shape",
+        "cargo::rustc-link-lib=opencv_ml",
+        "cargo::rustc-link-lib=opencv_ximgproc",
+        "cargo::rustc-link-lib=opencv_video",
+        "cargo::rustc-link-lib=opencv_xobjdetect",
+        "cargo::rustc-link-lib=opencv_objdetect",
+        "cargo::rustc-link-lib=opencv_calib3d",
+        "cargo::rustc-link-lib=opencv_imgcodecs",
+        "cargo::rustc-link-lib=opencv_features2d",
+        "cargo::rustc-link-lib=opencv_dnn",
+        "cargo::rustc-link-lib=opencv_flann",
+        "cargo::rustc-link-lib=opencv_xphoto",
+        "cargo::rustc-link-lib=opencv_photo",
+        "cargo::rustc-link-lib=opencv_imgproc",
+        "cargo::rustc-link-lib=opencv_core",
+    ],
+}
+=== Found OpenCV version: 4.13.0 in headers located at: /opt/homebrew/opt/opencv/include/opencv4
+=== Detected OpenCV module header dir at: /opt/homebrew/opt/opencv/include/opencv4/opencv2
+=== Generating code in: /Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out
+=== Placing generated bindings into: /Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out/opencv
+=== Using OpenCV headers from: /opt/homebrew/opt/opencv/include/opencv4
+=== Clang: Homebrew clang version 22.1.0
+=== Clang command line args: [
+    "-isystem/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/c++/v1",
+    "-isystem/Library/Developer/CommandLineTools/usr/lib/clang/17/include",
+    "-isystem/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include",
+    "-isystem/Library/Developer/CommandLineTools/usr/include",
+    "-isystem/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/System/Library/Frameworks",
+    "-isystem/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/System/Library/SubFrameworks",
+    "-I/opt/homebrew/Cellar/opencv/4.13.0_5/include/opencv4",
+    "-F/opt/homebrew/Cellar/opencv/4.13.0_5/include/opencv4",
+    "-I/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp",
+    "-F/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp",
+    "-DOCVRS_PARSING_HEADERS",
+    "-includeocvrs_common.hpp",
+    "-std=c++17",
+]
+=== Using environment job server with the the amount of available jobs: 10
+=== Generating 5 modules
+=== Running: "/Users/accusys/video_yolo_player/target/debug/build/opencv-5ede7add649d8d6b/build-script-build" "/opt/homebrew/opt/opencv/include/opencv4" "/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp" "/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out" "core" ""
+=== Running: "/Users/accusys/video_yolo_player/target/debug/build/opencv-5ede7add649d8d6b/build-script-build" "/opt/homebrew/opt/opencv/include/opencv4" "/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp" "/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out" "imgproc" ""
+=== Running: "/Users/accusys/video_yolo_player/target/debug/build/opencv-5ede7add649d8d6b/build-script-build" "/opt/homebrew/opt/opencv/include/opencv4" "/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp" "/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out" "highgui" ""
+=== Running: "/Users/accusys/video_yolo_player/target/debug/build/opencv-5ede7add649d8d6b/build-script-build" "/opt/homebrew/opt/opencv/include/opencv4" "/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp" "/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out" "dnn" ""
+=== Running: "/Users/accusys/video_yolo_player/target/debug/build/opencv-5ede7add649d8d6b/build-script-build" "/opt/homebrew/opt/opencv/include/opencv4" "/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp" "/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out" "videoio" ""
+=== Generated module bindings: highgui in: 1.159883291s
+=== Generated module bindings: videoio in: 1.159964541s
+=== Generated module bindings: imgproc in: 1.682992208s
+=== Generated module bindings: core in: 2.165579s
+=== Generated module bindings: dnn in: 2.473092042s
+=== Total binding generation time: 2.473287583s
+=== Total binding collection time: 73.435958ms
+=== Compiler information: Tool {
+    path: "c++",
+    cc_wrapper_path: None,
+    cc_wrapper_args: [],
+    args: [
+        "-O0",
+        "-ffunction-sections",
+        "-fdata-sections",
+        "-fPIC",
+        "-g",
+        "-gdwarf-2",
+        "-fno-omit-frame-pointer",
+        "--target=arm64-apple-macosx",
+        "-mmacosx-version-min=26.2",
+        "-std=c++17",
+        "-I",
+        "/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/src_cpp",
+        "-I",
+        "/Users/accusys/video_yolo_player/target/debug/build/opencv-4e105b5546afc119/out",
+        "-I",
+        ".",
+        "-I",
+        "/opt/homebrew/opt/opencv/include/opencv4",
+        "-Wall",
+        "-Wextra",
+        "-Wno-deprecated-declarations",
+        "-Wno-deprecated-copy",
+        "-Wno-unused-parameter",
+        "-Wno-sign-compare",
+        "-Wno-comment",
+        "-Wno-uninitialized",
+        "-Wno-unused-variable",
+        "-Wno-ignored-qualifiers",
+        "-Wno-return-type-c-linkage",
+        "-Wno-overloaded-virtual",
+        "-Wno-delete-non-virtual-dtor",
+        "-F/opt/homebrew/opt/opencv/include/opencv4",
+        "-DOCVRS_FFI_EXPORT_SUFFIX=_0_98_1",
+        "-DOCVRS_TARGET_OS_WINDOWS=0",
+    ],
+    env: [
+        (
+            "LC_ALL",
+            "C",
+        ),
+    ],
+    family: Clang {
+        zig_cc: false,
+    },
+    cuda: false,
+    removed_args: [],
+    has_internal_target_arg: false,
+}
+=== Total cpp build time: 3.109806292s

target/debug/build/opencv-5ede7add649d8d6b/build_script_build-5ede7add649d8d6b.d

@@ -0,0 +1,17 @@
+/Users/accusys/video_yolo_player/target/debug/build/opencv-5ede7add649d8d6b/build_script_build-5ede7add649d8d6b.d: /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/binding-generator.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/cmake_probe.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/docs.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/enums.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/generator.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/generator/collector.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/header.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/library.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/path_ext.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/cond_macros/opencv_branch.tpl.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/cond_macros/opencv_module.tpl.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/cond_macros/opencv_inherent_feature.tpl.rs
+
+/Users/accusys/video_yolo_player/target/debug/build/opencv-5ede7add649d8d6b/build_script_build-5ede7add649d8d6b: /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/binding-generator.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/cmake_probe.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/docs.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/enums.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/generator.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/generator/collector.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/header.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/library.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/path_ext.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/cond_macros/opencv_branch.tpl.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/cond_macros/opencv_module.tpl.rs /Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/cond_macros/opencv_inherent_feature.tpl.rs
+
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/binding-generator.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/cmake_probe.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/docs.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/enums.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/generator.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/generator/collector.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/header.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/library.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/path_ext.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/cond_macros/opencv_branch.tpl.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/cond_macros/opencv_module.tpl.rs:
+/Users/accusys/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/opencv-0.98.1/build/cond_macros/opencv_inherent_feature.tpl.rs: