ruby-qt6-qtmultimedia 2.0.0

data/ext/qt6/qtmultimedia/qcamera-rb.cpp

@@ -0,0 +1,181 @@
+#include "qcamera-rb.hpp"
+#include <qcamera.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QMediaCaptureSession>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQCamera;
+
+void Init_qcamera(Module rb_mQt6QtMultimedia)
+{
+    rb_cQCamera =
+        // RubyQt6::QtMultimedia::QCamera
+        define_class_under<QCamera, QObject>(rb_mQt6QtMultimedia, "QCamera")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QCamera::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QCamera, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("camera_device", &QCamera::cameraDevice)
+            .define_method("camera_format", &QCamera::cameraFormat)
+            .define_method("capture_session", &QCamera::captureSession)
+            .define_method("color_temperature", &QCamera::colorTemperature)
+            .define_method("custom_focus_point", &QCamera::customFocusPoint)
+            .define_method("error", &QCamera::error)
+            .define_method("error_string", &QCamera::errorString)
+            .define_method("exposure_compensation", &QCamera::exposureCompensation)
+            .define_method("exposure_mode", &QCamera::exposureMode)
+            .define_method("exposure_time", &QCamera::exposureTime)
+            .define_method("flash_mode", &QCamera::flashMode)
+            .define_method("focus_distance", &QCamera::focusDistance)
+            .define_method("focus_mode", &QCamera::focusMode)
+            .define_method("focus_point", &QCamera::focusPoint)
+            .define_method("active?", &QCamera::isActive)
+            .define_method("available?", &QCamera::isAvailable)
+            .define_method("exposure_mode_supported?", &QCamera::isExposureModeSupported, Arg("mode"))
+            .define_method("flash_mode_supported?", &QCamera::isFlashModeSupported, Arg("mode"))
+            .define_method("flash_ready?", &QCamera::isFlashReady)
+            .define_method("focus_mode_supported?", &QCamera::isFocusModeSupported, Arg("mode"))
+            .define_method("torch_mode_supported?", &QCamera::isTorchModeSupported, Arg("mode"))
+            .define_method("white_balance_mode_supported?", &QCamera::isWhiteBalanceModeSupported, Arg("mode"))
+            .define_method("iso_sensitivity", &QCamera::isoSensitivity)
+            .define_method("manual_exposure_time", &QCamera::manualExposureTime)
+            .define_method("manual_iso_sensitivity", &QCamera::manualIsoSensitivity)
+            .define_method("maximum_exposure_time", &QCamera::maximumExposureTime)
+            .define_method("maximum_iso_sensitivity", &QCamera::maximumIsoSensitivity)
+            .define_method("maximum_zoom_factor", &QCamera::maximumZoomFactor)
+            .define_method("minimum_exposure_time", &QCamera::minimumExposureTime)
+            .define_method("minimum_iso_sensitivity", &QCamera::minimumIsoSensitivity)
+            .define_method("minimum_zoom_factor", &QCamera::minimumZoomFactor)
+            .define_method("set_camera_device", &QCamera::setCameraDevice, Arg("camera_device"))
+            .define_method("set_camera_format", &QCamera::setCameraFormat, Arg("format"))
+            .define_method("set_custom_focus_point", &QCamera::setCustomFocusPoint, Arg("point"))
+            .define_method("set_focus_distance", &QCamera::setFocusDistance, Arg("d"))
+            .define_method("set_focus_mode", &QCamera::setFocusMode, Arg("mode"))
+            .define_method("set_zoom_factor", &QCamera::setZoomFactor, Arg("factor"))
+            .define_method("supported_features", &QCamera::supportedFeatures)
+            .define_method("torch_mode", &QCamera::torchMode)
+            .define_method("white_balance_mode", &QCamera::whiteBalanceMode)
+            .define_method("zoom_factor", &QCamera::zoomFactor)
+            // Public Slots
+            .define_method("set_active", &QCamera::setActive, Arg("active"))
+            .define_method("set_auto_exposure_time", &QCamera::setAutoExposureTime)
+            .define_method("set_auto_iso_sensitivity", &QCamera::setAutoIsoSensitivity)
+            .define_method("set_color_temperature", &QCamera::setColorTemperature, Arg("color_temperature"))
+            .define_method("set_exposure_compensation", &QCamera::setExposureCompensation, Arg("ev"))
+            .define_method("set_exposure_mode", &QCamera::setExposureMode, Arg("mode"))
+            .define_method("set_flash_mode", &QCamera::setFlashMode, Arg("mode"))
+            .define_method("set_manual_exposure_time", &QCamera::setManualExposureTime, Arg("seconds"))
+            .define_method("set_manual_iso_sensitivity", &QCamera::setManualIsoSensitivity, Arg("iso"))
+            .define_method("set_torch_mode", &QCamera::setTorchMode, Arg("mode"))
+            .define_method("set_white_balance_mode", &QCamera::setWhiteBalanceMode, Arg("mode"))
+            .define_method("start", &QCamera::start)
+            .define_method("stop", &QCamera::stop)
+            .define_method("zoom_to", &QCamera::zoomTo, Arg("zoom"), Arg("rate"));
+            // Signals
+            // .define_method("active_changed", &QCamera::activeChanged, Arg("active"))
+            // .define_method("brightness_changed", &QCamera::brightnessChanged)
+            // .define_method("camera_device_changed", &QCamera::cameraDeviceChanged)
+            // .define_method("camera_format_changed", &QCamera::cameraFormatChanged)
+            // .define_method("color_temperature_changed", &QCamera::colorTemperatureChanged)
+            // .define_method("contrast_changed", &QCamera::contrastChanged)
+            // .define_method("custom_focus_point_changed", &QCamera::customFocusPointChanged)
+            // .define_method("error_changed", &QCamera::errorChanged)
+            // .define_method("error_occurred", &QCamera::errorOccurred, Arg("error"), Arg("error_string"))
+            // .define_method("exposure_compensation_changed", &QCamera::exposureCompensationChanged, Arg("c"))
+            // .define_method("exposure_mode_changed", &QCamera::exposureModeChanged)
+            // .define_method("exposure_time_changed", &QCamera::exposureTimeChanged, Arg("speed"))
+            // .define_method("flash_mode_changed", &QCamera::flashModeChanged)
+            // .define_method("flash_ready", &QCamera::flashReady, Arg("ready"))
+            // .define_method("focus_distance_changed", &QCamera::focusDistanceChanged, Arg("d"))
+            // .define_method("focus_mode_changed", &QCamera::focusModeChanged)
+            // .define_method("focus_point_changed", &QCamera::focusPointChanged)
+            // .define_method("hue_changed", &QCamera::hueChanged)
+            // .define_method("iso_sensitivity_changed", &QCamera::isoSensitivityChanged, Arg("iso"))
+            // .define_method("manual_exposure_time_changed", &QCamera::manualExposureTimeChanged, Arg("speed"))
+            // .define_method("manual_iso_sensitivity_changed", &QCamera::manualIsoSensitivityChanged, Arg("iso"))
+            // .define_method("maximum_zoom_factor_changed", &QCamera::maximumZoomFactorChanged, Arg("factor"))
+            // .define_method("minimum_zoom_factor_changed", &QCamera::minimumZoomFactorChanged, Arg("factor"))
+            // .define_method("saturation_changed", &QCamera::saturationChanged)
+            // .define_method("supported_features_changed", &QCamera::supportedFeaturesChanged)
+            // .define_method("torch_mode_changed", &QCamera::torchModeChanged)
+            // .define_method("white_balance_mode_changed", &QCamera::whiteBalanceModeChanged)
+            // .define_method("zoom_factor_changed", &QCamera::zoomFactorChanged, Arg("factor"));
+
+    Data_Type<QCamera::Error> rb_cQCameraError =
+        // RubyQt6::QtMultimedia::QCamera::Error
+        define_qenum_under<QCamera::Error>(rb_cQCamera, "Error");
+        define_qenum_value_under(rb_cQCameraError, "NoError", QCamera::Error::NoError);
+        define_qenum_value_under(rb_cQCameraError, "CameraError", QCamera::Error::CameraError);
+
+    Data_Type<QCamera::ExposureMode> rb_cQCameraExposureMode =
+        // RubyQt6::QtMultimedia::QCamera::ExposureMode
+        define_qenum_under<QCamera::ExposureMode>(rb_cQCamera, "ExposureMode");
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureAuto", QCamera::ExposureMode::ExposureAuto);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureManual", QCamera::ExposureMode::ExposureManual);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposurePortrait", QCamera::ExposureMode::ExposurePortrait);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureNight", QCamera::ExposureMode::ExposureNight);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureSports", QCamera::ExposureMode::ExposureSports);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureSnow", QCamera::ExposureMode::ExposureSnow);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureBeach", QCamera::ExposureMode::ExposureBeach);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureAction", QCamera::ExposureMode::ExposureAction);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureLandscape", QCamera::ExposureMode::ExposureLandscape);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureNightPortrait", QCamera::ExposureMode::ExposureNightPortrait);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureTheatre", QCamera::ExposureMode::ExposureTheatre);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureSunset", QCamera::ExposureMode::ExposureSunset);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureSteadyPhoto", QCamera::ExposureMode::ExposureSteadyPhoto);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureFireworks", QCamera::ExposureMode::ExposureFireworks);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureParty", QCamera::ExposureMode::ExposureParty);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureCandlelight", QCamera::ExposureMode::ExposureCandlelight);
+        define_qenum_value_under(rb_cQCameraExposureMode, "ExposureBarcode", QCamera::ExposureMode::ExposureBarcode);
+
+    Data_Type<QCamera::Feature> rb_cQCameraFeature =
+        // RubyQt6::QtMultimedia::QCamera::Feature
+        define_qenum_under<QCamera::Feature>(rb_cQCamera, "Feature");
+        define_qenum_value_under(rb_cQCameraFeature, "ColorTemperature", QCamera::Feature::ColorTemperature);
+        define_qenum_value_under(rb_cQCameraFeature, "ExposureCompensation", QCamera::Feature::ExposureCompensation);
+        define_qenum_value_under(rb_cQCameraFeature, "IsoSensitivity", QCamera::Feature::IsoSensitivity);
+        define_qenum_value_under(rb_cQCameraFeature, "ManualExposureTime", QCamera::Feature::ManualExposureTime);
+        define_qenum_value_under(rb_cQCameraFeature, "CustomFocusPoint", QCamera::Feature::CustomFocusPoint);
+        define_qenum_value_under(rb_cQCameraFeature, "FocusDistance", QCamera::Feature::FocusDistance);
+
+
+    Data_Type<QCamera::FlashMode> rb_cQCameraFlashMode =
+        // RubyQt6::QtMultimedia::QCamera::FlashMode
+        define_qenum_under<QCamera::FlashMode>(rb_cQCamera, "FlashMode");
+        define_qenum_value_under(rb_cQCameraFlashMode, "FlashOff", QCamera::FlashMode::FlashOff);
+        define_qenum_value_under(rb_cQCameraFlashMode, "FlashOn", QCamera::FlashMode::FlashOn);
+        define_qenum_value_under(rb_cQCameraFlashMode, "FlashAuto", QCamera::FlashMode::FlashAuto);
+
+    Data_Type<QCamera::FocusMode> rb_cQCameraFocusMode =
+        // RubyQt6::QtMultimedia::QCamera::FocusMode
+        define_qenum_under<QCamera::FocusMode>(rb_cQCamera, "FocusMode");
+        define_qenum_value_under(rb_cQCameraFocusMode, "FocusModeAuto", QCamera::FocusMode::FocusModeAuto);
+        define_qenum_value_under(rb_cQCameraFocusMode, "FocusModeAutoNear", QCamera::FocusMode::FocusModeAutoNear);
+        define_qenum_value_under(rb_cQCameraFocusMode, "FocusModeAutoFar", QCamera::FocusMode::FocusModeAutoFar);
+        define_qenum_value_under(rb_cQCameraFocusMode, "FocusModeHyperfocal", QCamera::FocusMode::FocusModeHyperfocal);
+        define_qenum_value_under(rb_cQCameraFocusMode, "FocusModeInfinity", QCamera::FocusMode::FocusModeInfinity);
+        define_qenum_value_under(rb_cQCameraFocusMode, "FocusModeManual", QCamera::FocusMode::FocusModeManual);
+
+    Data_Type<QCamera::TorchMode> rb_cQCameraTorchMode =
+        // RubyQt6::QtMultimedia::QCamera::TorchMode
+        define_qenum_under<QCamera::TorchMode>(rb_cQCamera, "TorchMode");
+        define_qenum_value_under(rb_cQCameraTorchMode, "TorchOff", QCamera::TorchMode::TorchOff);
+        define_qenum_value_under(rb_cQCameraTorchMode, "TorchOn", QCamera::TorchMode::TorchOn);
+        define_qenum_value_under(rb_cQCameraTorchMode, "TorchAuto", QCamera::TorchMode::TorchAuto);
+
+    Data_Type<QCamera::WhiteBalanceMode> rb_cQCameraWhiteBalanceMode =
+        // RubyQt6::QtMultimedia::QCamera::WhiteBalanceMode
+        define_qenum_under<QCamera::WhiteBalanceMode>(rb_cQCamera, "WhiteBalanceMode");
+        define_qenum_value_under(rb_cQCameraWhiteBalanceMode, "WhiteBalanceAuto", QCamera::WhiteBalanceMode::WhiteBalanceAuto);
+        define_qenum_value_under(rb_cQCameraWhiteBalanceMode, "WhiteBalanceManual", QCamera::WhiteBalanceMode::WhiteBalanceManual);
+        define_qenum_value_under(rb_cQCameraWhiteBalanceMode, "WhiteBalanceSunlight", QCamera::WhiteBalanceMode::WhiteBalanceSunlight);
+        define_qenum_value_under(rb_cQCameraWhiteBalanceMode, "WhiteBalanceCloudy", QCamera::WhiteBalanceMode::WhiteBalanceCloudy);
+        define_qenum_value_under(rb_cQCameraWhiteBalanceMode, "WhiteBalanceShade", QCamera::WhiteBalanceMode::WhiteBalanceShade);
+        define_qenum_value_under(rb_cQCameraWhiteBalanceMode, "WhiteBalanceTungsten", QCamera::WhiteBalanceMode::WhiteBalanceTungsten);
+        define_qenum_value_under(rb_cQCameraWhiteBalanceMode, "WhiteBalanceFluorescent", QCamera::WhiteBalanceMode::WhiteBalanceFluorescent);
+        define_qenum_value_under(rb_cQCameraWhiteBalanceMode, "WhiteBalanceFlash", QCamera::WhiteBalanceMode::WhiteBalanceFlash);
+        define_qenum_value_under(rb_cQCameraWhiteBalanceMode, "WhiteBalanceSunset", QCamera::WhiteBalanceMode::WhiteBalanceSunset);
+}

