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

Compare commits

base: public:5.2.3
Branches Tags
public:master
public:5.12.5 public:5.12.4 public:5.12.3 public:5.12.2 public:5.12.1 public:5.12.0 public:5.11.5 public:5.11.4 public:5.11.3 public:5.11.2 public:5.11.1 public:5.11.0 public:5.10.2 public:5.10.1 public:5.10.0 public:5.9.4 public:5.9.3 public:5.9.2 public:5.9.1 public:5.9.0 public:5.8.2 public:5.8.1 public:5.8.0 public:5.7.4 public:5.7.3 public:5.7.2 public:5.7.1 public:5.7.0 public:5.6.8 public:5.6.7 public:5.6.6 public:5.6.5 public:5.6.4 public:5.6.3 public:5.6.2 public:5.6.1 public:5.6.0 public:5.5.10 public:5.5.9 public:5.5.8 public:5.5.7 public:5.5.6 public:5.5.5 public:5.5.4 public:5.5.3 public:5.5.2 public:5.5.1 public:5.5.0 public:5.4.1 public:5.4.0 public:5.3.8 public:5.3.7 public:5.3.6 public:5.3.5 public:5.3.4 public:5.3.3 public:5.3.2 public:5.3.1 public:5.3.0 public:5.2.3 public:5.2.2 public:5.2.1 public:5.2.0 public:5.1.3 public:5.1.2 public:5.1.1 public:5.1.0 public:5.0.3 public:5.0.2 public:5.0.1 public:5.0.0 public:4.3.5 public:4.3.4 public:4.3.3 public:4.3.2 public:4.3.1 public:4.3.0 public:4.2.6 public:4.2.5 public:4.2.4 public:4.2.3 public:4.2.2 public:4.2.1 public:4.2.0 public:4.1.11
...
compare: public:5.3.3
Branches Tags
public:master
public:5.12.5 public:5.12.4 public:5.12.3 public:5.12.2 public:5.12.1 public:5.12.0 public:5.11.5 public:5.11.4 public:5.11.3 public:5.11.2 public:5.11.1 public:5.11.0 public:5.10.2 public:5.10.1 public:5.10.0 public:5.9.4 public:5.9.3 public:5.9.2 public:5.9.1 public:5.9.0 public:5.8.2 public:5.8.1 public:5.8.0 public:5.7.4 public:5.7.3 public:5.7.2 public:5.7.1 public:5.7.0 public:5.6.8 public:5.6.7 public:5.6.6 public:5.6.5 public:5.6.4 public:5.6.3 public:5.6.2 public:5.6.1 public:5.6.0 public:5.5.10 public:5.5.9 public:5.5.8 public:5.5.7 public:5.5.6 public:5.5.5 public:5.5.4 public:5.5.3 public:5.5.2 public:5.5.1 public:5.5.0 public:5.4.1 public:5.4.0 public:5.3.8 public:5.3.7 public:5.3.6 public:5.3.5 public:5.3.4 public:5.3.3 public:5.3.2 public:5.3.1 public:5.3.0 public:5.2.3 public:5.2.2 public:5.2.1 public:5.2.0 public:5.1.3 public:5.1.2 public:5.1.1 public:5.1.0 public:5.0.3 public:5.0.2 public:5.0.1 public:5.0.0 public:4.3.5 public:4.3.4 public:4.3.3 public:4.3.2 public:4.3.1 public:4.3.0 public:4.2.6 public:4.2.5 public:4.2.4 public:4.2.3 public:4.2.2 public:4.2.1 public:4.2.0 public:4.1.11

12 Commits
5.2.3 ... 5.3.3

Author SHA1 Message Date
dec05eba
e7a95f830a 5.3.3 2025-03-16 01:22:35 +01:00
dec05eba
1e0e24c818 todo 2025-03-16 01:16:18 +01:00
dec05eba
22c76fb8c3 Ffmpeg changes the api YET AGAIN, breaking recording on nvidia 2025-03-16 00:48:38 +01:00
dec05eba
77b60a03b2 5.3.2 2025-03-15 13:23:09 +01:00
dec05eba
1280a5ed0c Fix application audio not working correctly after a recent update 2025-03-15 13:22:42 +01:00
dec05eba
190c775a08 Fix screenshot of window not working after latest change 2025-03-14 08:54:12 +01:00
dec05eba
bab9a0560d 5.3.0 2025-03-14 00:17:52 +01:00
dec05eba
5d87dbd075 texture filter change 2025-03-13 22:38:28 +01:00
dec05eba
b0de8588f2 Take screenshot with XGetImage on x11 to workaround nvidia driver (nvfbc) limitation that only allows one nvfbc session at a time 2025-03-13 22:34:29 +01:00
dec05eba
f63409bdd7 nvfbc region capture work 2025-03-13 01:50:36 +01:00
dec05eba
af54684103 Fix screenshot with region not working correctly for some sizes and possibly crashing 2025-03-13 01:38:26 +01:00
dec05eba
92492db788 Add region capture with -w region -region WxH+X+Y 2025-03-13 00:18:28 +01:00
25 changed files with 709 additions and 283 deletions
Expand all files Collapse all files

8
TODO
View File

@@ -244,3 +244,11 @@ Find out how nvidia-smi fixes nvenc not working on opensuse and do that ourselve
Pulseaudio code: add "running" variable to loops to allow stopping the running code when quitting.
Scale screenshot frame libswscale or implement lanczos shader for improved scaline for video as well.
Support high quality scaling with -s by using lanczos.
Support spanning multiple monitors with region capture. This would also allow the user to record multiple monitors at the same time, the same way screen-direct works on nvidia x11.
When webcam support is added also support v4l2loopback? this is done by using avdevice_register_all(); and -c v4l2 -o /dev/video0; but it needs to output raw data as well instead of h264 and possibly yuv420p. Maybe add a -k yuv420p option to do that.
Do proper exit, to call gsr_capture_destroy which will properly stop gsr-kms-server. Otherwise there can be zombie gsr-kms-server on error.

6
include/capture/kms.h
View File

@@ -5,13 +5,13 @@
typedef struct {
gsr_egl *egl;
const char *display_to_capture; /* if this is "screen", then the first monitor is captured. A copy is made of this */
gsr_color_depth color_depth;
gsr_color_range color_range;
const char *display_to_capture; /* A copy is made of this */
bool hdr;
bool record_cursor;
int fps;
vec2i output_resolution;
vec2i region_size;
vec2i region_position;
} gsr_capture_kms_params;
gsr_capture* gsr_capture_kms_create(const gsr_capture_kms_params *params);

6
include/capture/nvfbc.h
View File

@@ -8,13 +8,11 @@ typedef struct {
gsr_egl *egl;
const char *display_to_capture; /* if this is "screen", then the entire x11 screen is captured (all displays). A copy is made of this */
int fps;
vec2i pos;
vec2i size;
bool direct_capture;
gsr_color_depth color_depth;
gsr_color_range color_range;
bool record_cursor;
vec2i output_resolution;
vec2i region_size;
vec2i region_position;
} gsr_capture_nvfbc_params;
gsr_capture* gsr_capture_nvfbc_create(const gsr_capture_nvfbc_params *params);

2
include/capture/portal.h
View File

