ruby-qt6-qtmultimedia 2.0.0

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

@@ -0,0 +1,66 @@
+#include "qvideoframe-rb.hpp"
+#include <qvideoframe.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QPainter>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQVideoFrame;
+
+void Init_qvideoframe(Module rb_mQt6QtMultimedia)
+{
+    rb_cQVideoFrame =
+        // RubyQt6::QtMultimedia::QVideoFrame
+        define_class_under<QVideoFrame>(rb_mQt6QtMultimedia, "QVideoFrame")
+            // Constructor
+            .define_constructor(Constructor<QVideoFrame>())
+            .define_constructor(Constructor<QVideoFrame, const QImage &>(), Arg("image"))
+            .define_constructor(Constructor<QVideoFrame, const QVideoFrameFormat &>(), Arg("format"))
+            // Public Functions
+            .define_method<uchar *(QVideoFrame::*)(int)>("bits", &QVideoFrame::bits, Arg("plane"))
+            .define_method("bytes_per_line", &QVideoFrame::bytesPerLine, Arg("plane"))
+            .define_method("end_time", &QVideoFrame::endTime)
+            .define_method("handle_type", &QVideoFrame::handleType)
+            .define_method("height", &QVideoFrame::height)
+            .define_method("mapped?", &QVideoFrame::isMapped)
+            .define_method("readable?", &QVideoFrame::isReadable)
+            .define_method("valid?", &QVideoFrame::isValid)
+            .define_method("writable?", &QVideoFrame::isWritable)
+            .define_method("map", &QVideoFrame::map, Arg("mode"))
+            .define_method("map_mode", &QVideoFrame::mapMode)
+            .define_method("mapped_bytes", &QVideoFrame::mappedBytes, Arg("plane"))
+            .define_method("mirrored", &QVideoFrame::mirrored)
+            .define_method("paint", &QVideoFrame::paint, Arg("painter"), Arg("rect"), Arg("options"))
+            .define_method("pixel_format", &QVideoFrame::pixelFormat)
+            .define_method("plane_count", &QVideoFrame::planeCount)
+            .define_method("rotation", &QVideoFrame::rotation)
+            .define_method("set_end_time", &QVideoFrame::setEndTime, Arg("time"))
+            .define_method("set_mirrored", &QVideoFrame::setMirrored, Arg("mirrored"))
+            .define_method("set_rotation", &QVideoFrame::setRotation, Arg("angle"))
+            .define_method("set_start_time", &QVideoFrame::setStartTime, Arg("time"))
+            .define_method("set_stream_frame_rate", &QVideoFrame::setStreamFrameRate, Arg("rate"))
+            .define_method("set_subtitle_text", &QVideoFrame::setSubtitleText, Arg("text"))
+            .define_method("size", &QVideoFrame::size)
+            .define_method("start_time", &QVideoFrame::startTime)
+            .define_method("stream_frame_rate", &QVideoFrame::streamFrameRate)
+            .define_method("subtitle_text", &QVideoFrame::subtitleText)
+            .define_method("surface_format", &QVideoFrame::surfaceFormat)
+            .define_method("to_image", &QVideoFrame::toImage)
+            .define_method("unmap", &QVideoFrame::unmap)
+            .define_method("width", &QVideoFrame::width);
+
+    Data_Type<QVideoFrame::HandleType> rb_cQVideoFrameHandleType =
+        // RubyQt6::QtMultimedia::QVideoFrame::HandleType
+        define_qenum_under<QVideoFrame::HandleType>(rb_cQVideoFrame, "HandleType");
+        define_qenum_value_under(rb_cQVideoFrameHandleType, "NoHandle", QVideoFrame::HandleType::NoHandle);
+        define_qenum_value_under(rb_cQVideoFrameHandleType, "RhiTextureHandle", QVideoFrame::HandleType::RhiTextureHandle);
+
+    Data_Type<QVideoFrame::MapMode> rb_cQVideoFrameMapMode =
+        // RubyQt6::QtMultimedia::QVideoFrame::MapMode
+        define_qenum_under<QVideoFrame::MapMode>(rb_cQVideoFrame, "MapMode");
+        define_qenum_value_under(rb_cQVideoFrameMapMode, "NotMapped", QVideoFrame::MapMode::NotMapped);
+        define_qenum_value_under(rb_cQVideoFrameMapMode, "ReadOnly", QVideoFrame::MapMode::ReadOnly);
+        define_qenum_value_under(rb_cQVideoFrameMapMode, "WriteOnly", QVideoFrame::MapMode::WriteOnly);
+        define_qenum_value_under(rb_cQVideoFrameMapMode, "ReadWrite", QVideoFrame::MapMode::ReadWrite);
+}

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

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

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

