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/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);
+	}
+
+}
+
+