ruby-qt6-qtmultimedia 2.0.0

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

@@ -0,0 +1,57 @@
+#include "qmediametadata-rb.hpp"
+#include <qmediametadata.h>
+#include <rice/qt6/qenum.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQMediaMetaData;
+
+void Init_qmediametadata(Module rb_mQt6QtMultimedia)
+{
+    rb_cQMediaMetaData =
+        // RubyQt6::QtMultimedia::QMediaMetaData
+        define_class_under<QMediaMetaData>(rb_mQt6QtMultimedia, "QMediaMetaData")
+            // Constructor
+            .define_constructor(Constructor<QMediaMetaData>())
+            // Public Functions
+            .define_method("clear", &QMediaMetaData::clear)
+            .define_method("insert", &QMediaMetaData::insert, Arg("k"), Arg("value"))
+            .define_method("empty?", &QMediaMetaData::isEmpty)
+            .define_method("keys", &QMediaMetaData::keys)
+            .define_method("remove", &QMediaMetaData::remove, Arg("k"))
+            .define_method("string_value", &QMediaMetaData::stringValue, Arg("k"))
+            .define_method("value", &QMediaMetaData::value, Arg("k"));
+
+    Data_Type<QMediaMetaData::Key> rb_cQMediaMetaDataKey =
+        // RubyQt6::QtMultimedia::QMediaMetaData::Key
+        define_qenum_under<QMediaMetaData::Key>(rb_cQMediaMetaData, "Key");
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Title", QMediaMetaData::Key::Title);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Author", QMediaMetaData::Key::Author);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Comment", QMediaMetaData::Key::Comment);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Description", QMediaMetaData::Key::Description);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Genre", QMediaMetaData::Key::Genre);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Date", QMediaMetaData::Key::Date);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Language", QMediaMetaData::Key::Language);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Publisher", QMediaMetaData::Key::Publisher);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Copyright", QMediaMetaData::Key::Copyright);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Url", QMediaMetaData::Key::Url);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Duration", QMediaMetaData::Key::Duration);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "MediaType", QMediaMetaData::Key::MediaType);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "FileFormat", QMediaMetaData::Key::FileFormat);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "AudioBitRate", QMediaMetaData::Key::AudioBitRate);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "AudioCodec", QMediaMetaData::Key::AudioCodec);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "VideoBitRate", QMediaMetaData::Key::VideoBitRate);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "VideoCodec", QMediaMetaData::Key::VideoCodec);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "VideoFrameRate", QMediaMetaData::Key::VideoFrameRate);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "AlbumTitle", QMediaMetaData::Key::AlbumTitle);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "AlbumArtist", QMediaMetaData::Key::AlbumArtist);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "ContributingArtist", QMediaMetaData::Key::ContributingArtist);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "TrackNumber", QMediaMetaData::Key::TrackNumber);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Composer", QMediaMetaData::Key::Composer);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "LeadPerformer", QMediaMetaData::Key::LeadPerformer);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "ThumbnailImage", QMediaMetaData::Key::ThumbnailImage);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "CoverArtImage", QMediaMetaData::Key::CoverArtImage);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Orientation", QMediaMetaData::Key::Orientation);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "Resolution", QMediaMetaData::Key::Resolution);
+        define_qenum_value_under(rb_cQMediaMetaDataKey, "HasHdrContent", QMediaMetaData::Key::HasHdrContent);
+}

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

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

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