@@ -0,0 +1,122 @@
+#include "qvideoframeformat-rb.hpp"
+#include <qvideoframeformat.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QVideoFrame>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQVideoFrameFormat;
+
+void Init_qvideoframeformat(Module rb_mQt6QtMultimedia)
+{
+    rb_cQVideoFrameFormat =
+        // RubyQt6::QtMultimedia::QVideoFrameFormat
+        define_class_under<QVideoFrameFormat>(rb_mQt6QtMultimedia, "QVideoFrameFormat")
+            // Constructor
+            .define_constructor(Constructor<QVideoFrameFormat>())
+            .define_constructor(Constructor<QVideoFrameFormat, const QSize &, QVideoFrameFormat::PixelFormat>(), Arg("size"), Arg("pixel_format"))
+            // Public Functions
+            .define_method("color_range", &QVideoFrameFormat::colorRange)
+            .define_method("color_space", &QVideoFrameFormat::colorSpace)
+            .define_method("color_transfer", &QVideoFrameFormat::colorTransfer)
+            .define_method("detach", &QVideoFrameFormat::detach)
+            .define_method("fragment_shader_file_name", &QVideoFrameFormat::fragmentShaderFileName)
+            .define_method("frame_height", &QVideoFrameFormat::frameHeight)
+            .define_method("frame_size", &QVideoFrameFormat::frameSize)
+            .define_method("frame_width", &QVideoFrameFormat::frameWidth)
+            .define_method("mirrored?", &QVideoFrameFormat::isMirrored)
+            .define_method("valid?", &QVideoFrameFormat::isValid)
+            .define_method("max_luminance", &QVideoFrameFormat::maxLuminance)
+            .define_method("pixel_format", &QVideoFrameFormat::pixelFormat)
+            .define_method("plane_count", &QVideoFrameFormat::planeCount)
+            .define_method("rotation", &QVideoFrameFormat::rotation)
+            .define_method("scan_line_direction", &QVideoFrameFormat::scanLineDirection)
+            .define_method("set_color_range", &QVideoFrameFormat::setColorRange, Arg("range"))
+            .define_method("set_color_space", &QVideoFrameFormat::setColorSpace, Arg("color_space"))
+            .define_method("set_color_transfer", &QVideoFrameFormat::setColorTransfer, Arg("color_transfer"))
+            .define_method<void (QVideoFrameFormat::*)(const QSize &)>("set_frame_size", &QVideoFrameFormat::setFrameSize, Arg("size"))
+            .define_method<void (QVideoFrameFormat::*)(int, int)>("set_frame_size", &QVideoFrameFormat::setFrameSize, Arg("width"), Arg("height"))
+            .define_method("set_max_luminance", &QVideoFrameFormat::setMaxLuminance, Arg("lum"))
+            .define_method("set_mirrored", &QVideoFrameFormat::setMirrored, Arg("mirrored"))
+            .define_method("set_rotation", &QVideoFrameFormat::setRotation, Arg("rotation"))
+            .define_method("set_scan_line_direction", &QVideoFrameFormat::setScanLineDirection, Arg("direction"))
+            .define_method("set_stream_frame_rate", &QVideoFrameFormat::setStreamFrameRate, Arg("rate"))
+            .define_method("set_viewport", &QVideoFrameFormat::setViewport, Arg("viewport"))
+            .define_method("stream_frame_rate", &QVideoFrameFormat::streamFrameRate)
+            .define_method("viewport", &QVideoFrameFormat::viewport)
+            // Static Public Members
+            .define_singleton_function("image_format_from_pixel_format", &QVideoFrameFormat::imageFormatFromPixelFormat, Arg("format"))
+            .define_singleton_function("pixel_format_from_image_format", &QVideoFrameFormat::pixelFormatFromImageFormat, Arg("format"))
+            .define_singleton_function("pixel_format_to_string", &QVideoFrameFormat::pixelFormatToString, Arg("pixel_format"));
+
+    Data_Type<QVideoFrameFormat::ColorRange> rb_cQVideoFrameFormatColorRange =
+        // RubyQt6::QtMultimedia::QVideoFrameFormat::ColorRange
+        define_qenum_under<QVideoFrameFormat::ColorRange>(rb_cQVideoFrameFormat, "ColorRange");
+        define_qenum_value_under(rb_cQVideoFrameFormatColorRange, "ColorRange_Unknown", QVideoFrameFormat::ColorRange::ColorRange_Unknown);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorRange, "ColorRange_Video", QVideoFrameFormat::ColorRange::ColorRange_Video);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorRange, "ColorRange_Full", QVideoFrameFormat::ColorRange::ColorRange_Full);
+
+    Data_Type<QVideoFrameFormat::ColorSpace> rb_cQVideoFrameFormatColorSpace =
+        // RubyQt6::QtMultimedia::QVideoFrameFormat::ColorSpace
+        define_qenum_under<QVideoFrameFormat::ColorSpace>(rb_cQVideoFrameFormat, "ColorSpace");
+        define_qenum_value_under(rb_cQVideoFrameFormatColorSpace, "ColorSpace_Undefined", QVideoFrameFormat::ColorSpace::ColorSpace_Undefined);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorSpace, "ColorSpace_BT601", QVideoFrameFormat::ColorSpace::ColorSpace_BT601);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorSpace, "ColorSpace_BT709", QVideoFrameFormat::ColorSpace::ColorSpace_BT709);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorSpace, "ColorSpace_AdobeRgb", QVideoFrameFormat::ColorSpace::ColorSpace_AdobeRgb);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorSpace, "ColorSpace_BT2020", QVideoFrameFormat::ColorSpace::ColorSpace_BT2020);
+
+    Data_Type<QVideoFrameFormat::ColorTransfer> rb_cQVideoFrameFormatColorTransfer =
+        // RubyQt6::QtMultimedia::QVideoFrameFormat::ColorTransfer
+        define_qenum_under<QVideoFrameFormat::ColorTransfer>(rb_cQVideoFrameFormat, "ColorTransfer");
+        define_qenum_value_under(rb_cQVideoFrameFormatColorTransfer, "ColorTransfer_Unknown", QVideoFrameFormat::ColorTransfer::ColorTransfer_Unknown);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorTransfer, "ColorTransfer_BT709", QVideoFrameFormat::ColorTransfer::ColorTransfer_BT709);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorTransfer, "ColorTransfer_BT601", QVideoFrameFormat::ColorTransfer::ColorTransfer_BT601);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorTransfer, "ColorTransfer_Linear", QVideoFrameFormat::ColorTransfer::ColorTransfer_Linear);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorTransfer, "ColorTransfer_Gamma22", QVideoFrameFormat::ColorTransfer::ColorTransfer_Gamma22);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorTransfer, "ColorTransfer_Gamma28", QVideoFrameFormat::ColorTransfer::ColorTransfer_Gamma28);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorTransfer, "ColorTransfer_ST2084", QVideoFrameFormat::ColorTransfer::ColorTransfer_ST2084);
+        define_qenum_value_under(rb_cQVideoFrameFormatColorTransfer, "ColorTransfer_STD_B67", QVideoFrameFormat::ColorTransfer::ColorTransfer_STD_B67);
+
+    Data_Type<QVideoFrameFormat::Direction> rb_cQVideoFrameFormatDirection =
+        // RubyQt6::QtMultimedia::QVideoFrameFormat::Direction
+        define_qenum_under<QVideoFrameFormat::Direction>(rb_cQVideoFrameFormat, "Direction");
+        define_qenum_value_under(rb_cQVideoFrameFormatDirection, "TopToBottom", QVideoFrameFormat::Direction::TopToBottom);
+        define_qenum_value_under(rb_cQVideoFrameFormatDirection, "BottomToTop", QVideoFrameFormat::Direction::BottomToTop);
+
+    Data_Type<QVideoFrameFormat::PixelFormat> rb_cQVideoFrameFormatPixelFormat =
+        // RubyQt6::QtMultimedia::QVideoFrameFormat::PixelFormat
+        define_qenum_under<QVideoFrameFormat::PixelFormat>(rb_cQVideoFrameFormat, "PixelFormat");
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_Invalid", QVideoFrameFormat::PixelFormat::Format_Invalid);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_ARGB8888", QVideoFrameFormat::PixelFormat::Format_ARGB8888);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_ARGB8888_Premultiplied", QVideoFrameFormat::PixelFormat::Format_ARGB8888_Premultiplied);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_XRGB8888", QVideoFrameFormat::PixelFormat::Format_XRGB8888);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_BGRA8888", QVideoFrameFormat::PixelFormat::Format_BGRA8888);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_BGRA8888_Premultiplied", QVideoFrameFormat::PixelFormat::Format_BGRA8888_Premultiplied);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_BGRX8888", QVideoFrameFormat::PixelFormat::Format_BGRX8888);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_ABGR8888", QVideoFrameFormat::PixelFormat::Format_ABGR8888);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_XBGR8888", QVideoFrameFormat::PixelFormat::Format_XBGR8888);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_RGBA8888", QVideoFrameFormat::PixelFormat::Format_RGBA8888);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_RGBX8888", QVideoFrameFormat::PixelFormat::Format_RGBX8888);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_AYUV", QVideoFrameFormat::PixelFormat::Format_AYUV);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_AYUV_Premultiplied", QVideoFrameFormat::PixelFormat::Format_AYUV_Premultiplied);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_YUV420P", QVideoFrameFormat::PixelFormat::Format_YUV420P);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_YUV422P", QVideoFrameFormat::PixelFormat::Format_YUV422P);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_YV12", QVideoFrameFormat::PixelFormat::Format_YV12);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_UYVY", QVideoFrameFormat::PixelFormat::Format_UYVY);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_YUYV", QVideoFrameFormat::PixelFormat::Format_YUYV);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_NV12", QVideoFrameFormat::PixelFormat::Format_NV12);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_NV21", QVideoFrameFormat::PixelFormat::Format_NV21);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_IMC1", QVideoFrameFormat::PixelFormat::Format_IMC1);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_IMC2", QVideoFrameFormat::PixelFormat::Format_IMC2);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_IMC3", QVideoFrameFormat::PixelFormat::Format_IMC3);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_IMC4", QVideoFrameFormat::PixelFormat::Format_IMC4);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_Y8", QVideoFrameFormat::PixelFormat::Format_Y8);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_Y16", QVideoFrameFormat::PixelFormat::Format_Y16);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_P010", QVideoFrameFormat::PixelFormat::Format_P010);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_P016", QVideoFrameFormat::PixelFormat::Format_P016);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_SamplerExternalOES", QVideoFrameFormat::PixelFormat::Format_SamplerExternalOES);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_Jpeg", QVideoFrameFormat::PixelFormat::Format_Jpeg);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_SamplerRect", QVideoFrameFormat::PixelFormat::Format_SamplerRect);
+        define_qenum_value_under(rb_cQVideoFrameFormatPixelFormat, "Format_YUV420P10", QVideoFrameFormat::PixelFormat::Format_YUV420P10);
+}

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

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

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