data/ext/qt6/qtmultimedia/qcamera-rb.hpp

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qcamera(Module rb_mQt6QtMultimedia);

data/ext/qt6/qtmultimedia/qcameradevice-rb.cpp

@@ -0,0 +1,37 @@
+#include "qcameradevice-rb.hpp"
+#include <qcameradevice.h>
+#include <rice/qt6/qenum.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQCameraDevice;
+
+void Init_qcameradevice(Module rb_mQt6QtMultimedia)
+{
+    rb_cQCameraDevice =
+        // RubyQt6::QtMultimedia::QCameraDevice
+        define_class_under<QCameraDevice>(rb_mQt6QtMultimedia, "QCameraDevice")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_operator_equal", [](QCameraDevice *lhs, QCameraDevice *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
+            .define_singleton_function("_qvariant_register_metatype", []() -> int { return qRegisterMetaType<QCameraDevice>(); })
+            .define_singleton_function("_qvariant_from_value", [](const QCameraDevice &value) -> QVariant { return QVariant::fromValue(value); })
+            .define_singleton_function("_qvariant_to_value", [](const QVariant &qvariant) -> QCameraDevice { return qvariant.value<QCameraDevice>(); })
+            // Constructor
+            .define_constructor(Constructor<QCameraDevice>())
+            // Public Functions
+            .define_method("correction_angle", &QCameraDevice::correctionAngle)
+            .define_method("description", &QCameraDevice::description)
+            .define_method("id", &QCameraDevice::id)
+            .define_method("default?", &QCameraDevice::isDefault)
+            .define_method("null?", &QCameraDevice::isNull)
+            .define_method("photo_resolutions", &QCameraDevice::photoResolutions)
+            .define_method("position", &QCameraDevice::position)
+            .define_method("video_formats", &QCameraDevice::videoFormats);
+
+    Data_Type<QCameraDevice::Position> rb_cQCameraDevicePosition =
+        // RubyQt6::QtMultimedia::QCameraDevice::Position
+        define_qenum_under<QCameraDevice::Position>(rb_cQCameraDevice, "Position");
+        define_qenum_value_under(rb_cQCameraDevicePosition, "UnspecifiedPosition", QCameraDevice::Position::UnspecifiedPosition);
+        define_qenum_value_under(rb_cQCameraDevicePosition, "BackFace", QCameraDevice::Position::BackFace);
+        define_qenum_value_under(rb_cQCameraDevicePosition, "FrontFace", QCameraDevice::Position::FrontFace);
+}