@@ -0,0 +1,125 @@
+#include "qmediaplayer-rb.hpp"
+#include <qmediaplayer.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QIODevice>
+#include <QAudioBufferOutput>
+#include <QAudioOutput>
+#include <QMediaMetaData>
+#include <QMediaTimeRange>
+#include <QVideoSink>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQMediaPlayer;
+
+void Init_qmediaplayer(Module rb_mQt6QtMultimedia)
+{
+    rb_cQMediaPlayer =
+        // RubyQt6::QtMultimedia::QMediaPlayer
+        define_class_under<QMediaPlayer, QObject>(rb_mQt6QtMultimedia, "QMediaPlayer")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QMediaPlayer::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QMediaPlayer, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("active_audio_track", &QMediaPlayer::activeAudioTrack)
+            .define_method("active_subtitle_track", &QMediaPlayer::activeSubtitleTrack)
+            .define_method("active_video_track", &QMediaPlayer::activeVideoTrack)
+            .define_method("audio_buffer_output", &QMediaPlayer::audioBufferOutput)
+            .define_method("audio_output", &QMediaPlayer::audioOutput)
+            .define_method("audio_tracks", &QMediaPlayer::audioTracks)
+            .define_method("buffer_progress", &QMediaPlayer::bufferProgress)
+            .define_method("buffered_time_range", &QMediaPlayer::bufferedTimeRange)
+            .define_method("duration", &QMediaPlayer::duration)
+            .define_method("error", &QMediaPlayer::error)
+            .define_method("error_string", &QMediaPlayer::errorString)
+            .define_method("has_audio", &QMediaPlayer::hasAudio)
+            .define_method("has_video", &QMediaPlayer::hasVideo)
+            .define_method("available?", &QMediaPlayer::isAvailable)
+            .define_method("playing?", &QMediaPlayer::isPlaying)
+            .define_method("seekable?", &QMediaPlayer::isSeekable)
+            .define_method("loops", &QMediaPlayer::loops)
+            .define_method("media_status", &QMediaPlayer::mediaStatus)
+            .define_method("meta_data", &QMediaPlayer::metaData)
+            .define_method("playback_rate", &QMediaPlayer::playbackRate)
+            .define_method("playback_state", &QMediaPlayer::playbackState)
+            .define_method("position", &QMediaPlayer::position)
+            .define_method("set_active_audio_track", &QMediaPlayer::setActiveAudioTrack, Arg("index"))
+            .define_method("set_active_subtitle_track", &QMediaPlayer::setActiveSubtitleTrack, Arg("index"))
+            .define_method("set_active_video_track", &QMediaPlayer::setActiveVideoTrack, Arg("index"))
+            .define_method("set_audio_buffer_output", &QMediaPlayer::setAudioBufferOutput, Arg("output"))
+            .define_method("set_audio_output", &QMediaPlayer::setAudioOutput, Arg("output"))
+            .define_method("set_loops", &QMediaPlayer::setLoops, Arg("loops"))
+            .define_method("set_video_output", &QMediaPlayer::setVideoOutput, Arg("output"))
+            .define_method("set_video_sink", &QMediaPlayer::setVideoSink, Arg("sink"))
+            .define_method("source", &QMediaPlayer::source)
+            .define_method("source_device", &QMediaPlayer::sourceDevice)
+            .define_method("subtitle_tracks", &QMediaPlayer::subtitleTracks)
+            .define_method("video_output", &QMediaPlayer::videoOutput)
+            .define_method("video_sink", &QMediaPlayer::videoSink)
+            .define_method("video_tracks", &QMediaPlayer::videoTracks)
+            // Public Slots
+            .define_method("pause", &QMediaPlayer::pause)
+            .define_method("play", &QMediaPlayer::play)
+            .define_method("set_playback_rate", &QMediaPlayer::setPlaybackRate, Arg("rate"))
+            .define_method("set_position", &QMediaPlayer::setPosition, Arg("position"))
+            .define_method("set_source", &QMediaPlayer::setSource, Arg("source"))
+            .define_method("set_source_device", &QMediaPlayer::setSourceDevice, Arg("device"), Arg("source_url") = static_cast<const QUrl &>(QUrl()))
+            .define_method("stop", &QMediaPlayer::stop);
+            // Signals
+            // .define_method("active_tracks_changed", &QMediaPlayer::activeTracksChanged)
+            // .define_method("audio_buffer_output_changed", &QMediaPlayer::audioBufferOutputChanged)
+            // .define_method("audio_output_changed", &QMediaPlayer::audioOutputChanged)
+            // .define_method("buffer_progress_changed", &QMediaPlayer::bufferProgressChanged, Arg("progress"))
+            // .define_method("duration_changed", &QMediaPlayer::durationChanged, Arg("duration"))
+            // .define_method("error_changed", &QMediaPlayer::errorChanged)
+            // .define_method("error_occurred", &QMediaPlayer::errorOccurred, Arg("error"), Arg("error_string"))
+            // .define_method("has_audio_changed", &QMediaPlayer::hasAudioChanged, Arg("available"))
+            // .define_method("has_video_changed", &QMediaPlayer::hasVideoChanged, Arg("video_available"))
+            // .define_method("loops_changed", &QMediaPlayer::loopsChanged)
+            // .define_method("media_status_changed", &QMediaPlayer::mediaStatusChanged, Arg("status"))
+            // .define_method("meta_data_changed", &QMediaPlayer::metaDataChanged)
+            // .define_method("playback_rate_changed", &QMediaPlayer::playbackRateChanged, Arg("rate"))
+            // .define_method("playback_state_changed", &QMediaPlayer::playbackStateChanged, Arg("new_state"))
+            // .define_method("playing_changed", &QMediaPlayer::playingChanged, Arg("playing"))
+            // .define_method("position_changed", &QMediaPlayer::positionChanged, Arg("position"))
+            // .define_method("seekable_changed", &QMediaPlayer::seekableChanged, Arg("seekable"))
+            // .define_method("source_changed", &QMediaPlayer::sourceChanged, Arg("media"))
+            // .define_method("tracks_changed", &QMediaPlayer::tracksChanged)
+            // .define_method("video_output_changed", &QMediaPlayer::videoOutputChanged);
+
+    Data_Type<QMediaPlayer::Error> rb_cQMediaPlayerError =
+        // RubyQt6::QtMultimedia::QMediaPlayer::Error
+        define_qenum_under<QMediaPlayer::Error>(rb_cQMediaPlayer, "Error");
+        define_qenum_value_under(rb_cQMediaPlayerError, "NoError", QMediaPlayer::Error::NoError);
+        define_qenum_value_under(rb_cQMediaPlayerError, "ResourceError", QMediaPlayer::Error::ResourceError);
+        define_qenum_value_under(rb_cQMediaPlayerError, "FormatError", QMediaPlayer::Error::FormatError);
+        define_qenum_value_under(rb_cQMediaPlayerError, "NetworkError", QMediaPlayer::Error::NetworkError);
+        define_qenum_value_under(rb_cQMediaPlayerError, "AccessDeniedError", QMediaPlayer::Error::AccessDeniedError);
+
+    Data_Type<QMediaPlayer::Loops> rb_cQMediaPlayerLoops =
+        // RubyQt6::QtMultimedia::QMediaPlayer::Loops
+        define_qenum_under<QMediaPlayer::Loops>(rb_cQMediaPlayer, "Loops");
+        define_qenum_value_under(rb_cQMediaPlayerLoops, "Infinite", QMediaPlayer::Loops::Infinite);
+        define_qenum_value_under(rb_cQMediaPlayerLoops, "Once", QMediaPlayer::Loops::Once);
+
+    Data_Type<QMediaPlayer::MediaStatus> rb_cQMediaPlayerMediaStatus =
+        // RubyQt6::QtMultimedia::QMediaPlayer::MediaStatus
+        define_qenum_under<QMediaPlayer::MediaStatus>(rb_cQMediaPlayer, "MediaStatus");
+        define_qenum_value_under(rb_cQMediaPlayerMediaStatus, "NoMedia", QMediaPlayer::MediaStatus::NoMedia);
+        define_qenum_value_under(rb_cQMediaPlayerMediaStatus, "LoadingMedia", QMediaPlayer::MediaStatus::LoadingMedia);
+        define_qenum_value_under(rb_cQMediaPlayerMediaStatus, "LoadedMedia", QMediaPlayer::MediaStatus::LoadedMedia);
+        define_qenum_value_under(rb_cQMediaPlayerMediaStatus, "StalledMedia", QMediaPlayer::MediaStatus::StalledMedia);
+        define_qenum_value_under(rb_cQMediaPlayerMediaStatus, "BufferingMedia", QMediaPlayer::MediaStatus::BufferingMedia);
+        define_qenum_value_under(rb_cQMediaPlayerMediaStatus, "BufferedMedia", QMediaPlayer::MediaStatus::BufferedMedia);
+        define_qenum_value_under(rb_cQMediaPlayerMediaStatus, "EndOfMedia", QMediaPlayer::MediaStatus::EndOfMedia);
+        define_qenum_value_under(rb_cQMediaPlayerMediaStatus, "InvalidMedia", QMediaPlayer::MediaStatus::InvalidMedia);
+
+    Data_Type<QMediaPlayer::PlaybackState> rb_cQMediaPlayerPlaybackState =
+        // RubyQt6::QtMultimedia::QMediaPlayer::PlaybackState
+        define_qenum_under<QMediaPlayer::PlaybackState>(rb_cQMediaPlayer, "PlaybackState");
+        define_qenum_value_under(rb_cQMediaPlayerPlaybackState, "StoppedState", QMediaPlayer::PlaybackState::StoppedState);
+        define_qenum_value_under(rb_cQMediaPlayerPlaybackState, "PlayingState", QMediaPlayer::PlaybackState::PlayingState);
+        define_qenum_value_under(rb_cQMediaPlayerPlaybackState, "PausedState", QMediaPlayer::PlaybackState::PausedState);
+}

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

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

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