@@ -0,0 +1,26 @@
+#include "qvideoframeinput-rb.hpp"
+#include <qvideoframeinput.h>
+
+#include <QMediaCaptureSession>
+#include <QVideoFrame>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQVideoFrameInput;
+
+void Init_qvideoframeinput(Module rb_mQt6QtMultimedia)
+{
+    rb_cQVideoFrameInput =
+        // RubyQt6::QtMultimedia::QVideoFrameInput
+        define_class_under<QVideoFrameInput, QObject>(rb_mQt6QtMultimedia, "QVideoFrameInput")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QVideoFrameInput::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QVideoFrameInput, const QVideoFrameFormat &, QObject *>(), Arg("format"), Arg("parent"))
+            // Public Functions
+            .define_method("capture_session", &QVideoFrameInput::captureSession)
+            .define_method("format", &QVideoFrameInput::format)
+            .define_method("send_video_frame", &QVideoFrameInput::sendVideoFrame, Arg("frame"));
+            // Signals
+            // .define_method("ready_to_send_video_frame", &QVideoFrameInput::readyToSendVideoFrame);
+}

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

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

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

@@ -0,0 +1,29 @@
+#include "qvideosink-rb.hpp"
+#include <qvideosink.h>
+
+#include <QVideoFrame>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQVideoSink;
+
+void Init_qvideosink(Module rb_mQt6QtMultimedia)
+{
+    rb_cQVideoSink =
+        // RubyQt6::QtMultimedia::QVideoSink
+        define_class_under<QVideoSink, QObject>(rb_mQt6QtMultimedia, "QVideoSink")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QVideoSink::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QVideoSink, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("set_subtitle_text", &QVideoSink::setSubtitleText, Arg("subtitle"))
+            .define_method("set_video_frame", &QVideoSink::setVideoFrame, Arg("frame"))
+            .define_method("subtitle_text", &QVideoSink::subtitleText)
+            .define_method("video_frame", &QVideoSink::videoFrame)
+            .define_method("video_size", &QVideoSink::videoSize);
+            // Signals
+            // .define_method("subtitle_text_changed", &QVideoSink::subtitleTextChanged, Arg("subtitle_text"))
+            // .define_method("video_frame_changed", &QVideoSink::videoFrameChanged, Arg("frame"))
+            // .define_method("video_size_changed", &QVideoSink::videoSizeChanged);
+}

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

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

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