@@ -5,8 +5,6 @@
typedef struct {
gsr_egl *egl;
gsr_color_depth color_depth;
gsr_color_range color_range;
bool record_cursor;
bool restore_portal_session;
/* If this is set to NULL then this defaults to $XDG_CONFIG_HOME/gpu-screen-recorder/restore_token ($XDG_CONFIG_HOME defaults to $HOME/.config) */

2
include/capture/xcomposite.h
View File

@@ -8,9 +8,7 @@ typedef struct {
gsr_egl *egl;
unsigned long window;
bool follow_focused; /* If this is set then |window| is ignored */
gsr_color_range color_range;
bool record_cursor;
gsr_color_depth color_depth;
vec2i output_resolution;
} gsr_capture_xcomposite_params;

18
include/capture/ximage.h Normal file
View File

@@ -0,0 +1,18 @@
#ifndef GSR_CAPTURE_XIMAGE_H
#define GSR_CAPTURE_XIMAGE_H
#include "capture.h"
#include "../vec2.h"
typedef struct {
gsr_egl *egl;
const char *display_to_capture; /* A copy is made of this */
bool record_cursor;
vec2i output_resolution;
vec2i region_size;
vec2i region_position;
} gsr_capture_ximage_params;
gsr_capture* gsr_capture_ximage_create(const gsr_capture_ximage_params *params);
#endif /* GSR_CAPTURE_XIMAGE_H */

4
include/egl.h
View File

@@ -132,6 +132,8 @@ typedef void(*__GLXextFuncPtr)(void);
#define GL_ONE_MINUS_SRC_ALPHA 0x0303
#define GL_DEBUG_OUTPUT 0x92E0
#define GL_SCISSOR_TEST 0x0C11
#define GL_PACK_ALIGNMENT 0x0D05
#define GL_UNPACK_ALIGNMENT 0x0CF5
#define GL_VENDOR 0x1F00
#define GL_RENDERER 0x1F01
@@ -233,6 +235,7 @@ struct gsr_egl {
void (*glTexParameteriv)(unsigned int target, unsigned int pname, const int *params);
void (*glGetTexLevelParameteriv)(unsigned int target, int level, unsigned int pname, int *params);
void (*glTexImage2D)(unsigned int target, int level, int internalFormat, int width, int height, int border, unsigned int format, unsigned int type, const void *pixels);
void (*glTexSubImage2D)(unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned format, unsigned type, const void *pixels);
void (*glGetTexImage)(unsigned int target, int level, unsigned int format, unsigned int type, void *pixels);
void (*glGenFramebuffers)(int n, unsigned int *framebuffers);
void (*glBindFramebuffer)(unsigned int target, unsigned int framebuffer);
@@ -269,6 +272,7 @@ struct gsr_egl {
void (*glEnable)(unsigned int cap);
void (*glDisable)(unsigned int cap);
void (*glBlendFunc)(unsigned int sfactor, unsigned int dfactor);
void (*glPixelStorei)(unsigned int pname, int param);
int (*glGetUniformLocation)(unsigned int program, const char *name);
void (*glUniform1f)(int location, float v0);
void (*glUniform2f)(int location, float v0, float v1);

8
include/image_writer.h
View File

@@ -11,7 +11,8 @@ typedef enum {
} gsr_image_format;
typedef enum {
GSR_IMAGE_WRITER_SOURCE_OPENGL
GSR_IMAGE_WRITER_SOURCE_OPENGL,
GSR_IMAGE_WRITER_SOURCE_MEMORY
} gsr_image_writer_source;
typedef struct {
@@ -20,9 +21,12 @@ typedef struct {
int width;
int height;
unsigned int texture;
const void *memory; /* Reference */
} gsr_image_writer;
bool gsr_image_writer_init(gsr_image_writer *self, gsr_image_writer_source source, gsr_egl *egl, int width, int height);
bool gsr_image_writer_init_opengl(gsr_image_writer *self, gsr_egl *egl, int width, int height);
/* |memory| is taken as a reference */
bool gsr_image_writer_init_memory(gsr_image_writer *self, const void *memory, int width, int height);
void gsr_image_writer_deinit(gsr_image_writer *self);
/* Quality is between 1 and 100 where 100 is the max quality. Quality doesn't apply to lossless formats */

6
include/utils.h
View File

@@ -15,7 +15,7 @@ typedef struct AVFrame AVFrame;
typedef struct {
const char *name;
int name_len;
vec2i pos;
vec2i pos; /* This is 0, 0 on wayland. Use |drm_monitor_get_display_server_data| to get the position */
vec2i size;
uint32_t connector_id; /* Only on x11 and drm */
gsr_monitor_rotation rotation; /* Only on x11 and wayland */
@@ -43,7 +43,7 @@ typedef void (*active_monitor_callback)(const gsr_monitor *monitor, void *userda
void for_each_active_monitor_output_x11_not_cached(Display *display, active_monitor_callback callback, void *userdata);
void for_each_active_monitor_output(const gsr_window *window, const char *card_path, gsr_connection_type connection_type, active_monitor_callback callback, void *userdata);
bool get_monitor_by_name(const gsr_egl *egl, gsr_connection_type connection_type, const char *name, gsr_monitor *monitor);
gsr_monitor_rotation drm_monitor_get_display_server_rotation(const gsr_window *window, const gsr_monitor *monitor);
bool drm_monitor_get_display_server_data(const gsr_window *window, const gsr_monitor *monitor, gsr_monitor_rotation *monitor_rotation, vec2i *monitor_position);
int get_connector_type_by_name(const char *name);
drm_connector_type_count* drm_connector_types_get_index(drm_connector_type_count *type_counts, int *num_type_counts, int connector_type);
@@ -69,4 +69,6 @@ bool vaapi_copy_egl_image_to_video_surface(gsr_egl *egl, EGLImage image, vec2i s
vec2i scale_keep_aspect_ratio(vec2i from, vec2i to);
unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format, int filter);
#endif /* GSR_UTILS_H */

3
meson.build
View File

@@ -1,4 +1,4 @@
project('gpu-screen-recorder', ['c', 'cpp'], version : '5.2.3', default_options : ['warning_level=2'])
project('gpu-screen-recorder', ['c', 'cpp'], version : '5.3.3', default_options : ['warning_level=2'])
add_project_arguments('-Wshadow', language : ['c', 'cpp'])
if get_option('buildtype') == 'debug'
@@ -12,6 +12,7 @@ src = [
'src/capture/capture.c',
'src/capture/nvfbc.c',
'src/capture/xcomposite.c',
'src/capture/ximage.c',
'src/capture/kms.c',
'src/encoder/video/video.c',
'src/encoder/video/nvenc.c',

2
project.conf
View File

@@ -1,7 +1,7 @@
[package]
name = "gpu-screen-recorder"
type = "executable"
version = "5.2.3"
version = "5.3.3"
platforms = ["posix"]
[config]

49
src/capture/kms.c
View File

@@ -14,9 +14,7 @@
#include <xf86drm.h>
#include <libdrm/drm_fourcc.h>
#include <libavcodec/avcodec.h>
#include <libavutil/mastering_display_metadata.h>
#include <libavformat/avformat.h>
#define FIND_CRTC_BY_NAME_TIMEOUT_SECONDS 2.0
@@ -209,7 +207,8 @@ static int gsr_capture_kms_start(gsr_capture *cap, gsr_capture_metadata *capture
}
monitor.name = self->params.display_to_capture;
self->monitor_rotation = drm_monitor_get_display_server_rotation(self->params.egl->window, &monitor);
vec2i monitor_position = {0, 0};
drm_monitor_get_display_server_data(self->params.egl->window, &monitor, &self->monitor_rotation, &monitor_position);
self->capture_pos = monitor.pos;
/* Monitor size is already rotated on x11 when the monitor is rotated, no need to apply it ourselves */
@@ -218,14 +217,16 @@ static int gsr_capture_kms_start(gsr_capture *cap, gsr_capture_metadata *capture
else
self->capture_size = rotate_capture_size_if_rotated(self, monitor.size);
if(self->params.output_resolution.x == 0 && self->params.output_resolution.y == 0) {
self->params.output_resolution = self->capture_size;
capture_metadata->width = FFALIGN(self->capture_size.x, 2);
capture_metadata->height = FFALIGN(self->capture_size.y, 2);
} else {
if(self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0) {
self->params.output_resolution = scale_keep_aspect_ratio(self->capture_size, self->params.output_resolution);
capture_metadata->width = FFALIGN(self->params.output_resolution.x, 2);
capture_metadata->height = FFALIGN(self->params.output_resolution.y, 2);
capture_metadata->width = self->params.output_resolution.x;
capture_metadata->height = self->params.output_resolution.y;
} else if(self->params.region_size.x > 0 && self->params.region_size.y > 0) {
capture_metadata->width = self->params.region_size.x;
capture_metadata->height = self->params.region_size.y;
} else {
capture_metadata->width = self->capture_size.x;
capture_metadata->height = self->capture_size.y;
}
self->fast_path_failed = self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_AMD && !gl_driver_version_greater_than(&self->params.egl->gpu_info, 24, 0, 9);
@@ -448,7 +449,7 @@ static gsr_kms_response_item* find_cursor_drm_if_on_monitor(gsr_capture_kms *sel
return cursor_drm_fd;
}
static void render_drm_cursor(gsr_capture_kms *self, gsr_color_conversion *color_conversion, const gsr_kms_response_item *cursor_drm_fd, vec2i target_pos, float texture_rotation, vec2i output_size) {
static void render_drm_cursor(gsr_capture_kms *self, gsr_color_conversion *color_conversion, const gsr_kms_response_item *cursor_drm_fd, vec2i target_pos, float texture_rotation, vec2i output_size, vec2i framebuffer_size) {
const vec2d scale = {
self->capture_size.x == 0 ? 0 : (double)output_size.x / (double)self->capture_size.x,
self->capture_size.y == 0 ? 0 : (double)output_size.y / (double)self->capture_size.y
@@ -463,25 +464,28 @@ static void render_drm_cursor(gsr_capture_kms *self, gsr_color_conversion *color
break;
case GSR_MONITOR_ROT_90:
cursor_pos = swap_vec2i(cursor_pos);
cursor_pos.x = self->capture_size.x - cursor_pos.x;
cursor_pos.x = framebuffer_size.x - cursor_pos.x;
// TODO: Remove this horrible hack
cursor_pos.x -= cursor_size.x;
break;
case GSR_MONITOR_ROT_180:
cursor_pos.x = self->capture_size.x - cursor_pos.x;
cursor_pos.y = self->capture_size.y - cursor_pos.y;
cursor_pos.x = framebuffer_size.x - cursor_pos.x;
cursor_pos.y = framebuffer_size.y - cursor_pos.y;
// TODO: Remove this horrible hack
cursor_pos.x -= cursor_size.x;
cursor_pos.y -= cursor_size.y;
break;
case GSR_MONITOR_ROT_270:
cursor_pos = swap_vec2i(cursor_pos);
cursor_pos.y = self->capture_size.y - cursor_pos.y;
cursor_pos.y = framebuffer_size.y - cursor_pos.y;
// TODO: Remove this horrible hack
cursor_pos.y -= cursor_size.y;
break;
}
cursor_pos.x -= self->params.region_position.x;
cursor_pos.y -= self->params.region_position.y;
cursor_pos.x *= scale.x;
cursor_pos.y *= scale.y;
@@ -589,7 +593,8 @@ static void gsr_capture_kms_update_connector_ids(gsr_capture_kms *self) {
self->monitor_id.connector_ids[0] = monitor.connector_id;
monitor.name = self->params.display_to_capture;
self->monitor_rotation = drm_monitor_get_display_server_rotation(self->params.egl->window, &monitor);
vec2i monitor_position = {0, 0};
drm_monitor_get_display_server_data(self->params.egl->window, &monitor, &self->monitor_rotation, &monitor_position);
self->capture_pos = monitor.pos;
/* Monitor size is already rotated on x11 when the monitor is rotated, no need to apply it ourselves */
@@ -650,6 +655,8 @@ static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *captu
gsr_capture_kms_fail_fast_path_if_not_fast(self, drm_fd->pixel_format);
self->capture_size = rotate_capture_size_if_rotated(self, (vec2i){ drm_fd->src_w, drm_fd->src_h });
if(self->params.region_size.x > 0 && self->params.region_size.y > 0)
self->capture_size = self->params.region_size;
const bool is_scaled = self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0;
vec2i output_size = is_scaled ? self->params.output_resolution : self->capture_size;
@@ -663,6 +670,9 @@ static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *captu
if(!capture_is_combined_plane)
capture_pos = (vec2i){drm_fd->x, drm_fd->y};
capture_pos.x += self->params.region_position.x;
capture_pos.y += self->params.region_position.y;
self->params.egl->glFlush();
self->params.egl->glFinish();
@@ -706,10 +716,13 @@ static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *captu
// TODO: This doesn't work properly with software cursor on x11 since it will draw the x11 cursor on top of the cursor already in the framebuffer.
// Detect if software cursor is used on x11 somehow.
if(self->is_x11) {
const vec2i cursor_monitor_offset = self->capture_pos;
vec2i cursor_monitor_offset = self->capture_pos;
cursor_monitor_offset.x += self->params.region_position.x;
cursor_monitor_offset.y += self->params.region_position.y;
render_x11_cursor(self, color_conversion, cursor_monitor_offset, target_pos, output_size);
} else if(cursor_drm_fd) {
render_drm_cursor(self, color_conversion, cursor_drm_fd, target_pos, texture_rotation, output_size);
const vec2i framebuffer_size = rotate_capture_size_if_rotated(self, (vec2i){ drm_fd->src_w, drm_fd->src_h });
render_drm_cursor(self, color_conversion, cursor_drm_fd, target_pos, texture_rotation, output_size, framebuffer_size);
}
}

47
src/capture/nvfbc.c
View File

@@ -13,7 +13,6 @@
#include <assert.h>
#include <X11/Xlib.h>
#include <libavcodec/avcodec.h>
typedef struct {
gsr_capture_nvfbc_params params;
@@ -28,8 +27,7 @@ typedef struct {
NVFBC_TOGL_SETUP_PARAMS setup_params;
bool supports_direct_cursor;
bool capture_region;
uint32_t x, y, width, height;
uint32_t width, height;
NVFBC_TRACKING_TYPE tracking_type;
uint32_t output_id;
uint32_t tracking_width, tracking_height;
@@ -223,11 +221,8 @@ static int gsr_capture_nvfbc_setup_handle(gsr_capture_nvfbc *self) {
}
}
if(!self->capture_region) {
self->width = self->tracking_width;
self->height = self->tracking_height;
}
self->width = self->tracking_width;
self->height = self->tracking_height;
return 0;
error_cleanup:
@@ -243,8 +238,6 @@ static int gsr_capture_nvfbc_setup_session(gsr_capture_nvfbc *self) {
create_capture_params.bWithCursor = (!self->params.direct_capture || self->supports_direct_cursor) ? NVFBC_TRUE : NVFBC_FALSE;
if(!self->params.record_cursor)
create_capture_params.bWithCursor = false;
if(self->capture_region)
create_capture_params.captureBox = (NVFBC_BOX){ self->x, self->y, self->width, self->height };
create_capture_params.eTrackingType = self->tracking_type;
create_capture_params.dwSamplingRateMs = (uint32_t)ceilf(1000.0f / (float)self->params.fps);
create_capture_params.bAllowDirectCapture = self->params.direct_capture ? NVFBC_TRUE : NVFBC_FALSE;
@@ -292,13 +285,6 @@ static int gsr_capture_nvfbc_start(gsr_capture *cap, gsr_capture_metadata *captu
if(!gsr_capture_nvfbc_load_library(cap))
return -1;
self->x = max_int(self->params.pos.x, 0);
self->y = max_int(self->params.pos.y, 0);
self->width = max_int(self->params.size.x, 0);
self->height = max_int(self->params.size.y, 0);
self->capture_region = (self->x > 0 || self->y > 0 || self->width > 0 || self->height > 0);
self->supports_direct_cursor = false;
int driver_major_version = 0;
int driver_minor_version = 0;
@@ -331,20 +317,16 @@ static int gsr_capture_nvfbc_start(gsr_capture *cap, gsr_capture_metadata *captu
goto error_cleanup;
}
if(self->capture_region) {
capture_metadata->width = FFALIGN(self->width, 2);
capture_metadata->height = FFALIGN(self->height, 2);
} else {
capture_metadata->width = FFALIGN(self->tracking_width, 2);
capture_metadata->height = FFALIGN(self->tracking_height, 2);
}
capture_metadata->width = self->tracking_width;
capture_metadata->height = self->tracking_height;
if(self->params.output_resolution.x == 0 && self->params.output_resolution.y == 0) {
self->params.output_resolution = (vec2i){capture_metadata->width, capture_metadata->height};
} else {
if(self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0) {
self->params.output_resolution = scale_keep_aspect_ratio((vec2i){capture_metadata->width, capture_metadata->height}, self->params.output_resolution);
capture_metadata->width = FFALIGN(self->params.output_resolution.x, 2);
capture_metadata->height = FFALIGN(self->params.output_resolution.y, 2);
capture_metadata->width = self->params.output_resolution.x;
capture_metadata->height = self->params.output_resolution.y;
} else if(self->params.region_size.x > 0 && self->params.region_size.y > 0) {
capture_metadata->width = self->params.region_size.x;
capture_metadata->height = self->params.region_size.y;
}
return 0;
@@ -380,7 +362,10 @@ static int gsr_capture_nvfbc_capture(gsr_capture *cap, gsr_capture_metadata *cap
}
}
const vec2i frame_size = (vec2i){self->width, self->height};
vec2i frame_size = (vec2i){self->width, self->height};
if(self->params.region_size.x > 0 && self->params.region_size.y > 0)
frame_size = self->params.region_size;
const bool is_scaled = self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0;
vec2i output_size = is_scaled ? self->params.output_resolution : frame_size;
output_size = scale_keep_aspect_ratio(frame_size, output_size);
@@ -410,7 +395,7 @@ static int gsr_capture_nvfbc_capture(gsr_capture *cap, gsr_capture_metadata *cap
gsr_color_conversion_draw(color_conversion, self->setup_params.dwTextures[grab_params.dwTextureIndex],
target_pos, (vec2i){output_size.x, output_size.y},
(vec2i){0, 0}, frame_size,
self->params.region_position, frame_size,
0.0f, false, GSR_SOURCE_COLOR_BGR);
self->params.egl->glFlush();

12
src/capture/portal.c
View File

@@ -8,10 +8,9 @@
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <limits.h>
#include <assert.h>
#include <libavcodec/avcodec.h>
typedef struct {
gsr_capture_portal_params params;
@@ -298,13 +297,12 @@ static int gsr_capture_portal_start(gsr_capture *cap, gsr_capture_metadata *capt
}
if(self->params.output_resolution.x == 0 && self->params.output_resolution.y == 0) {
self->params.output_resolution = self->capture_size;
capture_metadata->width = FFALIGN(self->capture_size.x, 2);
capture_metadata->height = FFALIGN(self->capture_size.y, 2);
capture_metadata->width = self->capture_size.x;
capture_metadata->height = self->capture_size.y;
} else {
self->params.output_resolution = scale_keep_aspect_ratio(self->capture_size, self->params.output_resolution);
capture_metadata->width = FFALIGN(self->params.output_resolution.x, 2);
capture_metadata->height = FFALIGN(self->params.output_resolution.y, 2);
capture_metadata->width = self->params.output_resolution.x;
capture_metadata->height = self->params.output_resolution.y;
}
self->fast_path_failed = self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_AMD && !gl_driver_version_greater_than(&self->params.egl->gpu_info, 24, 0, 9);

12
src/capture/xcomposite.c
View File

@@ -12,9 +12,6 @@
#include <X11/Xlib.h>
#include <libavutil/frame.h>
#include <libavcodec/avcodec.h>
typedef struct {
gsr_capture_xcomposite_params params;
Display *display;
@@ -113,12 +110,11 @@ static int gsr_capture_xcomposite_start(gsr_capture *cap, gsr_capture_metadata *
self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
if(self->params.output_resolution.x == 0 && self->params.output_resolution.y == 0) {
self->params.output_resolution = self->texture_size;
capture_metadata->width = FFALIGN(self->texture_size.x, 2);
capture_metadata->height = FFALIGN(self->texture_size.y, 2);
capture_metadata->width = self->texture_size.x;
capture_metadata->height = self->texture_size.y;
} else {
capture_metadata->width = FFALIGN(self->params.output_resolution.x, 2);
capture_metadata->height = FFALIGN(self->params.output_resolution.y, 2);
capture_metadata->width = self->params.output_resolution.x;
capture_metadata->height = self->params.output_resolution.y;
}
self->fast_path_failed = self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_AMD && !gl_driver_version_greater_than(&self->params.egl->gpu_info, 24, 0, 9);

247
src/capture/ximage.c Normal file
View File

@@ -0,0 +1,247 @@
#include "../../include/capture/ximage.h"
#include "../../include/utils.h"
#include "../../include/cursor.h"
#include "../../include/color_conversion.h"
#include "../../include/window/window.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <X11/Xlib.h>
/* TODO: update when monitors are reconfigured */
typedef struct {
gsr_capture_ximage_params params;
Display *display;
gsr_cursor cursor;
gsr_monitor monitor;
vec2i capture_pos;
vec2i capture_size;
unsigned int texture_id;
Window root_window;
} gsr_capture_ximage;
static void gsr_capture_ximage_stop(gsr_capture_ximage *self) {
gsr_cursor_deinit(&self->cursor);
if(self->texture_id) {
self->params.egl->glDeleteTextures(1, &self->texture_id);
self->texture_id = 0;
}
}
static int max_int(int a, int b) {
return a > b ? a : b;
}
static int gsr_capture_ximage_start(gsr_capture *cap, gsr_capture_metadata *capture_metadata) {
gsr_capture_ximage *self = cap->priv;
self->root_window = DefaultRootWindow(self->display);
if(gsr_cursor_init(&self->cursor, self->params.egl, self->display) != 0) {
gsr_capture_ximage_stop(self);
return -1;
}
if(!get_monitor_by_name(self->params.egl, GSR_CONNECTION_X11, self->params.display_to_capture, &self->monitor)) {
fprintf(stderr, "gsr error: gsr_capture_ximage_start: failed to find monitor by name \"%s\"\n", self->params.display_to_capture);
gsr_capture_ximage_stop(self);
return -1;
}
self->capture_pos = self->monitor.pos;
self->capture_size = self->monitor.size;
if(self->params.region_size.x > 0 && self->params.region_size.y > 0)
self->capture_size = self->params.region_size;
if(self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0) {
self->params.output_resolution = scale_keep_aspect_ratio(self->capture_size, self->params.output_resolution);
capture_metadata->width = self->params.output_resolution.x;
capture_metadata->height = self->params.output_resolution.y;
} else if(self->params.region_size.x > 0 && self->params.region_size.y > 0) {
capture_metadata->width = self->params.region_size.x;
capture_metadata->height = self->params.region_size.y;
} else {
capture_metadata->width = self->capture_size.x;
capture_metadata->height = self->capture_size.y;
}
self->texture_id = gl_create_texture(self->params.egl, self->capture_size.x, self->capture_size.y, GL_RGB8, GL_RGB, GL_LINEAR);
if(self->texture_id == 0) {
fprintf(stderr, "gsr error: gsr_capture_ximage_start: failed to create texture\n");
gsr_capture_ximage_stop(self);
return -1;
}
return 0;
}
static void gsr_capture_ximage_on_event(gsr_capture *cap, gsr_egl *egl) {
gsr_capture_ximage *self = cap->priv;
XEvent *xev = gsr_window_get_event_data(egl->window);
gsr_cursor_on_event(&self->cursor, xev);
}
static bool gsr_capture_ximage_upload_to_texture(gsr_capture_ximage *self, int x, int y, int width, int height) {
const int max_width = XWidthOfScreen(DefaultScreenOfDisplay(self->display));
const int max_height = XHeightOfScreen(DefaultScreenOfDisplay(self->display));
if(x < 0)
x = 0;
else if(x >= max_width)
x = max_width - 1;
if(y < 0)
y = 0;
else if(y >= max_height)
y = max_height - 1;
if(width < 0)
width = 0;
else if(x + width >= max_width)
width = max_width - x;
if(height < 0)
height = 0;
else if(y + height >= max_height)
height = max_height - y;
XImage *image = XGetImage(self->display, self->root_window, x, y, width, height, AllPlanes, ZPixmap);
if(!image) {
fprintf(stderr, "gsr error: gsr_capture_ximage_upload_to_texture: XGetImage failed\n");
return false;
}
bool success = false;
uint8_t *image_data = malloc(image->width * image->height * 3);
if(!image_data) {
fprintf(stderr, "gsr error: gsr_capture_ximage_upload_to_texture: failed to allocate image data\n");
goto done;
}
for(int y = 0; y < image->height; ++y) {
for(int x = 0; x < image->width; ++x) {
unsigned long pixel = XGetPixel(image, x, y);
unsigned char red = (pixel & image->red_mask) >> 16;
unsigned char green = (pixel & image->green_mask) >> 8;
unsigned char blue = pixel & image->blue_mask;
const size_t texture_data_index = (x + y * image->width) * 3;
image_data[texture_data_index + 0] = red;
image_data[texture_data_index + 1] = green;
image_data[texture_data_index + 2] = blue;
}
}
self->params.egl->glBindTexture(GL_TEXTURE_2D, self->texture_id);
self->params.egl->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, image->width, image->height, GL_RGB, GL_UNSIGNED_BYTE, image_data);
self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
success = true;
done:
free(image_data);
XDestroyImage(image);
return success;
}
static int gsr_capture_ximage_capture(gsr_capture *cap, gsr_capture_metadata *capture_metdata, gsr_color_conversion *color_conversion) {
gsr_capture_ximage *self = cap->priv;
const bool is_scaled = self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0;
vec2i output_size = is_scaled ? self->params.output_resolution : self->capture_size;
output_size = scale_keep_aspect_ratio(self->capture_size, output_size);
const vec2i target_pos = { max_int(0, capture_metdata->width / 2 - output_size.x / 2), max_int(0, capture_metdata->height / 2 - output_size.y / 2) };
gsr_capture_ximage_upload_to_texture(self, self->capture_pos.x + self->params.region_position.x, self->capture_pos.y + self->params.region_position.y, self->capture_size.x, self->capture_size.y);
gsr_color_conversion_draw(color_conversion, self->texture_id,
target_pos, output_size,
(vec2i){0, 0}, self->capture_size,
0.0f, false, GSR_SOURCE_COLOR_RGB);
if(self->params.record_cursor && self->cursor.visible) {
const vec2d scale = {
self->capture_size.x == 0 ? 0 : (double)output_size.x / (double)self->capture_size.x,
self->capture_size.y == 0 ? 0 : (double)output_size.y / (double)self->capture_size.y
};
gsr_cursor_tick(&self->cursor, self->root_window);
const vec2i cursor_pos = {
target_pos.x + (self->cursor.position.x - self->cursor.hotspot.x) * scale.x - self->capture_pos.x - self->params.region_position.x,
target_pos.y + (self->cursor.position.y - self->cursor.hotspot.y) * scale.y - self->capture_pos.y - self->params.region_position.y
};
self->params.egl->glEnable(GL_SCISSOR_TEST);
self->params.egl->glScissor(target_pos.x, target_pos.y, output_size.x, output_size.y);
gsr_color_conversion_draw(color_conversion, self->cursor.texture_id,
cursor_pos, (vec2i){self->cursor.size.x * scale.x, self->cursor.size.y * scale.y},
(vec2i){0, 0}, self->cursor.size,
0.0f, false, GSR_SOURCE_COLOR_RGB);
self->params.egl->glDisable(GL_SCISSOR_TEST);
}
self->params.egl->glFlush();
self->params.egl->glFinish();
return 0;
}
static void gsr_capture_ximage_destroy(gsr_capture *cap) {
gsr_capture_ximage *self = cap->priv;
if(cap->priv) {
gsr_capture_ximage_stop(self);
free((void*)self->params.display_to_capture);
self->params.display_to_capture = NULL;
free(self);
cap->priv = NULL;
}
free(cap);
}
gsr_capture* gsr_capture_ximage_create(const gsr_capture_ximage_params *params) {
if(!params) {
fprintf(stderr, "gsr error: gsr_capture_ximage_create params is NULL\n");
return NULL;
}
gsr_capture *cap = calloc(1, sizeof(gsr_capture));
if(!cap)
return NULL;
gsr_capture_ximage *cap_ximage = calloc(1, sizeof(gsr_capture_ximage));
if(!cap_ximage) {
free(cap);
return NULL;
}
const char *display_to_capture = strdup(params->display_to_capture);
if(!display_to_capture) {
free(cap);
free(cap_ximage);
return NULL;
}
cap_ximage->params = *params;
cap_ximage->display = gsr_window_get_display(params->egl->window);
cap_ximage->params.display_to_capture = display_to_capture;
*cap = (gsr_capture) {
.start = gsr_capture_ximage_start,
.on_event = gsr_capture_ximage_on_event,
.tick = NULL,
.should_stop = NULL,
.capture = gsr_capture_ximage_capture,
.uses_external_image = NULL,
.get_window_id = NULL,
.destroy = gsr_capture_ximage_destroy,
.priv = cap_ximage
};
return cap;
}

4
src/egl.c
View File

@@ -288,6 +288,7 @@ static bool gsr_egl_load_gl(gsr_egl *self, void *library) {
{ (void**)&self->glTexParameteriv, "glTexParameteriv" },
{ (void**)&self->glGetTexLevelParameteriv, "glGetTexLevelParameteriv" },
{ (void**)&self->glTexImage2D, "glTexImage2D" },
{ (void**)&self->glTexSubImage2D, "glTexSubImage2D" },
{ (void**)&self->glGetTexImage, "glGetTexImage" },
{ (void**)&self->glGenFramebuffers, "glGenFramebuffers" },
{ (void**)&self->glBindFramebuffer, "glBindFramebuffer" },
@@ -324,6 +325,7 @@ static bool gsr_egl_load_gl(gsr_egl *self, void *library) {
{ (void**)&self->glEnable, "glEnable" },
{ (void**)&self->glDisable, "glDisable" },
{ (void**)&self->glBlendFunc, "glBlendFunc" },
{ (void**)&self->glPixelStorei, "glPixelStorei" },
{ (void**)&self->glGetUniformLocation, "glGetUniformLocation" },
{ (void**)&self->glUniform1f, "glUniform1f" },
{ (void**)&self->glUniform2f, "glUniform2f" },
@@ -448,6 +450,8 @@ bool gsr_egl_load(gsr_egl *self, gsr_window *window, bool is_monitor_capture, bo
self->glEnable(GL_BLEND);
self->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
self->glPixelStorei(GL_PACK_ALIGNMENT, 1);
self->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
if(enable_debug) {
self->glEnable(GL_DEBUG_OUTPUT);

29
src/encoder/video/nvenc.c
View File

@@ -65,21 +65,6 @@ static bool gsr_video_encoder_nvenc_setup_context(gsr_video_encoder_nvenc *self,
return true;
}
static unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format) {
unsigned int texture_id = 0;
egl->glGenTextures(1, &texture_id);
egl->glBindTexture(GL_TEXTURE_2D, texture_id);
egl->glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
egl->glBindTexture(GL_TEXTURE_2D, 0);
return texture_id;
}
static bool cuda_register_opengl_texture(gsr_cuda *cuda, CUgraphicsResource *cuda_graphics_resource, CUarray *mapped_array, unsigned int texture_id) {
CUresult res;
res = cuda->cuGraphicsGLRegisterImage(cuda_graphics_resource, texture_id, GL_TEXTURE_2D, CU_GRAPHICS_REGISTER_FLAGS_NONE);
@@ -110,7 +95,7 @@ static bool gsr_video_encoder_nvenc_setup_textures(gsr_video_encoder_nvenc *self
const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size
for(int i = 0; i < 2; ++i) {
self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i]);
self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i], GL_NEAREST);
if(self->target_textures[i] == 0) {
fprintf(stderr, "gsr error: gsr_video_encoder_nvenc_setup_textures: failed to create opengl texture\n");
return false;
@@ -138,6 +123,18 @@ static bool gsr_video_encoder_nvenc_start(gsr_video_encoder *encoder, AVCodecCon
return false;
}
video_codec_context->width = FFALIGN(video_codec_context->width, 2);
video_codec_context->height = FFALIGN(video_codec_context->height, 2);
if(video_codec_context->width < 128)
video_codec_context->width = 128;
if(video_codec_context->height < 128)
video_codec_context->height = 128;
frame->width = video_codec_context->width;
frame->height = video_codec_context->height;
if(!gsr_video_encoder_nvenc_setup_context(self, video_codec_context)) {
gsr_video_encoder_nvenc_stop(self, video_codec_context);
return false;

18
src/encoder/video/software.c
View File

@@ -1,5 +1,6 @@
#include "../../../include/encoder/video/software.h"
#include "../../../include/egl.h"
#include "../../../include/utils.h"
#include <libavcodec/avcodec.h>
#include <libavutil/frame.h>
@@ -14,21 +15,6 @@ typedef struct {
unsigned int target_textures[2];
} gsr_video_encoder_software;
static unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format) {
unsigned int texture_id = 0;
egl->glGenTextures(1, &texture_id);
egl->glBindTexture(GL_TEXTURE_2D, texture_id);
egl->glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
egl->glBindTexture(GL_TEXTURE_2D, 0);
return texture_id;
}
static bool gsr_video_encoder_software_setup_textures(gsr_video_encoder_software *self, AVCodecContext *video_codec_context, AVFrame *frame) {
int res = av_frame_get_buffer(frame, LINESIZE_ALIGNMENT);
if(res < 0) {
@@ -48,7 +34,7 @@ static bool gsr_video_encoder_software_setup_textures(gsr_video_encoder_software
const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size
for(int i = 0; i < 2; ++i) {
self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i]);
self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i], GL_NEAREST);
if(self->target_textures[i] == 0) {
fprintf(stderr, "gsr error: gsr_capture_kms_setup_cuda_textures: failed to create opengl texture\n");
return false;

31
src/encoder/video/vaapi.c
View File

@@ -167,32 +167,21 @@ static bool gsr_video_encoder_vaapi_start(gsr_video_encoder *encoder, AVCodecCon
} else {
video_codec_context->height = FFALIGN(video_codec_context->height, 16);
}
} else {
video_codec_context->width = FFALIGN(video_codec_context->width, 2);
video_codec_context->height = FFALIGN(video_codec_context->height, 2);
}
const int crop_top = (video_codec_context->height - frame->height) / 2;
const int crop_left = (video_codec_context->width - frame->width) / 2;
if(crop_top != 0 || crop_left != 0) {
if(FFALIGN(video_codec_context->width, 2) != FFALIGN(frame->width, 2) || FFALIGN(video_codec_context->height, 2) != FFALIGN(frame->height, 2)) {
fprintf(stderr, "gsr warning: gsr_video_encoder_vaapi_start: black bars have been added to the video because of a bug in AMD drivers/hardware. Record with h264 codec instead (-k h264) to get around this issue\n");
#if 0
#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(61, 10, 100)
const int crop_bottom = crop_top;
const int crop_right = crop_left;
fprintf(stderr, "gsr info: cropping metadata has been added to the file to try and workaround this issue. Video players that support this will remove the black bars when the video is playing\n");
const int frame_cropping_data_size = 4 * sizeof(uint32_t);
uint8_t *frame_cropping = av_malloc(frame_cropping_data_size);
if(frame_cropping) {
AV_WL32(frame_cropping + 0, crop_top);
AV_WL32(frame_cropping + 4, crop_bottom);
AV_WL32(frame_cropping + 8, crop_left);
AV_WL32(frame_cropping + 12, crop_right);
const bool sidedata_added = av_packet_side_data_add(&video_stream->codecpar->coded_side_data, &video_stream->codecpar->nb_coded_side_data, AV_PKT_DATA_FRAME_CROPPING, frame_cropping, frame_cropping_data_size, 0) != NULL;
if(!sidedata_added)
av_free(frame_cropping);
}
#endif
#endif
}
if(video_codec_context->width < 128)
video_codec_context->width = 128;
if(video_codec_context->height < 128)
video_codec_context->height = 128;
frame->width = video_codec_context->width;
frame->height = video_codec_context->height;

30
src/encoder/video/vulkan.c
View File

@@ -71,22 +71,6 @@ static bool gsr_video_encoder_vulkan_setup_context(gsr_video_encoder_vulkan *sel
return true;
}
static unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format) {
unsigned int texture_id = 0;
egl->glGenTextures(1, &texture_id);
egl->glBindTexture(GL_TEXTURE_2D, texture_id);
//egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_TILING_EXT, GL_OPTIMAL_TILING_EXT);
egl->glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
egl->glBindTexture(GL_TEXTURE_2D, 0);
return texture_id;
}
static AVVulkanDeviceContext* video_codec_context_get_vulkan_data(AVCodecContext *video_codec_context) {
AVBufferRef *hw_frames_ctx = video_codec_context->hw_frames_ctx;
if(!hw_frames_ctx)
@@ -116,7 +100,7 @@ static bool gsr_video_encoder_vulkan_setup_textures(gsr_video_encoder_vulkan *se
const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size
for(int i = 0; i < 2; ++i) {
self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i]);
self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i], GL_NEAREST);
if(self->target_textures[i] == 0) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_setup_textures: failed to create opengl texture\n");
return false;
@@ -165,6 +149,18 @@ static void gsr_video_encoder_vulkan_stop(gsr_video_encoder_vulkan *self, AVCode
static bool gsr_video_encoder_vulkan_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) {
gsr_video_encoder_vulkan *self = encoder->priv;
video_codec_context->width = FFALIGN(video_codec_context->width, 2);
video_codec_context->height = FFALIGN(video_codec_context->height, 2);
if(video_codec_context->width < 128)
video_codec_context->width = 128;
if(video_codec_context->height < 128)
video_codec_context->height = 128;
frame->width = video_codec_context->width;
frame->height = video_codec_context->height;
if(!gsr_video_encoder_vulkan_setup_context(self, video_codec_context)) {
gsr_video_encoder_vulkan_stop(self, video_codec_context);
return false;

77
src/image_writer.c
View File

@@ -1,5 +1,6 @@
#include "../include/image_writer.h"
#include "../include/egl.h"
#include "../include/utils.h"
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "../external/stb_image_write.h"
@@ -9,29 +10,14 @@
#include <stdio.h>
#include <assert.h>
static unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format) {
unsigned int texture_id = 0;
egl->glGenTextures(1, &texture_id);
egl->glBindTexture(GL_TEXTURE_2D, texture_id);
egl->glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
egl->glBindTexture(GL_TEXTURE_2D, 0);
return texture_id;
}
/* TODO: Support hdr/10-bit */
bool gsr_image_writer_init(gsr_image_writer *self, gsr_image_writer_source source, gsr_egl *egl, int width, int height) {
assert(source == GSR_IMAGE_WRITER_SOURCE_OPENGL);
self->source = source;
bool gsr_image_writer_init_opengl(gsr_image_writer *self, gsr_egl *egl, int width, int height) {
memset(self, 0, sizeof(*self));
self->source = GSR_IMAGE_WRITER_SOURCE_OPENGL;
self->egl = egl;
self->width = width;
self->height = height;
self->texture = gl_create_texture(self->egl, self->width, self->height, GL_RGB8, GL_RGB); /* TODO: use GL_RGB16 instead of GL_RGB8 for hdr/10-bit */
self->texture = gl_create_texture(self->egl, self->width, self->height, GL_RGB8, GL_RGB, GL_NEAREST); /* TODO: use GL_RGB16 instead of GL_RGB8 for hdr/10-bit */
if(self->texture == 0) {
fprintf(stderr, "gsr error: gsr_image_writer_init: failed to create texture\n");
return false;
@@ -39,6 +25,15 @@ bool gsr_image_writer_init(gsr_image_writer *self, gsr_image_writer_source sourc
return true;
}
bool gsr_image_writer_init_memory(gsr_image_writer *self, const void *memory, int width, int height) {
memset(self, 0, sizeof(*self));
self->source = GSR_IMAGE_WRITER_SOURCE_OPENGL;
self->width = width;
self->height = height;
self->memory = memory;
return true;
}
void gsr_image_writer_deinit(gsr_image_writer *self) {
if(self->texture) {
self->egl->glDeleteTextures(1, &self->texture);
@@ -46,12 +41,30 @@ void gsr_image_writer_deinit(gsr_image_writer *self) {
}
}
bool gsr_image_writer_write_to_file(gsr_image_writer *self, const char *filepath, gsr_image_format image_format, int quality) {
static bool gsr_image_writer_write_memory_to_file(gsr_image_writer *self, const char *filepath, gsr_image_format image_format, int quality, const void *data) {
if(quality < 1)
quality = 1;
else if(quality > 100)
quality = 100;
bool success = false;
switch(image_format) {
case GSR_IMAGE_FORMAT_JPEG:
success = stbi_write_jpg(filepath, self->width, self->height, 3, data, quality);
break;
case GSR_IMAGE_FORMAT_PNG:
success = stbi_write_png(filepath, self->width, self->height, 3, data, 0);
break;
}
if(!success)
fprintf(stderr, "gsr error: gsr_image_writer_write_to_file: failed to write image data to output file %s\n", filepath);
return success;
}
static bool gsr_image_writer_write_opengl_texture_to_file(gsr_image_writer *self, const char *filepath, gsr_image_format image_format, int quality) {
assert(self->source == GSR_IMAGE_WRITER_SOURCE_OPENGL);
uint8_t *frame_data = malloc(self->width * self->height * 3);
if(!frame_data) {
fprintf(stderr, "gsr error: gsr_image_writer_write_to_file: failed to allocate memory for image frame\n");
@@ -67,19 +80,17 @@ bool gsr_image_writer_write_to_file(gsr_image_writer *self, const char *filepath
self->egl->glFlush();
self->egl->glFinish();
bool success = false;
switch(image_format) {
case GSR_IMAGE_FORMAT_JPEG:
success = stbi_write_jpg(filepath, self->width, self->height, 3, frame_data, quality);
break;
case GSR_IMAGE_FORMAT_PNG:
success = stbi_write_png(filepath, self->width, self->height, 3, frame_data, 0);
break;
}
if(!success)
fprintf(stderr, "gsr error: gsr_image_writer_write_to_file: failed to write image data to output file %s\n", filepath);
const bool success = gsr_image_writer_write_memory_to_file(self, filepath, image_format, quality, frame_data);
free(frame_data);
return success;
}
bool gsr_image_writer_write_to_file(gsr_image_writer *self, const char *filepath, gsr_image_format image_format, int quality) {
switch(self->source) {
case GSR_IMAGE_WRITER_SOURCE_OPENGL:
return gsr_image_writer_write_opengl_texture_to_file(self, filepath, image_format, quality);
case GSR_IMAGE_WRITER_SOURCE_MEMORY:
return gsr_image_writer_write_memory_to_file(self, filepath, image_format, quality, self->memory);
}
return false;
}

317
src/main.cpp
View File

@@ -1,6 +1,7 @@
extern "C" {
#include "../include/capture/nvfbc.h"
#include "../include/capture/xcomposite.h"
#include "../include/capture/ximage.h"
#include "../include/capture/kms.h"
#ifdef GSR_PORTAL
#include "../include/capture/portal.h"
@@ -74,19 +75,52 @@ static const int VIDEO_STREAM_INDEX = 0;
static thread_local char av_error_buffer[AV_ERROR_MAX_STRING_SIZE];
typedef struct {
const gsr_window *window;
} MonitorOutputCallbackUserdata;
static void monitor_output_callback_print(const gsr_monitor *monitor, void *userdata) {
(void)userdata;
fprintf(stderr, " \"%.*s\" (%dx%d+%d+%d)\n", monitor->name_len, monitor->name, monitor->size.x, monitor->size.y, monitor->pos.x, monitor->pos.y);
const MonitorOutputCallbackUserdata *options = (MonitorOutputCallbackUserdata*)userdata;
vec2i monitor_position = monitor->pos;
if(gsr_window_get_display_server(options->window) == GSR_DISPLAY_SERVER_WAYLAND) {
gsr_monitor_rotation monitor_rotation = GSR_MONITOR_ROT_0;
drm_monitor_get_display_server_data(options->window, monitor, &monitor_rotation, &monitor_position);
}
fprintf(stderr, " \"%.*s\" (%dx%d+%d+%d)\n", monitor->name_len, monitor->name, monitor->size.x, monitor->size.y, monitor_position.x, monitor_position.y);
}
typedef struct {
const char *output_name;
char *output_name;
} FirstOutputCallback;
static void get_first_output(const gsr_monitor *monitor, void *userdata) {
FirstOutputCallback *first_output = (FirstOutputCallback*)userdata;
if(!first_output->output_name)
first_output->output_name = strndup(monitor->name, monitor->name_len + 1);
static void get_first_output_callback(const gsr_monitor *monitor, void *userdata) {
FirstOutputCallback *data = (FirstOutputCallback*)userdata;
if(!data->output_name)
data->output_name = strdup(monitor->name);
}
typedef struct {
gsr_window *window;
vec2i position;
char *output_name;
vec2i monitor_pos;
vec2i monitor_size;
} MonitorByPositionCallback;
static void get_monitor_by_position_callback(const gsr_monitor *monitor, void *userdata) {
MonitorByPositionCallback *data = (MonitorByPositionCallback*)userdata;
gsr_monitor_rotation monitor_rotation = GSR_MONITOR_ROT_0;
vec2i monitor_position = monitor->pos;
drm_monitor_get_display_server_data(data->window, monitor, &monitor_rotation, &monitor_position);
if(!data->output_name && data->position.x >= monitor_position.x && data->position.x <= monitor_position.x + monitor->size.x
&& data->position.y >= monitor_position.y && data->position.y <= monitor_position.y + monitor->size.y)
{
data->output_name = strdup(monitor->name);
data->monitor_pos = monitor_position;
data->monitor_size = monitor->size;
}
}
static char* av_error_to_string(int err) {
@@ -743,7 +777,7 @@ static void dict_set_profile(AVCodecContext *codec_context, gsr_gpu_vendor vendo
//if(color_depth == GSR_COLOR_DEPTH_10_BITS)
// av_dict_set_int(options, "profile", AV_PROFILE_H264_HIGH_10, 0);
//else
av_dict_set_int(options, "profile", AV_PROFILE_H264_HIGH, 0);
av_dict_set_int(options, "profile", vendor == GSR_GPU_VENDOR_NVIDIA ? 2 : AV_PROFILE_H264_HIGH, 0);
} else if(codec_context->codec_id == AV_CODEC_ID_AV1) {
if(vendor == GSR_GPU_VENDOR_NVIDIA) {
if(color_depth == GSR_COLOR_DEPTH_10_BITS)
@@ -753,9 +787,9 @@ static void dict_set_profile(AVCodecContext *codec_context, gsr_gpu_vendor vendo
}
} else if(codec_context->codec_id == AV_CODEC_ID_HEVC) {
if(color_depth == GSR_COLOR_DEPTH_10_BITS)
av_dict_set_int(options, "profile", AV_PROFILE_HEVC_MAIN_10, 0);
av_dict_set_int(options, "profile", vendor == GSR_GPU_VENDOR_NVIDIA ? 1 : AV_PROFILE_HEVC_MAIN_10, 0);
else
av_dict_set_int(options, "profile", AV_PROFILE_HEVC_MAIN, 0);
av_dict_set_int(options, "profile", vendor == GSR_GPU_VENDOR_NVIDIA ? 0 : AV_PROFILE_HEVC_MAIN, 0);
}
#endif
}
@@ -1070,7 +1104,7 @@ static void open_video_hardware(AVCodecContext *codec_context, VideoQuality vide
static void usage_header() {
const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
const char *program_name = inside_flatpak ? "flatpak run --command=gpu-screen-recorder com.dec05eba.gpu_screen_recorder" : "gpu-screen-recorder";
printf("usage: %s -w <window_id|monitor|focused|portal> [-c <container_format>] [-s WxH] [-f <fps>] [-a <audio_input>] [-q <quality>] [-r <replay_buffer_size_sec>] [-restart-replay-on-save yes|no] [-k h264|hevc|av1|vp8|vp9|hevc_hdr|av1_hdr|hevc_10bit|av1_10bit] [-ac aac|opus|flac] [-ab <bitrate>] [-oc yes|no] [-fm cfr|vfr|content] [-bm auto|qp|vbr|cbr] [-cr limited|full] [-df yes|no] [-sc <script_path>] [-cursor yes|no] [-keyint <value>] [-restore-portal-session yes|no] [-portal-session-token-filepath filepath] [-encoder gpu|cpu] [-o <output_file>] [--list-capture-options [card_path] [vendor]] [--list-audio-devices] [--list-application-audio] [-v yes|no] [-gl-debug yes|no] [--version] [-h|--help]\n", program_name);
printf("usage: %s -w <window_id|monitor|focused|portal|region> [-c <container_format>] [-s WxH] [-region WxH+X+Y] [-f <fps>] [-a <audio_input>] [-q <quality>] [-r <replay_buffer_size_sec>] [-restart-replay-on-save yes|no] [-k h264|hevc|av1|vp8|vp9|hevc_hdr|av1_hdr|hevc_10bit|av1_10bit] [-ac aac|opus|flac] [-ab <bitrate>] [-oc yes|no] [-fm cfr|vfr|content] [-bm auto|qp|vbr|cbr] [-cr limited|full] [-df yes|no] [-sc <script_path>] [-cursor yes|no] [-keyint <value>] [-restore-portal-session yes|no] [-portal-session-token-filepath filepath] [-encoder gpu|cpu] [-o <output_file>] [--list-capture-options [card_path] [vendor]] [--list-audio-devices] [--list-application-audio] [-v yes|no] [-gl-debug yes|no] [--version] [-h|--help]\n", program_name);
fflush(stdout);
}
@@ -1081,10 +1115,11 @@ static void usage_full() {
usage_header();
printf("\n");
printf("OPTIONS:\n");
printf(" -w Window id to record, a display (monitor name), \"screen\", \"screen-direct\", \"focused\" or \"portal\".\n");
printf(" -w Window id to record, a display (monitor name), \"screen\", \"screen-direct\", \"focused\", \"portal\" or \"region\".\n");
printf(" If this is \"portal\" then xdg desktop screencast portal with PipeWire will be used. Portal option is only available on Wayland.\n");
printf(" If you select to save the session (token) in the desktop portal capture popup then the session will be saved for the next time you use \"portal\",\n");
printf(" but the session will be ignored unless you run GPU Screen Recorder with the '-restore-portal-session yes' option.\n");
printf(" If this is \"region\" then the region specified by the -region option is recorded.\n");
printf(" If this is \"screen\" then the first monitor found is recorded.\n");
printf(" \"screen-direct\" can only be used on Nvidia X11, to allow recording without breaking VRR (G-SYNC). This also records all of your monitors.\n");
printf(" Using this \"screen-direct\" option is not recommended unless you use VRR (G-SYNC) as there are Nvidia driver issues that can cause your system or games to freeze/crash.\n");
@@ -1099,6 +1134,11 @@ static void usage_full() {
printf(" Note: the captured content is scaled to this size. The output resolution might not be exactly as specified by this option. The original aspect ratio is respected so the resolution will match that.\n");
printf(" The video encoder might also need to add padding, which will result in black bars on the sides of the video. This is especially an issue on AMD.\n");
printf("\n");
printf(" -region\n");
printf(" The region to capture, only to be used with -w region. This is in format WxH+X+Y, which is compatible with tools such as slop (X11) and slurp (kde plasma, wlroots and hyprland).\n");
printf(" The region can be inside any monitor. If width and height are 0 (for example 0x0+500+500) then the entire monitor that the region is inside in will be recorded.\n");
printf(" Note: currently the region can't span multiple monitors.\n");
printf("\n");
printf(" -f Frame rate to record at. Recording will only capture frames at this target frame rate.\n");
printf(" For constant frame rate mode this option is the frame rate every frame will be captured at and if the capture frame rate is below this target frame rate then the frames will be duplicated.\n");
printf(" For variable frame rate mode this option is the max frame rate and if the capture frame rate is below this target frame rate then frames will not be duplicated.\n");
@@ -1184,7 +1224,8 @@ static void usage_full() {
printf(" By default this value is set to 2.0.\n");
printf("\n");
printf(" -restore-portal-session\n");
printf(" If GPU Screen Recorder should use the same capture option as the last time. Using this option removes the popup asking what you want to record the next time you record with '-w portal' if you selected the option to save session (token) in the desktop portal screencast popup.\n");
printf(" If GPU Screen Recorder should use the same capture option as the last time. Using this option removes the popup asking what you want to record the next time you record with '-w portal'\n");
printf(" if you selected the option to save session (token) in the desktop portal screencast popup.\n");
printf(" This option may not have any effect on your Wayland compositor and your systems desktop portal needs to support ScreenCast version 5 or later. Optional, set to 'no' by default.\n");
printf("\n");
printf(" -portal-session-token-filepath\n");
@@ -1249,18 +1290,21 @@ static void usage_full() {
printf(" Send signal SIGUSR2 to gpu-screen-recorder (killall -SIGUSR2 gpu-screen-recorder) to pause/unpause recording. Only applicable and useful when recording (not streaming nor replay).\n");
printf("\n");
printf("EXAMPLES:\n");
printf(" %s -w screen -f 60 -a default_output -o \"$HOME/Videos/video.mp4\"\n", program_name);
printf(" %s -w screen -f 60 -a default_output -a default_input -o \"$HOME/Videos/video.mp4\"\n", program_name);
printf(" %s -w screen -f 60 -a \"default_output|default_input\" -o \"$HOME/Videos/video.mp4\"\n", program_name);
printf(" %s -w screen -f 60 -a default_output -o video.mp4\n", program_name);
printf(" %s -w screen -f 60 -a default_output -a default_input -o video.mp4\n", program_name);
printf(" %s -w screen -f 60 -a \"default_output|default_input\" -o video.mp4\n", program_name);
printf(" %s -w screen -f 60 -a default_output -c mkv -r 60 -o \"$HOME/Videos\"\n", program_name);
printf(" %s -w screen -f 60 -a default_output -c mkv -sc script.sh -r 60 -o \"$HOME/Videos\"\n", program_name);
printf(" %s -w portal -f 60 -a default_output -restore-portal-session yes -o \"$HOME/Videos/video.mp4\"\n", program_name);
printf(" %s -w screen -f 60 -a default_output -bm cbr -q 15000 -o \"$HOME/Videos/video.mp4\"\n", program_name);
printf(" %s -w screen -f 60 -a \"app:firefox|app:csgo\" -o \"$HOME/Videos/video.mp4\"\n", program_name);
printf(" %s -w screen -f 60 -a \"app-inverse:firefox|app-inverse:csgo\" -o \"$HOME/Videos/video.mp4\"\n", program_name);
printf(" %s -w screen -f 60 -a \"default-input|app-inverse:Brave\" -o \"$HOME/Videos/video.mp4\"\n", program_name);
printf(" %s -w screen -o \"$HOME/Pictures/image.jpg\"\n", program_name);
printf(" %s -w screen -q medium -o \"$HOME/Pictures/image.jpg\"\n", program_name);
printf(" %s -w portal -f 60 -a default_output -restore-portal-session yes -o video.mp4\n", program_name);
printf(" %s -w screen -f 60 -a default_output -bm cbr -q 15000 -o video.mp4\n", program_name);
printf(" %s -w screen -f 60 -a \"app:firefox|app:csgo\" -o video.mp4\n", program_name);
printf(" %s -w screen -f 60 -a \"app-inverse:firefox|app-inverse:csgo\" -o video.mp4\n", program_name);
printf(" %s -w screen -f 60 -a \"default-input|app-inverse:Brave\" -o video.mp4\n", program_name);
printf(" %s -w screen -o image.jpg\n", program_name);
printf(" %s -w screen -q medium -o image.jpg\n", program_name);
printf(" %s -w region -region 640x480+100+100 -o video.mp4\n", program_name);
printf(" %s -w region -region $(slop) -o video.mp4\n", program_name);
printf(" %s -w region -region $(slurp -f \"%%wx%%h+%%x+%%y\") -o video.mp4\n", program_name);
//fprintf(stderr, " gpu-screen-recorder -w screen -f 60 -q ultra -pixfmt yuv444 -o video.mp4\n");
fflush(stdout);
_exit(1);
@@ -2097,8 +2141,10 @@ static void output_monitor_info(const gsr_monitor *monitor, void *userdata) {
const capture_options_callback *options = (capture_options_callback*)userdata;
if(gsr_window_get_display_server(options->window) == GSR_DISPLAY_SERVER_WAYLAND) {
vec2i monitor_size = monitor->size;
const gsr_monitor_rotation rot = drm_monitor_get_display_server_rotation(options->window, monitor);
if(rot == GSR_MONITOR_ROT_90 || rot == GSR_MONITOR_ROT_270)
gsr_monitor_rotation monitor_rotation = GSR_MONITOR_ROT_0;
vec2i monitor_position = {0, 0};
drm_monitor_get_display_server_data(options->window, monitor, &monitor_rotation, &monitor_position);
if(monitor_rotation == GSR_MONITOR_ROT_90 || monitor_rotation == GSR_MONITOR_ROT_270)
std::swap(monitor_size.x, monitor_size.y);
printf("%.*s|%dx%d\n", monitor->name_len, monitor->name, monitor_size.x, monitor_size.y);
} else {
@@ -2112,6 +2158,7 @@ static void list_supported_capture_options(const gsr_window *window, const char
puts("window");
puts("focused");
}
puts("region");
if(list_monitors) {
capture_options_callback options;
@@ -2333,12 +2380,13 @@ static void validate_monitor_get_valid(const gsr_egl *egl, std::string &window_s
const bool capture_use_drm = monitor_capture_use_drm(egl->window, egl->gpu_info.vendor);
if(strcmp(window_str.c_str(), "screen") == 0) {
FirstOutputCallback first_output;
first_output.output_name = NULL;
for_each_active_monitor_output(egl->window, egl->card_path, connection_type, get_first_output, &first_output);
FirstOutputCallback data;
data.output_name = NULL;
for_each_active_monitor_output(egl->window, egl->card_path, connection_type, get_first_output_callback, &data);
if(first_output.output_name) {
window_str = first_output.output_name;
if(data.output_name) {
window_str = data.output_name;
free(data.output_name);
} else {
fprintf(stderr, "Error: no usable output found\n");
_exit(51);
@@ -2347,18 +2395,111 @@ static void validate_monitor_get_valid(const gsr_egl *egl, std::string &window_s
gsr_monitor gmon;
if(!get_monitor_by_name(egl, connection_type, window_str.c_str(), &gmon)) {
fprintf(stderr, "gsr error: display \"%s\" not found, expected one of:\n", window_str.c_str());
fprintf(stderr, " \"screen\"\n");
fprintf(stderr, " \"screen\"\n");
if(!capture_use_drm)
fprintf(stderr, " \"screen-direct\"\n");
for_each_active_monitor_output(egl->window, egl->card_path, connection_type, monitor_output_callback_print, NULL);
fprintf(stderr, " \"screen-direct\"\n");
MonitorOutputCallbackUserdata userdata;
userdata.window = egl->window;
for_each_active_monitor_output(egl->window, egl->card_path, connection_type, monitor_output_callback_print, &userdata);
_exit(51);
}
}
}
static gsr_capture* create_capture_impl(std::string &window_str, vec2i output_resolution, bool wayland, gsr_egl *egl, int fps, bool hdr, gsr_color_range color_range,
bool record_cursor, bool restore_portal_session, const char *portal_session_token_filepath,
gsr_color_depth color_depth)
static std::string get_monitor_by_region_center(const gsr_egl *egl, vec2i region_position, vec2i region_size, vec2i *monitor_pos, vec2i *monitor_size) {
const bool is_x11 = gsr_window_get_display_server(egl->window) == GSR_DISPLAY_SERVER_X11;
const gsr_connection_type connection_type = is_x11 ? GSR_CONNECTION_X11 : GSR_CONNECTION_DRM;
MonitorByPositionCallback data;
data.window = egl->window;
data.position = { region_position.x + region_size.x / 2, region_position.y + region_size.y / 2 };
data.output_name = NULL;
data.monitor_pos = {0, 0};
data.monitor_size = {0, 0};
for_each_active_monitor_output(egl->window, egl->card_path, connection_type, get_monitor_by_position_callback, &data);
std::string result;
if(data.output_name) {
result = data.output_name;
free(data.output_name);
}
*monitor_pos = data.monitor_pos;
*monitor_size = data.monitor_size;
return result;
}
static gsr_capture* create_monitor_capture(const std::string &window_str, vec2i output_resolution, vec2i region_size, vec2i region_position, gsr_egl *egl, int fps, bool hdr, bool record_cursor, bool prefer_ximage) {
if(gsr_window_get_display_server(egl->window) == GSR_DISPLAY_SERVER_X11 && prefer_ximage) {
gsr_capture_ximage_params ximage_params;
ximage_params.egl = egl;
ximage_params.display_to_capture = window_str.c_str();
ximage_params.record_cursor = record_cursor;
ximage_params.output_resolution = output_resolution;
ximage_params.region_size = region_size;
ximage_params.region_position = region_position;
return gsr_capture_ximage_create(&ximage_params);
}
if(monitor_capture_use_drm(egl->window, egl->gpu_info.vendor)) {
gsr_capture_kms_params kms_params;
kms_params.egl = egl;
kms_params.display_to_capture = window_str.c_str();
kms_params.record_cursor = record_cursor;
kms_params.hdr = hdr;
kms_params.fps = fps;
kms_params.output_resolution = output_resolution;
kms_params.region_size = region_size;
kms_params.region_position = region_position;
return gsr_capture_kms_create(&kms_params);
} else {
const char *capture_target = window_str.c_str();
const bool direct_capture = strcmp(window_str.c_str(), "screen-direct") == 0 || strcmp(window_str.c_str(), "screen-direct-force") == 0;
if(direct_capture) {
capture_target = "screen";
fprintf(stderr, "Warning: %s capture option is not recommended unless you use G-SYNC as Nvidia has driver issues that can cause your system or games to freeze/crash.\n", window_str.c_str());
}
gsr_capture_nvfbc_params nvfbc_params;
nvfbc_params.egl = egl;
nvfbc_params.display_to_capture = capture_target;
nvfbc_params.fps = fps;
nvfbc_params.direct_capture = direct_capture;
nvfbc_params.record_cursor = record_cursor;
nvfbc_params.output_resolution = output_resolution;
nvfbc_params.region_size = region_size;
nvfbc_params.region_position = region_position;
return gsr_capture_nvfbc_create(&nvfbc_params);
}
}
static void region_get_data(std::string &window_str, gsr_egl *egl, vec2i *region_size, vec2i *region_position) {
vec2i monitor_pos = {0, 0};
vec2i monitor_size = {0, 0};
window_str = get_monitor_by_region_center(egl, *region_position, *region_size, &monitor_pos, &monitor_size);
if(window_str.empty()) {
const bool is_x11 = gsr_window_get_display_server(egl->window) == GSR_DISPLAY_SERVER_X11;
const gsr_connection_type connection_type = is_x11 ? GSR_CONNECTION_X11 : GSR_CONNECTION_DRM;
fprintf(stderr, "Error: the region %dx%d+%d+%d doesn't match any monitor. Available monitors and their regions:\n", region_size->x, region_size->y, region_position->x, region_position->y);
MonitorOutputCallbackUserdata userdata;
userdata.window = egl->window;
for_each_active_monitor_output(egl->window, egl->card_path, connection_type, monitor_output_callback_print, &userdata);
_exit(51);
}
// Capture whole monitor when region size is set to 0x0
if(region_size->x == 0 && region_size->y == 0) {
region_position->x = 0;
region_position->y = 0;
} else {
region_position->x -= monitor_pos.x;
region_position->y -= monitor_pos.y;
}
}
static gsr_capture* create_capture_impl(std::string &window_str, vec2i output_resolution, vec2i region_size, vec2i region_position, bool wayland, gsr_egl *egl, int fps, bool hdr,
bool record_cursor, bool restore_portal_session, const char *portal_session_token_filepath, bool prefer_ximage)
{
Window src_window_id = None;
bool follow_focused = false;
@@ -2386,8 +2527,6 @@ static gsr_capture* create_capture_impl(std::string &window_str, vec2i output_re
gsr_capture_portal_params portal_params;
portal_params.egl = egl;
portal_params.color_depth = color_depth;
portal_params.color_range = color_range;
portal_params.record_cursor = record_cursor;
portal_params.restore_portal_session = restore_portal_session;
portal_params.portal_session_token_filepath = portal_session_token_filepath;
@@ -2399,44 +2538,16 @@ static gsr_capture* create_capture_impl(std::string &window_str, vec2i output_re
fprintf(stderr, "Error: option '-w portal' used but GPU Screen Recorder was compiled without desktop portal support. Please recompile GPU Screen recorder with the -Dportal=true option\n");
_exit(2);
#endif
} else if(strcmp(window_str.c_str(), "region") == 0) {
region_get_data(window_str, egl, &region_size, &region_position);
capture = create_monitor_capture(window_str, output_resolution, region_size, region_position, egl, fps, hdr, record_cursor, prefer_ximage);
if(!capture)
_exit(1);
} else if(contains_non_hex_number(window_str.c_str())) {
validate_monitor_get_valid(egl, window_str);
if(!monitor_capture_use_drm(egl->window, egl->gpu_info.vendor)) {
const char *capture_target = window_str.c_str();
const bool direct_capture = strcmp(window_str.c_str(), "screen-direct") == 0 || strcmp(window_str.c_str(), "screen-direct-force") == 0;
if(direct_capture) {
capture_target = "screen";
fprintf(stderr, "Warning: %s capture option is not recommended unless you use G-SYNC as Nvidia has driver issues that can cause your system or games to freeze/crash.\n", window_str.c_str());
}
gsr_capture_nvfbc_params nvfbc_params;
nvfbc_params.egl = egl;
nvfbc_params.display_to_capture = capture_target;
nvfbc_params.fps = fps;
nvfbc_params.pos = { 0, 0 };
nvfbc_params.size = { 0, 0 };
nvfbc_params.direct_capture = direct_capture;
nvfbc_params.color_depth = color_depth;
nvfbc_params.color_range = color_range;
nvfbc_params.record_cursor = record_cursor;
nvfbc_params.output_resolution = output_resolution;
capture = gsr_capture_nvfbc_create(&nvfbc_params);
if(!capture)
_exit(1);
} else {
gsr_capture_kms_params kms_params;
kms_params.egl = egl;
kms_params.display_to_capture = window_str.c_str();
kms_params.color_depth = color_depth;
kms_params.color_range = color_range;
kms_params.record_cursor = record_cursor;
kms_params.hdr = hdr;
kms_params.fps = fps;
kms_params.output_resolution = output_resolution;
capture = gsr_capture_kms_create(&kms_params);
if(!capture)
_exit(1);
}
capture = create_monitor_capture(window_str, output_resolution, region_size, region_position, egl, fps, hdr, record_cursor, prefer_ximage);
if(!capture)
_exit(1);
} else {
if(wayland) {
fprintf(stderr, "Error: GPU Screen Recorder window capture only works in a pure X11 session. Xwayland is not supported. You can record a monitor instead on wayland or use -w portal option which supports window capture if your wayland compositor supports window capture\n");
@@ -2456,9 +2567,7 @@ static gsr_capture* create_capture_impl(std::string &window_str, vec2i output_re
xcomposite_params.egl = egl;
xcomposite_params.window = src_window_id;
xcomposite_params.follow_focused = follow_focused;
xcomposite_params.color_range = color_range;
xcomposite_params.record_cursor = record_cursor;
xcomposite_params.color_depth = color_depth;
xcomposite_params.output_resolution = output_resolution;
capture = gsr_capture_xcomposite_create(&xcomposite_params);
if(!capture)
@@ -2493,11 +2602,12 @@ static int video_quality_to_image_quality_value(VideoQuality video_quality) {
}
// TODO: 10-bit and hdr.
static void capture_image_to_file(const char *filepath, std::string &window_str, vec2i output_resolution, bool wayland, gsr_egl *egl, gsr_image_format image_format,
static void capture_image_to_file(const char *filepath, std::string &window_str, vec2i output_resolution, vec2i region_size, vec2i region_position, bool wayland, gsr_egl *egl, gsr_image_format image_format,
bool record_cursor, bool restore_portal_session, const char *portal_session_token_filepath, VideoQuality video_quality) {
const gsr_color_range color_range = image_format_to_color_range(image_format);
const int fps = 60;
gsr_capture *capture = create_capture_impl(window_str, output_resolution, wayland, egl, fps, false, color_range, record_cursor, restore_portal_session, portal_session_token_filepath, GSR_COLOR_DEPTH_8_BITS);
const bool prefer_ximage = true;
gsr_capture *capture = create_capture_impl(window_str, output_resolution, region_size, region_position, wayland, egl, fps, false, record_cursor, restore_portal_session, portal_session_token_filepath, prefer_ximage);
gsr_capture_metadata capture_metadata;
capture_metadata.width = 0;
@@ -2508,13 +2618,13 @@ static void capture_image_to_file(const char *filepath, std::string &window_str,
int capture_result = gsr_capture_start(capture, &capture_metadata);
if(capture_result != 0) {
fprintf(stderr, "gsr error: gsr_capture_start failed\n");
fprintf(stderr, "gsr error: capture_image_to_file_wayland: gsr_capture_start failed\n");
_exit(capture_result);
}
gsr_image_writer image_writer;
if(!gsr_image_writer_init(&image_writer, GSR_IMAGE_WRITER_SOURCE_OPENGL, egl, capture_metadata.width, capture_metadata.height)) {
fprintf(stderr, "gsr error: gsr_image_write_gl_init failed\n");
if(!gsr_image_writer_init_opengl(&image_writer, egl, capture_metadata.width, capture_metadata.height)) {
fprintf(stderr, "gsr error: capture_image_to_file_wayland: gsr_image_write_gl_init failed\n");
_exit(1);
}
@@ -2530,7 +2640,7 @@ static void capture_image_to_file(const char *filepath, std::string &window_str,
gsr_color_conversion color_conversion;
if(gsr_color_conversion_init(&color_conversion, &color_conversion_params) != 0) {
fprintf(stderr, "gsr error: gsr_capture_kms_setup_vaapi_textures: failed to create color conversion\n");
fprintf(stderr, "gsr error: capture_image_to_file_wayland: failed to create color conversion\n");
_exit(1);
}
@@ -2560,7 +2670,7 @@ static void capture_image_to_file(const char *filepath, std::string &window_str,
const int image_quality = video_quality_to_image_quality_value(video_quality);
if(!gsr_image_writer_write_to_file(&image_writer, filepath, image_format, image_quality)) {
fprintf(stderr, "gsr error: failed to write opengl texture to image output file %s\n", filepath);
fprintf(stderr, "gsr error: capture_image_to_file_wayland: failed to write opengl texture to image output file %s\n", filepath);
_exit(1);
}
@@ -3229,6 +3339,7 @@ int main(int argc, char **argv) {
{ "-c", Arg { {}, is_optional, !is_list, ArgType::STRING, {false} } },
{ "-f", Arg { {}, is_optional, !is_list, ArgType::STRING, {false} } },
{ "-s", Arg { {}, is_optional, !is_list, ArgType::STRING, {false} } },
{ "-region", Arg { {}, is_optional, !is_list, ArgType::STRING, {false} } },
{ "-a", Arg { {}, is_optional, is_list, ArgType::STRING, {false} } },
{ "-q", Arg { {}, is_optional, !is_list, ArgType::STRING, {false} } },
{ "-o", Arg { {}, is_optional, !is_list, ArgType::STRING, {false} } },
@@ -3550,7 +3661,7 @@ int main(int argc, char **argv) {
video_codec = hdr_video_codec_to_sdr_video_codec(video_codec);
}
const bool is_monitor_capture = strcmp(window_str.c_str(), "focused") != 0 && !is_portal_capture && contains_non_hex_number(window_str.c_str());
const bool is_monitor_capture = strcmp(window_str.c_str(), "focused") != 0 && strcmp(window_str.c_str(), "region") != 0 && !is_portal_capture && contains_non_hex_number(window_str.c_str());
gsr_egl egl;
if(!gsr_egl_load(&egl, window, is_monitor_capture, gl_debug)) {
fprintf(stderr, "gsr error: failed to load opengl\n");
@@ -3703,7 +3814,7 @@ int main(int argc, char **argv) {
const char *output_resolution_str = args["-s"].value();
if(!output_resolution_str && strcmp(window_str.c_str(), "focused") == 0) {
fprintf(stderr, "Error: option -s is required when using -w focused option\n");
fprintf(stderr, "Error: option -s is required when using '-w focused' option\n");
usage();
}
@@ -3720,6 +3831,31 @@ int main(int argc, char **argv) {
}
}
vec2i region_size = {0, 0};
vec2i region_position = {0, 0};
const char *region_str = args["-region"].value();
if(region_str) {
if(strcmp(window_str.c_str(), "region") != 0) {
fprintf(stderr, "Error: option -region can only be used when option '-w region' is used\n");
usage();
}
if(sscanf(region_str, "%dx%d+%d+%d", &region_size.x, &region_size.y, &region_position.x, &region_position.y) != 4) {
fprintf(stderr, "Error: invalid value for option -region '%s', expected a value in format WxH+X+Y\n", region_str);
usage();
}
if(region_size.x < 0 || region_size.y < 0 || region_position.x < 0 || region_position.y < 0) {
fprintf(stderr, "Error: invalud value for option -region '%s', expected width, height, x and y to be greater or equal to 0\n", region_str);
usage();
}
} else {
if(strcmp(window_str.c_str(), "region") == 0) {
fprintf(stderr, "Error: option -region is required when '-w region' is used\n");
usage();
}
}
bool is_livestream = false;
const char *filename = args["-o"].value();
if(filename) {
@@ -3776,7 +3912,7 @@ int main(int argc, char **argv) {
_exit(1);
}
capture_image_to_file(filename, window_str, output_resolution, wayland, &egl, image_format, record_cursor, restore_portal_session, portal_session_token_filepath, quality);
capture_image_to_file(filename, window_str, output_resolution, region_size, region_position, wayland, &egl, image_format, record_cursor, restore_portal_session, portal_session_token_filepath, quality);
_exit(0);
}
@@ -3795,7 +3931,7 @@ int main(int argc, char **argv) {
const AVOutputFormat *output_format = av_format_context->oformat;
std::string file_extension = output_format->extensions;
std::string file_extension = output_format->extensions ? output_format->extensions : "";
{
size_t comma_index = file_extension.find(',');
if(comma_index != std::string::npos)
@@ -3811,7 +3947,7 @@ int main(int argc, char **argv) {
const AVCodec *video_codec_f = select_video_codec_with_fallback(&video_codec, video_codec_to_use, file_extension.c_str(), use_software_video_encoder, &egl, &low_power);
const gsr_color_depth color_depth = video_codec_to_bit_depth(video_codec);
gsr_capture *capture = create_capture_impl(window_str, output_resolution, wayland, &egl, fps, video_codec_is_hdr(video_codec), color_range, record_cursor, restore_portal_session, portal_session_token_filepath, color_depth);
gsr_capture *capture = create_capture_impl(window_str, output_resolution, region_size, region_position, wayland, &egl, fps, video_codec_is_hdr(video_codec), record_cursor, restore_portal_session, portal_session_token_filepath, false);
// (Some?) livestreaming services require at least one audio track to work.
// If not audio is provided then create one silent audio track.
@@ -3880,6 +4016,9 @@ int main(int argc, char **argv) {
_exit(1);
}
capture_metadata.width = video_codec_context->width;
capture_metadata.height = video_codec_context->height;
gsr_color_conversion_params color_conversion_params;
memset(&color_conversion_params, 0, sizeof(color_conversion_params));
color_conversion_params.color_range = color_range;
@@ -3889,7 +4028,7 @@ int main(int argc, char **argv) {
gsr_color_conversion color_conversion;
if(gsr_color_conversion_init(&color_conversion, &color_conversion_params) != 0) {
fprintf(stderr, "gsr error: gsr_capture_kms_setup_vaapi_textures: failed to create color conversion\n");
fprintf(stderr, "gsr error: main: failed to create color conversion\n");
_exit(1);
}

11
src/pipewire_audio.c
View File

@@ -365,6 +365,8 @@ static bool gsr_pipewire_audio_listen_on_metadata(gsr_pipewire_audio *self, uint
pw_proxy_add_object_listener(self->metadata_proxy, &self->metadata_listener, &metadata_events, self);
pw_proxy_add_listener(self->metadata_proxy, &self->metadata_proxy_listener, &metadata_proxy_events, self);
self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, self->server_version_sync);
return true;
}
@@ -562,12 +564,12 @@ bool gsr_pipewire_audio_init(gsr_pipewire_audio *self) {
// TODO: Error check
pw_core_add_listener(self->core, &self->core_listener, &core_events, self);
self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, 0);
pw_thread_loop_wait(self->thread_loop);
self->registry = pw_core_get_registry(self->core, PW_VERSION_REGISTRY, 0);
pw_registry_add_listener(self->registry, &self->registry_listener, &registry_events, self);
self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, self->server_version_sync);
pw_thread_loop_wait(self->thread_loop);
pw_thread_loop_unlock(self->thread_loop);
return true;
}
@@ -595,6 +597,9 @@ void gsr_pipewire_audio_deinit(gsr_pipewire_audio *self) {
self->metadata_proxy = NULL;
}
spa_hook_remove(&self->registry_listener);
spa_hook_remove(&self->core_listener);
if(self->core) {
pw_core_disconnect(self->core);
self->core = NULL;

43
src/utils.c
View File

@@ -289,6 +289,7 @@ bool get_monitor_by_name(const gsr_egl *egl, gsr_connection_type connection_type
typedef struct {
const gsr_monitor *monitor;
gsr_monitor_rotation rotation;
vec2i position;
bool match_found;
} get_monitor_by_connector_id_userdata;
@@ -300,6 +301,7 @@ static void get_monitor_by_name_and_size_callback(const gsr_monitor *monitor, vo
get_monitor_by_connector_id_userdata *data = (get_monitor_by_connector_id_userdata*)userdata;
if(monitor->name && data->monitor->name && strcmp(monitor->name, data->monitor->name) == 0 && vec2i_eql(monitor->size, data->monitor->size)) {
data->rotation = monitor->rotation;
data->position = monitor->pos;
data->match_found = true;
}
}
@@ -310,39 +312,51 @@ static void get_monitor_by_connector_id_callback(const gsr_monitor *monitor, voi
(!monitor->connector_id && monitor->monitor_identifier == data->monitor->monitor_identifier))
{
data->rotation = monitor->rotation;
data->position = monitor->pos;
data->match_found = true;
}
}
gsr_monitor_rotation drm_monitor_get_display_server_rotation(const gsr_window *window, const gsr_monitor *monitor) {
bool drm_monitor_get_display_server_data(const gsr_window *window, const gsr_monitor *monitor, gsr_monitor_rotation *monitor_rotation, vec2i *monitor_position) {
*monitor_rotation = GSR_MONITOR_ROT_0;
*monitor_position = (vec2i){0, 0};
if(gsr_window_get_display_server(window) == GSR_DISPLAY_SERVER_WAYLAND) {
{
get_monitor_by_connector_id_userdata userdata;
userdata.monitor = monitor;
userdata.rotation = GSR_MONITOR_ROT_0;
userdata.position = (vec2i){0, 0};
userdata.match_found = false;
gsr_window_for_each_active_monitor_output_cached(window, get_monitor_by_name_and_size_callback, &userdata);
if(userdata.match_found)
return userdata.rotation;
if(userdata.match_found) {
*monitor_rotation = userdata.rotation;
*monitor_position = userdata.position;
return true;
}
}
{
get_monitor_by_connector_id_userdata userdata;
userdata.monitor = monitor;
userdata.rotation = GSR_MONITOR_ROT_0;
userdata.position = (vec2i){0, 0};
userdata.match_found = false;
gsr_window_for_each_active_monitor_output_cached(window, get_monitor_by_connector_id_callback, &userdata);
return userdata.rotation;
*monitor_rotation = userdata.rotation;
*monitor_position = userdata.position;
return userdata.match_found;
}
} else {
get_monitor_by_connector_id_userdata userdata;
userdata.monitor = monitor;
userdata.rotation = GSR_MONITOR_ROT_0;
userdata.position = (vec2i){0, 0};
userdata.match_found = false;
gsr_window_for_each_active_monitor_output_cached(window, get_monitor_by_connector_id_callback, &userdata);
return userdata.rotation;
*monitor_rotation = userdata.rotation;
*monitor_position = userdata.position;
return userdata.match_found;
}
return GSR_MONITOR_ROT_0;
}
bool gl_get_gpu_info(gsr_egl *egl, gsr_gpu_info *info) {
@@ -898,3 +912,18 @@ vec2i scale_keep_aspect_ratio(vec2i from, vec2i to) {
return from;
}
unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format, int filter) {
unsigned int texture_id = 0;
egl->glGenTextures(1, &texture_id);
egl->glBindTexture(GL_TEXTURE_2D, texture_id);
egl->glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
egl->glBindTexture(GL_TEXTURE_2D, 0);
return texture_id;
}