@@ -0,0 +1,113 @@
+#include "qmediarecorder-rb.hpp"
+#include <qmediarecorder.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QIODevice>
+#include <QMediaCaptureSession>
+#include <QMediaFormat>
+#include <QUrl>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQMediaRecorder;
+
+void Init_qmediarecorder(Module rb_mQt6QtMultimedia)
+{
+    rb_cQMediaRecorder =
+        // RubyQt6::QtMultimedia::QMediaRecorder
+        define_class_under<QMediaRecorder, QObject>(rb_mQt6QtMultimedia, "QMediaRecorder")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QMediaRecorder::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QMediaRecorder, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("actual_location", &QMediaRecorder::actualLocation)
+            .define_method("add_meta_data", &QMediaRecorder::addMetaData, Arg("meta_data"))
+            .define_method("audio_bit_rate", &QMediaRecorder::audioBitRate)
+            .define_method("audio_channel_count", &QMediaRecorder::audioChannelCount)
+            .define_method("audio_sample_rate", &QMediaRecorder::audioSampleRate)
+            .define_method("auto_stop", &QMediaRecorder::autoStop)
+            .define_method("capture_session", &QMediaRecorder::captureSession)
+            .define_method("duration", &QMediaRecorder::duration)
+            .define_method("encoding_mode", &QMediaRecorder::encodingMode)
+            .define_method("error", &QMediaRecorder::error)
+            .define_method("error_string", &QMediaRecorder::errorString)
+            .define_method("available?", &QMediaRecorder::isAvailable)
+            .define_method("media_format", &QMediaRecorder::mediaFormat)
+            .define_method("meta_data", &QMediaRecorder::metaData)
+            .define_method("output_device", &QMediaRecorder::outputDevice)
+            .define_method("output_location", &QMediaRecorder::outputLocation)
+            .define_method("quality", &QMediaRecorder::quality)
+            .define_method("recorder_state", &QMediaRecorder::recorderState)
+            .define_method("set_audio_bit_rate", &QMediaRecorder::setAudioBitRate, Arg("bit_rate"))
+            .define_method("set_audio_channel_count", &QMediaRecorder::setAudioChannelCount, Arg("channels"))
+            .define_method("set_audio_sample_rate", &QMediaRecorder::setAudioSampleRate, Arg("sample_rate"))
+            .define_method("set_auto_stop", &QMediaRecorder::setAutoStop, Arg("auto_stop"))
+            .define_method("set_encoding_mode", &QMediaRecorder::setEncodingMode, Arg("mode"))
+            .define_method("set_media_format", &QMediaRecorder::setMediaFormat, Arg("format"))
+            .define_method("set_meta_data", &QMediaRecorder::setMetaData, Arg("meta_data"))
+            .define_method("set_output_device", &QMediaRecorder::setOutputDevice, Arg("device"))
+            .define_method("set_output_location", &QMediaRecorder::setOutputLocation, Arg("location"))
+            .define_method("set_quality", &QMediaRecorder::setQuality, Arg("quality"))
+            .define_method("set_video_bit_rate", &QMediaRecorder::setVideoBitRate, Arg("bit_rate"))
+            .define_method("set_video_frame_rate", &QMediaRecorder::setVideoFrameRate, Arg("frame_rate"))
+            .define_method<void (QMediaRecorder::*)(const QSize &)>("set_video_resolution", &QMediaRecorder::setVideoResolution, Arg("size"))
+            .define_method<void (QMediaRecorder::*)(int, int)>("set_video_resolution", &QMediaRecorder::setVideoResolution, Arg("width"), Arg("height"))
+            .define_method("video_bit_rate", &QMediaRecorder::videoBitRate)
+            .define_method("video_frame_rate", &QMediaRecorder::videoFrameRate)
+            .define_method("video_resolution", &QMediaRecorder::videoResolution)
+            // Public Slots
+            .define_method("pause", &QMediaRecorder::pause)
+            .define_method("record", &QMediaRecorder::record)
+            .define_method("stop", &QMediaRecorder::stop);
+            // Signals
+            // .define_method("actual_location_changed", &QMediaRecorder::actualLocationChanged, Arg("location"))
+            // .define_method("audio_bit_rate_changed", &QMediaRecorder::audioBitRateChanged)
+            // .define_method("audio_channel_count_changed", &QMediaRecorder::audioChannelCountChanged)
+            // .define_method("audio_sample_rate_changed", &QMediaRecorder::audioSampleRateChanged)
+            // .define_method("auto_stop_changed", &QMediaRecorder::autoStopChanged)
+            // .define_method("duration_changed", &QMediaRecorder::durationChanged, Arg("duration"))
+            // .define_method("encoding_mode_changed", &QMediaRecorder::encodingModeChanged)
+            // .define_method("error_changed", &QMediaRecorder::errorChanged)
+            // .define_method("error_occurred", &QMediaRecorder::errorOccurred, Arg("error"), Arg("error_string"))
+            // .define_method("media_format_changed", &QMediaRecorder::mediaFormatChanged)
+            // .define_method("meta_data_changed", &QMediaRecorder::metaDataChanged)
+            // .define_method("quality_changed", &QMediaRecorder::qualityChanged)
+            // .define_method("recorder_state_changed", &QMediaRecorder::recorderStateChanged, Arg("state"))
+            // .define_method("video_bit_rate_changed", &QMediaRecorder::videoBitRateChanged)
+            // .define_method("video_frame_rate_changed", &QMediaRecorder::videoFrameRateChanged)
+            // .define_method("video_resolution_changed", &QMediaRecorder::videoResolutionChanged);
+
+    Data_Type<QMediaRecorder::EncodingMode> rb_cQMediaRecorderEncodingMode =
+        // RubyQt6::QtMultimedia::QMediaRecorder::EncodingMode
+        define_qenum_under<QMediaRecorder::EncodingMode>(rb_cQMediaRecorder, "EncodingMode");
+        define_qenum_value_under(rb_cQMediaRecorderEncodingMode, "ConstantQualityEncoding", QMediaRecorder::EncodingMode::ConstantQualityEncoding);
+        define_qenum_value_under(rb_cQMediaRecorderEncodingMode, "ConstantBitRateEncoding", QMediaRecorder::EncodingMode::ConstantBitRateEncoding);
+        define_qenum_value_under(rb_cQMediaRecorderEncodingMode, "AverageBitRateEncoding", QMediaRecorder::EncodingMode::AverageBitRateEncoding);
+        define_qenum_value_under(rb_cQMediaRecorderEncodingMode, "TwoPassEncoding", QMediaRecorder::EncodingMode::TwoPassEncoding);
+
+    Data_Type<QMediaRecorder::Error> rb_cQMediaRecorderError =
+        // RubyQt6::QtMultimedia::QMediaRecorder::Error
+        define_qenum_under<QMediaRecorder::Error>(rb_cQMediaRecorder, "Error");
+        define_qenum_value_under(rb_cQMediaRecorderError, "NoError", QMediaRecorder::Error::NoError);
+        define_qenum_value_under(rb_cQMediaRecorderError, "ResourceError", QMediaRecorder::Error::ResourceError);
+        define_qenum_value_under(rb_cQMediaRecorderError, "FormatError", QMediaRecorder::Error::FormatError);
+        define_qenum_value_under(rb_cQMediaRecorderError, "OutOfSpaceError", QMediaRecorder::Error::OutOfSpaceError);
+        define_qenum_value_under(rb_cQMediaRecorderError, "LocationNotWritable", QMediaRecorder::Error::LocationNotWritable);
+
+    Data_Type<QMediaRecorder::Quality> rb_cQMediaRecorderQuality =
+        // RubyQt6::QtMultimedia::QMediaRecorder::Quality
+        define_qenum_under<QMediaRecorder::Quality>(rb_cQMediaRecorder, "Quality");
+        define_qenum_value_under(rb_cQMediaRecorderQuality, "VeryLowQuality", QMediaRecorder::Quality::VeryLowQuality);
+        define_qenum_value_under(rb_cQMediaRecorderQuality, "LowQuality", QMediaRecorder::Quality::LowQuality);
+        define_qenum_value_under(rb_cQMediaRecorderQuality, "NormalQuality", QMediaRecorder::Quality::NormalQuality);
+        define_qenum_value_under(rb_cQMediaRecorderQuality, "HighQuality", QMediaRecorder::Quality::HighQuality);
+        define_qenum_value_under(rb_cQMediaRecorderQuality, "VeryHighQuality", QMediaRecorder::Quality::VeryHighQuality);
+
+    Data_Type<QMediaRecorder::RecorderState> rb_cQMediaRecorderRecorderState =
+        // RubyQt6::QtMultimedia::QMediaRecorder::RecorderState
+        define_qenum_under<QMediaRecorder::RecorderState>(rb_cQMediaRecorder, "RecorderState");
+        define_qenum_value_under(rb_cQMediaRecorderRecorderState, "StoppedState", QMediaRecorder::RecorderState::StoppedState);
+        define_qenum_value_under(rb_cQMediaRecorderRecorderState, "RecordingState", QMediaRecorder::RecorderState::RecordingState);
+        define_qenum_value_under(rb_cQMediaRecorderRecorderState, "PausedState", QMediaRecorder::RecorderState::PausedState);
+}

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

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

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