@@ -0,0 +1,47 @@
+#include "qwindowcapture-rb.hpp"
+#include <qwindowcapture.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QMediaCaptureSession>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQWindowCapture;
+
+void Init_qwindowcapture(Module rb_mQt6QtMultimedia)
+{
+    rb_cQWindowCapture =
+        // RubyQt6::QtMultimedia::QWindowCapture
+        define_class_under<QWindowCapture, QObject>(rb_mQt6QtMultimedia, "QWindowCapture")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QWindowCapture::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QWindowCapture, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("capture_session", &QWindowCapture::captureSession)
+            .define_method("error", &QWindowCapture::error)
+            .define_method("error_string", &QWindowCapture::errorString)
+            .define_method("active?", &QWindowCapture::isActive)
+            .define_method("set_window", &QWindowCapture::setWindow, Arg("window"))
+            .define_method("window", &QWindowCapture::window)
+            // Public Slots
+            .define_method("set_active", &QWindowCapture::setActive, Arg("active"))
+            .define_method("start", &QWindowCapture::start)
+            .define_method("stop", &QWindowCapture::stop)
+            // Signals
+            // .define_method("active_changed", &QWindowCapture::activeChanged, Arg("active"))
+            // .define_method("error_changed", &QWindowCapture::errorChanged)
+            // .define_method("error_occurred", &QWindowCapture::errorOccurred, Arg("error"), Arg("error_string"))
+            // .define_method("window_changed", &QWindowCapture::windowChanged, Arg("window"))
+            // Static Public Members
+            .define_singleton_function("capturable_windows", &QWindowCapture::capturableWindows);
+
+    Data_Type<QWindowCapture::Error> rb_cQWindowCaptureError =
+        // RubyQt6::QtMultimedia::QWindowCapture::Error
+        define_qenum_under<QWindowCapture::Error>(rb_cQWindowCapture, "Error");
+        define_qenum_value_under(rb_cQWindowCaptureError, "NoError", QWindowCapture::Error::NoError);
+        define_qenum_value_under(rb_cQWindowCaptureError, "InternalError", QWindowCapture::Error::InternalError);
+        define_qenum_value_under(rb_cQWindowCaptureError, "CapturingNotSupported", QWindowCapture::Error::CapturingNotSupported);
+        define_qenum_value_under(rb_cQWindowCaptureError, "CaptureFailed", QWindowCapture::Error::CaptureFailed);
+        define_qenum_value_under(rb_cQWindowCaptureError, "NotFound", QWindowCapture::Error::NotFound);
+}

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

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

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