data/ext/qt6/qtmultimedia/qcameradevice-rb.hpp

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qcameradevice(Module rb_mQt6QtMultimedia);

data/ext/qt6/qtmultimedia/qcameraformat-rb.cpp

@@ -0,0 +1,21 @@
+#include "qcameraformat-rb.hpp"
+#include <qcameradevice.h>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQCameraFormat;
+
+void Init_qcameraformat(Module rb_mQt6QtMultimedia)
+{
+    rb_cQCameraFormat =
+        // RubyQt6::QtMultimedia::QCameraFormat
+        define_class_under<QCameraFormat>(rb_mQt6QtMultimedia, "QCameraFormat")
+            // Constructor
+            .define_constructor(Constructor<QCameraFormat>())
+            // Public Functions
+            .define_method("null?", &QCameraFormat::isNull)
+            .define_method("max_frame_rate", &QCameraFormat::maxFrameRate)
+            .define_method("min_frame_rate", &QCameraFormat::minFrameRate)
+            .define_method("pixel_format", &QCameraFormat::pixelFormat)
+            .define_method("resolution", &QCameraFormat::resolution);
+}

data/ext/qt6/qtmultimedia/qcameraformat-rb.hpp

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qcameraformat(Module rb_mQt6QtMultimedia);

data/ext/qt6/qtmultimedia/qcapturablewindow-rb.cpp

