5.3.5

Fix incorrect region when monitor is rotated
Remove -high-performance-encoding, always force enable it
2026-04-02 17:51:42 +09:00 · 2025-03-30 23:09:36 +02:00 · 2025-03-30 23:00:54 +02:00 · 2025-03-30 22:29:49 +02:00 · 2025-03-30 22:11:33 +02:00 · 2025-03-30 18:11:25 +02:00
46 changed files with 1292 additions and 1110 deletions
--- a/README.md
+++ b/README.md
@@ -68,7 +68,8 @@ Here are some known unofficial packages:
 * Nix: [NixOS wiki](https://wiki.nixos.org/wiki/Gpu-screen-recorder)
 * openSUSE: [openSUSE software repository](https://software.opensuse.org/package/gpu-screen-recorder)
 * Fedora: [Copr](https://copr.fedorainfracloud.org/coprs/brycensranch/gpu-screen-recorder-git/)
-* OpenMandriva: [gpu-screen-recorder](https://github.com/OpenMandrivaAssociation/gpu-screen-recorder/tree/master)
+* OpenMandriva: [gpu-screen-recorder](https://github.com/OpenMandrivaAssociation/gpu-screen-recorder)
+* Solus: [gpu-screen-recorder](https://github.com/getsolus/packages/tree/main/packages/g/gpu-screen-recorder)

 # Dependencies
 GPU Screen Recorder uses meson build system so you need to install `meson` to build GPU Screen Recorder.
@@ -184,3 +185,5 @@ To fix this you can either record the video in .mkv format or constant frame rat
 ## Colors look incorrect when recording HDR (with hevc_hdr/av1_hdr) or using an ICC profile
 KDE Plasma version 6.2 broke HDR and ICC profiles for screen recorders. This was changed in KDE plasma version 6.3 and recording HDR works now, as long as you set HDR brightness to 100% (which means setting "Maximum SDR Brightness" in KDE plasma display settings to 203) and set color accuracy to "Prefer color accuracy". If you want to convert HDR to SDR then record with desktop portal option (`-w portal`) instead.
 I don't know how well recording HDR works in wayland compositors other than KDE plasma.
+## GPU Screen Recorder starts lagging after 30-40 minutes when launching GPU Screen Recorder from steam command launcher
+This is a [steam issue](https://github.com/ValveSoftware/steam-for-linux/issues/11446). Prepend the gpu-screen-recorder command with `LD_PREFIX=""`, for example `LD_PREFIX="" gpu-screen-recorder -w screen -o video.mp4`.
--- a/16
+++ b/16
@@ -241,4 +241,18 @@ Support reconnecting (and setting things up again) if the audio server is restar

 Find out how nvidia-smi fixes nvenc not working on opensuse and do that ourselves instead of relying on nvidia-smi that is not always installed.

-Pulseaudio code: add "running" variable to loops to allow stopping the running code when quitting.
+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.
+
+Replace all scissors with clearing textures if the cursor hits the outside of the frame image.
+
+Cursor position might be slightly wrong on rotated monitor.
--- a/include/capture/kms.h
+++ b/include/capture/kms.h
@@ -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);
--- a/include/capture/nvfbc.h
+++ b/include/capture/nvfbc.h
@@ -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);
--- a/include/capture/portal.h
+++ b/include/capture/portal.h
@@ -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) */
--- a/include/capture/xcomposite.h
+++ b/include/capture/xcomposite.h
@@ -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;

--- a/include/capture/ximage.h
+++ b/include/capture/ximage.h
@@ -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 */
--- a/include/color_conversion.h
+++ b/include/color_conversion.h
@@ -2,9 +2,13 @@
 #define GSR_COLOR_CONVERSION_H

 #include "shader.h"
+#include "defs.h"
 #include "vec2.h"
 #include <stdbool.h>

+#define GSR_COLOR_CONVERSION_MAX_SHADERS 6
+#define GSR_COLOR_CONVERSION_MAX_FRAMEBUFFERS 2
+
 typedef enum {
    GSR_COLOR_RANGE_LIMITED,
    GSR_COLOR_RANGE_FULL
@@ -26,9 +30,18 @@ typedef enum {
    GSR_DESTINATION_COLOR_RGB8
 } gsr_destination_color;

+typedef enum {
+    GSR_ROT_0,
+    GSR_ROT_90,
+    GSR_ROT_180,
+    GSR_ROT_270
+} gsr_rotation;
+
 typedef struct {
-    int offset;
-    int rotation;
+    int rotation_matrix;
+    int source_position;
+    int target_position;
+    int scale;
 } gsr_color_uniforms;

 typedef struct {
@@ -45,19 +58,23 @@ typedef struct {

 typedef struct {
    gsr_color_conversion_params params;
-    gsr_color_uniforms uniforms[4];
-    gsr_shader shaders[4];
+    gsr_color_uniforms uniforms[GSR_COLOR_CONVERSION_MAX_SHADERS];
+    gsr_shader shaders[GSR_COLOR_CONVERSION_MAX_SHADERS];

-    unsigned int framebuffers[2];
+    unsigned int framebuffers[GSR_COLOR_CONVERSION_MAX_FRAMEBUFFERS];

    unsigned int vertex_array_object_id;
    unsigned int vertex_buffer_object_id;
+
+    int max_local_size_dim;
 } gsr_color_conversion;

 int gsr_color_conversion_init(gsr_color_conversion *self, const gsr_color_conversion_params *params);
 void gsr_color_conversion_deinit(gsr_color_conversion *self);

-void gsr_color_conversion_draw(gsr_color_conversion *self, unsigned int texture_id, vec2i source_pos, vec2i source_size, vec2i texture_pos, vec2i texture_size, float rotation, bool external_texture, gsr_source_color source_color);
+void gsr_color_conversion_draw(gsr_color_conversion *self, unsigned int texture_id, vec2i destination_pos, vec2i destination_size, vec2i source_pos, vec2i source_size, vec2i texture_size, gsr_rotation rotation, bool external_texture, gsr_source_color source_color);
 void gsr_color_conversion_clear(gsr_color_conversion *self);

+gsr_rotation gsr_monitor_rotation_to_rotation(gsr_monitor_rotation monitor_rotation);
+
 #endif /* GSR_COLOR_CONVERSION_H */
--- a/include/dbus.h
+++ b/include/dbus.h
@@ -37,7 +37,11 @@ void gsr_dbus_deinit(gsr_dbus *self);
 /* The follow functions should be called in order to setup ScreenCast properly */
 /* These functions that return an int return the response status code */
 int gsr_dbus_screencast_create_session(gsr_dbus *self, char **session_handle);
-int gsr_dbus_screencast_select_sources(gsr_dbus *self, const char *session_handle, gsr_portal_capture_type capture_type, gsr_portal_cursor_mode cursor_mode);
+/*
+    |capture_type| is a bitmask of gsr_portal_capture_type values. gsr_portal_capture_type values that are not supported by the desktop portal will be ignored.
+    |gsr_portal_cursor_mode| is a bitmask of gsr_portal_cursor_mode values. gsr_portal_cursor_mode values that are not supported will be ignored.
+*/
+int gsr_dbus_screencast_select_sources(gsr_dbus *self, const char *session_handle, uint32_t capture_type, uint32_t cursor_mode);
 int gsr_dbus_screencast_start(gsr_dbus *self, const char *session_handle, uint32_t *pipewire_node);
 bool gsr_dbus_screencast_open_pipewire_remote(gsr_dbus *self, const char *session_handle, int *pipewire_fd);
 const char* gsr_dbus_screencast_get_restore_token(gsr_dbus *self);
--- a/include/defs.h
+++ b/include/defs.h
@@ -6,7 +6,8 @@
 typedef enum {
    GSR_GPU_VENDOR_AMD,
    GSR_GPU_VENDOR_INTEL,
-    GSR_GPU_VENDOR_NVIDIA
+    GSR_GPU_VENDOR_NVIDIA,
+    GSR_GPU_VENDOR_BROADCOM
 } gsr_gpu_vendor;

 typedef struct {
--- a/include/egl.h
+++ b/include/egl.h
@@ -98,7 +98,7 @@ typedef void(*__GLXextFuncPtr)(void);
 #define GL_TEXTURE_EXTERNAL_OES                 0x8D65
 #define GL_RED                                  0x1903
 #define GL_GREEN                                0x1904
-#define GL_BLUE                                    0x1905
+#define GL_BLUE                                 0x1905
 #define GL_ALPHA                                0x1906
 #define GL_TEXTURE_SWIZZLE_RGBA                 0x8E46
 #define GL_RG                                   0x8227
@@ -111,6 +111,7 @@ typedef void(*__GLXextFuncPtr)(void);
 #define GL_R16                                  0x822A
 #define GL_RG16                                 0x822C
 #define GL_RGB16                                0x8054
+#define GL_RGBA32F                              0x8814
 #define GL_UNSIGNED_BYTE                        0x1401
 #define GL_COLOR_BUFFER_BIT                     0x00004000
 #define GL_TEXTURE_WRAP_S                       0x2802
@@ -132,6 +133,18 @@ 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_READ_ONLY                            0x88B8
+#define GL_WRITE_ONLY                           0x88B9
+#define GL_READ_WRITE                           0x88BA
+#define GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS  0x90EB
+#define GL_TEXTURE0                             0x84C0
+#define GL_TEXTURE1                             0x84C1
+#define GL_CLAMP_TO_BORDER                      0x812D
+#define GL_TEXTURE_BORDER_COLOR                 0x1004
+#define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT      0x00000020
+#define GL_ALL_BARRIER_BITS                     0xFFFFFFFF

 #define GL_VENDOR                               0x1F00
 #define GL_RENDERER                             0x1F01
@@ -141,6 +154,7 @@ typedef void(*__GLXextFuncPtr)(void);
 #define GL_INFO_LOG_LENGTH                      0x8B84
 #define GL_FRAGMENT_SHADER                      0x8B30
 #define GL_VERTEX_SHADER                        0x8B31
+#define GL_COMPUTE_SHADER                       0x91B9
 #define GL_COMPILE_STATUS                       0x8B81
 #define GL_LINK_STATUS                          0x8B82

@@ -228,15 +242,21 @@ struct gsr_egl {
    void (*glClearColor)(float red, float green, float blue, float alpha);
    void (*glGenTextures)(int n, unsigned int *textures);
    void (*glDeleteTextures)(int n, const unsigned int *texture);
+    void (*glActiveTexture)(unsigned int texture);
    void (*glBindTexture)(unsigned int target, unsigned int texture);
+    void (*glBindImageTexture)(unsigned int unit, unsigned int texture, int level, unsigned char layered, int layer, unsigned int access, unsigned int format);
    void (*glTexParameteri)(unsigned int target, unsigned int pname, int param);
    void (*glTexParameteriv)(unsigned int target, unsigned int pname, const int *params);
+    void (*glTexParameterfv)(unsigned int target, unsigned int pname, const float *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);
    void (*glDeleteFramebuffers)(int n, const unsigned int *framebuffers);
+    void (*glDispatchCompute)(unsigned int num_groups_x, unsigned int num_groups_y, unsigned int num_groups_z);
+    void (*glMemoryBarrier)(unsigned int barriers);
    void (*glViewport)(int x, int y, int width, int height);
    void (*glFramebufferTexture2D)(unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level);
    void (*glDrawBuffers)(int n, const unsigned int *bufs);
@@ -269,14 +289,19 @@ 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);
+    void (*glUniform1i)(int location, int v0);
+    void (*glUniform2i)(int location, int v0, int v1);
+    void (*glUniformMatrix2fv)(int location, int count, unsigned char transpose, const float *value);
    void (*glDebugMessageCallback)(GLDEBUGPROC callback, const void *userParam);
    void (*glScissor)(int x, int y, int width, int height);
    void (*glReadPixels)(int x, int y, int width, int height, unsigned int format, unsigned int type, void *pixels);
    void* (*glMapBuffer)(unsigned int target, unsigned int access);
    unsigned char (*glUnmapBuffer)(unsigned int target);
+    void (*glGetIntegerv)(unsigned int pname, int *params);
 };

 bool gsr_egl_load(gsr_egl *self, gsr_window *window, bool is_monitor_capture, bool enable_debug);
--- a/include/image_writer.h
+++ b/include/image_writer.h
@@ -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. The data is expected to be in rgba8 format (8 bit rgba) */
+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 */
--- a/include/pipewire_audio.h
+++ b/include/pipewire_audio.h
@@ -80,6 +80,7 @@ typedef struct {

    struct pw_proxy *metadata_proxy;
    struct spa_hook metadata_listener;
+    struct spa_hook metadata_proxy_listener;
    char default_output_device_name[128];
    char default_input_device_name[128];

--- a/include/shader.h
+++ b/include/shader.h
@@ -9,7 +9,7 @@ typedef struct {
 } gsr_shader;

 /* |vertex_shader| or |fragment_shader| may be NULL */
-int gsr_shader_init(gsr_shader *self, gsr_egl *egl, const char *vertex_shader, const char *fragment_shader);
+int gsr_shader_init(gsr_shader *self, gsr_egl *egl, const char *vertex_shader, const char *fragment_shader, const char *compute_shader);
 void gsr_shader_deinit(gsr_shader *self);

 int gsr_shader_bind_attribute_location(gsr_shader *self, const char *attribute, int location);
--- a/include/utils.h
+++ b/include/utils.h
@@ -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,15 +43,13 @@ 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);
 uint32_t monitor_identifier_from_type_and_count(int monitor_type_index, int monitor_type_count);

 bool gl_get_gpu_info(gsr_egl *egl, gsr_gpu_info *info);
-bool version_greater_than(int major, int minor, int patch, int other_major, int other_minor, int other_patch);
-bool gl_driver_version_greater_than(const gsr_gpu_info *gpu_info, int major, int minor, int patch);

 bool try_card_has_valid_plane(const char *card_path);
 /* |output| should be at least 128 bytes in size */
@@ -64,9 +62,9 @@ int create_directory_recursive(char *path);
 /* |img_attr| needs to be at least 44 in size */
 void setup_dma_buf_attrs(intptr_t *img_attr, uint32_t format, uint32_t width, uint32_t height, const int *fds, const uint32_t *offsets, const uint32_t *pitches, const uint64_t *modifiers, int num_planes, bool use_modifier);
 bool video_codec_context_is_vaapi(AVCodecContext *video_codec_context);
-bool vaapi_copy_drm_planes_to_video_surface(AVCodecContext *video_codec_context, AVFrame *video_frame, vec2i source_pos, vec2i source_size, vec2i dest_pos, vec2i dest_size, uint32_t format, vec2i size, const int *fds, const uint32_t *offsets, const uint32_t *pitches, const uint64_t *modifiers, int num_planes);
-bool vaapi_copy_egl_image_to_video_surface(gsr_egl *egl, EGLImage image, vec2i source_pos, vec2i source_size, vec2i dest_pos, vec2i dest_size, AVCodecContext *video_codec_context, AVFrame *video_frame);

 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 */
--- a/include/window/window_wayland.h
+++ b/include/window/window_wayland.h
--- a/include/window/window_x11.h
+++ b/include/window/window_x11.h
--- a/kms/server/kms_server.c
+++ b/kms/server/kms_server.c
@@ -25,7 +25,6 @@

 typedef struct {
    int drmfd;
-    drmModePlaneResPtr planes;
 } gsr_drm;

 typedef struct {
@@ -289,21 +288,31 @@ static int drm_prime_handles_to_fds(gsr_drm *drm, drmModeFB2Ptr drmfb, int *fb_f
    return GSR_KMS_MAX_DMA_BUFS;
 }

-static int kms_get_fb(gsr_drm *drm, gsr_kms_response *response, connector_to_crtc_map *c2crtc_map) {
+static int kms_get_fb(gsr_drm *drm, gsr_kms_response *response) {
    int result = -1;

    response->result = KMS_RESULT_OK;
    response->err_msg[0] = '\0';
    response->num_items = 0;

-    for(uint32_t i = 0; i < drm->planes->count_planes && response->num_items < GSR_KMS_MAX_ITEMS; ++i) {
+    connector_to_crtc_map c2crtc_map;
+    c2crtc_map.num_maps = 0;
+    map_crtc_to_connector_ids(drm, &c2crtc_map);
+
+    drmModePlaneResPtr planes = drmModeGetPlaneResources(drm->drmfd);
+    if(!planes) {
+        fprintf(stderr, "kms server error: failed to get plane resources, error: %s\n", strerror(errno));
+        goto done;
+    }
+
+    for(uint32_t i = 0; i < planes->count_planes && response->num_items < GSR_KMS_MAX_ITEMS; ++i) {
        drmModePlanePtr plane = NULL;
        drmModeFB2Ptr drmfb = NULL;

-        plane = drmModeGetPlane(drm->drmfd, drm->planes->planes[i]);
+        plane = drmModeGetPlane(drm->drmfd, planes->planes[i]);
        if(!plane) {
            response->result = KMS_RESULT_FAILED_TO_GET_PLANE;
-            snprintf(response->err_msg, sizeof(response->err_msg), "failed to get drm plane with id %u, error: %s\n", drm->planes->planes[i], strerror(errno));
+            snprintf(response->err_msg, sizeof(response->err_msg), "failed to get drm plane with id %u, error: %s\n", planes->planes[i], strerror(errno));
            fprintf(stderr, "kms server error: %s\n", response->err_msg);
            goto next;
        }
@@ -346,7 +355,7 @@ static int kms_get_fb(gsr_drm *drm, gsr_kms_response *response, connector_to_crt

        const int item_index = response->num_items;

-        const connector_crtc_pair *crtc_pair = get_connector_pair_by_crtc_id(c2crtc_map, plane->crtc_id);
+        const connector_crtc_pair *crtc_pair = get_connector_pair_by_crtc_id(&c2crtc_map, plane->crtc_id);
        if(crtc_pair && crtc_pair->hdr_metadata_blob_id) {
            response->items[item_index].has_hdr_metadata = get_hdr_metadata(drm->drmfd, crtc_pair->hdr_metadata_blob_id, &response->items[item_index].hdr_metadata);
        } else {
@@ -389,6 +398,11 @@ static int kms_get_fb(gsr_drm *drm, gsr_kms_response *response, connector_to_crt
            drmModeFreePlane(plane);
    }

+    done:
+
+    if(planes)
+        drmModeFreePlaneResources(planes);
+
    if(response->num_items > 0)
        response->result = KMS_RESULT_OK;

@@ -499,7 +513,6 @@ int main(int argc, char **argv) {
    int socket_fd = 0;
    gsr_drm drm;
    drm.drmfd = 0;
-    drm.planes = NULL;

    if(argc != 3) {
        fprintf(stderr, "usage: gsr-kms-server <domain_socket_path> <card_path>\n");
@@ -532,17 +545,6 @@ int main(int argc, char **argv) {
        fprintf(stderr, "kms server warning: drmSetClientCap DRM_CLIENT_CAP_ATOMIC failed, error: %s. The wrong monitor may be captured as a result\n", strerror(errno));
    }

-    drm.planes = drmModeGetPlaneResources(drm.drmfd);
-    if(!drm.planes) {
-        fprintf(stderr, "kms server error: failed to get plane resources, error: %s\n", strerror(errno));
-        res = 2;
-        goto done;
-    }
-
-    connector_to_crtc_map c2crtc_map;
-    c2crtc_map.num_maps = 0;
-    map_crtc_to_connector_ids(&drm, &c2crtc_map);
-
    fprintf(stderr, "kms server info: connecting to the client\n");
    bool connected = false;
    const double connect_timeout_sec = 5.0;
@@ -642,7 +644,7 @@ int main(int argc, char **argv) {
                response.version = GSR_KMS_PROTOCOL_VERSION;
                response.num_items = 0;
                
-                if(kms_get_fb(&drm, &response, &c2crtc_map) == 0) {
+                if(kms_get_fb(&drm, &response) == 0) {
                    if(send_msg_to_client(socket_fd, &response) == -1)
                        fprintf(stderr, "kms server error: failed to respond to client KMS_REQUEST_TYPE_GET_KMS request\n");
                } else {
@@ -681,8 +683,6 @@ int main(int argc, char **argv) {
    }

    done:
-    if(drm.planes)
-        drmModeFreePlaneResources(drm.planes);
    if(drm.drmfd > 0)
        close(drm.drmfd);
    if(socket_fd > 0)
--- a/meson.build
+++ b/meson.build
@@ -1,4 +1,4 @@
-project('gpu-screen-recorder', ['c', 'cpp'], version : '5.2.0', default_options : ['warning_level=2'])
+project('gpu-screen-recorder', ['c', 'cpp'], version : '5.3.5', 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',
@@ -22,8 +23,8 @@ src = [
    'src/codec_query/vaapi.c',
    'src/codec_query/vulkan.c',
    'src/window/window.c',
-    'src/window/window_x11.c',
-    'src/window/window_wayland.c',
+    'src/window/x11.c',
+    'src/window/wayland.c',
    'src/egl.c',
    'src/cuda.c',
    'src/xnvctrl.c',
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -1,5 +1,5 @@
 option('systemd', type : 'boolean', value : true, description : 'Install systemd service file')
 option('capabilities', type : 'boolean', value : true, description : 'Set binary admin capability on gsr-kms-server binary to remove password prompt when recording monitor (without desktop portal option) on amd/intel or nvidia wayland')
 option('nvidia_suspend_fix', type : 'boolean', value : true, description : 'Install nvidia modprobe config file to tell nvidia driver to preserve video memory on suspend. This is a workaround for an nvidia driver bug that breaks cuda (and gpu screen recorder) on suspend')
-option('portal', type : 'boolean', value : true, description : 'Build with support for xdg desktop portal ScreenCast capture (wayland only) (-w portal option)')
-option('app_audio', type : 'boolean', value : true, description : 'Build with support for recording a single audio source (-aa option). Requires pipewire')
+option('portal', type : 'boolean', value : true, description : 'Build with support for xdg desktop portal ScreenCast capture (wayland only) (-w portal option). Requires pipewire')
+option('app_audio', type : 'boolean', value : true, description : 'Build with support for recording a single audio source (-a app: option). Requires pipewire')
--- a/project.conf
+++ b/project.conf
@@ -1,7 +1,7 @@
 [package]
 name = "gpu-screen-recorder"
 type = "executable"
-version = "5.2.0"
+version = "5.3.5"
 platforms = ["posix"]

 [config]
--- a/scripts/replay-application-name.sh
+++ b/scripts/replay-application-name.sh
@@ -3,4 +3,4 @@
 window=$(xdotool selectwindow)
 window_name=$(xdotool getwindowname "$window" || xdotool getwindowclassname "$window" || echo "Game")
 window_name="$(echo "$window_name" | tr '/\\' '_')"
-gpu-screen-recorder -w "$window" -f 60 -c mkv -a default_output -r 60 -o "$HOME/Videos/Replays/$window_name"
+gpu-screen-recorder -w "$window" -f 60 -c mkv -a default_output -bm cbr -q 45000 -r 60 -o "$HOME/Videos/Replays/$window_name"
--- a/scripts/start-replay.sh
+++ b/scripts/start-replay.sh
@@ -3,4 +3,4 @@
 pidof -q gpu-screen-recorder && exit 0
 video_path="$HOME/Videos"
 mkdir -p "$video_path"
-gpu-screen-recorder -w screen -f 60 -a default_output -c mkv -r 30 -o "$video_path"
+gpu-screen-recorder -w screen -f 60 -a default_output -c mkv -bm cbr -q 45000 -r 30 -o "$video_path"
--- a/src/capture/kms.c
+++ b/src/capture/kms.c
@@ -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

@@ -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;
@@ -114,18 +108,22 @@ static int max_int(int a, int b) {
 }

 static void gsr_capture_kms_create_input_texture_ids(gsr_capture_kms *self) {
+    const float border_color[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+
    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_WRAP_S, GL_CLAMP_TO_BORDER);
+    self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    self->params.egl->glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
    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_WRAP_S, GL_CLAMP_TO_BORDER);
+    self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    self->params.egl->glTexParameterfv(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_BORDER_COLOR, border_color);
    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 +133,9 @@ 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_WRAP_S, GL_CLAMP_TO_BORDER);
+    self->params.egl->glTexParameteri(cursor_texture_id_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    self->params.egl->glTexParameterfv(cursor_texture_id_target, GL_TEXTURE_BORDER_COLOR, border_color);
    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 +208,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 +218,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 +264,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 +429,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 +444,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 +502,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), cursor_texture_id_is_external, GSR_SOURCE_COLOR_RGB);

    self->params.egl->glDisable(GL_SCISSOR_TEST);
 }
@@ -546,8 +530,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, false, GSR_SOURCE_COLOR_RGB);

    self->params.egl->glDisable(GL_SCISSOR_TEST);
 }
@@ -589,7 +573,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 */
@@ -599,16 +584,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 +615,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,41 +631,22 @@ 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();
+    capture_pos.x += self->params.region_position.x;
+    capture_pos.y += self->params.region_position.y;

-    /* 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;
+    //self->params.egl->glFlush();
+    //self->params.egl->glFinish();
+
+    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);
    }

-    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);
-        }
-
-        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);
-    }
+    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), self->external_texture_fallback, GSR_SOURCE_COLOR_RGB);

    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);
@@ -706,15 +655,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);

--- a/src/capture/nvfbc.c
+++ b/src/capture/nvfbc.c
@@ -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,11 @@ 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};
+    const vec2i original_frame_size = frame_size;
+    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);
@@ -405,16 +391,16 @@ static int gsr_capture_nvfbc_capture(gsr_capture *cap, gsr_capture_metadata *cap
        return 0;
    }

-    self->params.egl->glFlush();
-    self->params.egl->glFinish();
+    //self->params.egl->glFlush();
+    //self->params.egl->glFinish();

    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,
-        0.0f, false, GSR_SOURCE_COLOR_BGR);
+        self->params.region_position, frame_size, original_frame_size,
+        GSR_ROT_0, false, GSR_SOURCE_COLOR_BGR);

-    self->params.egl->glFlush();
-    self->params.egl->glFinish();
+    //self->params.egl->glFlush();
+    //self->params.egl->glFinish();

    return 0;
 }
--- a/src/capture/portal.c
+++ b/src/capture/portal.c
@@ -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;

@@ -24,9 +23,6 @@ typedef struct {
    vec2i capture_size;
    gsr_pipewire_video_dmabuf_data dmabuf_data[GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES];
    int num_dmabuf_data;
-
-    bool fast_path_failed;
-    bool mesa_supports_compute_only_vaapi_copy;
 } gsr_capture_portal;

 static void gsr_capture_portal_cleanup_plane_fds(gsr_capture_portal *self) {
@@ -68,26 +64,31 @@ static void gsr_capture_portal_stop(gsr_capture_portal *self) {
 }

 static void gsr_capture_portal_create_input_textures(gsr_capture_portal *self) {
+    const float border_color[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+
    self->params.egl->glGenTextures(1, &self->texture_map.texture_id);
    self->params.egl->glBindTexture(GL_TEXTURE_2D, self->texture_map.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_WRAP_S, GL_CLAMP_TO_BORDER);
+    self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    self->params.egl->glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
    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->texture_map.external_texture_id);
    self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, self->texture_map.external_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_WRAP_S, GL_CLAMP_TO_BORDER);
+    self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    self->params.egl->glTexParameterfv(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_BORDER_COLOR, border_color);
    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);

    self->params.egl->glGenTextures(1, &self->texture_map.cursor_texture_id);
    self->params.egl->glBindTexture(GL_TEXTURE_2D, self->texture_map.cursor_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_WRAP_S, GL_CLAMP_TO_BORDER);
+    self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    self->params.egl->glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
    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);
@@ -298,21 +299,14 @@ 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);
-    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");
-
-    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);
-
    return 0;
 }

@@ -320,16 +314,6 @@ static int max_int(int a, int b) {
    return a > b ? a : b;
 }

-static void gsr_capture_portal_fail_fast_path_if_not_fast(gsr_capture_portal *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 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_portal_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
    (void)color_conversion;
    gsr_capture_portal *self = cap->priv;
@@ -350,45 +334,21 @@ static int gsr_capture_portal_capture(gsr_capture *cap, gsr_capture_metadata *ca
        return 0;
    }

-    gsr_capture_portal_fail_fast_path_if_not_fast(self, pipewire_fourcc);
-
    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_metadata->width / 2 - output_size.x / 2), max_int(0, capture_metadata->height / 2 - output_size.y / 2) };

-    self->params.egl->glFlush();
-    self->params.egl->glFinish();
+    //self->params.egl->glFlush();
+    //self->params.egl->glFinish();

    // TODO: Handle region crop

-    /* Fast opengl free path */
-    if(!self->fast_path_failed && 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 < self->num_dmabuf_data; ++i) {
-            fds[i] = self->dmabuf_data[i].fd;
-            offsets[i] = self->dmabuf_data[i].offset;
-            pitches[i] = self->dmabuf_data[i].stride;
-            modifiers[i] = pipewire_modifiers;
-        }
-        if(!vaapi_copy_drm_planes_to_video_surface(capture_metadata->video_codec_context, capture_metadata->frame, (vec2i){region.x, region.y}, self->capture_size, target_pos, output_size, pipewire_fourcc, self->capture_size, fds, offsets, pitches, modifiers, self->num_dmabuf_data)) {
-            fprintf(stderr, "gsr error: gsr_capture_portal_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;
-    }
-
-    if(self->fast_path_failed) {
-        gsr_color_conversion_draw(color_conversion, using_external_image ? self->texture_map.external_texture_id : self->texture_map.texture_id,
-            target_pos, output_size,
-            (vec2i){region.x, region.y}, self->capture_size,
-            0.0f, using_external_image, GSR_SOURCE_COLOR_RGB);
-    }
+    gsr_color_conversion_draw(color_conversion, using_external_image ? self->texture_map.external_texture_id : self->texture_map.texture_id,
+        target_pos, output_size,
+        (vec2i){region.x, region.y}, self->capture_size, self->capture_size,
+        GSR_ROT_0, using_external_image, GSR_SOURCE_COLOR_RGB);

    if(self->params.record_cursor && self->texture_map.cursor_texture_id > 0 && cursor_region.width > 0) {
        const vec2d scale = {
@@ -405,13 +365,13 @@ static int gsr_capture_portal_capture(gsr_capture *cap, gsr_capture_metadata *ca
        self->params.egl->glScissor(target_pos.x, target_pos.y, output_size.x, output_size.y);
        gsr_color_conversion_draw(color_conversion, self->texture_map.cursor_texture_id,
            (vec2i){cursor_pos.x, cursor_pos.y}, (vec2i){cursor_region.width * scale.x, cursor_region.height * scale.y},
-            (vec2i){0, 0}, (vec2i){cursor_region.width, cursor_region.height},
-            0.0f, false, GSR_SOURCE_COLOR_RGB);
+            (vec2i){0, 0}, (vec2i){cursor_region.width, cursor_region.height}, (vec2i){cursor_region.width, cursor_region.height},
+            GSR_ROT_0, false, GSR_SOURCE_COLOR_RGB);
        self->params.egl->glDisable(GL_SCISSOR_TEST);
    }

-    self->params.egl->glFlush();
-    self->params.egl->glFinish();
+    //self->params.egl->glFlush();
+    //self->params.egl->glFinish();

    gsr_capture_portal_cleanup_plane_fds(self);

--- a/src/capture/xcomposite.c
+++ b/src/capture/xcomposite.c
@@ -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;
@@ -37,7 +34,6 @@ typedef struct {
    gsr_cursor cursor;

    bool clear_background;
-    bool fast_path_failed;
 } gsr_capture_xcomposite;

 static void gsr_capture_xcomposite_stop(gsr_capture_xcomposite *self) {
@@ -113,18 +109,13 @@ 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);
-    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");
-
    self->window_resize_timer = clock_get_monotonic_seconds();
    return 0;
 }
@@ -262,25 +253,13 @@ static int gsr_capture_xcomposite_capture(gsr_capture *cap, gsr_capture_metadata

    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) };

-    self->params.egl->glFlush();
-    self->params.egl->glFinish();
+    //self->params.egl->glFlush();
+    //self->params.egl->glFinish();

-    /* Fast opengl free path */
-    if(!self->fast_path_failed && video_codec_context_is_vaapi(capture_metdata->video_codec_context) && self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_AMD) {
-        if(!vaapi_copy_egl_image_to_video_surface(self->params.egl, self->window_texture.image, (vec2i){0, 0}, self->texture_size, target_pos, output_size, capture_metdata->video_codec_context, capture_metdata->frame)) {
-            fprintf(stderr, "gsr error: gsr_capture_xcomposite_capture: vaapi_copy_egl_image_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;
-    }
-
-    if(self->fast_path_failed) {
-        gsr_color_conversion_draw(color_conversion, window_texture_get_opengl_texture_id(&self->window_texture),
-            target_pos, output_size,
-            (vec2i){0, 0}, self->texture_size,
-            0.0f, false, GSR_SOURCE_COLOR_RGB);
-    }
+    gsr_color_conversion_draw(color_conversion, window_texture_get_opengl_texture_id(&self->window_texture),
+        target_pos, output_size,
+        (vec2i){0, 0}, self->texture_size, self->texture_size,
+        GSR_ROT_0, false, GSR_SOURCE_COLOR_RGB);

    if(self->params.record_cursor && self->cursor.visible) {
        const vec2d scale = {
@@ -295,19 +274,17 @@ static int gsr_capture_xcomposite_capture(gsr_capture *cap, gsr_capture_metadata
            target_pos.y + (self->cursor.position.y - self->cursor.hotspot.y) * scale.y
        };

-        self->params.egl->glEnable(GL_SCISSOR_TEST);
-        self->params.egl->glScissor(target_pos.x, target_pos.y, output_size.x, output_size.y);
+        if(cursor_pos.x < target_pos.x || cursor_pos.x + self->cursor.size.x > target_pos.x + output_size.x || cursor_pos.y < target_pos.y || cursor_pos.y + self->cursor.size.y > target_pos.y + output_size.y)
+            self->clear_background = true;

        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);
+            (vec2i){0, 0}, self->cursor.size, self->cursor.size,
+            GSR_ROT_0, false, GSR_SOURCE_COLOR_RGB);
    }

-    self->params.egl->glFlush();
-    self->params.egl->glFinish();
+    //self->params.egl->glFlush();
+    //self->params.egl->glFinish();

    return 0;
 }
--- a/src/capture/ximage.c
+++ b/src/capture/ximage.c
@@ -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, self->capture_size,
+        GSR_ROT_0, 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, self->cursor.size,
+            GSR_ROT_0, 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;
+}
--- a/src/color_conversion.c
+++ b/src/color_conversion.c
@@ -1,26 +1,19 @@
 #include "../include/color_conversion.h"
 #include "../include/egl.h"
 #include <stdio.h>
-#include <string.h>
 #include <math.h>
+#include <string.h>
 #include <assert.h>

-/* TODO: highp instead of mediump? */
+#define SHADER_INDEX_Y            0
+#define SHADER_INDEX_UV           1
+#define SHADER_INDEX_Y_EXTERNAL   2
+#define SHADER_INDEX_UV_EXTERNAL  3
+#define SHADER_INDEX_RGB          4
+#define SHADER_INDEX_RGB_EXTERNAL 5

-#define MAX_SHADERS 4
-#define MAX_FRAMEBUFFERS 2
-#define EXTERNAL_TEXTURE_SHADER_OFFSET 2
-
-static float abs_f(float v) {
-    return v >= 0.0f ? v : -v;
-}
-
-#define ROTATE_Z   "mat4 rotate_z(in float angle) {\n"                        \
-                   "    return mat4(cos(angle), -sin(angle), 0.0, 0.0,\n"     \
-                   "                sin(angle),  cos(angle), 0.0, 0.0,\n"     \
-                   "                0.0,           0.0,      1.0, 0.0,\n"     \
-                   "                0.0,           0.0,      0.0, 1.0);\n"    \
-                   "}\n"
+// TODO: Scissor doesn't work with compute shader. In the compute shader this can be implemented with two step calls, and using the result
+// with a call to mix to choose source/output color.

 /* https://en.wikipedia.org/wiki/YCbCr, see study/color_space_transform_matrix.png */

@@ -50,6 +43,10 @@ static float abs_f(float v) {
                            "                           0.060118,  0.429412, -0.038049, 0.000000,\n" \
                            "                           0.062745,  0.500000,  0.500000, 1.000000);\n"

+static int max_int(int a, int b) {
+    return a > b ? a : b;
+}
+
 static const char* color_format_range_get_transform_matrix(gsr_destination_color color_format, gsr_color_range color_range) {
    switch(color_format) {
        case GSR_DESTINATION_COLOR_NV12: {
@@ -78,194 +75,134 @@ static const char* color_format_range_get_transform_matrix(gsr_destination_color
    return NULL;
 }

-static int load_shader_y(gsr_shader *shader, gsr_egl *egl, gsr_color_uniforms *uniforms, gsr_destination_color color_format, gsr_color_range color_range, bool external_texture) {
+// TODO: Make alpha blending optional
+// TODO: Optimize these shaders.
+static int load_compute_shader_y(gsr_shader *shader, gsr_egl *egl, gsr_color_uniforms *uniforms, int max_local_size_dim, gsr_destination_color color_format, gsr_color_range color_range, bool external_texture) {
    const char *color_transform_matrix = color_format_range_get_transform_matrix(color_format, color_range);

-    char vertex_shader[2048];
-    snprintf(vertex_shader, sizeof(vertex_shader),
-        "#version 300 es                                   \n"
-        "in vec2 pos;                                      \n"
-        "in vec2 texcoords;                                \n"
-        "out vec2 texcoords_out;                           \n"
-        "uniform vec2 offset;                              \n"
-        "uniform float rotation;                           \n"
-        ROTATE_Z
-        "void main()                                       \n"
-        "{                                                 \n"
-        "  texcoords_out = (vec4(texcoords.x - 0.5, texcoords.y - 0.5, 0.0, 0.0) * rotate_z(rotation)).xy + vec2(0.5, 0.5);  \n"
-        "  gl_Position = vec4(offset.x, offset.y, 0.0, 0.0) + vec4(pos.x, pos.y, 0.0, 1.0);    \n"
-        "}                                                 \n");
+    char compute_shader[2048];
+    snprintf(compute_shader, sizeof(compute_shader),
+        "#version 310 es\n"
+        "#extension GL_OES_EGL_image_external : enable\n"
+        "#extension GL_OES_EGL_image_external_essl3 : require\n"
+        "precision highp float;\n"
+        "layout (local_size_x = %d, local_size_y = %d, local_size_z = 1) in;\n"
+        "layout(binding = 0) uniform highp %s img_input;\n"
+        "layout(binding = 1) uniform highp sampler2D img_background;\n"
+        "uniform ivec2 source_position;\n"
+        "uniform ivec2 target_position;\n"
+        "uniform vec2 scale;\n"
+        "uniform mat2 rotation_matrix;\n"
+        "layout(rgba8, binding = 0) writeonly uniform highp image2D img_output;\n"
+        "%s"
+        "void main() {\n"
+        "    ivec2 texel_coord = ivec2(gl_GlobalInvocationID.xy);\n"
+        "    ivec2 size = ivec2(vec2(textureSize(img_input, 0)) * scale + 0.5);\n"
+        "    ivec2 output_size = textureSize(img_background, 0);\n"
+        "    vec2 rotated_texel_coord = vec2(texel_coord - source_position - size/2) * rotation_matrix + vec2(size/2) + 0.5;\n"
+        "    vec2 output_texel_coord = vec2(texel_coord - source_position + target_position) + 0.5;\n"
+        "    vec2 tex_coord = vec2(rotated_texel_coord)/vec2(size);\n"
+        "    vec4 source_color = texture(img_input, tex_coord);\n"
+        "    vec4 source_color_yuv = RGBtoYUV * vec4(source_color.rgb, 1.0);\n"
+        "    vec4 output_color_yuv = texture(img_background, output_texel_coord/vec2(output_size));\n"
+        "    float y_color = mix(output_color_yuv.r, source_color_yuv.r, source_color.a);\n"
+        "    imageStore(img_output, texel_coord + target_position, vec4(y_color, 1.0, 1.0, 1.0));\n"
+        "}\n", max_local_size_dim, max_local_size_dim, external_texture ? "samplerExternalOES" : "sampler2D", color_transform_matrix);

-    const char *main_code =
-        main_code =
-            "  vec4 pixel = texture(tex1, texcoords_out);                                    \n"
-            "  FragColor.x = (RGBtoYUV * vec4(pixel.rgb, 1.0)).x;                            \n"
-            "  FragColor.w = pixel.a;                                                        \n";
-
-    char fragment_shader[2048];
-    if(external_texture) {
-        snprintf(fragment_shader, sizeof(fragment_shader),
-            "#version 300 es                                                                 \n"
-            "#extension GL_OES_EGL_image_external : enable                                   \n"
-            "#extension GL_OES_EGL_image_external_essl3 : require                            \n"
-            "precision mediump float;                                                        \n"
-            "in vec2 texcoords_out;                                                          \n"
-            "uniform samplerExternalOES tex1;                                                \n"
-            "out vec4 FragColor;                                                             \n"
-            "%s"
-            "void main()                                                                     \n"
-            "{                                                                               \n"
-            "%s"
-            "}                                                                               \n", color_transform_matrix, main_code);
-    } else {
-        snprintf(fragment_shader, sizeof(fragment_shader),
-            "#version 300 es                                                                 \n"
-            "precision mediump float;                                                        \n"
-            "in vec2 texcoords_out;                                                          \n"
-            "uniform sampler2D tex1;                                                         \n"
-            "out vec4 FragColor;                                                             \n"
-            "%s"
-            "void main()                                                                     \n"
-            "{                                                                               \n"
-            "%s"
-            "}                                                                               \n", color_transform_matrix, main_code);
-    }
-
-    if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0)
+    if(gsr_shader_init(shader, egl, NULL, NULL, compute_shader) != 0)
        return -1;

-    gsr_shader_bind_attribute_location(shader, "pos", 0);
-    gsr_shader_bind_attribute_location(shader, "texcoords", 1);
-    uniforms->offset = egl->glGetUniformLocation(shader->program_id, "offset");
-    uniforms->rotation = egl->glGetUniformLocation(shader->program_id, "rotation");
+    uniforms->source_position = egl->glGetUniformLocation(shader->program_id, "source_position");
+    uniforms->target_position = egl->glGetUniformLocation(shader->program_id, "target_position");
+    uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix");
+    uniforms->scale = egl->glGetUniformLocation(shader->program_id, "scale");
    return 0;
 }

-static unsigned int load_shader_uv(gsr_shader *shader, gsr_egl *egl, gsr_color_uniforms *uniforms, gsr_destination_color color_format, gsr_color_range color_range, bool external_texture) {
+static int load_compute_shader_uv(gsr_shader *shader, gsr_egl *egl, gsr_color_uniforms *uniforms, int max_local_size_dim, gsr_destination_color color_format, gsr_color_range color_range, bool external_texture) {
    const char *color_transform_matrix = color_format_range_get_transform_matrix(color_format, color_range);

-    char vertex_shader[2048];
-    snprintf(vertex_shader, sizeof(vertex_shader),
-        "#version 300 es                                 \n"
-        "in vec2 pos;                                    \n"
-        "in vec2 texcoords;                              \n"
-        "out vec2 texcoords_out;                         \n"
-        "uniform vec2 offset;                            \n"
-        "uniform float rotation;                         \n"
-        ROTATE_Z
-        "void main()                                     \n"
-        "{                                               \n"
-        "  texcoords_out = (vec4(texcoords.x - 0.5, texcoords.y - 0.5, 0.0, 0.0) * rotate_z(rotation)).xy + vec2(0.5, 0.5);                      \n"
-        "  gl_Position = (vec4(offset.x, offset.y, 0.0, 0.0) + vec4(pos.x, pos.y, 0.0, 1.0)) * vec4(0.5, 0.5, 1.0, 1.0) - vec4(0.5, 0.5, 0.0, 0.0);   \n"
-        "}                                               \n");
+    char compute_shader[2048];
+    snprintf(compute_shader, sizeof(compute_shader),
+        "#version 310 es\n"
+        "#extension GL_OES_EGL_image_external : enable\n"
+        "#extension GL_OES_EGL_image_external_essl3 : require\n"
+        "precision highp float;\n"
+        "layout (local_size_x = %d, local_size_y = %d, local_size_z = 1) in;\n"
+        "layout(binding = 0) uniform highp %s img_input;\n"
+        "layout(binding = 1) uniform highp sampler2D img_background;\n"
+        "uniform ivec2 source_position;\n"
+        "uniform ivec2 target_position;\n"
+        "uniform vec2 scale;\n"
+        "uniform mat2 rotation_matrix;\n"
+        "layout(rgba8, binding = 0) writeonly uniform highp image2D img_output;\n"
+        "%s"
+        "void main() {\n"
+        "    ivec2 texel_coord = ivec2(gl_GlobalInvocationID.xy);\n"
+        "    ivec2 size = ivec2(vec2(textureSize(img_input, 0)) * scale + 0.5);\n"
+        "    ivec2 output_size = textureSize(img_background, 0);\n"
+        "    vec2 rotated_texel_coord = vec2(texel_coord - source_position/2 - size/4) * rotation_matrix + vec2(size/4) + 0.5;\n"
+        "    vec2 output_texel_coord = vec2(texel_coord - source_position/2 + target_position/2) + 0.5;\n"
+        "    vec2 tex_coord = vec2(rotated_texel_coord)/vec2(size);\n"
+        "    vec4 source_color = texture(img_input, tex_coord * 2.0);\n"
+        "    vec4 source_color_yuv = RGBtoYUV * vec4(source_color.rgb, 1.0);\n"
+        "    vec4 output_color_yuv = texture(img_background, output_texel_coord/vec2(output_size));\n"
+        "    vec2 uv_color = mix(output_color_yuv.rg, source_color_yuv.gb, source_color.a);\n"
+        "    imageStore(img_output, texel_coord + target_position/2, vec4(uv_color, 1.0, 1.0));\n"
+        "}\n", max_local_size_dim, max_local_size_dim, external_texture ? "samplerExternalOES" : "sampler2D", color_transform_matrix);

-    const char *main_code =
-        main_code =
-            "  vec4 pixel = texture(tex1, texcoords_out);                                          \n"
-            "  FragColor.xy = (RGBtoYUV * vec4(pixel.rgb, 1.0)).yz;                                \n"
-            "  FragColor.w = pixel.a;                                                              \n";
-
-    char fragment_shader[2048];
-    if(external_texture) {
-        snprintf(fragment_shader, sizeof(fragment_shader),
-            "#version 300 es                                                                       \n"
-            "#extension GL_OES_EGL_image_external : enable                                         \n"
-            "#extension GL_OES_EGL_image_external_essl3 : require                                  \n"
-            "precision mediump float;                                                              \n"
-            "in vec2 texcoords_out;                                                                \n"
-            "uniform samplerExternalOES tex1;                                                      \n"
-            "out vec4 FragColor;                                                                   \n"
-            "%s"
-            "void main()                                                                           \n"
-            "{                                                                                     \n"
-            "%s"
-            "}                                                                                     \n", color_transform_matrix, main_code);
-    } else {
-        snprintf(fragment_shader, sizeof(fragment_shader),
-            "#version 300 es                                                                       \n"
-            "precision mediump float;                                                              \n"
-            "in vec2 texcoords_out;                                                                \n"
-            "uniform sampler2D tex1;                                                               \n"
-            "out vec4 FragColor;                                                                   \n"
-            "%s"
-            "void main()                                                                           \n"
-            "{                                                                                     \n"
-            "%s"
-            "}                                                                                     \n", color_transform_matrix, main_code);
-    }
-
-    if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0)
+    if(gsr_shader_init(shader, egl, NULL, NULL, compute_shader) != 0)
        return -1;

-    gsr_shader_bind_attribute_location(shader, "pos", 0);
-    gsr_shader_bind_attribute_location(shader, "texcoords", 1);
-    uniforms->offset = egl->glGetUniformLocation(shader->program_id, "offset");
-    uniforms->rotation = egl->glGetUniformLocation(shader->program_id, "rotation");
+    uniforms->source_position = egl->glGetUniformLocation(shader->program_id, "source_position");
+    uniforms->target_position = egl->glGetUniformLocation(shader->program_id, "target_position");
+    uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix");
+    uniforms->scale = egl->glGetUniformLocation(shader->program_id, "scale");
    return 0;
 }

-static unsigned int load_shader_rgb(gsr_shader *shader, gsr_egl *egl, gsr_color_uniforms *uniforms, bool external_texture) {
-    char vertex_shader[2048];
-    snprintf(vertex_shader, sizeof(vertex_shader),
-        "#version 300 es                                   \n"
-        "in vec2 pos;                                      \n"
-        "in vec2 texcoords;                                \n"
-        "out vec2 texcoords_out;                           \n"
-        "uniform vec2 offset;                              \n"
-        "uniform float rotation;                           \n"
-        ROTATE_Z
-        "void main()                                       \n"
-        "{                                                 \n"
-        "  texcoords_out = (vec4(texcoords.x - 0.5, texcoords.y - 0.5, 0.0, 0.0) * rotate_z(rotation)).xy + vec2(0.5, 0.5);  \n"
-        "  gl_Position = vec4(offset.x, offset.y, 0.0, 0.0) + vec4(pos.x, pos.y, 0.0, 1.0);    \n"
-        "}                                                 \n");
+static int load_compute_shader_rgb(gsr_shader *shader, gsr_egl *egl, gsr_color_uniforms *uniforms, int max_local_size_dim, bool external_texture) {
+    char compute_shader[2048];
+    snprintf(compute_shader, sizeof(compute_shader),
+        "#version 310 es\n"
+        "#extension GL_OES_EGL_image_external : enable\n"
+        "#extension GL_OES_EGL_image_external_essl3 : require\n"
+        "precision highp float;\n"
+        "layout (local_size_x = %d, local_size_y = %d, local_size_z = 1) in;\n"
+        "layout(binding = 0) uniform highp %s img_input;\n"
+        "layout(binding = 1) uniform highp sampler2D img_background;\n"
+        "uniform ivec2 source_position;\n"
+        "uniform ivec2 target_position;\n"
+        "uniform vec2 scale;\n"
+        "uniform mat2 rotation_matrix;\n"
+        "layout(rgba8, binding = 0) writeonly uniform highp image2D img_output;\n"
+        "void main() {\n"
+        "    ivec2 texel_coord = ivec2(gl_GlobalInvocationID.xy);\n"
+        "    ivec2 size = ivec2(vec2(textureSize(img_input, 0)) * scale + 0.5);\n"
+        "    ivec2 output_size = textureSize(img_background, 0);\n"
+        "    vec2 rotated_texel_coord = vec2(texel_coord - source_position - size/2) * rotation_matrix + vec2(size/2) + 0.5;\n"
+        "    vec2 output_texel_coord = vec2(texel_coord - source_position + target_position) + 0.5;\n"
+        "    vec2 tex_coord = vec2(rotated_texel_coord)/vec2(size);\n"
+        "    vec4 source_color = texture(img_input, tex_coord);\n"
+        "    vec4 output_color = texture(img_background, output_texel_coord/vec2(output_size));\n"
+        "    vec3 color = mix(output_color.rgb, source_color.rgb, source_color.a);\n"
+        "    imageStore(img_output, texel_coord + target_position, vec4(color, 1.0));\n"
+        "}\n", max_local_size_dim, max_local_size_dim, external_texture ? "samplerExternalOES" : "sampler2D");

-    const char *main_code =
-        main_code =
-            "  vec4 pixel = texture(tex1, texcoords_out);                                          \n"
-            "  FragColor = pixel;                                                                  \n";
-
-    char fragment_shader[2048];
-    if(external_texture) {
-        snprintf(fragment_shader, sizeof(fragment_shader),
-            "#version 300 es                                                                       \n"
-            "#extension GL_OES_EGL_image_external : enable                                         \n"
-            "#extension GL_OES_EGL_image_external_essl3 : require                                  \n"
-            "precision mediump float;                                                              \n"
-            "in vec2 texcoords_out;                                                                \n"
-            "uniform samplerExternalOES tex1;                                                      \n"
-            "out vec4 FragColor;                                                                   \n"
-            "void main()                                                                           \n"
-            "{                                                                                     \n"
-            "%s"
-            "}                                                                                     \n", main_code);
-    } else {
-        snprintf(fragment_shader, sizeof(fragment_shader),
-            "#version 300 es                                                                       \n"
-            "precision mediump float;                                                              \n"
-            "in vec2 texcoords_out;                                                                \n"
-            "uniform sampler2D tex1;                                                               \n"
-            "out vec4 FragColor;                                                                   \n"
-            "void main()                                                                           \n"
-            "{                                                                                     \n"
-            "%s"
-            "}                                                                                     \n", main_code);
-    }
-
-    if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0)
+    if(gsr_shader_init(shader, egl, NULL, NULL, compute_shader) != 0)
        return -1;

-    gsr_shader_bind_attribute_location(shader, "pos", 0);
-    gsr_shader_bind_attribute_location(shader, "texcoords", 1);
-    uniforms->offset = egl->glGetUniformLocation(shader->program_id, "offset");
-    uniforms->rotation = egl->glGetUniformLocation(shader->program_id, "rotation");
+    uniforms->source_position = egl->glGetUniformLocation(shader->program_id, "source_position");
+    uniforms->target_position = egl->glGetUniformLocation(shader->program_id, "target_position");
+    uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix");
+    uniforms->scale = egl->glGetUniformLocation(shader->program_id, "scale");
    return 0;
 }

 static int load_framebuffers(gsr_color_conversion *self) {
    /* TODO: Only generate the necessary amount of framebuffers (self->params.num_destination_textures) */
    const unsigned int draw_buffer = GL_COLOR_ATTACHMENT0;
-    self->params.egl->glGenFramebuffers(MAX_FRAMEBUFFERS, self->framebuffers);
+    self->params.egl->glGenFramebuffers(GSR_COLOR_CONVERSION_MAX_FRAMEBUFFERS, self->framebuffers);

    self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]);
    self->params.egl->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self->params.destination_textures[0], 0);
@@ -317,6 +254,10 @@ int gsr_color_conversion_init(gsr_color_conversion *self, const gsr_color_conver
    memset(self, 0, sizeof(*self));
    self->params.egl = params->egl;
    self->params = *params;
+    
+    int max_compute_work_group_invocations = 256;
+    self->params.egl->glGetIntegerv(GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS, &max_compute_work_group_invocations);
+    self->max_local_size_dim = sqrt(max_compute_work_group_invocations);

    switch(params->destination_color) {
        case GSR_DESTINATION_COLOR_NV12:
@@ -326,24 +267,24 @@ int gsr_color_conversion_init(gsr_color_conversion *self, const gsr_color_conver
                return -1;
            }

-            if(load_shader_y(&self->shaders[0], self->params.egl, &self->uniforms[0], params->destination_color, params->color_range, false) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y shader\n");
+            if(load_compute_shader_y(&self->shaders[SHADER_INDEX_Y], self->params.egl, &self->uniforms[SHADER_INDEX_Y], self->max_local_size_dim, params->destination_color, params->color_range, false) != 0) {
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y compute shader\n");
                goto err;
            }

-            if(load_shader_uv(&self->shaders[1], self->params.egl, &self->uniforms[1], params->destination_color, params->color_range, false) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV shader\n");
+            if(load_compute_shader_uv(&self->shaders[SHADER_INDEX_UV], self->params.egl, &self->uniforms[SHADER_INDEX_UV], self->max_local_size_dim, params->destination_color, params->color_range, false) != 0) {
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV compute shader\n");
                goto err;
            }

            if(self->params.load_external_image_shader) {
-                if(load_shader_y(&self->shaders[EXTERNAL_TEXTURE_SHADER_OFFSET], self->params.egl, &self->uniforms[EXTERNAL_TEXTURE_SHADER_OFFSET], params->destination_color, params->color_range, true) != 0) {
-                    fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y shader\n");
+                if(load_compute_shader_y(&self->shaders[SHADER_INDEX_Y_EXTERNAL], self->params.egl, &self->uniforms[SHADER_INDEX_Y_EXTERNAL], self->max_local_size_dim, params->destination_color, params->color_range, true) != 0) {
+                    fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y compute shader\n");
                    goto err;
                }

-                if(load_shader_uv(&self->shaders[EXTERNAL_TEXTURE_SHADER_OFFSET + 1], self->params.egl, &self->uniforms[EXTERNAL_TEXTURE_SHADER_OFFSET + 1], params->destination_color, params->color_range, true) != 0) {
-                    fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV shader\n");
+                if(load_compute_shader_uv(&self->shaders[SHADER_INDEX_UV_EXTERNAL], self->params.egl, &self->uniforms[SHADER_INDEX_UV_EXTERNAL], self->max_local_size_dim, params->destination_color, params->color_range, true) != 0) {
+                    fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV compute shader\n");
                    goto err;
                }
            }
@@ -355,14 +296,14 @@ int gsr_color_conversion_init(gsr_color_conversion *self, const gsr_color_conver
                return -1;
            }

-            if(load_shader_rgb(&self->shaders[0], self->params.egl, &self->uniforms[0], false) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y shader\n");
+            if(load_compute_shader_rgb(&self->shaders[SHADER_INDEX_RGB], self->params.egl, &self->uniforms[SHADER_INDEX_RGB], self->max_local_size_dim, false) != 0) {
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y compute shader\n");
                goto err;
            }

            if(self->params.load_external_image_shader) {
-                if(load_shader_rgb(&self->shaders[EXTERNAL_TEXTURE_SHADER_OFFSET], self->params.egl, &self->uniforms[EXTERNAL_TEXTURE_SHADER_OFFSET], true) != 0) {
-                    fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y shader\n");
+                if(load_compute_shader_rgb(&self->shaders[SHADER_INDEX_RGB_EXTERNAL], self->params.egl, &self->uniforms[SHADER_INDEX_RGB_EXTERNAL], self->max_local_size_dim, true) != 0) {
+                    fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y compute shader\n");
                    goto err;
                }
            }
@@ -397,18 +338,59 @@ void gsr_color_conversion_deinit(gsr_color_conversion *self) {
        self->vertex_array_object_id = 0;
    }

-    self->params.egl->glDeleteFramebuffers(MAX_FRAMEBUFFERS, self->framebuffers);
-    for(int i = 0; i < MAX_FRAMEBUFFERS; ++i) {
+    self->params.egl->glDeleteFramebuffers(GSR_COLOR_CONVERSION_MAX_FRAMEBUFFERS, self->framebuffers);
+    for(int i = 0; i < GSR_COLOR_CONVERSION_MAX_FRAMEBUFFERS; ++i) {
        self->framebuffers[i] = 0;
    }

-    for(int i = 0; i < MAX_SHADERS; ++i) {
+    for(int i = 0; i < GSR_COLOR_CONVERSION_MAX_SHADERS; ++i) {
        gsr_shader_deinit(&self->shaders[i]);
    }

    self->params.egl = NULL;
 }

+static void gsr_color_conversion_apply_rotation(gsr_rotation rotation, float rotation_matrix[2][2], vec2i *source_position, vec2i texture_size, vec2f scale) {
+    /*
+    rotation_matrix[0][0] =  cos(angle);
+    rotation_matrix[0][1] = -sin(angle);
+    rotation_matrix[1][0] =  sin(angle);
+    rotation_matrix[1][1] =  cos(angle);
+    The manual matrix code below is the same as this code above, but without floating-point errors.
+    This is done to remove any blurring caused by these floating-point errors.
+    */
+    switch(rotation) {
+        case GSR_ROT_0:
+            rotation_matrix[0][0] = 1.0f;
+            rotation_matrix[0][1] = 0.0f;
+            rotation_matrix[1][0] = 0.0f;
+            rotation_matrix[1][1] = 1.0f;
+            break;
+        case GSR_ROT_90:
+            rotation_matrix[0][0] =  0.0f;
+            rotation_matrix[0][1] = -1.0f;
+            rotation_matrix[1][0] =  1.0f;
+            rotation_matrix[1][1] =  0.0f;
+            source_position->x += (((double)texture_size.x*0.5 - (double)texture_size.y*0.5) * scale.x + 0.5);
+            source_position->y += (((double)texture_size.y*0.5 - (double)texture_size.x*0.5) * scale.y + 0.5);
+            break;
+        case GSR_ROT_180:
+            rotation_matrix[0][0] = -1.0f;
+            rotation_matrix[0][1] =  0.0f;
+            rotation_matrix[1][0] =  0.0f;
+            rotation_matrix[1][1] = -1.0f;
+            break;
+        case GSR_ROT_270:
+            rotation_matrix[0][0] =  0.0f;
+            rotation_matrix[0][1] =  1.0f;
+            rotation_matrix[1][0] = -1.0f;
+            rotation_matrix[1][1] =  0.0f;
+            source_position->x += (((double)texture_size.x*0.5 - (double)texture_size.y*0.5) * scale.x + 0.5);
+            source_position->y += (((double)texture_size.y*0.5 - (double)texture_size.x*0.5) * scale.y + 0.5);
+            break;
+    }
+}
+
 static void gsr_color_conversion_swizzle_texture_source(gsr_color_conversion *self, gsr_source_color source_color) {
    if(source_color == GSR_SOURCE_COLOR_BGR) {
        const int swizzle_mask[] = { GL_BLUE, GL_GREEN, GL_RED, 1 };
@@ -423,106 +405,99 @@ static void gsr_color_conversion_swizzle_reset(gsr_color_conversion *self, gsr_s
    }
 }

-/* |source_pos| is in pixel coordinates and |source_size|  */
-void gsr_color_conversion_draw(gsr_color_conversion *self, unsigned int texture_id, vec2i source_pos, vec2i source_size, vec2i texture_pos, vec2i texture_size, float rotation, bool external_texture, gsr_source_color source_color) {
-    // TODO: Remove this crap
-    rotation = M_PI*2.0f - rotation;
+typedef enum {
+    GSR_COLOR_COMP_Y,
+    GSR_COLOR_COMP_UV,
+    GSR_COLOR_COMP_RGB
+} gsr_color_component;

-    /* TODO: Do not call this every frame? */
-    vec2i dest_texture_size = {0, 0};
-    self->params.egl->glBindTexture(GL_TEXTURE_2D, self->params.destination_textures[0]);
-    self->params.egl->glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &dest_texture_size.x);
-    self->params.egl->glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &dest_texture_size.y);
-    self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
+static int color_component_get_texture_index(gsr_color_component color_component) {
+    switch(color_component) {
+        case GSR_COLOR_COMP_Y:   return 0;
+        case GSR_COLOR_COMP_UV:  return 1;
+        case GSR_COLOR_COMP_RGB: return 0;
+    }
+    assert(false);
+    return 0;
+}
+
+static unsigned int color_component_get_color_format(gsr_color_component color_component, bool use_16bit_colors) {
+    switch(color_component) {
+        case GSR_COLOR_COMP_Y:   return use_16bit_colors ? GL_R16 : GL_R8;
+        case GSR_COLOR_COMP_UV:  return use_16bit_colors ? GL_RG16 : GL_RG8;
+        case GSR_COLOR_COMP_RGB: return GL_RGBA8; // TODO: 16-bit color support
+    }
+    assert(false);
+    return GL_RGBA8;
+}
+
+static int color_component_get_shader_index(gsr_color_component color_component, bool external_texture) {
+    switch(color_component) {
+        case GSR_COLOR_COMP_Y:   return external_texture ? SHADER_INDEX_Y_EXTERNAL : SHADER_INDEX_Y;
+        case GSR_COLOR_COMP_UV:  return external_texture ? SHADER_INDEX_UV_EXTERNAL : SHADER_INDEX_UV;
+        case GSR_COLOR_COMP_RGB: return external_texture ? SHADER_INDEX_RGB_EXTERNAL : SHADER_INDEX_RGB;
+    }
+    assert(false);
+    return SHADER_INDEX_RGB;
+}
+
+static void gsr_color_conversion_dispatch_compute_shader(gsr_color_conversion *self, bool external_texture, float rotation_matrix[2][2], vec2i source_position, vec2i destination_pos, vec2i destination_size, vec2f scale, bool use_16bit_colors, gsr_color_component color_component) {
+    const int shader_index = color_component_get_shader_index(color_component, external_texture);
+    const int texture_index = color_component_get_texture_index(color_component);
+    const unsigned int color_format = color_component_get_color_format(color_component, use_16bit_colors);
+
+    self->params.egl->glActiveTexture(GL_TEXTURE1);
+    self->params.egl->glBindTexture(GL_TEXTURE_2D, self->params.destination_textures[texture_index]);
+    self->params.egl->glActiveTexture(GL_TEXTURE0);
+
+    gsr_color_uniforms *uniform = &self->uniforms[shader_index];
+    gsr_shader_use(&self->shaders[shader_index]);
+    self->params.egl->glUniformMatrix2fv(uniform->rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix);
+    self->params.egl->glUniform2i(uniform->source_position, source_position.x, source_position.y);
+    self->params.egl->glUniform2i(uniform->target_position, destination_pos.x, destination_pos.y);
+    self->params.egl->glUniform2f(uniform->scale, scale.x, scale.y);
+    self->params.egl->glBindImageTexture(0, self->params.destination_textures[texture_index], 0, GL_FALSE, 0, GL_WRITE_ONLY, color_format);
+    const double num_groups_x = ceil((double)destination_size.x/(double)self->max_local_size_dim);
+    const double num_groups_y = ceil((double)destination_size.y/(double)self->max_local_size_dim);
+    self->params.egl->glDispatchCompute(max_int(1, num_groups_x), max_int(1, num_groups_y), 1);
+}
+
+void gsr_color_conversion_draw(gsr_color_conversion *self, unsigned int texture_id, vec2i destination_pos, vec2i destination_size, vec2i source_pos, vec2i source_size, vec2i texture_size, gsr_rotation rotation, bool external_texture, gsr_source_color source_color) {
+    vec2f scale = {0.0f, 0.0f};
+    if(source_size.x > 0 && source_size.y > 0)
+        scale = (vec2f){ (double)destination_size.x/(double)source_size.x, (double)destination_size.y/(double)source_size.y };
+
+    vec2i source_position = {0, 0};
+    float rotation_matrix[2][2] = {{0, 0}, {0, 0}};
+    gsr_color_conversion_apply_rotation(rotation, rotation_matrix, &source_position, texture_size, scale);
+
+    source_position.x -= (source_pos.x * scale.x + 0.5);
+    source_position.y -= (source_pos.y * scale.y + 0.5);

    const int texture_target = external_texture ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
-
    self->params.egl->glBindTexture(texture_target, texture_id);
-
-    vec2i source_texture_size = {0, 0};
-    if(external_texture) {
-        assert(self->params.load_external_image_shader);
-        source_texture_size = source_size;
-    } else {
-        /* TODO: Do not call this every frame? */
-        self->params.egl->glGetTexLevelParameteriv(texture_target, 0, GL_TEXTURE_WIDTH, &source_texture_size.x);
-        self->params.egl->glGetTexLevelParameteriv(texture_target, 0, GL_TEXTURE_HEIGHT, &source_texture_size.y);
-    }
-
-    // TODO: Remove this crap
-    if(abs_f(M_PI * 0.5f - rotation) <= 0.001f || abs_f(M_PI * 1.5f - rotation) <= 0.001f) {
-        float tmp = source_texture_size.x;
-        source_texture_size.x = source_texture_size.y;
-        source_texture_size.y = tmp;
-    }
-
-    const vec2f pos_norm = {
-        ((float)source_pos.x / (dest_texture_size.x == 0 ? 1.0f : (float)dest_texture_size.x)) * 2.0f,
-        ((float)source_pos.y / (dest_texture_size.y == 0 ? 1.0f : (float)dest_texture_size.y)) * 2.0f,
-    };
-
-    const vec2f size_norm = {
-        ((float)source_size.x / (dest_texture_size.x == 0 ? 1.0f : (float)dest_texture_size.x)) * 2.0f,
-        ((float)source_size.y / (dest_texture_size.y == 0 ? 1.0f : (float)dest_texture_size.y)) * 2.0f,
-    };
-
-    const vec2f texture_pos_norm = {
-        (float)texture_pos.x / (source_texture_size.x == 0 ? 1.0f : (float)source_texture_size.x),
-        (float)texture_pos.y / (source_texture_size.y == 0 ? 1.0f : (float)source_texture_size.y),
-    };
-
-    const vec2f texture_size_norm = {
-        (float)texture_size.x / (source_texture_size.x == 0 ? 1.0f : (float)source_texture_size.x),
-        (float)texture_size.y / (source_texture_size.y == 0 ? 1.0f : (float)source_texture_size.y),
-    };
-
-    const float vertices[] = {
-        -1.0f + 0.0f,               -1.0f + 0.0f + size_norm.y, texture_pos_norm.x,                       texture_pos_norm.y + texture_size_norm.y,
-        -1.0f + 0.0f,               -1.0f + 0.0f,               texture_pos_norm.x,                       texture_pos_norm.y,
-        -1.0f + 0.0f + size_norm.x, -1.0f + 0.0f,               texture_pos_norm.x + texture_size_norm.x, texture_pos_norm.y,
-
-        -1.0f + 0.0f,               -1.0f + 0.0f + size_norm.y, texture_pos_norm.x,                       texture_pos_norm.y + texture_size_norm.y,
-        -1.0f + 0.0f + size_norm.x, -1.0f + 0.0f,               texture_pos_norm.x + texture_size_norm.x, texture_pos_norm.y,
-        -1.0f + 0.0f + size_norm.x, -1.0f + 0.0f + size_norm.y, texture_pos_norm.x + texture_size_norm.x, texture_pos_norm.y + texture_size_norm.y
-    };
-
    gsr_color_conversion_swizzle_texture_source(self, source_color);

-    self->params.egl->glBindVertexArray(self->vertex_array_object_id);
-    self->params.egl->glViewport(0, 0, dest_texture_size.x, dest_texture_size.y);
-
-    /* TODO: this, also cleanup */
-    //self->params.egl->glBindBuffer(GL_ARRAY_BUFFER, self->vertex_buffer_object_id);
-    self->params.egl->glBufferSubData(GL_ARRAY_BUFFER, 0, 24 * sizeof(float), vertices);
-
-    {
-        self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]);
-        //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); // TODO: Do this in a separate clear_ function. We want to do that when using multiple drm to create the final image (multiple monitors for example)
-
-        const int shader_index = external_texture ? EXTERNAL_TEXTURE_SHADER_OFFSET : 0;
-        gsr_shader_use(&self->shaders[shader_index]);
-        self->params.egl->glUniform1f(self->uniforms[shader_index].rotation, rotation);
-        self->params.egl->glUniform2f(self->uniforms[shader_index].offset, pos_norm.x, pos_norm.y);
-        self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6);
+    switch(self->params.destination_color) {
+        case GSR_DESTINATION_COLOR_NV12:
+        case GSR_DESTINATION_COLOR_P010: {
+            const bool use_16bit_colors = self->params.destination_color == GSR_DESTINATION_COLOR_P010;
+            gsr_color_conversion_dispatch_compute_shader(self, external_texture, rotation_matrix, source_position, destination_pos, destination_size, scale, use_16bit_colors, GSR_COLOR_COMP_Y);
+            gsr_color_conversion_dispatch_compute_shader(self, external_texture, rotation_matrix, source_position, destination_pos, (vec2i){destination_size.x/2, destination_size.y/2}, scale, use_16bit_colors, GSR_COLOR_COMP_UV);
+            break;
+        }
+        case GSR_DESTINATION_COLOR_RGB8: {
+            gsr_color_conversion_dispatch_compute_shader(self, external_texture, rotation_matrix, source_position, destination_pos, destination_size, scale, false, GSR_COLOR_COMP_RGB);
+            break;
+        }
    }

-    if(self->params.num_destination_textures > 1) {
-        self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[1]);
-        //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT);
-
-        const int shader_index = external_texture ? EXTERNAL_TEXTURE_SHADER_OFFSET + 1 : 1;
-        gsr_shader_use(&self->shaders[shader_index]);
-        self->params.egl->glUniform1f(self->uniforms[shader_index].rotation, rotation);
-        self->params.egl->glUniform2f(self->uniforms[shader_index].offset, pos_norm.x, pos_norm.y);
-        self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6);
-    }
-
-    self->params.egl->glBindVertexArray(0);
-    gsr_shader_use_none(&self->shaders[0]);
-    self->params.egl->glBindTexture(texture_target, 0);
-    self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    // TODO: Use the minimal barrier required
+    self->params.egl->glMemoryBarrier(GL_ALL_BARRIER_BITS); // GL_SHADER_IMAGE_ACCESS_BARRIER_BIT
+    self->params.egl->glUseProgram(0);

    gsr_color_conversion_swizzle_reset(self, source_color);
+    self->params.egl->glBindTexture(texture_target, 0);
 }

 void gsr_color_conversion_clear(gsr_color_conversion *self) {
@@ -559,3 +534,7 @@ void gsr_color_conversion_clear(gsr_color_conversion *self) {

    self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
+
+gsr_rotation gsr_monitor_rotation_to_rotation(gsr_monitor_rotation monitor_rotation) {
+    return (gsr_rotation)monitor_rotation;
+}
--- a/src/cursor.c
+++ b/src/cursor.c
@@ -56,8 +56,10 @@ static bool gsr_cursor_set_from_x11_cursor_image(gsr_cursor *self, XFixesCursorI
    self->egl->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, self->size.x, self->size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, cursor_data);
    free(cursor_data);

-    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    const float border_color[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    self->egl->glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

--- a/src/dbus.c
+++ b/src/dbus.c
@@ -614,9 +614,41 @@ int gsr_dbus_screencast_create_session(gsr_dbus *self, char **session_handle) {
    return 0;
 }

-int gsr_dbus_screencast_select_sources(gsr_dbus *self, const char *session_handle, gsr_portal_capture_type capture_type, gsr_portal_cursor_mode cursor_mode) {
+static uint32_t unset_unsupported_capture_types(uint32_t requested_capture_types, uint32_t available_capture_types) {
+    if(!(available_capture_types & GSR_PORTAL_CAPTURE_TYPE_MONITOR))
+        requested_capture_types &= ~GSR_PORTAL_CAPTURE_TYPE_MONITOR;
+    if(!(available_capture_types & GSR_PORTAL_CAPTURE_TYPE_WINDOW))
+        requested_capture_types &= ~GSR_PORTAL_CAPTURE_TYPE_WINDOW;
+    if(!(available_capture_types & GSR_PORTAL_CAPTURE_TYPE_VIRTUAL))
+        requested_capture_types &= ~GSR_PORTAL_CAPTURE_TYPE_VIRTUAL;
+    return requested_capture_types;
+}
+
+static uint32_t unset_unsupported_cursor_modes(uint32_t requested_cursor_modes, uint32_t available_cursor_modes) {
+    if(!(available_cursor_modes & GSR_PORTAL_CURSOR_MODE_HIDDEN))
+        requested_cursor_modes &= ~GSR_PORTAL_CURSOR_MODE_HIDDEN;
+    if(!(available_cursor_modes & GSR_PORTAL_CURSOR_MODE_EMBEDDED))
+        requested_cursor_modes &= ~GSR_PORTAL_CURSOR_MODE_EMBEDDED;
+    if(!(available_cursor_modes & GSR_PORTAL_CURSOR_MODE_METADATA))
+        requested_cursor_modes &= ~GSR_PORTAL_CURSOR_MODE_METADATA;
+    return requested_cursor_modes;
+}
+
+int gsr_dbus_screencast_select_sources(gsr_dbus *self, const char *session_handle, uint32_t capture_type, uint32_t cursor_mode) {
    assert(session_handle);

+    uint32_t available_source_types = 0;
+    gsr_dbus_desktop_portal_get_property(self, "org.freedesktop.portal.ScreenCast", "AvailableSourceTypes", &available_source_types);
+    if(available_source_types == 0)
+        fprintf(stderr, "gsr error: gsr_dbus_screencast_select_sources: no source types are available\n");
+    capture_type = unset_unsupported_capture_types(capture_type, available_source_types);
+
+    uint32_t available_cursor_modes = 0;
+    gsr_dbus_desktop_portal_get_property(self, "org.freedesktop.portal.ScreenCast", "AvailableCursorModes", &available_cursor_modes);
+    if(available_cursor_modes == 0)
+        fprintf(stderr, "gsr error: gsr_dbus_screencast_select_sources: no cursors modes are available\n");
+    cursor_mode = unset_unsupported_cursor_modes(cursor_mode, available_cursor_modes);
+
    char handle_token[64];
    gsr_dbus_portal_get_unique_handle_token(self, handle_token, sizeof(handle_token));

--- a/src/egl.c
+++ b/src/egl.c
@@ -283,15 +283,21 @@ static bool gsr_egl_load_gl(gsr_egl *self, void *library) {
        { (void**)&self->glClearColor, "glClearColor" },
        { (void**)&self->glGenTextures, "glGenTextures" },
        { (void**)&self->glDeleteTextures, "glDeleteTextures" },
+        { (void**)&self->glActiveTexture, "glActiveTexture" },
        { (void**)&self->glBindTexture, "glBindTexture" },
+        { (void**)&self->glBindImageTexture, "glBindImageTexture" },
        { (void**)&self->glTexParameteri, "glTexParameteri" },
        { (void**)&self->glTexParameteriv, "glTexParameteriv" },
+        { (void**)&self->glTexParameterfv, "glTexParameterfv" },
        { (void**)&self->glGetTexLevelParameteriv, "glGetTexLevelParameteriv" },
        { (void**)&self->glTexImage2D, "glTexImage2D" },
+        { (void**)&self->glTexSubImage2D, "glTexSubImage2D" },
        { (void**)&self->glGetTexImage, "glGetTexImage" },
        { (void**)&self->glGenFramebuffers, "glGenFramebuffers" },
        { (void**)&self->glBindFramebuffer, "glBindFramebuffer" },
        { (void**)&self->glDeleteFramebuffers, "glDeleteFramebuffers" },
+        { (void**)&self->glDispatchCompute, "glDispatchCompute" },
+        { (void**)&self->glMemoryBarrier, "glMemoryBarrier" },
        { (void**)&self->glViewport, "glViewport" },
        { (void**)&self->glFramebufferTexture2D, "glFramebufferTexture2D" },
        { (void**)&self->glDrawBuffers, "glDrawBuffers" },
@@ -324,14 +330,19 @@ 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" },
+        { (void**)&self->glUniform1i, "glUniform1i" },
+        { (void**)&self->glUniform2i, "glUniform2i" },
+        { (void**)&self->glUniformMatrix2fv, "glUniformMatrix2fv" },
        { (void**)&self->glDebugMessageCallback, "glDebugMessageCallback" },
        { (void**)&self->glScissor, "glScissor" },
        { (void**)&self->glReadPixels, "glReadPixels" },
        { (void**)&self->glMapBuffer, "glMapBuffer" },
        { (void**)&self->glUnmapBuffer, "glUnmapBuffer" },
+        { (void**)&self->glGetIntegerv, "glGetIntegerv" },

        { NULL, NULL }
    };
@@ -448,6 +459,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);
--- a/src/encoder/video/nvenc.c
+++ b/src/encoder/video/nvenc.c
@@ -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;
--- a/src/encoder/video/software.c
+++ b/src/encoder/video/software.c
@@ -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;
@@ -97,8 +83,8 @@ static void gsr_video_encoder_software_copy_textures_to_frame(gsr_video_encoder
    self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
    // cap_kms->kms.base.egl->eglSwapBuffers(cap_kms->kms.base.egl->egl_display, cap_kms->kms.base.egl->egl_surface);

-    self->params.egl->glFlush();
-    self->params.egl->glFinish();
+    //self->params.egl->glFlush();
+    //self->params.egl->glFinish();
 }

 static void gsr_video_encoder_software_get_textures(gsr_video_encoder *encoder, unsigned int *textures, int *num_textures, gsr_destination_color *destination_color) {
--- a/src/encoder/video/vaapi.c
+++ b/src/encoder/video/vaapi.c
@@ -92,6 +92,10 @@ static bool gsr_video_encoder_vaapi_setup_textures(gsr_video_encoder_vaapi *self
    if(self->prime.fourcc == VA_FOURCC_NV12 || self->prime.fourcc == VA_FOURCC_P010) {
        const uint32_t *formats = self->prime.fourcc == VA_FOURCC_NV12 ? formats_nv12 : formats_p010;
        const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size
+        const float border_colors[2][4] = {
+            {0.0f, 0.0f, 0.0f, 1.0f},
+            {0.5f, 0.5f, 0.0f, 1.0f}
+        };

        self->params.egl->glGenTextures(2, self->target_textures);
        for(int i = 0; i < 2; ++i) {
@@ -121,10 +125,11 @@ static bool gsr_video_encoder_vaapi_setup_textures(gsr_video_encoder_vaapi *self
            }

            self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[i]);
-            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->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+            self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+            self->params.egl->glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_colors[i]);
+            self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+            self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

            while(self->params.egl->glGetError()) {}
            while(self->params.egl->eglGetError() != EGL_SUCCESS){}
@@ -167,32 +172,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;

--- a/src/encoder/video/vulkan.c
+++ b/src/encoder/video/vulkan.c
@@ -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)
@@ -110,13 +94,13 @@ static bool gsr_video_encoder_vulkan_setup_textures(gsr_video_encoder_vulkan *se
    //AVVkFrame *target_surface_id = (AVVkFrame*)frame->data[0];
    self->vv = video_codec_context_get_vulkan_data(video_codec_context);

-    const unsigned int internal_formats_nv12[2] = { GL_RGBA8, GL_RGBA8 };
+    const unsigned int internal_formats_nv12[2] = { GL_RGBA8, GL_RGBA8 }; // TODO: GL_R8, GL_R16
    const unsigned int internal_formats_p010[2] = { GL_R16, GL_RG16 };
    const unsigned int formats[2] = { GL_RED, GL_RG };
    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;
--- a/src/image_writer.c
+++ b/src/image_writer.c
@@ -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_RGBA8, GL_RGBA, 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,13 +41,31 @@ 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;

-    uint8_t *frame_data = malloc(self->width * self->height * 3);
+    bool success = false;
+    switch(image_format) {
+        case GSR_IMAGE_FORMAT_JPEG:
+            success = stbi_write_jpg(filepath, self->width, self->height, 4, data, quality);
+            break;
+        case GSR_IMAGE_FORMAT_PNG:
+            success = stbi_write_png(filepath, self->width, self->height, 4, 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 * 4);
    if(!frame_data) {
        fprintf(stderr, "gsr error: gsr_image_writer_write_to_file: failed to allocate memory for image frame\n");
        return false;
@@ -61,25 +74,23 @@ bool gsr_image_writer_write_to_file(gsr_image_writer *self, const char *filepath
    // TODO: hdr support
    self->egl->glBindTexture(GL_TEXTURE_2D, self->texture);
    // We could use glGetTexSubImage, but it's only available starting from opengl 4.5
-    self->egl->glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_UNSIGNED_BYTE, frame_data);
+    self->egl->glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, frame_data);
    self->egl->glBindTexture(GL_TEXTURE_2D, 0);

    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;
+}
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -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"
@@ -16,8 +17,8 @@ extern "C" {
 #include "../include/codec_query/nvenc.h"
 #include "../include/codec_query/vaapi.h"
 #include "../include/codec_query/vulkan.h"
-#include "../include/window/window_x11.h"
-#include "../include/window/window_wayland.h"
+#include "../include/window/x11.h"
+#include "../include/window/wayland.h"
 #include "../include/egl.h"
 #include "../include/utils.h"
 #include "../include/damage.h"
@@ -74,19 +75,60 @@ 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;
+    vec2i monitor_size = monitor->size;
+    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);
+        if(monitor_rotation == GSR_MONITOR_ROT_90 || monitor_rotation == GSR_MONITOR_ROT_270)
+            std::swap(monitor_size.x, monitor_size.y);
+    }
+    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;
+
+    vec2i monitor_position = monitor->pos;
+    vec2i monitor_size = monitor->size;
+    if(gsr_window_get_display_server(data->window) == GSR_DISPLAY_SERVER_WAYLAND) {
+        gsr_monitor_rotation monitor_rotation = GSR_MONITOR_ROT_0;
+        drm_monitor_get_display_server_data(data->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);
+    }
+
+    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 +785,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 +795,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
 }
@@ -881,7 +923,7 @@ static void video_hardware_set_qp(AVCodecContext *codec_context, VideoQuality vi
                    av_dict_set_int(options, "qp", 30 * qp_multiply, 0);
                    break;
                case VideoQuality::VERY_HIGH:
-                    av_dict_set_int(options, "qp", 27 * qp_multiply, 0);
+                    av_dict_set_int(options, "qp", 25 * qp_multiply, 0);
                    break;
                case VideoQuality::ULTRA:
                    av_dict_set_int(options, "qp", 22 * qp_multiply, 0);
@@ -896,7 +938,7 @@ static void video_hardware_set_qp(AVCodecContext *codec_context, VideoQuality vi
                    av_dict_set_int(options, "qp", 30 * qp_multiply, 0);
                    break;
                case VideoQuality::VERY_HIGH:
-                    av_dict_set_int(options, "qp", 27 * qp_multiply, 0);
+                    av_dict_set_int(options, "qp", 25 * qp_multiply, 0);
                    break;
                case VideoQuality::ULTRA:
                    av_dict_set_int(options, "qp", 22 * qp_multiply, 0);
@@ -911,7 +953,7 @@ static void video_hardware_set_qp(AVCodecContext *codec_context, VideoQuality vi
                    av_dict_set_int(options, "qp", 30 * qp_multiply, 0);
                    break;
                case VideoQuality::VERY_HIGH:
-                    av_dict_set_int(options, "qp", 27 * qp_multiply, 0);
+                    av_dict_set_int(options, "qp", 25 * qp_multiply, 0);
                    break;
                case VideoQuality::ULTRA:
                    av_dict_set_int(options, "qp", 22 * qp_multiply, 0);
@@ -926,7 +968,7 @@ static void video_hardware_set_qp(AVCodecContext *codec_context, VideoQuality vi
                    av_dict_set_int(options, "qp", 30 * qp_multiply, 0);
                    break;
                case VideoQuality::VERY_HIGH:
-                    av_dict_set_int(options, "qp", 27 * qp_multiply, 0);
+                    av_dict_set_int(options, "qp", 25 * qp_multiply, 0);
                    break;
                case VideoQuality::ULTRA:
                    av_dict_set_int(options, "qp", 22 * qp_multiply, 0);
@@ -945,7 +987,7 @@ static void video_hardware_set_qp(AVCodecContext *codec_context, VideoQuality vi
                    av_dict_set_int(options, "qp", 30 * qp_multiply, 0);
                    break;
                case VideoQuality::VERY_HIGH:
-                    av_dict_set_int(options, "qp", 27 * qp_multiply, 0);
+                    av_dict_set_int(options, "qp", 25 * qp_multiply, 0);
                    break;
                case VideoQuality::ULTRA:
                    av_dict_set_int(options, "qp", 22 * qp_multiply, 0);
@@ -960,7 +1002,7 @@ static void video_hardware_set_qp(AVCodecContext *codec_context, VideoQuality vi
                    av_dict_set_int(options, "qp", 30 * qp_multiply, 0);
                    break;
                case VideoQuality::VERY_HIGH:
-                    av_dict_set_int(options, "qp", 27 * qp_multiply, 0);
+                    av_dict_set_int(options, "qp", 25 * qp_multiply, 0);
                    break;
                case VideoQuality::ULTRA:
                    av_dict_set_int(options, "qp", 22 * qp_multiply, 0);
@@ -975,7 +1017,7 @@ static void video_hardware_set_qp(AVCodecContext *codec_context, VideoQuality vi
                    av_dict_set_int(options, "qp", 30 * qp_multiply, 0);
                    break;
                case VideoQuality::VERY_HIGH:
-                    av_dict_set_int(options, "qp", 27 * qp_multiply, 0);
+                    av_dict_set_int(options, "qp", 25 * qp_multiply, 0);
                    break;
                case VideoQuality::ULTRA:
                    av_dict_set_int(options, "qp", 22 * qp_multiply, 0);
@@ -1038,8 +1080,9 @@ static void open_video_hardware(AVCodecContext *codec_context, VideoQuality vide
        // TODO: More quality options
        if(low_power)
            av_dict_set_int(&options, "low_power", 1, 0);
-        // Improves performance but increases vram
-        //av_dict_set_int(&options, "async_depth", 8, 0);
+        // Improves performance but increases vram.
+        // TODO: Might need a different async_depth for optimal performance on different amd/intel gpus
+        av_dict_set_int(&options, "async_depth", 3, 0);

        if(codec_context->codec_id == AV_CODEC_ID_H264) {
            // Removed because it causes stutter in games for some people
@@ -1070,7 +1113,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 +1124,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 +1143,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 +1233,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");
@@ -1211,7 +1261,7 @@ static void usage_full() {
    printf("          window\n");
    printf("          DP-1|1920x1080\n");
    printf("        The <option> and <monitor_name> is the name that can be passed to GPU Screen Recorder with the -w option.\n");
-    printf("        --list-capture-options optionally accepts a card path (\"/dev/dri/cardN\") and vendor (\"amd\", \"intel\" or \"nvidia\") which can improve the performance of running this command.\n");
+    printf("        --list-capture-options optionally accepts a card path (\"/dev/dri/cardN\") and vendor (\"amd\", \"intel\", \"nvidia\" or \"broadcom\") which can improve the performance of running this command.\n");
    printf("\n");
    printf("  --list-audio-devices\n");
    printf("        List audio devices. Lists audio devices in the following format (prints them to stdout and exits):\n");
@@ -1249,18 +1299,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);
@@ -1878,7 +1931,8 @@ static gsr_video_encoder* create_video_encoder(gsr_egl *egl, bool overclock, gsr

    switch(egl->gpu_info.vendor) {
        case GSR_GPU_VENDOR_AMD:
-        case GSR_GPU_VENDOR_INTEL: {
+        case GSR_GPU_VENDOR_INTEL:
+        case GSR_GPU_VENDOR_BROADCOM: {
            gsr_video_encoder_vaapi_params params;
            params.egl = egl;
            params.color_depth = color_depth;
@@ -1912,6 +1966,7 @@ static bool get_supported_video_codecs(gsr_egl *egl, VideoCodec video_codec, boo
    switch(egl->gpu_info.vendor) {
        case GSR_GPU_VENDOR_AMD:
        case GSR_GPU_VENDOR_INTEL:
+        case GSR_GPU_VENDOR_BROADCOM:
            return gsr_get_supported_video_codecs_vaapi(video_codecs, egl->card_path, cleanup);
        case GSR_GPU_VENDOR_NVIDIA:
            return gsr_get_supported_video_codecs_nvenc(video_codecs, cleanup);
@@ -1985,6 +2040,9 @@ static void list_gpu_info(gsr_egl *egl) {
        case GSR_GPU_VENDOR_NVIDIA:
            printf("vendor|nvidia\n");
            break;
+        case GSR_GPU_VENDOR_BROADCOM:
+            printf("vendor|broadcom\n");
+            break;
    }
    printf("card_path|%s\n", egl->card_path);
 }
@@ -2097,8 +2155,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 +2172,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;
@@ -2322,6 +2383,9 @@ static bool gpu_vendor_from_string(const char *vendor_str, gsr_gpu_vendor *vendo
    } else if(strcmp(vendor_str, "nvidia") == 0) {
        *vendor = GSR_GPU_VENDOR_NVIDIA;
        return true;
+    } else if(strcmp(vendor_str, "broadcom") == 0) {
+        *vendor = GSR_GPU_VENDOR_BROADCOM;
+        return true;
    } else {
        return false;
    }
@@ -2333,12 +2397,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 +2412,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 +2544,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 +2555,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 +2584,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 +2619,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 +2635,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 +2657,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 +2687,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);
    }

@@ -3203,7 +3330,7 @@ int main(int argc, char **argv) {
            const char *vendor_str = argv[3];
            gsr_gpu_vendor vendor;
            if(!gpu_vendor_from_string(vendor_str, &vendor)) {
-                fprintf(stderr, "Error: \"%s\" is not a valid vendor, expected \"amd\", \"intel\" or \"nvidia\"\n", vendor_str);
+                fprintf(stderr, "Error: \"%s\" is not a valid vendor, expected \"amd\", \"intel\", \"nvidia\" or \"broadcom\"\n", vendor_str);
                _exit(1);
            }

@@ -3229,6 +3356,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} } },
@@ -3249,7 +3377,7 @@ int main(int argc, char **argv) {
        { "-cursor",                        Arg { {},  is_optional,  !is_list,  ArgType::BOOLEAN, {false} } },
        { "-keyint",                        Arg { {},  is_optional,  !is_list,  ArgType::STRING,  {false} } },
        { "-restore-portal-session",        Arg { {},  is_optional,  !is_list,  ArgType::BOOLEAN, {false} } },
-        { "-portal-session-token-filepath", Arg { {},  is_optional,  !is_list,  ArgType::BOOLEAN, {false} } },
+        { "-portal-session-token-filepath", Arg { {},  is_optional,  !is_list,  ArgType::STRING,  {false} } },
        { "-encoder",                       Arg { {},  is_optional,  !is_list,  ArgType::STRING,  {false} } },
    };

@@ -3550,7 +3678,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 +3831,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 +3848,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 +3929,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 +3948,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 +3964,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 +4033,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 +4045,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);
    }

--- a/src/pipewire_audio.c
+++ b/src/pipewire_audio.c
@@ -329,22 +329,20 @@ static const struct pw_metadata_events metadata_events = {
 static void on_metadata_proxy_removed_cb(void *data) {
    gsr_pipewire_audio *self = data;
    if(self->metadata_proxy) {
-        // TODO:
-        //pw_proxy_destroy(self->metadata_proxy);
-        //self->metadata_proxy = NULL;
+        pw_proxy_destroy(self->metadata_proxy);
+        self->metadata_proxy = NULL;
    }
 }

 static void on_metadata_proxy_destroy_cb(void *data) {
 	gsr_pipewire_audio *self = data;

-    // TODO:
-	//spa_hook_remove(&metadata->metadata_listener);
-	//spa_hook_remove(&metadata->proxy_listener);
-	//spa_zero(metadata->metadata_listener);
-	//spa_zero(metadata->proxy_listener);
+	spa_hook_remove(&self->metadata_listener);
+	spa_hook_remove(&self->metadata_proxy_listener);
+	spa_zero(self->metadata_listener);
+	spa_zero(self->metadata_proxy_listener);

-	//self->metadata_proxy = NULL;
+	self->metadata_proxy = NULL;
 }

 static const struct pw_proxy_events metadata_proxy_events = {
@@ -365,11 +363,10 @@ static bool gsr_pipewire_audio_listen_on_metadata(gsr_pipewire_audio *self, uint
        return false;
    }

-    // TODO:
    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);

-    //struct spa_hook proxy_listener;
-    //pw_proxy_add_listener(self->metadata_proxy, &proxy_listener, &metadata_proxy_events, self);
+    self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, self->server_version_sync);
    return true;
 }

@@ -549,15 +546,14 @@ bool gsr_pipewire_audio_init(gsr_pipewire_audio *self) {

    pw_context_load_module(self->context, "libpipewire-module-link-factory", NULL, NULL);

-    pw_thread_loop_lock(self->thread_loop);
-
    if(pw_thread_loop_start(self->thread_loop) < 0) {
        fprintf(stderr, "gsr error: gsr_pipewire_audio_init: failed to start thread\n");
-        pw_thread_loop_unlock(self->thread_loop);
        gsr_pipewire_audio_deinit(self);
        return false;
    }

+    pw_thread_loop_lock(self->thread_loop);
+
    self->core = pw_context_connect(self->context, pw_properties_new(PW_KEY_REMOTE_NAME, NULL, NULL), 0);
    if(!self->core) {
        pw_thread_loop_unlock(self->thread_loop);
@@ -571,8 +567,9 @@ bool gsr_pipewire_audio_init(gsr_pipewire_audio *self) {
    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, 0);
+    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;
 }
@@ -592,10 +589,17 @@ void gsr_pipewire_audio_deinit(gsr_pipewire_audio *self) {
    self->num_virtual_sink_proxies = 0;

    if(self->metadata_proxy) {
+        spa_hook_remove(&self->metadata_listener);
+        spa_hook_remove(&self->metadata_proxy_listener);
        pw_proxy_destroy(self->metadata_proxy);
+        spa_zero(self->metadata_listener);
+        spa_zero(self->metadata_proxy_listener);
        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;
--- a/src/pipewire_video.c
+++ b/src/pipewire_video.c
@@ -413,6 +413,7 @@ static void renegotiate_format(void *data, uint64_t expirations) {
    uint8_t params_buffer[4096];
    struct spa_pod_builder pod_builder = SPA_POD_BUILDER_INIT(params_buffer, sizeof(params_buffer));
    if (!gsr_pipewire_video_build_format_params(self, &pod_builder, params, &num_video_formats)) {
+        fprintf(stderr, "gsr error: renegotiate_format: failed to build formats\n");
        pw_thread_loop_unlock(self->thread_loop);
        return;
    }
@@ -509,6 +510,9 @@ static bool gsr_pipewire_video_setup_stream(gsr_pipewire_video *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);
+
    gsr_pipewire_video_init_modifiers(self);

    // TODO: Cleanup?
@@ -519,9 +523,6 @@ static bool gsr_pipewire_video_setup_stream(gsr_pipewire_video *self) {
        goto error;
    }

-    self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, 0);
-    pw_thread_loop_wait(self->thread_loop);
-
    self->stream = pw_stream_new(self->core, "com.dec05eba.gpu_screen_recorder",
        pw_properties_new(PW_KEY_MEDIA_TYPE, "Video",
                          PW_KEY_MEDIA_CATEGORY, "Capture",
@@ -735,11 +736,13 @@ static void gsr_pipewire_video_update_cursor_texture(gsr_pipewire_video *self, g
    if(!self->cursor.data)
        return;

+    const float border_color[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
    self->egl->glBindTexture(GL_TEXTURE_2D, texture_map.cursor_texture_id);
    // TODO: glTextureSubImage2D if same size
    self->egl->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, self->cursor.width, self->cursor.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, self->cursor.data);
-    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    self->egl->glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    self->egl->glBindTexture(GL_TEXTURE_2D, 0);
--- a/src/shader.c
+++ b/src/shader.c
@@ -36,28 +36,36 @@ static unsigned int loader_shader(gsr_egl *egl, unsigned int type, const char *s
    return shader_id;
 }

-static unsigned int load_program(gsr_egl *egl, const char *vertex_shader, const char *fragment_shader) {
+static unsigned int load_program(gsr_egl *egl, const char *vertex_shader, const char *fragment_shader, const char *compute_shader) {
    unsigned int vertex_shader_id = 0;
    unsigned int fragment_shader_id = 0;
+    unsigned int compute_shader_id = 0;
    unsigned int program_id = 0;
    int linked = 0;
+    bool success = false;

    if(vertex_shader) {
        vertex_shader_id = loader_shader(egl, GL_VERTEX_SHADER, vertex_shader);
        if(vertex_shader_id == 0)
-            goto err;
+            goto done;
    }

    if(fragment_shader) {
        fragment_shader_id = loader_shader(egl, GL_FRAGMENT_SHADER, fragment_shader);
        if(fragment_shader_id == 0)
-            goto err;
+            goto done;
+    }
+
+    if(compute_shader) {
+        compute_shader_id = loader_shader(egl, GL_COMPUTE_SHADER, compute_shader);
+        if(compute_shader_id == 0)
+            goto done;
    }

    program_id = egl->glCreateProgram();
    if(program_id == 0) {
        fprintf(stderr, "gsr error: load_program: failed to create shader program, error: %d\n", egl->glGetError());
-        goto err;
+        goto done;
    }

    if(vertex_shader_id)
@@ -66,6 +74,9 @@ static unsigned int load_program(gsr_egl *egl, const char *vertex_shader, const
    if(fragment_shader_id)
        egl->glAttachShader(program_id, fragment_shader_id);

+    if(compute_shader_id)
+        egl->glAttachShader(program_id, compute_shader_id);
+
    egl->glLinkProgram(program_id);

    egl->glGetProgramiv(program_id, GL_LINK_STATUS, &linked);
@@ -79,37 +90,36 @@ static unsigned int load_program(gsr_egl *egl, const char *vertex_shader, const
            fprintf(stderr, "gsr error: load program: linking shader program failed, error:\n%s\n", info_log);            
        }

-        goto err;
+        goto done;
    }

+    success = true;
+    done:
+
+    if(!success) {
+        if(program_id)
+            egl->glDeleteProgram(program_id);
+    }
+    if(compute_shader_id)
+        egl->glDeleteShader(compute_shader_id);
    if(fragment_shader_id)
        egl->glDeleteShader(fragment_shader_id);
    if(vertex_shader_id)
        egl->glDeleteShader(vertex_shader_id);
-
    return program_id;
-
-    err:
-    if(program_id)
-        egl->glDeleteProgram(program_id);
-    if(fragment_shader_id)
-        egl->glDeleteShader(fragment_shader_id);
-    if(vertex_shader_id)
-        egl->glDeleteShader(vertex_shader_id);
-    return 0;
 }

-int gsr_shader_init(gsr_shader *self, gsr_egl *egl, const char *vertex_shader, const char *fragment_shader) {
+int gsr_shader_init(gsr_shader *self, gsr_egl *egl, const char *vertex_shader, const char *fragment_shader, const char *compute_shader) {
    assert(egl);
    self->egl = egl;
    self->program_id = 0;

-    if(!vertex_shader && !fragment_shader) {
-        fprintf(stderr, "gsr error: gsr_shader_init: vertex shader and fragment shader can't be NULL at the same time\n");
+    if(!vertex_shader && !fragment_shader && !compute_shader) {
+        fprintf(stderr, "gsr error: gsr_shader_init: vertex, fragment shader and compute shaders can't be NULL at the same time\n");
        return -1;
    }

-    self->program_id = load_program(self->egl, vertex_shader, fragment_shader);
+    self->program_id = load_program(self->egl, vertex_shader, fragment_shader, compute_shader);
    if(self->program_id == 0)
        return -1;

--- a/src/sound.cpp
+++ b/src/sound.cpp
@@ -101,7 +101,7 @@ static void subscribe_update_default_devices(pa_context*, const pa_server_info *
    if(server_info->default_sink_name) {
        // TODO: Size check
        snprintf(handle->default_output_device_name, sizeof(handle->default_output_device_name), "%s.monitor", server_info->default_sink_name);
-        if(handle->device_type == DeviceType::DEFAULT_OUTPUT && strcmp(handle->device_name, server_info->default_sink_name) != 0) {
+        if(handle->device_type == DeviceType::DEFAULT_OUTPUT && strcmp(handle->device_name, handle->default_output_device_name) != 0) {
            handle->reconnect = true;
            handle->reconnect_last_tried_seconds = clock_get_monotonic_seconds();
            // TODO: Size check
@@ -112,7 +112,7 @@ static void subscribe_update_default_devices(pa_context*, const pa_server_info *
    if(server_info->default_source_name) {
        // TODO: Size check
        snprintf(handle->default_input_device_name, sizeof(handle->default_input_device_name), "%s", server_info->default_source_name);
-        if(handle->device_type == DeviceType::DEFAULT_INPUT && strcmp(handle->device_name, server_info->default_sink_name) != 0) {
+        if(handle->device_type == DeviceType::DEFAULT_INPUT && strcmp(handle->device_name, handle->default_input_device_name) != 0) {
            handle->reconnect = true;
            handle->reconnect_last_tried_seconds = clock_get_monotonic_seconds();
            // TODO: Size check
@@ -124,7 +124,7 @@ static void subscribe_update_default_devices(pa_context*, const pa_server_info *
 static void subscribe_cb(pa_context *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
    (void)idx;
    pa_handle *handle = (pa_handle*)userdata;
-    if(t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) {
+    if((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SERVER) {
        pa_operation *pa = pa_context_get_server_info(c, subscribe_update_default_devices, handle);
        if(pa)
            pa_operation_unref(pa);
--- a/src/utils.c
+++ b/src/utils.c
@@ -14,10 +14,8 @@

 #include <xf86drmMode.h>
 #include <xf86drm.h>
-#include <libdrm/drm_fourcc.h>
 #include <X11/Xatom.h>
 #include <X11/extensions/Xrandr.h>
-#include <va/va_drmcommon.h>
 #include <libavcodec/avcodec.h>
 #include <libavutil/hwcontext_vaapi.h>

@@ -289,6 +287,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 +299,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 +310,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) {
@@ -382,6 +394,8 @@ bool gl_get_gpu_info(gsr_egl *egl, gsr_gpu_info *info) {
        info->vendor = GSR_GPU_VENDOR_INTEL;
    else if(strstr((const char*)gl_vendor, "NVIDIA"))
        info->vendor = GSR_GPU_VENDOR_NVIDIA;
+    else if(strstr((const char*)gl_vendor, "Broadcom"))
+        info->vendor = GSR_GPU_VENDOR_BROADCOM;
    else {
        fprintf(stderr, "gsr error: unknown gpu vendor: %s\n", gl_vendor);
        supported = false;
@@ -413,14 +427,6 @@ bool gl_get_gpu_info(gsr_egl *egl, gsr_gpu_info *info) {
    return supported;
 }

-bool version_greater_than(int major, int minor, int patch, int other_major, int other_minor, int other_patch) {
-    return (major > other_major) || (major == other_major && minor > other_minor) || (major == other_major && minor == other_minor && patch > other_patch);
-}
-
-bool gl_driver_version_greater_than(const gsr_gpu_info *gpu_info, int major, int minor, int patch) {
-    return version_greater_than(gpu_info->driver_major, gpu_info->driver_minor, gpu_info->driver_patch, major, minor, patch);
-}
-
 bool try_card_has_valid_plane(const char *card_path) {
    drmVersion *ver = NULL;
    drmModePlaneResPtr planes = NULL;
@@ -647,241 +653,6 @@ bool video_codec_context_is_vaapi(AVCodecContext *video_codec_context) {
    return device_context->type == AV_HWDEVICE_TYPE_VAAPI;
 }

-static uint32_t drm_fourcc_to_va_fourcc(uint32_t drm_fourcc) {
-    switch(drm_fourcc) {
-        case DRM_FORMAT_XRGB8888: return VA_FOURCC_BGRX;
-        case DRM_FORMAT_XBGR8888: return VA_FOURCC_RGBX;
-        case DRM_FORMAT_RGBX8888: return VA_FOURCC_XBGR;
-        case DRM_FORMAT_BGRX8888: return VA_FOURCC_XRGB;
-        case DRM_FORMAT_ARGB8888: return VA_FOURCC_BGRA;
-        case DRM_FORMAT_ABGR8888: return VA_FOURCC_RGBA;
-        case DRM_FORMAT_RGBA8888: return VA_FOURCC_ABGR;
-        case DRM_FORMAT_BGRA8888: return VA_FOURCC_ARGB;
-        default:                  return drm_fourcc;
-    }
-}
-
-bool vaapi_copy_drm_planes_to_video_surface(AVCodecContext *video_codec_context, AVFrame *video_frame, vec2i source_pos, vec2i source_size, vec2i dest_pos, vec2i dest_size, uint32_t format, vec2i size, const int *fds, const uint32_t *offsets, const uint32_t *pitches, const uint64_t *modifiers, int num_planes) {
-    VAConfigID config_id = 0;
-    VAContextID context_id = 0;
-    VASurfaceID input_surface_id = 0;
-    VABufferID buffer_id = 0;
-    bool success = true;
-
-    VADisplay va_dpy = video_codec_context_get_vaapi_display(video_codec_context);
-    if(!va_dpy) {
-        success = false;
-        goto done;
-    }
-
-    VAStatus va_status = vaCreateConfig(va_dpy, VAProfileNone, VAEntrypointVideoProc, NULL, 0, &config_id);
-    if(va_status != VA_STATUS_SUCCESS) {
-        fprintf(stderr, "gsr error: vaapi_copy_drm_planes_to_video_surface: vaCreateConfig failed, error: %s\n", vaErrorStr(va_status));
-        success = false;
-        goto done;
-    }
-
-    VASurfaceID output_surface_id = (uintptr_t)video_frame->data[3];
-    va_status = vaCreateContext(va_dpy, config_id, size.x, size.y, VA_PROGRESSIVE, &output_surface_id, 1, &context_id);
-    if(va_status != VA_STATUS_SUCCESS) {
-        fprintf(stderr, "gsr error: vaapi_copy_drm_planes_to_video_surface: vaCreateContext failed, error: %s\n", vaErrorStr(va_status));
-        success = false;
-        goto done;
-    }
-
-    VADRMPRIMESurfaceDescriptor buf = {0};
-    buf.fourcc = drm_fourcc_to_va_fourcc(format);//VA_FOURCC_BGRX; // TODO: VA_FOURCC_BGRA, VA_FOURCC_X2R10G10B10
-    buf.width = size.x;
-    buf.height = size.y;
-    buf.num_objects = num_planes;
-    buf.num_layers = 1;
-    buf.layers[0].drm_format = format;
-    buf.layers[0].num_planes = buf.num_objects;
-    for(int i = 0; i < num_planes; ++i) {
-        buf.objects[i].fd = fds[i];
-        buf.objects[i].size = size.y * pitches[i]; // TODO:
-        buf.objects[i].drm_format_modifier = modifiers[i];
-
-        buf.layers[0].object_index[i] = i;
-        buf.layers[0].offset[i] = offsets[i];
-        buf.layers[0].pitch[i] = pitches[i];
-    }
-
-    VASurfaceAttrib attribs[2] = {0};
-    attribs[0].type = VASurfaceAttribMemoryType;
-    attribs[0].flags = VA_SURFACE_ATTRIB_SETTABLE;
-    attribs[0].value.type = VAGenericValueTypeInteger;
-    attribs[0].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2;
-    attribs[1].type = VASurfaceAttribExternalBufferDescriptor;
-    attribs[1].flags = VA_SURFACE_ATTRIB_SETTABLE;
-    attribs[1].value.type = VAGenericValueTypePointer;
-    attribs[1].value.value.p = &buf;
-    
-    // TODO: RT_FORMAT with 10 bit/hdr, VA_RT_FORMAT_RGB32_10
-    // TODO: Max size same as source_size
-    va_status = vaCreateSurfaces(va_dpy, VA_RT_FORMAT_RGB32, size.x, size.y, &input_surface_id, 1, attribs, 2);
-    if(va_status != VA_STATUS_SUCCESS) {
-        fprintf(stderr, "gsr error: vaapi_copy_drm_planes_to_video_surface: vaCreateSurfaces failed, error: %s\n", vaErrorStr(va_status));
-        success = false;
-        goto done;
-    }
-
-    const VARectangle source_region = {
-        .x = source_pos.x,
-        .y = source_pos.y,
-        .width = source_size.x,
-        .height = source_size.y
-    };
-
-    const VARectangle output_region = {
-        .x = dest_pos.x,
-        .y = dest_pos.y,
-        .width = dest_size.x,
-        .height = dest_size.y
-    };
-
-    const bool scaled = dest_size.x != source_size.x || dest_size.y != source_size.y;
-
-    // Copying a surface to another surface will automatically perform the color conversion. Thanks vaapi!
-    VAProcPipelineParameterBuffer params = {0};
-    params.surface = input_surface_id;
-    params.surface_region = NULL;
-    params.surface_region = &source_region;
-    params.output_region = &output_region;
-    params.output_background_color = 0;
-    params.filter_flags = scaled ? (VA_FILTER_SCALING_HQ | VA_FILTER_INTERPOLATION_BILINEAR) : 0;
-    params.pipeline_flags = VA_PROC_PIPELINE_FAST;
-
-    params.input_color_properties.colour_primaries = 1;
-    params.input_color_properties.transfer_characteristics = 1;
-    params.input_color_properties.matrix_coefficients = 1;
-    params.surface_color_standard = VAProcColorStandardBT709; // TODO:
-    params.input_color_properties.color_range = video_frame->color_range == AVCOL_RANGE_JPEG ? VA_SOURCE_RANGE_FULL : VA_SOURCE_RANGE_REDUCED;
-
-    params.output_color_properties.colour_primaries = 1;
-    params.output_color_properties.transfer_characteristics = 1;
-    params.output_color_properties.matrix_coefficients = 1;
-    params.output_color_standard = VAProcColorStandardBT709; // TODO:
-    params.output_color_properties.color_range = video_frame->color_range == AVCOL_RANGE_JPEG ? VA_SOURCE_RANGE_FULL : VA_SOURCE_RANGE_REDUCED;
-
-    params.processing_mode = VAProcPerformanceMode;
-
-    // VAProcPipelineCaps pipeline_caps = {0};
-    // va_status = vaQueryVideoProcPipelineCaps(self->va_dpy,
-    //                                    self->context_id,
-    //                                    NULL, 0,
-    //                                    &pipeline_caps);
-    // if(va_status == VA_STATUS_SUCCESS) {
-    //     fprintf(stderr, "pipeline_caps: %u, %u\n", (unsigned int)pipeline_caps.rotation_flags, pipeline_caps.blend_flags);
-    // }
-
-    // TODO: params.output_hdr_metadata
-
-    // TODO:
-    // if (first surface to render)
-    //     pipeline_param->output_background_color = 0xff000000; // black
-
-    va_status = vaCreateBuffer(va_dpy, context_id, VAProcPipelineParameterBufferType, sizeof(params), 1, &params, &buffer_id);
-    if(va_status != VA_STATUS_SUCCESS) {
-        fprintf(stderr, "gsr error: vaapi_copy_drm_planes_to_video_surface: vaCreateBuffer failed, error: %d\n", va_status);
-        success = false;
-        goto done;
-    }
-
-    va_status = vaBeginPicture(va_dpy, context_id, output_surface_id);
-    if(va_status != VA_STATUS_SUCCESS) {
-        fprintf(stderr, "gsr error: vaapi_copy_drm_planes_to_video_surface: vaBeginPicture failed, error: %d\n", va_status);
-        success = false;
-        goto done;
-    }
-
-    va_status = vaRenderPicture(va_dpy, context_id, &buffer_id, 1);
-    if(va_status != VA_STATUS_SUCCESS) {
-        vaEndPicture(va_dpy, context_id);
-        fprintf(stderr, "gsr error: vaapi_copy_drm_planes_to_video_surface: vaRenderPicture failed, error: %d\n", va_status);
-        success = false;
-        goto done;
-    }
-
-    va_status = vaEndPicture(va_dpy, context_id);
-    if(va_status != VA_STATUS_SUCCESS) {
-        fprintf(stderr, "gsr error: vaapi_copy_drm_planes_to_video_surface: vaEndPicture failed, error: %d\n", va_status);
-        success = false;
-        goto done;
-    }
-
-    // vaSyncBuffer(va_dpy, buffer_id, 1000 * 1000 * 1000);
-    // vaSyncSurface(va_dpy, input_surface_id);
-    // vaSyncSurface(va_dpy, output_surface_id);
-
-    done:
-    if(buffer_id)
-        vaDestroyBuffer(va_dpy, buffer_id);
-
-    if(input_surface_id)
-        vaDestroySurfaces(va_dpy, &input_surface_id, 1);
-
-    if(context_id)
-        vaDestroyContext(va_dpy, context_id);
-
-    if(config_id)
-        vaDestroyConfig(va_dpy, config_id);
-
-    return success;
-}
-
-bool vaapi_copy_egl_image_to_video_surface(gsr_egl *egl, EGLImage image, vec2i source_pos, vec2i source_size, vec2i dest_pos, vec2i dest_size, AVCodecContext *video_codec_context, AVFrame *video_frame) {
-    if(!image)
-        return false;
-
-    int texture_fourcc = 0;
-    int texture_num_planes = 0;
-    uint64_t texture_modifiers = 0;
-    if(!egl->eglExportDMABUFImageQueryMESA(egl->egl_display, image, &texture_fourcc, &texture_num_planes, &texture_modifiers)) {
-        fprintf(stderr, "gsr error: gsr_capture_xcomposite_vaapi_tick: eglExportDMABUFImageQueryMESA failed\n");
-        return false;
-    }
-
-    if(texture_num_planes <= 0 || texture_num_planes > 8) {
-        fprintf(stderr, "gsr error: gsr_capture_xcomposite_vaapi_tick: expected planes size to be 0<planes<=8 for drm buf, got %d planes\n", texture_num_planes);
-        return false;
-    }
-
-    int texture_fds[8];
-    int32_t texture_strides[8];
-    int32_t texture_offsets[8];
-
-    while(egl->eglGetError() != EGL_SUCCESS){}
-    if(!egl->eglExportDMABUFImageMESA(egl->egl_display, image, texture_fds, texture_strides, texture_offsets)) {
-        fprintf(stderr, "gsr error: gsr_capture_xcomposite_vaapi_tick: eglExportDMABUFImageMESA failed, error: %d\n", egl->eglGetError());
-        return false;
-    }
-
-    int fds[8];
-    uint32_t offsets[8];
-    uint32_t pitches[8];
-    uint64_t modifiers[8];
-    for(int i = 0; i < texture_num_planes; ++i) {
-        fds[i] = texture_fds[i];
-        offsets[i] = texture_offsets[i];
-        pitches[i] = texture_strides[i];
-        modifiers[i] = texture_modifiers;
-
-        if(fds[i] == -1)
-            texture_num_planes = i;
-    }
-    const bool success = texture_num_planes > 0 && vaapi_copy_drm_planes_to_video_surface(video_codec_context, video_frame, source_pos, source_size, dest_pos, dest_size, texture_fourcc, source_size, fds, offsets, pitches, modifiers, texture_num_planes);
-
-    for(int i = 0; i < texture_num_planes; ++i) {
-        if(texture_fds[i] > 0) {
-            close(texture_fds[i]);
-            texture_fds[i] = -1;
-        }
-    }
-
-    return success;
-}
-
 vec2i scale_keep_aspect_ratio(vec2i from, vec2i to) {
    if(from.x == 0 || from.y == 0)
        return (vec2i){0, 0};
@@ -898,3 +669,27 @@ 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) {
+    float border_color[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
+    if(format == GL_RG) { // UV
+        border_color[0] = 0.5f;
+        border_color[1] = 0.5f;
+        border_color[2] = 0.0f;
+        border_color[3] = 1.0f;
+    }
+
+    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_BORDER);
+    egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    egl->glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
+    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;
+}
--- a/src/window/window_wayland.c
+++ b/src/window/window_wayland.c
@@ -1,4 +1,4 @@
-#include "../../include/window/window_wayland.h"
+#include "../../include/window/wayland.h"

 #include "../../include/vec2.h"
 #include "../../include/defs.h"
--- a/src/window/window_x11.c
+++ b/src/window/window_x11.c
@@ -1,4 +1,4 @@
-#include "../../include/window/window_x11.h"
+#include "../../include/window/x11.h"

 #include "../../include/vec2.h"
 #include "../../include/defs.h"
--- a/src/window_texture.c
+++ b/src/window_texture.c
@@ -85,8 +85,10 @@ int window_texture_on_resize(WindowTexture *self) {
        texture_id = self->texture_id;
    }

-    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    const float border_color[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    self->egl->glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
Author	SHA1	Message	Date
dec05eba	7ed9977068	5.3.5	2025-03-30 23:09:36 +02:00
dec05eba	8feb94f518	Fix incorrect region when monitor is rotated	2025-03-30 23:00:54 +02:00
dec05eba	6acd65a9c2	Remove -high-performance-encoding, always force enable it	2025-03-30 22:29:49 +02:00
dec05eba	56e2a82474	Fix cursor rotated background in compute shader on wayland	2025-03-30 22:11:33 +02:00
dec05eba	3e3d8a179f	Fix incorrect region for region capture after compute shader change	2025-03-30 18:11:25 +02:00
dec05eba	9599834d9c	5.3.4	2025-03-30 16:42:26 +02:00
dec05eba	d37688e4c2	Compute shader cleanup	2025-03-30 16:06:01 +02:00
dec05eba	3b617ddc53	Cleanup	2025-03-30 15:17:37 +02:00
dec05eba	ec0411c248	TODO: scissor conversion to compute shader	2025-03-30 15:09:52 +02:00
dec05eba	ad26bc77db	Fix incorrect compute size when scaling image	2025-03-30 13:46:06 +02:00
dec05eba	74865fad78	Highp rgb shader	2025-03-30 12:57:47 +02:00
dec05eba	82ec8e9630	Change quality parameters for 'very_high' (default) quality	2025-03-30 05:52:42 +02:00
dec05eba	a4713da02c	Refine options text	2025-03-30 05:43:01 +02:00
dec05eba	7502f1ebbc	GL_READ_WRITE -> GL_WRITE_ONLY	2025-03-30 05:13:44 +02:00
dec05eba	9e61479c9c	Add -high-performance-encoding option to improve encoding performance (on amd)	2025-03-30 05:11:31 +02:00
dec05eba	bb58870a94	Compute shader cleanup	2025-03-30 05:02:32 +02:00
dec05eba	eb9761af1a	Compute shader: nvidia: render full image (incorrect dispatch size)	2025-03-30 04:54:36 +02:00
dec05eba	96ca048856	Compute shader: add support for external texture, color component swapping (bgr to rgb)	2025-03-30 04:47:30 +02:00
dec05eba	c679b2fdb6	Use sampler2D for alpha blending compute shader instead of output image2D	2025-03-30 03:36:39 +02:00
dec05eba	b8a521a785	Reapply "WIP: use compute shader instead of graphics shader for better performance (especially on amd)" This reverts commit `f85a7ab205`.	2025-03-29 15:38:05 +01:00
dec05eba	f85a7ab205	Revert "WIP: use compute shader instead of graphics shader for better performance (especially on amd)" This reverts commit `a41a32cb90`.	2025-03-29 15:37:53 +01:00
dec05eba	a41a32cb90	WIP: use compute shader instead of graphics shader for better performance (especially on amd)	2025-03-29 13:29:10 +01:00
dec05eba	634a563bc0	Use highp instead of mediump	2025-03-19 10:51:19 +01:00
dec05eba	8e0b20df62	m	2025-03-18 23:03:22 +01:00
dec05eba	d2ab24121d	Test broadcom (raspberry pi) support	2025-03-18 21:54:12 +01:00
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
dec05eba	f23308444a	5.2.3	2025-03-07 20:24:13 +01:00
dec05eba	fadf9b64de	Test fix 2: crtc map update	2025-03-07 19:44:08 +01:00
dec05eba	e6f1d47eef	Test fix for monitor changing after power off/on	2025-03-07 19:29:19 +01:00
dec05eba	7af4f106e7	Example scripts: use cbr for replay scripts	2025-03-07 02:47:20 +01:00
dec05eba	a26aa2dd3e	5.2.2	2025-03-05 21:24:37 +01:00
dec05eba	8364aaadad	Fix pipewire server breaking when pipewire connection is closed too quickly (--info)	2025-03-05 21:20:51 +01:00
dec05eba	5f3a14d3f6	Rename window_wayland to wayland and window_x11 to x11	2025-03-05 18:07:52 +01:00
dec05eba	0129ab140d	5.2.1	2025-03-03 13:40:53 +01:00
dec05eba	0fff47cc58	Revert "Pulseaudio audio device capture: dont change default output when switching default output" This reverts commit `902556b143`.	2025-03-03 13:36:49 +01:00
dec05eba	902556b143	Pulseaudio audio device capture: dont change default output when switching default output	2025-03-03 13:17:35 +01:00
dec05eba	6024a54551	Fix portal capture on sway and hyprland: unset capture types/cursor modes that are not supported by the desktop portal	2025-03-03 12:36:44 +01:00
dec05eba	23122ce9b0	Correct check for default audio output change in pulseaudio	2025-03-01 02:30:24 +01:00
dec05eba	f071d8c373	Mention solus package	2025-02-28 13:57:40 +01:00