@@ -0,0 +1,20 @@
+#include "t-qtmultimedia-rb.hpp"
+#include <rice/qt6/qlist.hpp>
+
+#include <QAudioDevice>
+#include <QCameraDevice>
+#include <QMediaFormat>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_t_qtmultimedia(Module rb_mQt6T)
+{
+    // QList<QAudioDevice>
+    define_qlist_under<QAudioDevice>(rb_mQt6T);
+
+    // QList<QCameraDevice>
+    define_qlist_under<QCameraDevice>(rb_mQt6T);
+
+    // QList<QMediaFormat::FileFormat>
+    define_qlist_under<QMediaFormat::FileFormat>(rb_mQt6T);
+}

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

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

data/lib/qt6/qtmultimedia/qaudiodevice.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtMultimedia
+    # @see https://doc.qt.io/qt-6/qaudiodevice.html
+    class QAudioDevice
+      # @!parse class Mode; end
+      rubyqt6_declare_enum_under QAudioDevice, QAudioDevice::Mode
+
+      # @!parse
+      QtCore::QVariant.register(
+        _qvariant_register_metatype,
+        method(:_qvariant_from_value),
+        method(:_qvariant_to_value),
+        from: self
+      )
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QAudioDevice]
+      def initialize
+        _initialize
+      end
+
+      # @!visibility private
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        self.class._operator_equal(self, other)
+      end
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, id: id.to_s, description: description.to_s)
+      end
+    end
+  end
+end