@@ -0,0 +1,45 @@
+#include "qscreencapture-rb.hpp"
+#include <qscreencapture.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QMediaCaptureSession>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQScreenCapture;
+
+void Init_qscreencapture(Module rb_mQt6QtMultimedia)
+{
+    rb_cQScreenCapture =
+        // RubyQt6::QtMultimedia::QScreenCapture
+        define_class_under<QScreenCapture, QObject>(rb_mQt6QtMultimedia, "QScreenCapture")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QScreenCapture::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QScreenCapture, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("capture_session", &QScreenCapture::captureSession)
+            .define_method("error", &QScreenCapture::error)
+            .define_method("error_string", &QScreenCapture::errorString)
+            .define_method("active?", &QScreenCapture::isActive)
+            .define_method("screen", &QScreenCapture::screen)
+            .define_method("set_screen", &QScreenCapture::setScreen, Arg("screen"))
+            // Public Slots
+            .define_method("set_active", &QScreenCapture::setActive, Arg("active"))
+            .define_method("start", &QScreenCapture::start)
+            .define_method("stop", &QScreenCapture::stop);
+            // Signals
+            // .define_method("active_changed", &QScreenCapture::activeChanged, Arg("active"))
+            // .define_method("error_changed", &QScreenCapture::errorChanged)
+            // .define_method("error_occurred", &QScreenCapture::errorOccurred, Arg("error"), Arg("error_string"))
+            // .define_method("screen_changed", &QScreenCapture::screenChanged, Arg("screen"));
+
+    Data_Type<QScreenCapture::Error> rb_cQScreenCaptureError =
+        // RubyQt6::QtMultimedia::QScreenCapture::Error
+        define_qenum_under<QScreenCapture::Error>(rb_cQScreenCapture, "Error");
+        define_qenum_value_under(rb_cQScreenCaptureError, "NoError", QScreenCapture::Error::NoError);
+        define_qenum_value_under(rb_cQScreenCaptureError, "InternalError", QScreenCapture::Error::InternalError);
+        define_qenum_value_under(rb_cQScreenCaptureError, "CapturingNotSupported", QScreenCapture::Error::CapturingNotSupported);
+        define_qenum_value_under(rb_cQScreenCaptureError, "CaptureFailed", QScreenCapture::Error::CaptureFailed);
+        define_qenum_value_under(rb_cQScreenCaptureError, "NotFound", QScreenCapture::Error::NotFound);
+}

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

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

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