@@ -0,0 +1,18 @@
+#include "qcapturablewindow-rb.hpp"
+#include <qcapturablewindow.h>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQCapturableWindow;
+
+void Init_qcapturablewindow(Module rb_mQt6QtMultimedia)
+{
+    rb_cQCapturableWindow =
+        // RubyQt6::QtMultimedia::QCapturableWindow
+        define_class_under<QCapturableWindow>(rb_mQt6QtMultimedia, "QCapturableWindow")
+            // Constructor
+            .define_constructor(Constructor<QCapturableWindow>())
+            // Public Functions
+            .define_method("description", &QCapturableWindow::description)
+            .define_method("valid?", &QCapturableWindow::isValid);
+}

data/ext/qt6/qtmultimedia/qcapturablewindow-rb.hpp

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qcapturablewindow(Module rb_mQt6QtMultimedia);

data/ext/qt6/qtmultimedia/qimagecapture-rb.cpp

@@ -0,0 +1,86 @@
+#include "qimagecapture-rb.hpp"
+#include <qimagecapture.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QMediaCaptureSession>
+#include <QMediaMetaData>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQImageCapture;
+
+void Init_qimagecapture(Module rb_mQt6QtMultimedia)
+{
+    rb_cQImageCapture =
+        // RubyQt6::QtMultimedia::QImageCapture
+        define_class_under<QImageCapture, QObject>(rb_mQt6QtMultimedia, "QImageCapture")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QImageCapture::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QImageCapture, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("add_meta_data", &QImageCapture::addMetaData, Arg("meta_data"))
+            .define_method("capture_session", &QImageCapture::captureSession)
+            .define_method("error", &QImageCapture::error)
+            .define_method("error_string", &QImageCapture::errorString)
+            .define_method("file_format", &QImageCapture::fileFormat)
+            .define_method("available?", &QImageCapture::isAvailable)
+            .define_method("ready_for_capture?", &QImageCapture::isReadyForCapture)
+            .define_method("meta_data", &QImageCapture::metaData)
+            .define_method("quality", &QImageCapture::quality)
+            .define_method("resolution", &QImageCapture::resolution)
+            .define_method("set_file_format", &QImageCapture::setFileFormat, Arg("format"))
+            .define_method("set_meta_data", &QImageCapture::setMetaData, Arg("meta_data"))
+            .define_method("set_quality", &QImageCapture::setQuality, Arg("quality"))
+            .define_method<void (QImageCapture::*)(const QSize &)>("set_resolution", &QImageCapture::setResolution, Arg("size"))
+            .define_method<void (QImageCapture::*)(int, int)>("set_resolution", &QImageCapture::setResolution, Arg("width"), Arg("height"))
+            // Public Slots
+            .define_method("capture", &QImageCapture::capture)
+            .define_method("capture_to_file", &QImageCapture::captureToFile, Arg("location") = static_cast<const QString &>(QString()))
+            // Signals
+            // .define_method("error_changed", &QImageCapture::errorChanged)
+            // .define_method("error_occurred", &QImageCapture::errorOccurred, Arg("id"), Arg("error"), Arg("error_string"))
+            // .define_method("file_format_changed", &QImageCapture::fileFormatChanged)
+            // .define_method("image_available", &QImageCapture::imageAvailable, Arg("id"), Arg("frame"))
+            // .define_method("image_captured", &QImageCapture::imageCaptured, Arg("id"), Arg("preview"))
+            // .define_method("image_exposed", &QImageCapture::imageExposed, Arg("id"))
+            // .define_method("image_metadata_available", &QImageCapture::imageMetadataAvailable, Arg("id"), Arg("meta_data"))
+            // .define_method("image_saved", &QImageCapture::imageSaved, Arg("id"), Arg("file_name"))
+            // .define_method("meta_data_changed", &QImageCapture::metaDataChanged)
+            // .define_method("quality_changed", &QImageCapture::qualityChanged)
+            // .define_method("ready_for_capture_changed", &QImageCapture::readyForCaptureChanged, Arg("ready"))
+            // .define_method("resolution_changed", &QImageCapture::resolutionChanged)
+            // Static Public Members
+            .define_singleton_function("file_format_description", &QImageCapture::fileFormatDescription, Arg("c"))
+            .define_singleton_function("file_format_name", &QImageCapture::fileFormatName, Arg("c"))
+            .define_singleton_function("supported_formats", &QImageCapture::supportedFormats);
+
+    Data_Type<QImageCapture::Error> rb_cQImageCaptureError =
+        // RubyQt6::QtMultimedia::QImageCapture::Error
+        define_qenum_under<QImageCapture::Error>(rb_cQImageCapture, "Error");
+        define_qenum_value_under(rb_cQImageCaptureError, "NoError", QImageCapture::Error::NoError);
+        define_qenum_value_under(rb_cQImageCaptureError, "NotReadyError", QImageCapture::Error::NotReadyError);
+        define_qenum_value_under(rb_cQImageCaptureError, "ResourceError", QImageCapture::Error::ResourceError);
+        define_qenum_value_under(rb_cQImageCaptureError, "OutOfSpaceError", QImageCapture::Error::OutOfSpaceError);
+        define_qenum_value_under(rb_cQImageCaptureError, "NotSupportedFeatureError", QImageCapture::Error::NotSupportedFeatureError);
+        define_qenum_value_under(rb_cQImageCaptureError, "FormatError", QImageCapture::Error::FormatError);
+
+    Data_Type<QImageCapture::FileFormat> rb_cQImageCaptureFileFormat =
+        // RubyQt6::QtMultimedia::QImageCapture::FileFormat
+        define_qenum_under<QImageCapture::FileFormat>(rb_cQImageCapture, "FileFormat");
+        define_qenum_value_under(rb_cQImageCaptureFileFormat, "UnspecifiedFormat", QImageCapture::FileFormat::UnspecifiedFormat);
+        define_qenum_value_under(rb_cQImageCaptureFileFormat, "JPEG", QImageCapture::FileFormat::JPEG);
+        define_qenum_value_under(rb_cQImageCaptureFileFormat, "PNG", QImageCapture::FileFormat::PNG);
+        define_qenum_value_under(rb_cQImageCaptureFileFormat, "WebP", QImageCapture::FileFormat::WebP);
+        define_qenum_value_under(rb_cQImageCaptureFileFormat, "Tiff", QImageCapture::FileFormat::Tiff);
+        define_qenum_value_under(rb_cQImageCaptureFileFormat, "LastFileFormat", QImageCapture::FileFormat::LastFileFormat);
+
+    Data_Type<QImageCapture::Quality> rb_cQImageCaptureQuality =
+        // RubyQt6::QtMultimedia::QImageCapture::Quality
+        define_qenum_under<QImageCapture::Quality>(rb_cQImageCapture, "Quality");
+        define_qenum_value_under(rb_cQImageCaptureQuality, "VeryLowQuality", QImageCapture::Quality::VeryLowQuality);
+        define_qenum_value_under(rb_cQImageCaptureQuality, "LowQuality", QImageCapture::Quality::LowQuality);
+        define_qenum_value_under(rb_cQImageCaptureQuality, "NormalQuality", QImageCapture::Quality::NormalQuality);
+        define_qenum_value_under(rb_cQImageCaptureQuality, "HighQuality", QImageCapture::Quality::HighQuality);
+        define_qenum_value_under(rb_cQImageCaptureQuality, "VeryHighQuality", QImageCapture::Quality::VeryHighQuality);
+}

