public/gpu-screen-recorder-ui
1
0
Fork 0
mirror of https://repo.dec05eba.com/gpu-screen-recorder-ui synced 2026-01-31 01:13:04 +09:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add option to choose webcam resolution and fps

Browse Source
This commit is contained in:
dec05eba
2026-01-18 17:03:23 +01:00
parent 40b2af5668
commit 5c4ebbab59
8 changed files with 102 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
include/Config.hpp
View File

@@ -65,6 +65,9 @@ namespace gsr {
std::string webcam_source = "";
bool webcam_flip_horizontally = false;
std::string webcam_video_format = "auto";
int32_t webcam_camera_width = 0;
int32_t webcam_camera_height = 0;
int32_t webcam_camera_fps = 0;
int32_t webcam_x = 0; // A value between 0 and 100 (percentage)
int32_t webcam_y = 0; // A value between 0 and 100 (percentage)
int32_t webcam_width = 30; // A value between 0 and 100 (percentage), 0 = Don't scale it

2
include/gui/ComboBox.hpp
View File

@@ -18,7 +18,7 @@ namespace gsr {
bool on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) override;
void draw(mgl::Window &window, mgl::vec2f offset) override;
void add_item(const std::string &text, const std::string &id);
void add_item(const std::string &text, const std::string &id, bool allow_duplicate = true);
void clear_items();
// The item can only be selected if it's enabled

3
include/gui/SettingsPage.hpp
View File

@@ -67,7 +67,9 @@ namespace gsr {
std::unique_ptr<Widget> create_change_video_resolution_section();
std::unique_ptr<Widget> create_capture_target_section();
std::unique_ptr<List> create_webcam_sources();
std::unique_ptr<List> create_webcam_video_setups();
std::unique_ptr<List> create_webcam_video_format();
std::unique_ptr<List> create_webcam_video_setup_list();
std::unique_ptr<Widget> create_webcam_location_widget();
std::unique_ptr<CheckBox> create_flip_camera_checkbox();
std::unique_ptr<List> create_webcam_body();
@@ -219,6 +221,7 @@ namespace gsr {
CheckBox *led_indicator_checkbox_ptr = nullptr;
CheckBox *show_notification_checkbox_ptr = nullptr;
ComboBox *webcam_sources_box_ptr = nullptr;
ComboBox *webcam_video_setup_box_ptr = nullptr;
ComboBox *webcam_video_format_box_ptr = nullptr;
List *webcam_body_list_ptr = nullptr;
CheckBox *flip_camera_horizontally_checkbox_ptr = nullptr;

9
src/Config.cpp
View File

@@ -203,6 +203,9 @@ namespace gsr {
{"streaming.record_options.webcam_source", &config.streaming_config.record_options.webcam_source},
{"streaming.record_options.webcam_flip_horizontally", &config.streaming_config.record_options.webcam_flip_horizontally},
{"streaming.record_options.webcam_video_format", &config.streaming_config.record_options.webcam_video_format},
{"streaming.record_options.webcam_camera_width", &config.streaming_config.record_options.webcam_camera_width},
{"streaming.record_options.webcam_camera_height", &config.streaming_config.record_options.webcam_camera_height},
{"streaming.record_options.webcam_camera_fps", &config.streaming_config.record_options.webcam_camera_fps},
{"streaming.record_options.webcam_x", &config.streaming_config.record_options.webcam_x},
{"streaming.record_options.webcam_y", &config.streaming_config.record_options.webcam_y},
{"streaming.record_options.webcam_width", &config.streaming_config.record_options.webcam_width},
@@ -245,6 +248,9 @@ namespace gsr {
{"record.record_options.webcam_source", &config.record_config.record_options.webcam_source},
{"record.record_options.webcam_flip_horizontally", &config.record_config.record_options.webcam_flip_horizontally},
{"record.record_options.webcam_video_format", &config.record_config.record_options.webcam_video_format},
{"record.record_options.webcam_camera_width", &config.record_config.record_options.webcam_camera_width},
{"record.record_options.webcam_camera_height", &config.record_config.record_options.webcam_camera_height},
{"record.record_options.webcam_camera_fps", &config.record_config.record_options.webcam_camera_fps},
{"record.record_options.webcam_x", &config.record_config.record_options.webcam_x},
{"record.record_options.webcam_y", &config.record_config.record_options.webcam_y},
{"record.record_options.webcam_width", &config.record_config.record_options.webcam_width},
@@ -282,6 +288,9 @@ namespace gsr {
{"replay.record_options.webcam_source", &config.replay_config.record_options.webcam_source},
{"replay.record_options.webcam_flip_horizontally", &config.replay_config.record_options.webcam_flip_horizontally},
{"replay.record_options.webcam_video_format", &config.replay_config.record_options.webcam_video_format},
{"replay.record_options.webcam_camera_width", &config.replay_config.record_options.webcam_camera_width},
{"replay.record_options.webcam_camera_height", &config.replay_config.record_options.webcam_camera_height},
{"replay.record_options.webcam_camera_fps", &config.replay_config.record_options.webcam_camera_fps},
{"replay.record_options.webcam_x", &config.replay_config.record_options.webcam_x},
{"replay.record_options.webcam_y", &config.replay_config.record_options.webcam_y},
{"replay.record_options.webcam_width", &config.replay_config.record_options.webcam_width},

3
src/CursorTracker/CursorTrackerWayland.cpp
View File

@@ -368,8 +368,7 @@ namespace gsr {
if(!properties)
goto next_crtc;
if(!get_drm_property_by_name(drm_fd, properties, "VRR_ENABLED", &vrr_enabled))
goto next_crtc;
get_drm_property_by_name(drm_fd, properties, "VRR_ENABLED", &vrr_enabled);
connector = get_drm_connector_by_crtc_id(drm_connectors, crtc->crtc_id);
if(!connector)

3
src/Overlay.cpp
View File

@@ -2763,6 +2763,9 @@ namespace gsr {
capture_source_arg += ";width=" + std::to_string(webcam_size.x) + "%";
capture_source_arg += ";height=" + std::to_string(webcam_size.y) + "%";
capture_source_arg += ";pixfmt=" + record_options.webcam_video_format;
capture_source_arg += ";camera_width=" + std::to_string(record_options.webcam_camera_width);
capture_source_arg += ";camera_height=" + std::to_string(record_options.webcam_camera_height);
capture_source_arg += ";camera_fps=" + std::to_string(record_options.webcam_camera_fps);
if(record_options.webcam_flip_horizontally)
capture_source_arg += ";hflip=true";
}

9
src/gui/ComboBox.cpp
View File

@@ -83,7 +83,14 @@ namespace gsr {
draw_unselected(window, draw_pos);
}
void ComboBox::add_item(const std::string &text, const std::string &id) {
void ComboBox::add_item(const std::string &text, const std::string &id, bool allow_duplicate) {
if(!allow_duplicate) {
for(const auto &item : items) {
if(item.id == id)
return;
}
}
items.push_back({mgl::Text(text, *font), id, {0.0f, 0.0f}});
items.back().text.set_max_width(font->get_character_size() * 20); // TODO: Make a proper solution
//items.back().text.set_max_rows(1);

75
src/gui/SettingsPage.cpp
View File

@@ -248,6 +248,27 @@ namespace gsr {
return ll;
}
std::unique_ptr<List> SettingsPage::create_webcam_video_setups() {
auto ll = std::make_unique<List>(List::Orientation::VERTICAL);
ll->add_widget(std::make_unique<Label>(&get_theme().body_font, "Video setup:", get_color_theme().text_color));
auto combobox = std::make_unique<ComboBox>(&get_theme().body_font);
webcam_video_setup_box_ptr = combobox.get();
ll->add_widget(std::move(combobox));
return ll;
}
static std::vector<GsrCameraSetup> sort_camera_setup(const std::vector<GsrCameraSetup> &setups) {
auto result = setups;
std::sort(result.begin(), result.end(), [](const auto &a, const auto &b) {
const uint64_t score_a = (uint64_t)a.resolution.x * (uint64_t)a.resolution.y * (uint64_t)a.fps;
const uint64_t score_b = (uint64_t)b.resolution.x * (uint64_t)b.resolution.y * (uint64_t)b.fps;
return score_a > score_b;
});
return result;
}
std::unique_ptr<List> SettingsPage::create_webcam_video_format() {
auto ll = std::make_unique<List>(List::Orientation::VERTICAL);
ll->add_widget(std::make_unique<Label>(&get_theme().body_font, "Video format:", get_color_theme().text_color));
@@ -257,12 +278,52 @@ namespace gsr {
webcam_video_format_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
get_current_record_options().webcam_video_format = id;
auto it = std::find_if(capture_options.cameras.begin(), capture_options.cameras.end(), [&](const GsrCamera &camera) {
return camera.path == webcam_sources_box_ptr->get_selected_id();
});
if(it == capture_options.cameras.end())
return;
webcam_video_setup_box_ptr->clear_items();
if(id == "yuyv") {
const auto setups = sort_camera_setup(it->yuyv_setups);
for(const auto &setup : setups) {
char setup_str[256];
snprintf(setup_str, sizeof(setup_str), "%dx%d@%dhz", setup.resolution.x, setup.resolution.y, setup.fps);
webcam_video_setup_box_ptr->add_item(setup_str, setup_str, false);
}
} else if(id == "mjpeg") {
const auto setups = sort_camera_setup(it->mjpeg_setups);
for(const auto &setup : setups) {
char setup_str[256];
snprintf(setup_str, sizeof(setup_str), "%dx%d@%dhz", setup.resolution.x, setup.resolution.y, setup.fps);
webcam_video_setup_box_ptr->add_item(setup_str, setup_str, false);
}
} else if(id == "auto") {
auto setups = it->yuyv_setups;
setups.insert(setups.end(), it->mjpeg_setups.begin(), it->mjpeg_setups.end());
setups = sort_camera_setup(setups);
for(const auto &setup : setups) {
char setup_str[256];
snprintf(setup_str, sizeof(setup_str), "%dx%d@%dhz", setup.resolution.x, setup.resolution.y, setup.fps);
webcam_video_setup_box_ptr->add_item(setup_str, setup_str, false);
}
}
};
ll->add_widget(std::move(combobox));
return ll;
}
std::unique_ptr<List> SettingsPage::create_webcam_video_setup_list() {
auto list = std::make_unique<List>(List::Orientation::HORIZONTAL);
list->add_widget(create_webcam_video_format());
list->add_widget(create_webcam_video_setups());
return list;
}
std::unique_ptr<Widget> SettingsPage::create_webcam_location_widget() {
const float camera_screen_width = std::min(400.0f, (float)settings_scrollable_page_ptr->get_inner_size().x * 0.90f);
camera_screen_size = mgl::vec2f(camera_screen_width, camera_screen_width * 0.5625);
@@ -405,7 +466,7 @@ namespace gsr {
body_list->add_widget(create_webcam_location_widget());
body_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "* Right click in the bottom right corner to resize the webcam", get_color_theme().text_color));
body_list->add_widget(create_flip_camera_checkbox());
body_list->add_widget(create_webcam_video_format());
body_list->add_widget(create_webcam_video_setup_list());
return body_list;
}
@@ -1530,9 +1591,13 @@ namespace gsr {
led_indicator_checkbox_ptr->set_checked(record_options.use_led_indicator);
low_power_mode_checkbox_ptr->set_checked(record_options.low_power_mode);
char webcam_setup_str[256];
snprintf(webcam_setup_str, sizeof(webcam_setup_str), "%dx%d@%dhz", record_options.webcam_camera_width, record_options.webcam_camera_height, record_options.webcam_camera_fps);
webcam_sources_box_ptr->set_selected_item(record_options.webcam_source);
flip_camera_horizontally_checkbox_ptr->set_checked(record_options.webcam_flip_horizontally);
webcam_video_format_box_ptr->set_selected_item(record_options.webcam_video_format);
webcam_video_setup_box_ptr->set_selected_item(webcam_setup_str);
webcam_box_pos.x = ((float)record_options.webcam_x / 100.0f) * screen_inner_size.x;
webcam_box_pos.y = ((float)record_options.webcam_y / 100.0f) * screen_inner_size.y;
webcam_box_size.x = ((float)record_options.webcam_width / 100.0f * screen_inner_size.x);
@@ -1679,9 +1744,17 @@ namespace gsr {
if(selected_camera_setup.has_value())
webcam_box_size = clamp_keep_aspect_ratio(selected_camera_setup->resolution.to_vec2f(), webcam_box_size);
int camera_width = 0;
int camera_height = 0;
int camera_fps = 0;
sscanf(webcam_video_setup_box_ptr->get_selected_id().c_str(), "%dx%d@%dhz", &camera_width, &camera_height, &camera_fps);
record_options.webcam_source = webcam_sources_box_ptr->get_selected_id();
record_options.webcam_flip_horizontally = flip_camera_horizontally_checkbox_ptr->is_checked();
record_options.webcam_video_format = webcam_video_format_box_ptr->get_selected_id();
record_options.webcam_camera_width = camera_width;
record_options.webcam_camera_height = camera_height;
record_options.webcam_camera_fps = camera_fps;
record_options.webcam_x = std::round((webcam_box_pos.x / screen_inner_size.x) * 100.0f);
record_options.webcam_y = std::round((webcam_box_pos.y / screen_inner_size.y) * 100.0f);
record_options.webcam_width = std::round((webcam_box_size.x / screen_inner_size.x) * 100.0f);