@@ -0,0 +1,63 @@
+#include "qsoundeffect-rb.hpp"
+#include <qsoundeffect.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QAudioDevice>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQSoundEffect;
+
+void Init_qsoundeffect(Module rb_mQt6QtMultimedia)
+{
+    rb_cQSoundEffect =
+        // RubyQt6::QtMultimedia::QSoundEffect
+        define_class_under<QSoundEffect, QObject>(rb_mQt6QtMultimedia, "QSoundEffect")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QSoundEffect::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QSoundEffect, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("audio_device", &QSoundEffect::audioDevice)
+            .define_method("loaded?", &QSoundEffect::isLoaded)
+            .define_method("muted?", &QSoundEffect::isMuted)
+            .define_method("playing?", &QSoundEffect::isPlaying)
+            .define_method("loop_count", &QSoundEffect::loopCount)
+            .define_method("loops_remaining", &QSoundEffect::loopsRemaining)
+            .define_method("set_audio_device", &QSoundEffect::setAudioDevice, Arg("device"))
+            .define_method("set_loop_count", &QSoundEffect::setLoopCount, Arg("loop_count"))
+            .define_method("set_muted", &QSoundEffect::setMuted, Arg("muted"))
+            .define_method("set_source", &QSoundEffect::setSource, Arg("url"))
+            .define_method("set_volume", &QSoundEffect::setVolume, Arg("volume"))
+            .define_method("source", &QSoundEffect::source)
+            .define_method("status", &QSoundEffect::status)
+            .define_method("volume", &QSoundEffect::volume)
+            // Public Slots
+            .define_method("play", &QSoundEffect::play)
+            .define_method("stop", &QSoundEffect::stop)
+            // Signals
+            // .define_method("audio_device_changed", &QSoundEffect::audioDeviceChanged)
+            // .define_method("loaded_changed", &QSoundEffect::loadedChanged)
+            // .define_method("loop_count_changed", &QSoundEffect::loopCountChanged)
+            // .define_method("loops_remaining_changed", &QSoundEffect::loopsRemainingChanged)
+            // .define_method("muted_changed", &QSoundEffect::mutedChanged)
+            // .define_method("playing_changed", &QSoundEffect::playingChanged)
+            // .define_method("source_changed", &QSoundEffect::sourceChanged)
+            // .define_method("status_changed", &QSoundEffect::statusChanged)
+            // .define_method("volume_changed", &QSoundEffect::volumeChanged)
+            // Static Public Members
+            .define_singleton_function("supported_mime_types", &QSoundEffect::supportedMimeTypes);
+
+    Data_Type<QSoundEffect::Loop> rb_cQSoundEffectLoop =
+        // RubyQt6::QtMultimedia::QSoundEffect::Loop
+        define_qenum_under<QSoundEffect::Loop>(rb_cQSoundEffect, "Loop");
+        define_qenum_value_under(rb_cQSoundEffectLoop, "Infinite", QSoundEffect::Loop::Infinite);
+
+    Data_Type<QSoundEffect::Status> rb_cQSoundEffectStatus =
+        // RubyQt6::QtMultimedia::QSoundEffect::Status
+        define_qenum_under<QSoundEffect::Status>(rb_cQSoundEffect, "Status");
+        define_qenum_value_under(rb_cQSoundEffectStatus, "Null", QSoundEffect::Status::Null);
+        define_qenum_value_under(rb_cQSoundEffectStatus, "Loading", QSoundEffect::Status::Loading);
+        define_qenum_value_under(rb_cQSoundEffectStatus, "Ready", QSoundEffect::Status::Ready);
+        define_qenum_value_under(rb_cQSoundEffectStatus, "Error", QSoundEffect::Status::Error);
+}

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

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

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