data/ext/qt6/qtmultimedia/qimagecapture-rb.hpp

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qimagecapture(Module rb_mQt6QtMultimedia);

data/ext/qt6/qtmultimedia/qmediacapturesession-rb.cpp

@@ -0,0 +1,62 @@
+#include "qmediacapturesession-rb.hpp"
+#include <qmediacapturesession.h>
+
+#include <QAudioBufferInput>
+#include <QAudioInput>
+#include <QAudioOutput>
+#include <QCamera>
+#include <QImageCapture>
+#include <QMediaRecorder>
+#include <QScreenCapture>
+#include <QVideoFrameInput>
+#include <QVideoSink>
+#include <QWindowCapture>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQMediaCaptureSession;
+
+void Init_qmediacapturesession(Module rb_mQt6QtMultimedia)
+{
+    rb_cQMediaCaptureSession =
+        // RubyQt6::QtMultimedia::QMediaCaptureSession
+        define_class_under<QMediaCaptureSession, QObject>(rb_mQt6QtMultimedia, "QMediaCaptureSession")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QMediaCaptureSession::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QMediaCaptureSession, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("audio_buffer_input", &QMediaCaptureSession::audioBufferInput)
+            .define_method("audio_input", &QMediaCaptureSession::audioInput)
+            .define_method("audio_output", &QMediaCaptureSession::audioOutput)
+            .define_method("camera", &QMediaCaptureSession::camera)
+            .define_method("image_capture", &QMediaCaptureSession::imageCapture)
+            .define_method("recorder", &QMediaCaptureSession::recorder)
+            .define_method("screen_capture", &QMediaCaptureSession::screenCapture)
+            .define_method("set_audio_buffer_input", &QMediaCaptureSession::setAudioBufferInput, Arg("input"))
+            .define_method("set_audio_input", &QMediaCaptureSession::setAudioInput, Arg("input"))
+            .define_method("set_audio_output", &QMediaCaptureSession::setAudioOutput, Arg("output"))
+            .define_method("set_camera", &QMediaCaptureSession::setCamera, Arg("camera"))
+            .define_method("set_image_capture", &QMediaCaptureSession::setImageCapture, Arg("image_capture"))
+            .define_method("set_recorder", &QMediaCaptureSession::setRecorder, Arg("recorder"))
+            .define_method("set_screen_capture", &QMediaCaptureSession::setScreenCapture, Arg("screen_capture"))
+            .define_method("set_video_frame_input", &QMediaCaptureSession::setVideoFrameInput, Arg("input"))
+            .define_method("set_video_output", &QMediaCaptureSession::setVideoOutput, Arg("output"))
+            .define_method("set_video_sink", &QMediaCaptureSession::setVideoSink, Arg("sink"))
+            .define_method("set_window_capture", &QMediaCaptureSession::setWindowCapture, Arg("window_capture"))
+            .define_method("video_frame_input", &QMediaCaptureSession::videoFrameInput)
+            .define_method("video_output", &QMediaCaptureSession::videoOutput)
+            .define_method("video_sink", &QMediaCaptureSession::videoSink)
+            .define_method("window_capture", &QMediaCaptureSession::windowCapture);
+            // Signals
+            // .define_method("audio_buffer_input_changed", &QMediaCaptureSession::audioBufferInputChanged)
+            // .define_method("audio_input_changed", &QMediaCaptureSession::audioInputChanged)
+            // .define_method("audio_output_changed", &QMediaCaptureSession::audioOutputChanged)
+            // .define_method("camera_changed", &QMediaCaptureSession::cameraChanged)
+            // .define_method("image_capture_changed", &QMediaCaptureSession::imageCaptureChanged)
+            // .define_method("recorder_changed", &QMediaCaptureSession::recorderChanged)
+            // .define_method("screen_capture_changed", &QMediaCaptureSession::screenCaptureChanged)
+            // .define_method("video_frame_input_changed", &QMediaCaptureSession::videoFrameInputChanged)
+            // .define_method("video_output_changed", &QMediaCaptureSession::videoOutputChanged)
+            // .define_method("window_capture_changed", &QMediaCaptureSession::windowCaptureChanged);
+}