data/lib/qt6/qtmultimedia/qaudioformat.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtMultimedia
+    # @see https://doc.qt.io/qt-6/qaudioformat.html
+    class QAudioFormat
+      # @!parse class AudioChannelPosition; end
+      # @!parse class ChannelConfig       ; end
+      # @!parse class SampleFormat        ; end
+      rubyqt6_declare_enum_under QAudioFormat, QAudioFormat::AudioChannelPosition
+      rubyqt6_declare_enum_under QAudioFormat, QAudioFormat::ChannelConfig
+      rubyqt6_declare_enum_under QAudioFormat, QAudioFormat::SampleFormat
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QAudioFormat]
+      def initialize
+        _initialize
+      end
+    end
+  end
+end

data/lib/qt6/qtmultimedia/qaudioinput.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtMultimedia
+    # @see https://doc.qt.io/qt-6/qaudioinput.html
+    class QAudioInput < RubyQt6::QtCore::QObject
+      # @!parse
+      q_object do
+        signal "deviceChanged()"
+        signal "mutedChanged(bool)"
+        signal "volumeChanged(float)"
+        slot "setDevice(QAudioDevice)"
+        slot "setMuted(bool)"
+        slot "setVolume(float)"
+      end
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param parent [QObject]
+      # @return [QAudioInput]
+      def initialize(parent = nil)
+        _initialize(parent)
+        _take_ownership_from_ruby(self)
+      end
+    end
+  end
+end

data/lib/qt6/qtmultimedia/qaudiooutput.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtMultimedia
+    # @see https://doc.qt.io/qt-6/qaudiooutput.html
+    class QAudioOutput < RubyQt6::QtCore::QObject
+      # @!parse
+      q_object do
+        signal "deviceChanged()"
+        signal "mutedChanged(bool)"
+        signal "volumeChanged(float)"
+        slot "setDevice(QAudioDevice)"
+        slot "setMuted(bool)"
+        slot "setVolume(float)"
+      end
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param parent [QObject]
+      # @return [QAudioOutput]
+      def initialize(parent = nil)
+        _initialize(parent)
+        _take_ownership_from_ruby(self)
+      end
+    end
+  end
+end

data/lib/qt6/qtmultimedia/qaudiosink.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtMultimedia
+    # @see https://doc.qt.io/qt-6/qaudiosink.html
+    class QAudioSink < RubyQt6::QtCore::QObject
+      # @!parse
+      q_object do
+        signal "stateChanged(QtAudio::State)"
+      end
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param device [QAudioDevice]
+      # @param format [QAudioFormat]
+      # @param parent [QObject]
+      # @return [QAudioSink]
+      def initialize(device, format, parent = nil)
+        _initialize(device, format, parent)
+        _take_ownership_from_ruby(self)
+      end
+    end
+  end
+end

data/lib/qt6/qtmultimedia/qaudiosource.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtMultimedia
+    # @see https://doc.qt.io/qt-6/qaudiosource.html
+    class QAudioSource < RubyQt6::QtCore::QObject
+      # @!parse
+      q_object do
+        signal "stateChanged(QtAudio::State)"
+      end
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param device [QAudioDevice]
+      # @param format [QAudioFormat]
+      # @param parent [QObject]
+      # @return [QAudioSource]
+      def initialize(device, format, parent = nil)
+        _initialize(device, format, parent)
+        _take_ownership_from_ruby(self)
+      end
+    end
+  end
+end