@@ -0,0 +1,38 @@
+#include "qtaudio-rb.hpp"
+#include <qtaudio.h>
+#include <rice/qt6/qenum.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qtaudio(Module rb_mQt6QtMultimedia)
+{
+    Module rb_mQtAudio =
+        // RubyQt6::QtMultimedia::QtAudio
+        define_module_under(rb_mQt6QtMultimedia, "QtAudio")
+            .define_module_function("convert_volume", &QtAudio::convertVolume, Arg("volume"), Arg("from"), Arg("to"));
+
+    Data_Type<QtAudio::Error> rb_cQtAudioError =
+        // RubyQt6::QtMultimedia::QtAudio::Error
+        define_qenum_under<QtAudio::Error>(rb_mQtAudio, "Error");
+        define_qenum_value_under(rb_cQtAudioError, "NoError", QtAudio::Error::NoError);
+        define_qenum_value_under(rb_cQtAudioError, "OpenError", QtAudio::Error::OpenError);
+        define_qenum_value_under(rb_cQtAudioError, "IOError", QtAudio::Error::IOError);
+        define_qenum_value_under(rb_cQtAudioError, "UnderrunError", QtAudio::Error::UnderrunError);
+        define_qenum_value_under(rb_cQtAudioError, "FatalError", QtAudio::Error::FatalError);
+
+    Data_Type<QtAudio::State> rb_cQtAudioState =
+        // RubyQt6::QtMultimedia::QtAudio::State
+        define_qenum_under<QtAudio::State>(rb_mQtAudio, "State");
+        define_qenum_value_under(rb_cQtAudioState, "ActiveState", QtAudio::State::ActiveState);
+        define_qenum_value_under(rb_cQtAudioState, "SuspendedState", QtAudio::State::SuspendedState);
+        define_qenum_value_under(rb_cQtAudioState, "StoppedState", QtAudio::State::StoppedState);
+        define_qenum_value_under(rb_cQtAudioState, "IdleState", QtAudio::State::IdleState);
+
+    Data_Type<QtAudio::VolumeScale> rb_cQtAudioVolumeScale =
+        // RubyQt6::QtMultimedia::QtAudio::VolumeScale
+        define_qenum_under<QtAudio::VolumeScale>(rb_mQtAudio, "VolumeScale");
+        define_qenum_value_under(rb_cQtAudioVolumeScale, "LinearVolumeScale", QtAudio::VolumeScale::LinearVolumeScale);
+        define_qenum_value_under(rb_cQtAudioVolumeScale, "CubicVolumeScale", QtAudio::VolumeScale::CubicVolumeScale);
+        define_qenum_value_under(rb_cQtAudioVolumeScale, "LogarithmicVolumeScale", QtAudio::VolumeScale::LogarithmicVolumeScale);
+        define_qenum_value_under(rb_cQtAudioVolumeScale, "DecibelVolumeScale", QtAudio::VolumeScale::DecibelVolumeScale);
+}

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

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

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