data/ext/qt6/qtmultimedia/qmediacapturesession-rb.hpp

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qmediacapturesession(Module rb_mQt6QtMultimedia);

data/ext/qt6/qtmultimedia/qmediadevices-rb.cpp

@@ -0,0 +1,32 @@
+#include "qmediadevices-rb.hpp"
+#include <qmediadevices.h>
+
+#include <QList>
+#include <QAudioDevice>
+#include <QCameraDevice>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQMediaDevices;
+
+void Init_qmediadevices(Module rb_mQt6QtMultimedia)
+{
+    rb_cQMediaDevices =
+        // RubyQt6::QtMultimedia::QMediaDevices
+        define_class_under<QMediaDevices, QObject>(rb_mQt6QtMultimedia, "QMediaDevices")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QMediaDevices::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QMediaDevices, QObject *>(), Arg("parent"))
+            // Signals
+            // .define_method("audio_inputs_changed", &QMediaDevices::audioInputsChanged)
+            // .define_method("audio_outputs_changed", &QMediaDevices::audioOutputsChanged)
+            // .define_method("video_inputs_changed", &QMediaDevices::videoInputsChanged)
+            // Static Public Members
+            .define_singleton_function("audio_inputs", &QMediaDevices::audioInputs)
+            .define_singleton_function("audio_outputs", &QMediaDevices::audioOutputs)
+            .define_singleton_function("default_audio_input", &QMediaDevices::defaultAudioInput)
+            .define_singleton_function("default_audio_output", &QMediaDevices::defaultAudioOutput)
+            .define_singleton_function("default_video_input", &QMediaDevices::defaultVideoInput)
+            .define_singleton_function("video_inputs", &QMediaDevices::videoInputs);
+}