data/lib/qt6/qtmultimedia/qcamera.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtMultimedia
+    # @see https://doc.qt.io/qt-6/qcamera.html
+    class QCamera < RubyQt6::QtCore::QObject
+      # @!parse class Error           ; end
+      # @!parse class ExposureMode    ; end
+      # @!parse class Feature         ; end
+      # @!parse class FlashMode       ; end
+      # @!parse class FocusMode       ; end
+      # @!parse class TorchMode       ; end
+      # @!parse class WhiteBalanceMode; end
+      rubyqt6_declare_enum_under QCamera, QCamera::Error
+      rubyqt6_declare_enum_under QCamera, QCamera::ExposureMode
+      rubyqt6_declare_enum_under QCamera, QCamera::Feature, alias: false
+      rubyqt6_declare_enum_under QCamera, QCamera::FlashMode
+      rubyqt6_declare_enum_under QCamera, QCamera::FocusMode
+      rubyqt6_declare_enum_under QCamera, QCamera::TorchMode
+      rubyqt6_declare_enum_under QCamera, QCamera::WhiteBalanceMode
+
+      # @!parse
+      q_object do
+        signal "activeChanged(bool)"
+        signal "brightnessChanged()"
+        signal "cameraDeviceChanged()"
+        signal "cameraFormatChanged()"
+        signal "colorTemperatureChanged()"
+        signal "contrastChanged()"
+        signal "customFocusPointChanged()"
+        signal "errorChanged()"
+        signal "errorOccurred(QCamera::Error,QString)"
+        signal "exposureCompensationChanged(float)"
+        signal "exposureModeChanged()"
+        signal "exposureTimeChanged(float)"
+        signal "flashModeChanged()"
+        signal "flashReady(bool)"
+        signal "focusDistanceChanged(float)"
+        signal "focusModeChanged()"
+        signal "focusPointChanged()"
+        signal "hueChanged()"
+        signal "isoSensitivityChanged(int)"
+        signal "manualExposureTimeChanged(float)"
+        signal "manualIsoSensitivityChanged(int)"
+        signal "maximumZoomFactorChanged(float)"
+        signal "minimumZoomFactorChanged(float)"
+        signal "saturationChanged()"
+        signal "supportedFeaturesChanged()"
+        signal "torchModeChanged()"
+        signal "whiteBalanceModeChanged()"
+        signal "zoomFactorChanged(float)"
+        slot "setActive(bool)"
+        slot "setAutoExposureTime()"
+        slot "setAutoIsoSensitivity()"
+        slot "setColorTemperature(int)"
+        slot "setExposureCompensation(float)"
+        slot "setExposureMode(ExposureMode)"
+        slot "setFlashMode(FlashMode)"
+        slot "setManualExposureTime(float)"
+        slot "setManualIsoSensitivity(int)"
+        slot "setTorchMode(TorchMode)"
+        slot "setWhiteBalanceMode(WhiteBalanceMode)"
+        slot "start()"
+        slot "stop()"
+        slot "zoomTo(float,float)"
+      end
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param parent [QObject]
+      # @return [QCamera]
+      def initialize(parent = nil)
+        _initialize(parent)
+        _take_ownership_from_ruby(self)
+      end
+    end
+  end
+end

data/lib/qt6/qtmultimedia/qcameradevice.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtMultimedia
+    # @see https://doc.qt.io/qt-6/qcameradevice.html
+    class QCameraDevice
+      # @!parse class Position; end
+      rubyqt6_declare_enum_under QCameraDevice, QCameraDevice::Position
+
+      # @!parse
+      QtCore::QVariant.register(
+        _qvariant_register_metatype,
+        method(:_qvariant_from_value),
+        method(:_qvariant_to_value),
+        from: self
+      )
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QCameraDevice]
+      def initialize
+        _initialize
+      end
+
+      # @!visibility private
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        self.class._operator_equal(self, other)
+      end
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, id: id.to_s, description: description.to_s)
+      end
+    end
+  end
+end