@@ -0,0 +1,75 @@
+#include "qtmultimedia-rb.hpp"
+#include "qtmultimediaversion-rb.hpp"
+#include "qtaudio-rb.hpp"
+#include "qtvideo-rb.hpp"
+
+#include "qaudiodevice-rb.hpp"
+#include "qaudioformat-rb.hpp"
+#include "qcameradevice-rb.hpp"
+#include "qcameraformat-rb.hpp"
+#include "qcapturablewindow-rb.hpp"
+#include "qmediaformat-rb.hpp"
+#include "qmediametadata-rb.hpp"
+#include "qvideoframe-rb.hpp"
+#include "qvideoframeformat-rb.hpp"
+
+#include "qaudioinput-rb.hpp"
+#include "qaudiooutput-rb.hpp"
+#include "qaudiosink-rb.hpp"
+#include "qaudiosource-rb.hpp"
+#include "qcamera-rb.hpp"
+#include "qimagecapture-rb.hpp"
+#include "qmediacapturesession-rb.hpp"
+#include "qmediadevices-rb.hpp"
+#include "qmediaplayer-rb.hpp"
+#include "qmediarecorder-rb.hpp"
+#include "qscreencapture-rb.hpp"
+#include "qsoundeffect-rb.hpp"
+#include "qwindowcapture-rb.hpp"
+#include "qvideoframeinput-rb.hpp"
+#include "qvideosink-rb.hpp"
+
+#include "t-qtmultimedia-rb.hpp"
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+extern "C" void Init_qtmultimedia()
+{
+    return detail::cpp_protect([] {
+        Module rb_mQt6 = define_module("RubyQt6");
+        Module rb_mQt6QtMultimedia = define_module_under(rb_mQt6, "QtMultimedia");
+
+        Init_qtmultimediaversion(rb_mQt6QtMultimedia);
+        Init_qtaudio(rb_mQt6QtMultimedia);
+        Init_qtvideo(rb_mQt6QtMultimedia);
+
+        Init_qaudiodevice(rb_mQt6QtMultimedia);
+        Init_qaudioformat(rb_mQt6QtMultimedia);
+        Init_qcameradevice(rb_mQt6QtMultimedia);
+        Init_qcameraformat(rb_mQt6QtMultimedia);
+        Init_qcapturablewindow(rb_mQt6QtMultimedia);
+        Init_qmediaformat(rb_mQt6QtMultimedia);
+        Init_qmediametadata(rb_mQt6QtMultimedia);
+        Init_qvideoframe(rb_mQt6QtMultimedia);
+        Init_qvideoframeformat(rb_mQt6QtMultimedia);
+
+        Init_qaudioinput(rb_mQt6QtMultimedia);
+        Init_qaudiooutput(rb_mQt6QtMultimedia);
+        Init_qaudiosink(rb_mQt6QtMultimedia);
+        Init_qaudiosource(rb_mQt6QtMultimedia);
+        Init_qcamera(rb_mQt6QtMultimedia);
+        Init_qimagecapture(rb_mQt6QtMultimedia);
+        Init_qmediacapturesession(rb_mQt6QtMultimedia);
+        Init_qmediadevices(rb_mQt6QtMultimedia);
+        Init_qmediaplayer(rb_mQt6QtMultimedia);
+        Init_qmediarecorder(rb_mQt6QtMultimedia);
+        Init_qsoundeffect(rb_mQt6QtMultimedia);
+        Init_qscreencapture(rb_mQt6QtMultimedia);
+        Init_qvideoframeinput(rb_mQt6QtMultimedia);
+        Init_qvideosink(rb_mQt6QtMultimedia);
+        Init_qwindowcapture(rb_mQt6QtMultimedia);
+
+        Module rb_mQt6T = define_module_under(rb_mQt6, "T");
+        Init_t_qtmultimedia(rb_mQt6T);
+    });
+}

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