data/ext/qt6/qtmultimedia/qmediadevices-rb.hpp

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qmediadevices(Module rb_mQt6QtMultimedia);

data/ext/qt6/qtmultimedia/qmediaformat-rb.cpp

@@ -0,0 +1,103 @@
+#include "qmediaformat-rb.hpp"
+#include <qmediaformat.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QMimeType>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQMediaFormat;
+
+void Init_qmediaformat(Module rb_mQt6QtMultimedia)
+{
+    rb_cQMediaFormat =
+        // RubyQt6::QtMultimedia::QMediaFormat
+        define_class_under<QMediaFormat>(rb_mQt6QtMultimedia, "QMediaFormat")
+            // Constructor
+            .define_constructor(Constructor<QMediaFormat, QMediaFormat::FileFormat>(), Arg("format"))
+            // Public Functions
+            .define_method("audio_codec", &QMediaFormat::audioCodec)
+            .define_method("file_format", &QMediaFormat::fileFormat)
+            .define_method("supported?", &QMediaFormat::isSupported, Arg("mode"))
+            .define_method("mime_type", &QMediaFormat::mimeType)
+            .define_method("resolve_for_encoding", &QMediaFormat::resolveForEncoding, Arg("flags"))
+            .define_method("set_audio_codec", &QMediaFormat::setAudioCodec, Arg("codec"))
+            .define_method("set_file_format", &QMediaFormat::setFileFormat, Arg("f"))
+            .define_method("set_video_codec", &QMediaFormat::setVideoCodec, Arg("codec"))
+            .define_method("supported_audio_codecs", &QMediaFormat::supportedAudioCodecs, Arg("m"))
+            .define_method("supported_file_formats", &QMediaFormat::supportedFileFormats, Arg("m"))
+            .define_method("supported_video_codecs", &QMediaFormat::supportedVideoCodecs, Arg("m"))
+            .define_method("video_codec", &QMediaFormat::videoCodec)
+            // Static Public Members
+            .define_singleton_function("audio_codec_description", &QMediaFormat::audioCodecDescription, Arg("codec"))
+            .define_singleton_function("audio_codec_name", &QMediaFormat::audioCodecName, Arg("codec"))
+            .define_singleton_function("file_format_description", &QMediaFormat::fileFormatDescription, Arg("file_format"))
+            .define_singleton_function("file_format_name", &QMediaFormat::fileFormatName, Arg("file_format"))
+            .define_singleton_function("video_codec_description", &QMediaFormat::videoCodecDescription, Arg("codec"))
+            .define_singleton_function("video_codec_name", &QMediaFormat::videoCodecName, Arg("codec"));
+
+    Data_Type<QMediaFormat::ConversionMode> rb_cQMediaFormatConversionMode =
+        // RubyQt6::QtMultimedia::QMediaFormat::ConversionMode
+        define_qenum_under<QMediaFormat::ConversionMode>(rb_cQMediaFormat, "ConversionMode");
+        define_qenum_value_under(rb_cQMediaFormatConversionMode, "Encode", QMediaFormat::ConversionMode::Encode);
+        define_qenum_value_under(rb_cQMediaFormatConversionMode, "Decode", QMediaFormat::ConversionMode::Decode);
+
+    Data_Type<QMediaFormat::FileFormat> rb_cQMediaFormatFileFormat =
+        // RubyQt6::QtMultimedia::QMediaFormat::FileFormat
+        define_qenum_under<QMediaFormat::FileFormat>(rb_cQMediaFormat, "FileFormat");
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "UnspecifiedFormat", QMediaFormat::FileFormat::UnspecifiedFormat);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "WMV", QMediaFormat::FileFormat::WMV);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "AVI", QMediaFormat::FileFormat::AVI);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "Matroska", QMediaFormat::FileFormat::Matroska);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "MPEG4", QMediaFormat::FileFormat::MPEG4);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "Ogg", QMediaFormat::FileFormat::Ogg);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "QuickTime", QMediaFormat::FileFormat::QuickTime);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "WebM", QMediaFormat::FileFormat::WebM);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "Mpeg4Audio", QMediaFormat::FileFormat::Mpeg4Audio);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "AAC", QMediaFormat::FileFormat::AAC);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "WMA", QMediaFormat::FileFormat::WMA);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "MP3", QMediaFormat::FileFormat::MP3);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "FLAC", QMediaFormat::FileFormat::FLAC);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "Wave", QMediaFormat::FileFormat::Wave);
+        define_qenum_value_under(rb_cQMediaFormatFileFormat, "LastFileFormat", QMediaFormat::FileFormat::LastFileFormat);
+
+    Data_Type<QMediaFormat::ResolveFlags> rb_cQMediaFormatResolveFlags =
+        // RubyQt6::QtMultimedia::QMediaFormat::ResolveFlags
+        define_qenum_under<QMediaFormat::ResolveFlags>(rb_cQMediaFormat, "ResolveFlags");
+        define_qenum_value_under(rb_cQMediaFormatResolveFlags, "NoFlags", QMediaFormat::ResolveFlags::NoFlags);
+        define_qenum_value_under(rb_cQMediaFormatResolveFlags, "RequiresVideo", QMediaFormat::ResolveFlags::RequiresVideo);
+
+    Data_Type<QMediaFormat::AudioCodec> rb_cQMediaFormatAudioCodec =
+        // RubyQt6::QtMultimedia::QMediaFormat::AudioCodec
+        define_qenum_under<QMediaFormat::AudioCodec>(rb_cQMediaFormat, "AudioCodec");
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "Unspecified", QMediaFormat::AudioCodec::Unspecified);
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "MP3", QMediaFormat::AudioCodec::MP3);
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "AAC", QMediaFormat::AudioCodec::AAC);
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "AC3", QMediaFormat::AudioCodec::AC3);
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "EAC3", QMediaFormat::AudioCodec::EAC3);
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "FLAC", QMediaFormat::AudioCodec::FLAC);
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "DolbyTrueHD", QMediaFormat::AudioCodec::DolbyTrueHD);
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "Opus", QMediaFormat::AudioCodec::Opus);
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "Vorbis", QMediaFormat::AudioCodec::Vorbis);
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "Wave", QMediaFormat::AudioCodec::Wave);
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "WMA", QMediaFormat::AudioCodec::WMA);
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "ALAC", QMediaFormat::AudioCodec::ALAC);
+        define_qenum_value_under(rb_cQMediaFormatAudioCodec, "LastAudioCodec", QMediaFormat::AudioCodec::LastAudioCodec);
+
+    Data_Type<QMediaFormat::VideoCodec> rb_cQMediaFormatVideoCodec =
+        // RubyQt6::QtMultimedia::QMediaFormat::VideoCodec
+        define_qenum_under<QMediaFormat::VideoCodec>(rb_cQMediaFormat, "VideoCodec");
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "Unspecified", QMediaFormat::VideoCodec::Unspecified);
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "MPEG1", QMediaFormat::VideoCodec::MPEG1);
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "MPEG2", QMediaFormat::VideoCodec::MPEG2);
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "MPEG4", QMediaFormat::VideoCodec::MPEG4);
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "H264", QMediaFormat::VideoCodec::H264);
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "H265", QMediaFormat::VideoCodec::H265);
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "VP8", QMediaFormat::VideoCodec::VP8);
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "VP9", QMediaFormat::VideoCodec::VP9);
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "AV1", QMediaFormat::VideoCodec::AV1);
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "Theora", QMediaFormat::VideoCodec::Theora);
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "WMV", QMediaFormat::VideoCodec::WMV);
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "MotionJPEG", QMediaFormat::VideoCodec::MotionJPEG);
+        define_qenum_value_under(rb_cQMediaFormatVideoCodec, "LastVideoCodec", QMediaFormat::VideoCodec::LastVideoCodec);
+}

data/ext/qt6/qtmultimedia/qmediaformat-rb.hpp

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qmediaformat(Module rb_mQt6QtMultimedia);