1 files changed, 50 insertions, 108 deletions

diff --git a/src/capture/kms.c b/src/capture/kms.c
index 266d4e6..36a5355 100644
--- a/src/capture/kms.c
+++ b/src/capture/kms.c
@@ -12,11 +12,9 @@
 #include <fcntl.h>
 
 #include <xf86drm.h>
-#include <libdrm/drm_fourcc.h>
+#include <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
 
@@ -55,10 +53,6 @@ typedef struct {
     bool is_x11;
     gsr_cursor x11_cursor;
 
-    bool performance_error_shown;
-    bool fast_path_failed;
-    bool mesa_supports_compute_only_vaapi_copy;
-
     //int drm_fd;
     //uint64_t prev_sequence;
     //bool damaged;
@@ -116,16 +110,12 @@ static int max_int(int a, int b) {
 static void gsr_capture_kms_create_input_texture_ids(gsr_capture_kms *self) {
     self->params.egl->glGenTextures(1, &self->input_texture_id);
     self->params.egl->glBindTexture(GL_TEXTURE_2D, self->input_texture_id);
-    self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
 
     self->params.egl->glGenTextures(1, &self->external_input_texture_id);
     self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, self->external_input_texture_id);
-    self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
@@ -135,8 +125,6 @@ static void gsr_capture_kms_create_input_texture_ids(gsr_capture_kms *self) {
 
     self->params.egl->glGenTextures(1, &self->cursor_texture_id);
     self->params.egl->glBindTexture(cursor_texture_id_target, self->cursor_texture_id);
-    self->params.egl->glTexParameteri(cursor_texture_id_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    self->params.egl->glTexParameteri(cursor_texture_id_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     self->params.egl->glTexParameteri(cursor_texture_id_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     self->params.egl->glTexParameteri(cursor_texture_id_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     self->params.egl->glBindTexture(cursor_texture_id_target, 0);
@@ -209,7 +197,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,27 +207,18 @@ 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);
-    if(self->fast_path_failed)
-        fprintf(stderr, "gsr warning: gsr_capture_kms_start: your amd driver (mesa) version is known to be buggy (<= version 24.0.9), falling back to opengl copy\n");
-
-    //if(self->params.hdr) {
-    //    self->fast_path_failed = true;
-    //    fprintf(stderr, "gsr warning: gsr_capture_kms_start: recording with hdr requires shader color conversion which might be slow. If this is an issue record with -w portal instead (which converts HDR to SDR)\n");
-    //}
-
-    self->mesa_supports_compute_only_vaapi_copy = self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_AMD && gl_driver_version_greater_than(&self->params.egl->gpu_info, 24, 3, 6);
-
     self->last_time_monitor_check = clock_get_monotonic_seconds();
     return 0;
 }
@@ -273,16 +253,6 @@ static void gsr_capture_kms_on_event(gsr_capture *cap, gsr_egl *egl) {
 //     }
 // }
 
-static float monitor_rotation_to_radians(gsr_monitor_rotation rot) {
-    switch(rot) {
-        case GSR_MONITOR_ROT_0:   return 0.0f;
-        case GSR_MONITOR_ROT_90:  return M_PI_2;
-        case GSR_MONITOR_ROT_180: return M_PI;
-        case GSR_MONITOR_ROT_270: return M_PI + M_PI_2;
-    }
-    return 0.0f;
-}
-
 static gsr_kms_response_item* find_drm_by_connector_id(gsr_kms_response *kms_response, uint32_t connector_id) {
     for(int i = 0; i < kms_response->num_items; ++i) {
         if(kms_response->items[i].connector_id == connector_id && !kms_response->items[i].is_cursor)
@@ -448,7 +418,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, 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 +433,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;
 
@@ -518,8 +491,8 @@ static void render_drm_cursor(gsr_capture_kms *self, gsr_color_conversion *color
 
     gsr_color_conversion_draw(color_conversion, self->cursor_texture_id,
         cursor_pos, (vec2i){cursor_size.x * scale.x, cursor_size.y * scale.y},
-        (vec2i){0, 0}, cursor_size,
-        texture_rotation, cursor_texture_id_is_external, GSR_SOURCE_COLOR_RGB);
+        (vec2i){0, 0}, cursor_size, cursor_size,
+        gsr_monitor_rotation_to_rotation(self->monitor_rotation), GSR_SOURCE_COLOR_RGB, cursor_texture_id_is_external, true);
 
     self->params.egl->glDisable(GL_SCISSOR_TEST);
 }
@@ -546,8 +519,8 @@ static void render_x11_cursor(gsr_capture_kms *self, gsr_color_conversion *color
 
     gsr_color_conversion_draw(color_conversion, self->x11_cursor.texture_id,
         cursor_pos, (vec2i){self->x11_cursor.size.x * scale.x, self->x11_cursor.size.y * scale.y},
-        (vec2i){0, 0}, self->x11_cursor.size,
-        0.0f, false, GSR_SOURCE_COLOR_RGB);
+        (vec2i){0, 0}, self->x11_cursor.size, self->x11_cursor.size,
+        GSR_ROT_0, GSR_SOURCE_COLOR_RGB, false, true);
 
     self->params.egl->glDisable(GL_SCISSOR_TEST);
 }
@@ -589,7 +562,9 @@ 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};
+    // TODO: This is cached. We need it updated.
+    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 */
@@ -599,16 +574,6 @@ static void gsr_capture_kms_update_connector_ids(gsr_capture_kms *self) {
         self->capture_size = rotate_capture_size_if_rotated(self, monitor.size);
 }
 
-static void gsr_capture_kms_fail_fast_path_if_not_fast(gsr_capture_kms *self, uint32_t pixel_format) {
-    const uint8_t pixel_format_color_depth_1 = (pixel_format >> 16) & 0xFF;
-    if(!self->fast_path_failed && self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_AMD && !self->mesa_supports_compute_only_vaapi_copy && (pixel_format_color_depth_1 == '3' || pixel_format_color_depth_1 == '4')) {
-        self->fast_path_failed = true;
-        fprintf(stderr, "gsr warning: gsr_capture_kms_capture: the monitor you are recording is in 10/12-bit color format and your mesa version is <= 24.3.6, composition will be used."
-            " If you experience performance problems in the video then record on a single window on X11 or use portal capture option instead or disable 10/12-bit color option in your desktop environment settings,"
-            " or try to record the monitor on X11 instead (if you aren't already doing that) or update your mesa version.\n");
-    }
-}
-
 static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
     gsr_capture_kms *self = cap->priv;
 
@@ -640,22 +605,15 @@ static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *captu
     if(drm_fd->has_hdr_metadata && self->params.hdr && hdr_metadata_is_supported_format(&drm_fd->hdr_metadata))
         gsr_kms_set_hdr_metadata(self, drm_fd);
 
-    if(!self->performance_error_shown && self->monitor_rotation != GSR_MONITOR_ROT_0 && video_codec_context_is_vaapi(capture_metadata->video_codec_context) && self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_AMD) {
-        self->performance_error_shown = true;
-        self->fast_path_failed = true;
-        fprintf(stderr, "gsr warning: gsr_capture_kms_capture: the monitor you are recording is rotated, composition will have to be used."
-            " If you experience performance problems in the video then record a single window on X11 or use portal capture option instead\n");
-    }
-
-    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 });
+    const vec2i original_frame_size = self->capture_size;
+    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;
     output_size = scale_keep_aspect_ratio(self->capture_size, output_size);
 
-    const float texture_rotation = monitor_rotation_to_radians(self->monitor_rotation);
     const vec2i target_pos = { max_int(0, capture_metadata->width / 2 - output_size.x / 2), max_int(0, capture_metadata->height / 2 - output_size.y / 2) };
     gsr_capture_kms_update_capture_size_change(self, color_conversion, target_pos, drm_fd);
 
@@ -663,42 +621,23 @@ 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};
 
-    self->params.egl->glFlush();
-    self->params.egl->glFinish();
-
-    /* Fast opengl free path */
-    if(!self->fast_path_failed && self->monitor_rotation == GSR_MONITOR_ROT_0 && video_codec_context_is_vaapi(capture_metadata->video_codec_context) && self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_AMD) {
-        int fds[4];
-        uint32_t offsets[4];
-        uint32_t pitches[4];
-        uint64_t modifiers[4];
-        for(int i = 0; i < drm_fd->num_dma_bufs; ++i) {
-            fds[i] = drm_fd->dma_buf[i].fd;
-            offsets[i] = drm_fd->dma_buf[i].offset;
-            pitches[i] = drm_fd->dma_buf[i].pitch;
-            modifiers[i] = drm_fd->modifier;
-        }
-        if(!vaapi_copy_drm_planes_to_video_surface(capture_metadata->video_codec_context, capture_metadata->frame, (vec2i){capture_pos.x, capture_pos.y}, self->capture_size, target_pos, output_size, drm_fd->pixel_format, (vec2i){drm_fd->width, drm_fd->height}, fds, offsets, pitches, modifiers, drm_fd->num_dma_bufs)) {
-            fprintf(stderr, "gsr error: gsr_capture_kms_capture: vaapi_copy_drm_planes_to_video_surface failed, falling back to opengl copy. Please report this as an issue at https://github.com/dec05eba/gpu-screen-recorder-issues\n");
-            self->fast_path_failed = true;
-        }
-    } else {
-        self->fast_path_failed = true;
-    }
+    capture_pos.x += self->params.region_position.x;
+    capture_pos.y += self->params.region_position.y;
 
-    if(self->fast_path_failed) {
-        EGLImage image = gsr_capture_kms_create_egl_image_with_fallback(self, drm_fd);
-        if(image) {
-            gsr_capture_kms_bind_image_to_input_texture_with_fallback(self, image);
-            self->params.egl->eglDestroyImage(self->params.egl->egl_display, image);
-        }
+    //self->params.egl->glFlush();
+    //self->params.egl->glFinish();
 
-        gsr_color_conversion_draw(color_conversion, self->external_texture_fallback ? self->external_input_texture_id : self->input_texture_id,
-            target_pos, output_size,
-            capture_pos, self->capture_size,
-            texture_rotation, self->external_texture_fallback, GSR_SOURCE_COLOR_RGB);
+    EGLImage image = gsr_capture_kms_create_egl_image_with_fallback(self, drm_fd);
+    if(image) {
+        gsr_capture_kms_bind_image_to_input_texture_with_fallback(self, image);
+        self->params.egl->eglDestroyImage(self->params.egl->egl_display, image);
     }
 
+    gsr_color_conversion_draw(color_conversion, self->external_texture_fallback ? self->external_input_texture_id : self->input_texture_id,
+        target_pos, output_size,
+        capture_pos, self->capture_size, original_frame_size,
+        gsr_monitor_rotation_to_rotation(self->monitor_rotation), GSR_SOURCE_COLOR_RGB, self->external_texture_fallback, false);
+
     if(self->params.record_cursor) {
         gsr_kms_response_item *cursor_drm_fd = find_cursor_drm_if_on_monitor(self, drm_fd->connector_id, capture_is_combined_plane);
         // The cursor is handled by x11 on x11 instead of using the cursor drm plane because on prime systems with a dedicated nvidia gpu
@@ -706,15 +645,18 @@ 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, output_size, framebuffer_size);
         }
     }
 
-    self->params.egl->glFlush();
-    self->params.egl->glFinish();
+    //self->params.egl->glFlush();
+    //self->params.egl->glFinish();
 
     gsr_capture_kms_cleanup_kms_fds(self);