@@ -0,0 +1,3 @@
+#include <rice/qt6.hpp>
+
+extern "C" void Init_qtmultimedia();

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

@@ -0,0 +1,9 @@
+#include "qtmultimediaversion-rb.hpp"
+#include <qtmultimediaversion.h>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qtmultimediaversion(Module rb_mQt6QtMultimedia)
+{
+    rb_mQt6QtMultimedia.define_constant("QTMULTIMEDIA_VERSION", QTMULTIMEDIA_VERSION_STR);
+}

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

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

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

@@ -0,0 +1,20 @@
+#include "qtvideo-rb.hpp"
+#include <qtvideo.h>
+#include <rice/qt6/qenum.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qtvideo(Module rb_mQt6QtMultimedia)
+{
+    Module rb_mQtVideo =
+        // RubyQt6::QtMultimedia::QtVideo
+        define_module_under(rb_mQt6QtMultimedia, "QtVideo");
+
+    Data_Type<QtVideo::Rotation> rb_cQtVideoRotation =
+        // RubyQt6::QtMultimedia::QtVideo::Rotation
+        define_qenum_under<QtVideo::Rotation>(rb_mQtVideo, "Rotation");
+        define_qenum_value_under(rb_cQtVideoRotation, "None", QtVideo::Rotation::None);
+        define_qenum_value_under(rb_cQtVideoRotation, "Clockwise90", QtVideo::Rotation::Clockwise90);
+        define_qenum_value_under(rb_cQtVideoRotation, "Clockwise180", QtVideo::Rotation::Clockwise180);
+        define_qenum_value_under(rb_cQtVideoRotation, "Clockwise270", QtVideo::Rotation::Clockwise270);
+}

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

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