5.12.3

Add -write-first-frame-ts switch that creates a .ts file next to the output
file with values from CLOCK_MONOTONIC and CLOCK_REALTIME corresponding to the
first frame to be able to synchronize video with other timestamped data.

README.md

@@ -191,6 +191,9 @@ For you as a user this only means that if you installed GPU Screen Recorder as a
 This should work fine on AMD/Intel X11 or Wayland. On Nvidia X11 G-SYNC only works with the -w screen-direct option, but because of bugs in the Nvidia driver this option is not always recommended.
 For example it can cause your computer to freeze when recording certain games.
 
+# License
+This software is licensed under GPL-3.0-only, see the LICENSE file for more information.
+
 # Reporting bugs, contributing patches, questions or donation
 See [https://git.dec05eba.com/?p=about](https://git.dec05eba.com/?p=about).
 

TODO

@@ -312,8 +312,6 @@ Check if region capture works properly with fractional scaling on wayland.
 Add option to specify medium/high/very high/ultra for -bm cbr as well, which should automatically pick bitrate based on resolution and framerate.
     This should also be reflected in gsr ui.
 
-Create a manpage and move --help text there and mention the manpage command to view it (and make it work in flatpak, maybe with man <link-to-manpage-file>).
-
 Implement webcam support by using mjpeg with v4l2 and use ffmpeg mjpeg decoder.
 
 After adding rpc, making recording while in replay/streaming work differently. Start recording should take audio as an argument, to optionally specify different audio for recording than replay/stream.
@@ -384,4 +382,20 @@ Set v4l2 camera fps to video output fps (if lower than the camera fps) and the s
 
 Support camera controls, such as white balance. Otherwise tell user to use cameractrl software.
 
-Camera capture doesn't work perfectly. The image gets glitched, need to properly wait for image to be done.
+Camera capture doesn't work perfectly. The image gets glitched, need to properly wait for image to be done.
+
+Use one pipewire connection (pipewire video) instead of multiple ones when recording with portal multiple times (multiple sources).
+
+Close pipewire links or maybe there are file descriptor leaks?
+
+Make multiple capture sources work properly in regards to size. The size of the video should be the region size of each capture source.
+
+Support hdr camera capture.
+
+Return the max resolution of each codec in --info to display an error in the UI before capture starts. Right now its fine since the UI will report bad resolution after capture starts and fails but it doesn't say what the max resolution is.
+
+Should -low-power option also use vaapi/vulkan low power, if available?
+
+Should capture option x=bla;y=bla be scaled by -s (output resolution scale)? width and height is.
+
+Certain webcam resolutions yuyv resolutions dont work (on amd at least), such as 800x600. Maybe it's because of alignment issue, 600 isn't divisible by 16.

gpu-screen-recorder.1

@@ -101,20 +101,24 @@ Additional options can be passed to each capture source by splitting capture sou
 for example
 .BR "screen;x=50;y=50".
 .br
-These are the available options for capture sources:
+These are the available options for all capture sources (optional):
 .RS
 .IP \(bu 3
 .B x
-- The X position in pixels. If the number ends with % and is a number between 0 and 100 then it's a position relative to the video size
+- The X position in pixels. If the number ends with % then this sets the X position relative to the video width (integer percentage where 100 = 100%)
 .IP \(bu 3
 .B y
-- The Y position in pixels. If the number ends with % and is a number between 0 and 100 then it's a position relative to the video size
+- The Y position in pixels. If the number ends with % then this sets the Y position relative to the video height (integer percentage where 100 = 100%)
 .IP \(bu 3
 .B width
-- The width in pixels. If the number ends with % and is a number between 0 and 100 then it's a size relative to the video size
+- The width in pixels. If the number ends with % then this sets the width relative to the video width (integer percentage where 100 = 100%).
+
+A value of 0 means to not scale the capture source and instead use the original width.
 .IP \(bu 3
 .B height
-- The height in pixels. If the number ends with % and is a number between 0 and 100 then it's a size relative to the video size
+- The height in pixels. If the number ends with % then this sets the height relative to the video height (integer percentage where 100 = 100%).
+
+A value of 0 means to not scale the capture source and instead use the original height.
 .IP \(bu 3
 .B halign
 - The horizontal alignment, should be either
@@ -125,9 +129,9 @@ or
 
 Set to
 .B center
-by default, except for camera (V4L2) when capturing the camera above something else in which case this is set to
+by default when using one capture source, otherwise it's set to
 .B start
-by default
+by default.
 .IP \(bu 3
 .B valign
 - The vertical alignment, should be either
@@ -138,9 +142,9 @@ or
 
 Set to
 .B center
-by default, except for camera (V4L2) when capturing the camera above something else in which case this is set to
-.B end
-by default
+by default when using one capture source, otherwise it's set to
+.B start
+by default.
 .IP \(bu 3
 .B hflip
 - If the source should be flipped horizontally, should be either
@@ -159,9 +163,13 @@ or
 Set to
 .B false
 by default
+.RE
+.PP
+These are the additional options available for camera (V4L2) sources (optional):
+.RS
 .IP \(bu 3
 .B pixfmt
-- The pixel format for cameras (V4L2), should be either
+- The pixel format, should be either
 .BR "auto",
 .B yuyv
 or
@@ -169,6 +177,33 @@ or
 Set to
 .B auto
 by default
+.IP \(bu 3
+.B camera_fps
+- The camera fps. Has to match a camera fps returned in
+.B --info
+or
+.B --list-v4l2-devices
+for the device.
+
+A value of 0 means to use the best option available.
+.IP \(bu 3
+.B camera_width
+- The camera width in pixels. Has to match a camera width returned in
+.B --info
+or
+.B --list-v4l2-devices
+for the device.
+
+A value of 0 means to use the best option available.
+.IP \(bu 3
+.B camera_height
+- The camera height in pixels. Has to match a camera height returned in
+.B --info
+or
+.B --list-v4l2-devices
+for the device.
+
+A value of 0 means to use the best option available.
 .RE
 .TP
 .BI \-region " WxH+X+Y"
@@ -297,11 +332,54 @@ Script to run after saving video. Receives filepath and type ("regular", "replay
 .BI \-portal\-session\-token\-filepath " path"
 Portal session token file (default: ~/.config/gpu-screen-recorder/restore_token).
 .TP
+.BI \-ffmpeg-opts " options"
+Additional arguments to pass to FFmpeg for the file in a list of key-values pairs in the format "key=value;key=value",
+.br
+for example: -ffmpeg-opts "hls_list_size=3;hls_time=1;hls_flags=delete_segments".
+.br
+Note: this overwrites options set by GPU Screen Recorder with the same name.
+.TP
+.BI \-ffmpeg-video-opts " options"
+Additional arguments to pass to FFmpeg for the video in a list of key-values pairs in the format "key=value;key=value",
+.br
+for example: -ffmpeg-video-opts "codec=cabac;rc_mode=CQP;qp=16".
+.br
+Note: this overwrites options set by GPU Screen Recorder with the same name.
+.TP
+.BI \-ffmpeg-audio-opts " options"
+Additional arguments to pass to FFmpeg for the audio in a list of key-values pairs in the format "key=value;key=value",
+.br
+for example: -ffmpeg-audio-opts "aac_coder=fast;aac_pce=true".
+.br
+Note: this overwrites options set by GPU Screen Recorder with the same name.
+.TP
 .BI \-gl\-debug " yes|no"
 OpenGL debug output (default: no).
 .TP
 .BI \-v " yes|no"
 Print FPS and damage info (default: yes).
+.TP
+.BI \-low-power " yes|no"
+Run in low power mode. This currently has only an affect on AMD (as it's only an issue on AMD) and allows the GPU to go into a lower power mode when recording (default: no).
+.br
+Setting this to
+.B yes
+might not always be ideal because of AMD driver issues where after playing a video with VAAPI on the system the video encoding performance
+also reduces, which affects GPU Screen Recorder.
+.br
+It's recommended to also use the option
+.B -fm content
+when this is set to
+.B yes
+to only encode frames when the screen content updates to lower GPU and video encoding usage when the system is idle.
+.TP
+.BI \-write\-first\-frame\-ts " yes|no"
+When enabled, writes a timestamp file with extra extension \fI.ts\fR next to the output video containing:
+.nf
+monotonic_microsec	realtime_microsec
+<monotonic_microsec>	<realtime_microsec>
+.fi
+(default: no). Ignored for livestreaming and when output is piped.
 .SS Output Options
 .TP
 .BI \-o " output"
@@ -397,7 +475,7 @@ Instant replay (last 60 seconds):
 .PP
 .nf
 .RS
-gpu-screen-recorder -w screen -f 60 -c mkv -r 60 -o ~/Videos
+gpu-screen-recorder -w screen -c mkv -r 60 -o ~/Videos
 .RE
 .fi
 .PP
@@ -421,15 +499,15 @@ Instant replay and launch a script when saving replay:
 .PP
 .nf
 .RS
-gpu-screen-recorder -w screen -f 60 -c mkv -r 60 -sc ./script.sh -o ~/Videos
+gpu-screen-recorder -w screen -c mkv -r 60 -sc ./script.sh -o ~/Videos
 .RE
 .fi
 .PP
-Stream to Twitch:
+Stream to Twitch with constant bitrate mode:
 .PP
 .nf
 .RS
-gpu-screen-recorder -w screen -f 60 -a default_output -o "rtmp://live.twitch.tv/app/stream_key"
+gpu-screen-recorder -w screen -c flv -a default_output -bm cbr -q 8000 -o "rtmp://live.twitch.tv/app/stream_key"
 .RE
 .fi
 .PP
@@ -449,11 +527,19 @@ gpu-screen-recorder -w "screen|/dev/video0" -o video.mp4
 .PP
 .RE
 .fi
-Record screen and camera. The camera is located at the bottom right flipped horizontally:
+Record screen and camera. The camera is located at the bottom right and flipped horizontally:
 .PP
 .nf
 .RS
-gpu-screen-recorder -w "monitor:screen|v4l2:/dev/video0;halign=end;valign=end;hflip=true" -o video.mp4
+gpu-screen-recorder -w "screen|/dev/video0;halign=end;valign=end;hflip=true;width=30%;height=30%" -o video.mp4
+.PP
+.RE
+.fi
+Record two monitors, side by side (assuming the first monitor has a resolution of 1920x1080)
+.PP
+.nf
+.RS
+gpu-screen-recorder -w "DP-1|DP-2;x=1920" -o video.mp4
 .RE
 .fi
 .SH FILES

include/args_parser.h

@@ -8,7 +8,7 @@
 
 typedef struct gsr_egl gsr_egl;
 
-#define NUM_ARGS 32
+#define NUM_ARGS 37
 
 typedef enum {
     GSR_CAPTURE_SOURCE_TYPE_WINDOW,
@@ -85,14 +85,19 @@ typedef struct {
     const char *replay_recording_directory;
     const char *portal_session_token_filepath;
     const char *recording_saved_script;
+    const char *ffmpeg_opts;
+    const char *ffmpeg_video_opts;
+    const char *ffmpeg_audio_opts;
     bool verbose;
     bool gl_debug;
     bool fallback_cpu_encoding;
+    bool low_power;
     bool record_cursor;
     bool date_folders;
     bool restore_portal_session;
     bool restart_replay_on_save;
     bool overclock;
+    bool write_first_frame_ts;
     bool is_livestream;
     bool is_output_piped;
     bool low_latency_recording;

include/capture/v4l2.h

@@ -10,21 +10,35 @@ typedef enum {
 } gsr_capture_v4l2_pixfmt;
 
 typedef struct {
-    bool yuyv;
-    bool mjpeg;
-} gsr_capture_v4l2_supported_pixfmts;
+    uint32_t width;
+    uint32_t height;
+} gsr_capture_v4l2_resolution;
+
+typedef struct {
+    uint32_t denominator;
+    uint32_t numerator;
+} gsr_capture_v4l2_framerate;
+
+typedef struct {
+    gsr_capture_v4l2_pixfmt pixfmt;
+    gsr_capture_v4l2_resolution resolution;
+    gsr_capture_v4l2_framerate framerate;
+} gsr_capture_v4l2_supported_setup;
 
 typedef struct {
     gsr_egl *egl;
     vec2i output_resolution;
     const char *device_path;
     gsr_capture_v4l2_pixfmt pixfmt;
-    int fps;
+    uint32_t camera_fps; /* Set to 0 if the best option should be chosen */
+    gsr_capture_v4l2_resolution camera_resolution; /* Set to 0, 0 if the best option should be chosen */
 } gsr_capture_v4l2_params;
 
 gsr_capture* gsr_capture_v4l2_create(const gsr_capture_v4l2_params *params);
 
-typedef void (*v4l2_devices_query_callback)(const char *path, gsr_capture_v4l2_supported_pixfmts supported_pixfmts, vec2i size, void *userdata);
+const char* gsr_capture_v4l2_pixfmt_to_string(gsr_capture_v4l2_pixfmt pixfmt);
+uint32_t gsr_capture_v4l2_framerate_to_number(gsr_capture_v4l2_framerate framerate);
+typedef void (*v4l2_devices_query_callback)(const char *path, const gsr_capture_v4l2_supported_setup *supported_setup, void *userdata);
 void gsr_capture_v4l2_list_devices(v4l2_devices_query_callback callback, void *userdata);
 
 #endif /* GSR_CAPTURE_V4L2_H */

include/egl.h

@@ -257,6 +257,7 @@ struct gsr_egl {
     void (*glTexParameterfv)(unsigned int target, unsigned int pname, const float *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 (*glTexStorage2D)(unsigned int target, int levels, unsigned int internalformat, int width, int height);
     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);

include/encoder/encoder.h

@@ -20,12 +20,18 @@ typedef struct {
     AVStream *stream;
     int64_t start_pts;
     bool has_received_keyframe;
+    char *first_frame_ts_filepath;
+    bool first_frame_ts_written;
 } gsr_encoder_recording_destination;
 
 typedef struct {
     gsr_replay_buffer *replay_buffer;
+
     pthread_mutex_t file_write_mutex;
-    bool mutex_created;
+    bool file_write_mutex_created;
+
+    pthread_mutex_t replay_mutex;
+    bool replay_mutex_created;
 
     gsr_encoder_recording_destination recording_destinations[GSR_MAX_RECORDING_DESTINATIONS];
     size_t num_recording_destinations;
@@ -39,5 +45,6 @@ void gsr_encoder_receive_packets(gsr_encoder *self, AVCodecContext *codec_contex
 /* Returns the id to the recording destination, or -1 on error */
 size_t gsr_encoder_add_recording_destination(gsr_encoder *self, AVCodecContext *codec_context, AVFormatContext *format_context, AVStream *stream, int64_t start_pts);
 bool gsr_encoder_remove_recording_destination(gsr_encoder *self, size_t id);
+bool gsr_encoder_set_recording_destination_first_frame_ts_filepath(gsr_encoder *self, size_t id, const char *filepath);
 
 #endif /* GSR_ENCODER_H */

include/replay_buffer/replay_buffer.h

@@ -2,7 +2,6 @@
 #define GSR_REPLAY_BUFFER_H
 
 #include "../defs.h"
-#include <pthread.h>
 #include <stdbool.h>
 #include <libavcodec/packet.h>
 
@@ -27,17 +26,11 @@ struct gsr_replay_buffer {
     /* Returns {-1, 0} if not found */
     gsr_replay_buffer_iterator (*find_keyframe)(gsr_replay_buffer *self, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index);
     bool (*iterator_next)(gsr_replay_buffer *self, gsr_replay_buffer_iterator *iterator);
-
-    pthread_mutex_t mutex;
-    bool mutex_initialized;
-    gsr_replay_buffer *original_replay_buffer;
 };
 
 gsr_replay_buffer* gsr_replay_buffer_create(gsr_replay_storage replay_storage, const char *replay_directory, double replay_buffer_time, size_t replay_buffer_num_packets);
 void gsr_replay_buffer_destroy(gsr_replay_buffer *self);
 
-void gsr_replay_buffer_lock(gsr_replay_buffer *self);
-void gsr_replay_buffer_unlock(gsr_replay_buffer *self);
 bool gsr_replay_buffer_append(gsr_replay_buffer *self, const AVPacket *av_packet, double timestamp);
 void gsr_replay_buffer_clear(gsr_replay_buffer *self);
 AVPacket* gsr_replay_buffer_iterator_get_packet(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator);

include/utils.h

@@ -16,6 +16,8 @@ typedef struct {
     int name_len;
     vec2i pos; /* This is 0, 0 on wayland. Use |drm_monitor_get_display_server_data| to get the position */
     vec2i size;
+    vec2i logical_pos;
+    vec2i logical_size;
     uint32_t connector_id; /* Only on x11 and drm */
     gsr_monitor_rotation rotation; /* Only on x11 and wayland */
     uint32_t monitor_identifier; /* On x11 this is the crtc id */

meson.build

@@ -1,4 +1,4 @@
-project('gpu-screen-recorder', ['c', 'cpp'], version : '5.11.0', default_options : ['warning_level=2'])
+project('gpu-screen-recorder', ['c', 'cpp'], version : '5.12.3', default_options : ['warning_level=2'])
 
 add_project_arguments('-Wshadow', language : ['c', 'cpp'])
 if get_option('buildtype') == 'debug'
@@ -117,6 +117,7 @@ executable('gpu-screen-recorder', src, dependencies : dep, install : true)
 
 install_headers('plugin/plugin.h', install_dir : 'include/gsr')
 install_man('gpu-screen-recorder.1', 'gsr-kms-server.1')
+install_subdir('scripts', install_dir: 'share/gpu-screen-recorder')
 
 if get_option('systemd') == true
     install_data(files('extra/gpu-screen-recorder.service'), install_dir : 'lib/systemd/user')

project.conf

@@ -1,7 +1,7 @@
 [package]
 name = "gpu-screen-recorder"
 type = "executable"
-version = "5.11.0"
+version = "5.12.3"
 platforms = ["posix"]
 
 [config]
@@ -33,4 +33,4 @@ wayland-client = ">=1"
 dbus-1 = ">=1"
 libpipewire-0.3 = ">=1"
 libspa-0.2 = ">=0"
-vulkan = ">=1"
+vulkan = ">=1"

scripts/twitch-stream-local-copy.sh

@@ -4,4 +4,4 @@
 
 [ "$#" -ne 4 ] && echo "usage: twitch-stream-local-copy.sh <window_id> <fps> <livestream_key> <local_file>" && exit 1
 active_sink=default_output
-gpu-screen-recorder -w "$1" -c flv -f "$2" -q high -a "$active_sink" | tee -- "$4" | ffmpeg -i pipe:0 -c copy -f flv -- "rtmp://live.twitch.tv/app/$3"
+gpu-screen-recorder -w "$1" -c flv -f "$2" -bm cbr -q 8000 -a "$active_sink" | tee -- "$4" | ffmpeg -i pipe:0 -c copy -f flv -- "rtmp://live.twitch.tv/app/$3"

scripts/twitch-stream.sh

@@ -2,4 +2,4 @@
 
 [ "$#" -ne 3 ] && echo "usage: twitch-stream.sh <window_id> <fps> <livestream_key>" && exit 1
 active_sink=default_output
-gpu-screen-recorder -w "$1" -c flv -f "$2" -q high -a "$active_sink" -o "rtmp://live.twitch.tv/app/$3"
+gpu-screen-recorder -w "$1" -c flv -f "$2" -bm cbr -q 8000 -a "$active_sink" -o "rtmp://live.twitch.tv/app/$3"

scripts/youtube-hls-stream.sh

@@ -2,4 +2,4 @@
 
 [ "$#" -ne 3 ] && echo "usage: youtube-hls-stream.sh <window_id> <fps> <livestream_key>" && exit 1
 active_sink=default_output
-gpu-screen-recorder -w "$1" -c hls -f "$2" -q high -a "$active_sink" -ac aac -o "https://a.upload.youtube.com/http_upload_hls?cid=$3&copy=0&file=stream.m3u8"
+gpu-screen-recorder -w "$1" -c hls -f "$2" -bm cbr -q 8000 -a "$active_sink" -ac aac -o "https://a.upload.youtube.com/http_upload_hls?cid=$3&copy=0&file=stream.m3u8"

src/args_parser.c

@@ -9,7 +9,6 @@
 #include <inttypes.h>
 #include <limits.h>
 #include <assert.h>
-#include <errno.h>
 #include <libgen.h>
 #include <sys/stat.h>
 
@@ -196,13 +195,11 @@ static void usage_header(void) {
            "[-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] [-tune performance|quality] [-df yes|no] [-sc <script_path>] [-p <plugin_path>] "
            "[-cursor yes|no] [-keyint <value>] [-restore-portal-session yes|no] [-portal-session-token-filepath filepath] [-encoder gpu|cpu] "
-           "[-fallback-cpu-encoding yes|no] [-o <output_file>] [-ro <output_directory>] [--list-capture-options [card_path]] [--list-audio-devices] "
-           "[--list-application-audio] [--list-v4l2-devices] [-v yes|no] [-gl-debug yes|no] [--version] [-h|--help]\n", program_name);
+           "[-fallback-cpu-encoding yes|no] [-o <output_file>] [-ro <output_directory>] [-ffmpeg-opts <options>] [--list-capture-options [card_path]] "
+           "[--list-audio-devices] [--list-application-audio] [--list-v4l2-devices] [-write-first-frame-ts yes|no] [-low-power yes|no] [-v yes|no] [-gl-debug yes|no] [--version] [-h|--help]\n", program_name);
     fflush(stdout);
 }
 
-// TODO: Add --list-v4l2-devices option
-
 static void usage_full(void) {
     const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
     usage_header();
@@ -258,6 +255,8 @@ static bool args_parser_set_values(args_parser *self) {
     self->restart_replay_on_save = args_get_boolean_by_key(self->args, NUM_ARGS, "-restart-replay-on-save", false);
     self->overclock = args_get_boolean_by_key(self->args, NUM_ARGS, "-oc", false);
     self->fallback_cpu_encoding = args_get_boolean_by_key(self->args, NUM_ARGS, "-fallback-cpu-encoding", false);
+    self->write_first_frame_ts = args_get_boolean_by_key(self->args, NUM_ARGS, "-write-first-frame-ts", false);
+    self->low_power = args_get_boolean_by_key(self->args, NUM_ARGS, "-low-power", false);
 
     self->audio_bitrate = args_get_i64_by_key(self->args, NUM_ARGS, "-ab", 0);
     self->audio_bitrate *= 1000LL;
@@ -434,6 +433,10 @@ static bool args_parser_set_values(args_parser *self) {
 
     self->is_output_piped = strcmp(self->filename, "/dev/stdout") == 0;
     self->low_latency_recording = self->is_livestream || self->is_output_piped;
+    if(self->write_first_frame_ts && (self->is_livestream || self->is_output_piped)) {
+        fprintf(stderr, "gsr warning: -write-first-frame-ts is ignored for livestreaming or when output is piped\n");
+        self->write_first_frame_ts = false;
+    }
 
     self->replay_recording_directory = args_get_value_by_key(self->args, NUM_ARGS, "-ro");
 
@@ -442,6 +445,10 @@ static bool args_parser_set_values(args_parser *self) {
         self->recording_saved_script = NULL;
     }
 
+    self->ffmpeg_opts = args_get_value_by_key(self->args, NUM_ARGS, "-ffmpeg-opts");
+    self->ffmpeg_video_opts = args_get_value_by_key(self->args, NUM_ARGS, "-ffmpeg-video-opts");
+    self->ffmpeg_audio_opts = args_get_value_by_key(self->args, NUM_ARGS, "-ffmpeg-audio-opts");
+
     return true;
 }
 
@@ -531,6 +538,11 @@ bool args_parser_parse(args_parser *self, int argc, char **argv, const args_hand
     self->args[arg_index++] = (Arg){ .key = "-fallback-cpu-encoding",         .optional = true,  .list = false, .type = ARG_TYPE_BOOLEAN };
     self->args[arg_index++] = (Arg){ .key = "-replay-storage",                .optional = true,  .list = false, .type = ARG_TYPE_ENUM, .enum_values = replay_storage_enums, .num_enum_values = sizeof(replay_storage_enums)/sizeof(ArgEnum) };
     self->args[arg_index++] = (Arg){ .key = "-p",                             .optional = true,  .list = true,  .type = ARG_TYPE_STRING };
+    self->args[arg_index++] = (Arg){ .key = "-ffmpeg-opts",                   .optional = true,  .list = false, .type = ARG_TYPE_STRING };
+    self->args[arg_index++] = (Arg){ .key = "-ffmpeg-video-opts",             .optional = true,  .list = false, .type = ARG_TYPE_STRING };
+    self->args[arg_index++] = (Arg){ .key = "-ffmpeg-audio-opts",             .optional = true,  .list = false, .type = ARG_TYPE_STRING };
+    self->args[arg_index++] = (Arg){ .key = "-write-first-frame-ts",          .optional = true,  .list = false, .type = ARG_TYPE_BOOLEAN };
+    self->args[arg_index++] = (Arg){ .key = "-low-power",                     .optional = true,  .list = false, .type = ARG_TYPE_BOOLEAN };
     assert(arg_index == NUM_ARGS);
 
     for(int i = 1; i < argc; i += 2) {

src/capture/kms.c

@@ -34,7 +34,8 @@ typedef struct {
     vec2i capture_size;
     MonitorId monitor_id;
 
-    gsr_monitor_rotation monitor_rotation;
+    gsr_monitor_rotation display_server_monitor_rotation;
+    gsr_monitor_rotation final_monitor_rotation;
 
     unsigned int input_texture_id;
     unsigned int external_input_texture_id;
@@ -137,8 +138,8 @@ static void monitor_callback(const gsr_monitor *monitor, void *userdata) {
         fprintf(stderr, "gsr warning: reached max connector ids\n");
 }
 
-static vec2i rotate_capture_size_if_rotated(gsr_capture_kms *self, vec2i capture_size) {
-    if(self->monitor_rotation == GSR_MONITOR_ROT_90 || self->monitor_rotation == GSR_MONITOR_ROT_270) {
+static vec2i rotate_capture_size_if_rotated(gsr_capture_kms *self, vec2i capture_size, gsr_monitor_rotation rotation) {
+    if(rotation == GSR_MONITOR_ROT_90 || rotation == GSR_MONITOR_ROT_270) {
         int tmp_x = capture_size.x;
         capture_size.x = capture_size.y;
         capture_size.y = tmp_x;
@@ -172,14 +173,14 @@ static int gsr_capture_kms_start(gsr_capture *cap, gsr_capture_metadata *capture
 
     monitor.name = self->params.display_to_capture;
     vec2i monitor_position = {0, 0};
-    drm_monitor_get_display_server_data(self->params.egl->window, &monitor, &self->monitor_rotation, &monitor_position);
+    drm_monitor_get_display_server_data(self->params.egl->window, &monitor, &self->display_server_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 */
     if(self->is_x11)
         self->capture_size = monitor.size;
     else
-        self->capture_size = rotate_capture_size_if_rotated(self, monitor.size);
+        self->capture_size = rotate_capture_size_if_rotated(self, monitor.size, self->display_server_monitor_rotation);
 
     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);
@@ -403,7 +404,7 @@ static void render_drm_cursor(gsr_capture_kms *self, gsr_color_conversion *color
     const vec2i cursor_size = {cursor_drm_fd->width, cursor_drm_fd->height};
 
     const gsr_monitor_rotation cursor_plane_rotation = kms_rotation_to_gsr_monitor_rotation(cursor_drm_fd->rotation);
-    const gsr_monitor_rotation rotation = sub_rotations(self->monitor_rotation, cursor_plane_rotation);
+    const gsr_monitor_rotation rotation = sub_rotations(self->display_server_monitor_rotation, cursor_plane_rotation);
 
     vec2i cursor_pos = {cursor_drm_fd->x, cursor_drm_fd->y};
     switch(rotation) {
@@ -539,14 +540,14 @@ static void gsr_capture_kms_update_connector_ids(gsr_capture_kms *self) {
     monitor.name = self->params.display_to_capture;
     vec2i monitor_position = {0, 0};
     // TODO: This is cached. We need it updated.
-    drm_monitor_get_display_server_data(self->params.egl->window, &monitor, &self->monitor_rotation, &monitor_position);
+    drm_monitor_get_display_server_data(self->params.egl->window, &monitor, &self->display_server_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 */
     if(self->is_x11)
         self->capture_size = monitor.size;
     else
-        self->capture_size = rotate_capture_size_if_rotated(self, monitor.size);
+        self->capture_size = rotate_capture_size_if_rotated(self, monitor.size, self->display_server_monitor_rotation);
 }
 
 static void gsr_capture_kms_pre_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
@@ -571,7 +572,10 @@ static void gsr_capture_kms_pre_capture(gsr_capture *cap, gsr_capture_metadata *
     if(self->drm_fd->has_hdr_metadata && self->params.hdr && hdr_metadata_is_supported_format(&self->drm_fd->hdr_metadata))
         gsr_kms_set_hdr_metadata(self, self->drm_fd);
 
-    self->capture_size = rotate_capture_size_if_rotated(self, (vec2i){ self->drm_fd->src_w, self->drm_fd->src_h });
+    const gsr_monitor_rotation plane_rotation = kms_rotation_to_gsr_monitor_rotation(self->drm_fd->rotation);
+    self->final_monitor_rotation = self->capture_is_combined_plane ? GSR_MONITOR_ROT_0 : sub_rotations(self->display_server_monitor_rotation, plane_rotation);
+
+    self->capture_size = rotate_capture_size_if_rotated(self, (vec2i){ self->drm_fd->src_w, self->drm_fd->src_h }, self->final_monitor_rotation);
     if(self->params.region_size.x > 0 && self->params.region_size.y > 0)
         self->capture_size = self->params.region_size;
 
@@ -603,13 +607,10 @@ static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *captu
         self->params.egl->eglDestroyImage(self->params.egl->egl_display, image);
     }
 
-    const gsr_monitor_rotation plane_rotation = kms_rotation_to_gsr_monitor_rotation(self->drm_fd->rotation);
-    const gsr_monitor_rotation rotation = self->capture_is_combined_plane ? GSR_MONITOR_ROT_0 : sub_rotations(self->monitor_rotation, plane_rotation);
-
     gsr_color_conversion_draw(color_conversion, self->external_texture_fallback ? self->external_input_texture_id : self->input_texture_id,
         self->target_pos, self->output_size,
         capture_pos, self->capture_size, (vec2i){ self->drm_fd->width, self->drm_fd->height },
-        gsr_monitor_rotation_to_rotation(rotation), capture_metadata->flip, GSR_SOURCE_COLOR_RGB, self->external_texture_fallback);
+        gsr_monitor_rotation_to_rotation(self->final_monitor_rotation), capture_metadata->flip, GSR_SOURCE_COLOR_RGB, self->external_texture_fallback);
 
     if(self->params.record_cursor) {
         gsr_kms_response_item *cursor_drm_fd = find_cursor_drm_if_on_monitor(self, self->drm_fd->connector_id, self->capture_is_combined_plane);
@@ -623,7 +624,7 @@ static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *captu
             cursor_monitor_offset.y += self->params.region_position.y;
             render_x11_cursor(self, color_conversion, capture_metadata, cursor_monitor_offset, self->target_pos, self->output_size);
         } else if(cursor_drm_fd) {
-            const vec2i framebuffer_size = rotate_capture_size_if_rotated(self, (vec2i){ self->drm_fd->src_w, self->drm_fd->src_h });
+            const vec2i framebuffer_size = rotate_capture_size_if_rotated(self, (vec2i){ self->drm_fd->src_w, self->drm_fd->src_h }, self->final_monitor_rotation);
             render_drm_cursor(self, color_conversion, capture_metadata, cursor_drm_fd, self->target_pos, self->output_size, framebuffer_size);
         }
     }

src/capture/v4l2.c

@@ -43,6 +43,11 @@ typedef enum {
     V4L2_BUFFER_TYPE_MMAP
 } v4l2_buffer_type;
 
+typedef struct {
+    bool yuyv;
+    bool mjpeg;
+} gsr_capture_v4l2_supported_pixfmts;
+
 typedef struct {
     gsr_capture_v4l2_params params;
     vec2i capture_size;
@@ -157,7 +162,35 @@ static void gsr_capture_v4l2_reset_cropping(gsr_capture_v4l2 *self) {
     }
 }
 
-gsr_capture_v4l2_supported_pixfmts gsr_capture_v4l2_get_supported_pixfmts(int fd) {
+static uint32_t gsr_pixfmt_to_v4l2_pixfmt(gsr_capture_v4l2_pixfmt pixfmt) {
+    switch(pixfmt) {
+        case GSR_CAPTURE_V4L2_PIXFMT_AUTO:
+            assert(false);
+            break;
+        case GSR_CAPTURE_V4L2_PIXFMT_YUYV:
+            return V4L2_PIX_FMT_YUYV;
+        case GSR_CAPTURE_V4L2_PIXFMT_MJPEG:
+            return V4L2_PIX_FMT_MJPEG;
+    }
+    assert(false);
+    return V4L2_PIX_FMT_YUYV;
+}
+
+const char* gsr_capture_v4l2_pixfmt_to_string(gsr_capture_v4l2_pixfmt pixfmt) {
+    switch(pixfmt) {
+        case GSR_CAPTURE_V4L2_PIXFMT_AUTO:
+            assert(false);
+            break;
+        case GSR_CAPTURE_V4L2_PIXFMT_YUYV:
+            return "yuyv";
+        case GSR_CAPTURE_V4L2_PIXFMT_MJPEG:
+            return "mjpeg";
+    }
+    assert(false);
+    return "";
+}
+
+static gsr_capture_v4l2_supported_pixfmts gsr_capture_v4l2_get_supported_pixfmts(int fd) {
     gsr_capture_v4l2_supported_pixfmts result = {0};
 
     struct v4l2_fmtdesc fmt = {
@@ -179,28 +212,189 @@ gsr_capture_v4l2_supported_pixfmts gsr_capture_v4l2_get_supported_pixfmts(int fd
     return result;
 }
 
-static uint32_t gsr_pixfmt_to_v4l2_pixfmt(gsr_capture_v4l2_pixfmt pixfmt) {
-    switch(pixfmt) {
-        case GSR_CAPTURE_V4L2_PIXFMT_AUTO:
-            assert(false);
-            break;
-        case GSR_CAPTURE_V4L2_PIXFMT_YUYV:
-            return V4L2_PIX_FMT_YUYV;
-        case GSR_CAPTURE_V4L2_PIXFMT_MJPEG:
-            return V4L2_PIX_FMT_MJPEG;
+/* Returns the number of resolutions added */
+static size_t gsr_capture_v4l2_get_supported_resolutions(int fd, gsr_capture_v4l2_pixfmt pixfmt, gsr_capture_v4l2_resolution *resolutions, size_t max_resolutions) {
+    size_t resolution_index = 0;
+    struct v4l2_frmsizeenum fmt = {
+        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+        .pixel_format = gsr_pixfmt_to_v4l2_pixfmt(pixfmt),
+    };
+
+    while(xioctl(fd, VIDIOC_ENUM_FRAMESIZES, &fmt) == 0) {
+        if(fmt.type == V4L2_FRMSIZE_TYPE_DISCRETE && resolution_index < max_resolutions) {
+            resolutions[resolution_index] = (gsr_capture_v4l2_resolution){
+                .width = fmt.discrete.width,
+                .height = fmt.discrete.height,
+            };
+            ++resolution_index;
+        }
+        ++fmt.index;
     }
-    assert(false);
-    return V4L2_PIX_FMT_YUYV;
+
+    return resolution_index;
 }
 
-static bool gsr_capture_v4l2_validate_pixfmt(gsr_capture_v4l2 *self, const gsr_capture_v4l2_supported_pixfmts supported_pixfmts) {
+/* Returns the number of framerates added */
+static size_t gsr_capture_v4l2_get_supported_framerates(int fd, gsr_capture_v4l2_pixfmt pixfmt, gsr_capture_v4l2_resolution resolution, gsr_capture_v4l2_framerate *framerates, size_t max_framerates) {
+    size_t framerate_index = 0;
+    struct v4l2_frmivalenum fmt = {
+        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+        .pixel_format = gsr_pixfmt_to_v4l2_pixfmt(pixfmt),
+        .width = resolution.width,
+        .height = resolution.height,
+    };
+
+    while(xioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &fmt) == 0) {
+        if(fmt.type == V4L2_FRMIVAL_TYPE_DISCRETE && fmt.discrete.denominator > 0 && fmt.discrete.numerator > 0 && framerate_index < max_framerates) {
+            framerates[framerate_index] = (gsr_capture_v4l2_framerate){
+                .denominator = fmt.discrete.denominator,
+                .numerator = fmt.discrete.numerator,
+            };
+            ++framerate_index;
+        }
+        ++fmt.index;
+    }
+
+    return framerate_index;
+}
+
+/* Returns the number of setups added */
+static size_t gsr_capture_v4l2_get_supported_setups(int fd, gsr_capture_v4l2_supported_setup *supported_setups, size_t max_supported_setups, bool has_libturbojpeg_lib) {
+    const gsr_capture_v4l2_supported_pixfmts supported_pixfmts = gsr_capture_v4l2_get_supported_pixfmts(fd);
+
+    size_t num_pixfmts = 0;
+    gsr_capture_v4l2_pixfmt pixfmts[2];
+
+    if(supported_pixfmts.yuyv)
+        pixfmts[num_pixfmts++] = GSR_CAPTURE_V4L2_PIXFMT_YUYV;
+
+    if(supported_pixfmts.mjpeg && has_libturbojpeg_lib)
+        pixfmts[num_pixfmts++] = GSR_CAPTURE_V4L2_PIXFMT_MJPEG;
+
+    gsr_capture_v4l2_resolution resolutions[32];
+    gsr_capture_v4l2_framerate framerates[32];
+    size_t supported_setup_index = 0;
+
+    for(size_t pixfmt_index = 0; pixfmt_index < num_pixfmts; ++pixfmt_index) {
+        const gsr_capture_v4l2_pixfmt pixfmt = pixfmts[pixfmt_index];
+        const size_t num_resolutions = gsr_capture_v4l2_get_supported_resolutions(fd, pixfmt, resolutions, 32);
+
+        for(size_t resolution_index = 0; resolution_index < num_resolutions; ++resolution_index) {
+            const gsr_capture_v4l2_resolution resolution = resolutions[resolution_index];
+            const size_t num_framerates = gsr_capture_v4l2_get_supported_framerates(fd, pixfmt, resolution, framerates, 32);
+
+            for(size_t framerate_index = 0; framerate_index < num_framerates; ++framerate_index) {
+                const gsr_capture_v4l2_framerate framerate = framerates[framerate_index];
+
+                if(supported_setup_index < max_supported_setups) {
+                    supported_setups[supported_setup_index] = (gsr_capture_v4l2_supported_setup){
+                        .pixfmt = pixfmt,
+                        .resolution = resolution,
+                        .framerate = framerate,
+                    };
+                    ++supported_setup_index;
+                }
+            }
+        }
+    }
+
+    return supported_setup_index;
+}
+
+uint32_t gsr_capture_v4l2_framerate_to_number(gsr_capture_v4l2_framerate framerate) {
+    return (uint32_t)((double)framerate.denominator / (double)framerate.numerator);
+}
+
+static bool gsr_capture_v4l2_get_best_matching_setup(
+    const gsr_capture_v4l2_supported_setup *supported_setups,
+    size_t num_supported_setups,
+    gsr_capture_v4l2_pixfmt pixfmt,
+    uint32_t camera_fps,
+    gsr_capture_v4l2_resolution camera_resolution,
+    gsr_capture_v4l2_supported_setup *best_supported_setup)
+{
+    memset(best_supported_setup, 0, sizeof(*best_supported_setup));
+
+    int best_match_index = -1;
+    uint64_t best_match_score = 0;
+
+    for(size_t i = 0; i < num_supported_setups; ++i) {
+        const gsr_capture_v4l2_supported_setup *setup = &supported_setups[i];
+        if(pixfmt != GSR_CAPTURE_V4L2_PIXFMT_AUTO && pixfmt != setup->pixfmt)
+            continue;
+
+        uint64_t setup_resolution_width = (uint64_t)setup->resolution.width;
+        uint64_t setup_resolution_height = (uint64_t)setup->resolution.height;
+        uint64_t setup_framerate = gsr_capture_v4l2_framerate_to_number(setup->framerate);
+
+        if(setup_resolution_width == camera_resolution.width && setup_resolution_height == camera_resolution.height) {
+            setup_resolution_width = 50000;
+            setup_resolution_height = 50000;
+        }
+
+        if(setup_framerate == camera_fps) {
+            setup_framerate = 50000;
+        }
+
+        const uint64_t match_score = setup_resolution_width * setup_resolution_height * setup_framerate + (pixfmt == GSR_CAPTURE_V4L2_PIXFMT_YUYV ? 5 : 0);
+        if(match_score > best_match_score) {
+            best_match_score = match_score;
+            best_match_index = i;
+        }
+
+        //fprintf(stderr, "supported setup[%d]: pixfmt: %d, size: %ux%u, fps: %u/%u\n", (int)i, setup->pixfmt, setup->resolution.width, setup->resolution.height, setup->framerate.denominator, setup->framerate.numerator);
+    }
+
+    if(best_match_index == -1)
+        return false;
+
+    //fprintf(stderr, "best match index: %d\n", best_match_index);
+    *best_supported_setup = supported_setups[best_match_index];
+    return true;
+}
+
+/* Seems like some cameras need this? */
+static void gsr_capture_v4l2_update_params(int fd) {
+    struct v4l2_streamparm streamparm = {
+        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+    };
+    if(xioctl(fd, VIDIOC_G_PARM, &streamparm) == -1) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_set_framerate: VIDIOC_G_PARM failed, error: %s\n", strerror(errno));
+        return;
+    }
+
+    if(xioctl(fd, VIDIOC_S_PARM, &streamparm) == -1) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_set_framerate: VIDIOC_S_PARM failed, error: %s\n", strerror(errno));
+        return;
+    }
+}
+
+static void gsr_capture_v4l2_set_framerate(int fd, gsr_capture_v4l2_framerate framerate) {
+    struct v4l2_streamparm streamparm = {
+        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+    };
+    if(xioctl(fd, VIDIOC_G_PARM, &streamparm) == -1) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_set_framerate: VIDIOC_G_PARM failed, error: %s\n", strerror(errno));
+        return;
+    }
+
+    streamparm.parm.capture.timeperframe.denominator = framerate.denominator;
+    streamparm.parm.capture.timeperframe.numerator = framerate.numerator;
+    if(xioctl(fd, VIDIOC_S_PARM, &streamparm) == -1) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_set_framerate: VIDIOC_S_PARM failed, error: %s\n", strerror(errno));
+        return;
+    }
+
+    if(streamparm.parm.capture.timeperframe.denominator == 0 || streamparm.parm.capture.timeperframe.numerator == 0) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_set_framerate: VIDIOC_S_PARM failed, error: invalid framerate: %u/%u\n", framerate.denominator, framerate.numerator);;
+        return;
+    }
+}
+
+static bool gsr_capture_v4l2_validate_pixfmt(const gsr_capture_v4l2 *self, const gsr_capture_v4l2_supported_pixfmts supported_pixfmts) {
     switch(self->params.pixfmt) {
         case GSR_CAPTURE_V4L2_PIXFMT_AUTO: {
-            if(supported_pixfmts.yuyv) {
-                self->params.pixfmt = GSR_CAPTURE_V4L2_PIXFMT_YUYV;
-            } else if(supported_pixfmts.mjpeg) {
-                self->params.pixfmt = GSR_CAPTURE_V4L2_PIXFMT_MJPEG;
-            } else {
+            if(!supported_pixfmts.yuyv && !supported_pixfmts.mjpeg) {
                 fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s doesn't support yuyv nor mjpeg. GPU Screen Recorder supports only yuyv and mjpeg at the moment. Report this as an issue, see: https://git.dec05eba.com/?p=about\n", self->params.device_path);
                 return false;
             }
@@ -208,14 +402,14 @@ static bool gsr_capture_v4l2_validate_pixfmt(gsr_capture_v4l2 *self, const gsr_c
         }
         case GSR_CAPTURE_V4L2_PIXFMT_YUYV: {
             if(!supported_pixfmts.yuyv) {
-                fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s doesn't support yuyv. Try recording with -pixfmt mjpeg or -pixfmt auto instead\n", self->params.device_path);
+                fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s doesn't support yuyv. Try recording with pixfmt=mjpeg or pixfmt=auto instead\n", self->params.device_path);
                 return false;
             }
             break;
         }
         case GSR_CAPTURE_V4L2_PIXFMT_MJPEG: {
             if(!supported_pixfmts.mjpeg) {
-                fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s doesn't support mjpeg. Try recording with -pixfmt yuyv or -pixfmt auto instead\n", self->params.device_path);
+                fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s doesn't support mjpeg. Try recording with pixfmt=yuyv or pixfmt=auto instead\n", self->params.device_path);
                 return false;
             }
             break;
@@ -321,6 +515,14 @@ static bool gsr_capture_v4l2_map_buffer(gsr_capture_v4l2 *self, const struct v4l
     return true;
 }
 
+static bool is_libturbojpeg_library_available(void) {
+    void *libturbojpeg_lib = dlopen("libturbojpeg.so.0", RTLD_LAZY);
+    const bool has_libturbojpeg_lib = libturbojpeg_lib != NULL;
+    if(libturbojpeg_lib)
+        dlclose(libturbojpeg_lib);
+    return has_libturbojpeg_lib;
+}
+
 static int gsr_capture_v4l2_setup(gsr_capture_v4l2 *self) {
     self->fd = open(self->params.device_path, O_RDWR | O_NONBLOCK);
     if(self->fd < 0) {
@@ -351,10 +553,35 @@ static int gsr_capture_v4l2_setup(gsr_capture_v4l2 *self) {
 
     gsr_capture_v4l2_reset_cropping(self);
 
+    const bool has_libturbojpeg_lib = is_libturbojpeg_library_available();
+    if(!has_libturbojpeg_lib && self->params.pixfmt == GSR_CAPTURE_V4L2_PIXFMT_AUTO) {
+        fprintf(stderr, "gsr warning: gsr_capture_v4l2_create: libturbojpeg.so.0 isn't available on the system, yuyv camera capture will be used\n");
+        self->params.pixfmt = GSR_CAPTURE_V4L2_PIXFMT_YUYV;
+    }
+
     const gsr_capture_v4l2_supported_pixfmts supported_pixfmts = gsr_capture_v4l2_get_supported_pixfmts(self->fd);
     if(!gsr_capture_v4l2_validate_pixfmt(self, supported_pixfmts))
         return -1;
 
+    gsr_capture_v4l2_supported_setup supported_setups[128];
+    const size_t num_supported_setups = gsr_capture_v4l2_get_supported_setups(self->fd, supported_setups, 128, has_libturbojpeg_lib);
+
+    gsr_capture_v4l2_supported_setup best_supported_setup = {0};
+    if(!gsr_capture_v4l2_get_best_matching_setup(supported_setups, num_supported_setups, self->params.pixfmt, self->params.camera_fps, self->params.camera_resolution, &best_supported_setup)) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s doesn't report any frame resolutions and framerates\n", self->params.device_path);
+        return -1;
+    }
+
+    fprintf(stderr, "gsr info: gsr_capture_v4l2_create: capturing %s at %ux%u@%dhz, pixfmt: %s\n",
+        self->params.device_path,
+        best_supported_setup.resolution.width,
+        best_supported_setup.resolution.height,
+        gsr_capture_v4l2_framerate_to_number(best_supported_setup.framerate),
+        gsr_capture_v4l2_pixfmt_to_string(best_supported_setup.pixfmt));
+
+    gsr_capture_v4l2_update_params(self->fd);
+    self->params.pixfmt = best_supported_setup.pixfmt;
+
     if(self->params.pixfmt == GSR_CAPTURE_V4L2_PIXFMT_MJPEG) {
         dlerror(); /* clear */
         self->libturbojpeg_lib = dlopen("libturbojpeg.so.0", RTLD_LAZY);
@@ -384,7 +611,9 @@ static int gsr_capture_v4l2_setup(gsr_capture_v4l2 *self) {
     const uint32_t v4l2_pixfmt = gsr_pixfmt_to_v4l2_pixfmt(self->params.pixfmt);
     struct v4l2_format fmt = {
         .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
-        .fmt.pix.pixelformat = v4l2_pixfmt
+        .fmt.pix.pixelformat = v4l2_pixfmt,
+        .fmt.pix.width = best_supported_setup.resolution.width,
+        .fmt.pix.height = best_supported_setup.resolution.height,
     };
     if(xioctl(self->fd, VIDIOC_S_FMT, &fmt) == -1) {
         fprintf(stderr, "gsr error: gsr_capture_v4l2_create: VIDIOC_S_FMT failed, error: %s\n", strerror(errno));
@@ -399,6 +628,8 @@ static int gsr_capture_v4l2_setup(gsr_capture_v4l2 *self) {
     self->capture_size.x = fmt.fmt.pix.width;
     self->capture_size.y = fmt.fmt.pix.height;
 
+    gsr_capture_v4l2_set_framerate(self->fd, best_supported_setup.framerate);
+
     struct v4l2_requestbuffers reqbuf = {
         .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
         .memory = V4L2_MEMORY_MMAP,
@@ -553,6 +784,9 @@ static int gsr_capture_v4l2_capture(gsr_capture *cap, gsr_capture_metadata *capt
     const vec2i target_pos = gsr_capture_get_target_position(output_size, capture_metadata);
 
     self->params.egl->glFlush();
+    // TODO: Use the minimal barrier required
+    self->params.egl->glMemoryBarrier(GL_ALL_BARRIER_BITS);
+    // TODO: Remove this?
     if(self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA)
         self->params.egl->glFinish();
 
@@ -642,12 +876,10 @@ gsr_capture* gsr_capture_v4l2_create(const gsr_capture_v4l2_params *params) {
 }
 
 void gsr_capture_v4l2_list_devices(v4l2_devices_query_callback callback, void *userdata) {
-    void *libturbojpeg_lib = dlopen("libturbojpeg.so.0", RTLD_LAZY);
-    const bool has_libturbojpeg_lib = libturbojpeg_lib != NULL;
-    if(libturbojpeg_lib)
-        dlclose(libturbojpeg_lib);
-
+    const bool has_libturbojpeg_lib = is_libturbojpeg_library_available();
     char v4l2_device_path[128];
+    gsr_capture_v4l2_supported_setup supported_setups[128];
+
     for(int i = 0; i < 8; ++i) {
         snprintf(v4l2_device_path, sizeof(v4l2_device_path), "/dev/video%d", i);
 
@@ -671,9 +903,14 @@ void gsr_capture_v4l2_list_devices(v4l2_devices_query_callback callback, void *u
         if(xioctl(fd, VIDIOC_G_FMT, &fmt) == -1)
             goto next;
 
-        const gsr_capture_v4l2_supported_pixfmts supported_pixfmts = gsr_capture_v4l2_get_supported_pixfmts(fd);
-        if(supported_pixfmts.yuyv || (supported_pixfmts.mjpeg && has_libturbojpeg_lib))
-            callback(v4l2_device_path, supported_pixfmts, (vec2i){ fmt.fmt.pix.width, fmt.fmt.pix.height }, userdata);
+        const size_t num_supported_setups = gsr_capture_v4l2_get_supported_setups(fd, supported_setups, 128, has_libturbojpeg_lib);
+        if(num_supported_setups == 0)
+            continue;
+
+        for(size_t j = 0; j < num_supported_setups; ++j) {
+            const gsr_capture_v4l2_supported_setup *setup = &supported_setups[j];
+            callback(v4l2_device_path, setup, userdata);
+        }
 
         next:
         close(fd);

src/color_conversion.c

@@ -781,7 +781,6 @@ static void gsr_color_conversion_draw_graphics(gsr_color_conversion *self, unsig
     self->params.egl->glBindBuffer(GL_ARRAY_BUFFER, self->vertex_buffer_object_id);
     self->params.egl->glBufferSubData(GL_ARRAY_BUFFER, 0, 24 * sizeof(float), vertices);
 
-    // TODO:
     switch(source_color) {
         case GSR_SOURCE_COLOR_RGB:
         case GSR_SOURCE_COLOR_BGR: {

src/dbus.c

@@ -78,14 +78,6 @@ bool gsr_dbus_init(gsr_dbus *self, const char *screencast_restore_token) {
         return false;
     }
 
-    /* TODO: Check the name */
-    const int ret = dbus_bus_request_name(self->con, "com.dec05eba.gpu_screen_recorder", DBUS_NAME_FLAG_REPLACE_EXISTING, &self->err);
-    if(dbus_error_is_set(&self->err)) {
-        fprintf(stderr, "gsr error: gsr_dbus_init: dbus_bus_request_name failed with error: %s\n", self->err.message);
-        gsr_dbus_deinit(self);
-        return false;
-    }
-
     if(screencast_restore_token) {
         self->screencast_restore_token = strdup(screencast_restore_token);
         if(!self->screencast_restore_token) {
@@ -95,12 +87,6 @@ bool gsr_dbus_init(gsr_dbus *self, const char *screencast_restore_token) {
         }
     }
 
-    (void)ret;
-    // if(ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
-    //     fprintf(stderr, "gsr error: gsr_capture_portal_setup_dbus: dbus_bus_request_name failed to get primary owner\n");
-    //     return false;
-    // }
-
     return true;
 }
 
@@ -119,8 +105,6 @@ void gsr_dbus_deinit(gsr_dbus *self) {
     if(self->con) {
         dbus_error_free(&self->err);
 
-        dbus_bus_release_name(self->con, "com.dec05eba.gpu_screen_recorder", NULL);
-
         // Apparently shouldn't be used when a connection is setup by using dbus_bus_get
         //dbus_connection_close(self->con);
         dbus_connection_unref(self->con);

src/egl.c

@@ -282,6 +282,7 @@ static bool gsr_egl_load_gl(gsr_egl *self, void *library) {
         { (void**)&self->glTexParameterfv, "glTexParameterfv" },
         { (void**)&self->glTexImage2D, "glTexImage2D" },
         { (void**)&self->glTexSubImage2D, "glTexSubImage2D" },
+        { (void**)&self->glTexStorage2D, "glTexStorage2D" },
         { (void**)&self->glGetTexImage, "glGetTexImage" },
         { (void**)&self->glGenFramebuffers, "glGenFramebuffers" },
         { (void**)&self->glBindFramebuffer, "glBindFramebuffer" },
@@ -522,4 +523,7 @@ void gsr_egl_swap_buffers(gsr_egl *self) {
     self->glFlush();
     // TODO: Use the minimal barrier required
     self->glMemoryBarrier(GL_ALL_BARRIER_BITS); // GL_SHADER_IMAGE_ACCESS_BARRIER_BIT
+    // TODO: This is needed on nvidia because the cursor can flicker otherwise. Find a better solution
+    if(self->gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA)
+        self->glFinish();
 }

src/encoder/encoder.c

@@ -3,10 +3,37 @@
 
 #include <string.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <time.h>
+#include <errno.h>
 
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 
+static uint64_t clock_gettime_microseconds(clockid_t clock_id) {
+    struct timespec ts;
+    ts.tv_sec = 0;
+    ts.tv_nsec = 0;
+    clock_gettime(clock_id, &ts);
+    return (uint64_t)ts.tv_sec * 1000000ULL + (uint64_t)ts.tv_nsec / 1000ULL;
+}
+
+static void gsr_write_first_frame_timestamp_file(const char *filepath) {
+    const uint64_t evdev_compatible_ts = clock_gettime_microseconds(CLOCK_MONOTONIC);
+    const uint64_t unix_time_microsec = clock_gettime_microseconds(CLOCK_REALTIME);
+
+    FILE *file = fopen(filepath, "w");
+    if(!file) {
+        fprintf(stderr, "gsr warning: failed to open timestamp file '%s': %s\n", filepath, strerror(errno));
+        return;
+    }
+
+    fputs("monotonic_microsec\trealtime_microsec\n", file);
+    fprintf(file, "%" PRIu64 "\t%" PRIu64 "\n", evdev_compatible_ts, unix_time_microsec);
+    fclose(file);
+}
+
 bool gsr_encoder_init(gsr_encoder *self, gsr_replay_storage replay_storage, size_t replay_buffer_num_packets, double replay_buffer_time, const char *replay_directory) {
     memset(self, 0, sizeof(*self));
     self->num_recording_destinations = 0;
@@ -14,9 +41,17 @@ bool gsr_encoder_init(gsr_encoder *self, gsr_replay_storage replay_storage, size
 
     if(pthread_mutex_init(&self->file_write_mutex, NULL) != 0) {
         fprintf(stderr, "gsr error: gsr_encoder_init: failed to create mutex\n");
+        gsr_encoder_deinit(self);
         return false;
     }
-    self->mutex_created = true;
+    self->file_write_mutex_created = true;
+
+    if(pthread_mutex_init(&self->replay_mutex, NULL) != 0) {
+        fprintf(stderr, "gsr error: gsr_encoder_init: failed to create mutex\n");
+        gsr_encoder_deinit(self);
+        return false;
+    }
+    self->replay_mutex_created = true;
 
     if(replay_buffer_num_packets > 0) {
         self->replay_buffer = gsr_replay_buffer_create(replay_storage, replay_directory, replay_buffer_time, replay_buffer_num_packets);
@@ -31,14 +66,31 @@ bool gsr_encoder_init(gsr_encoder *self, gsr_replay_storage replay_storage, size
 }
 
 void gsr_encoder_deinit(gsr_encoder *self)  {
-    if(self->mutex_created) {
-        self->mutex_created = false;
+    if(self->file_write_mutex_created)
+        pthread_mutex_lock(&self->file_write_mutex);
+    for(size_t i = 0; i < self->num_recording_destinations; ++i) {
+        free(self->recording_destinations[i].first_frame_ts_filepath);
+        self->recording_destinations[i].first_frame_ts_filepath = NULL;
+        self->recording_destinations[i].first_frame_ts_written = false;
+    }
+    if(self->file_write_mutex_created)
+        pthread_mutex_unlock(&self->file_write_mutex);
+
+    if(self->replay_buffer) {
+        pthread_mutex_lock(&self->replay_mutex);
+        gsr_replay_buffer_destroy(self->replay_buffer);
+        self->replay_buffer = NULL;
+        pthread_mutex_unlock(&self->replay_mutex);
+    }
+
+    if(self->file_write_mutex_created) {
+        self->file_write_mutex_created = false;
         pthread_mutex_destroy(&self->file_write_mutex);
     }
 
-    if(self->replay_buffer) {
-        gsr_replay_buffer_destroy(self->replay_buffer);
-        self->replay_buffer = NULL;
+    if(self->replay_mutex_created) {
+        self->replay_mutex_created = false;
+        pthread_mutex_destroy(&self->replay_mutex);
     }
 
     self->num_recording_destinations = 0;
@@ -60,9 +112,11 @@ void gsr_encoder_receive_packets(gsr_encoder *self, AVCodecContext *codec_contex
             av_packet->dts = pts;
 
             if(self->replay_buffer) {
+                pthread_mutex_lock(&self->replay_mutex);
                 const double time_now = clock_get_monotonic_seconds();
                 if(!gsr_replay_buffer_append(self->replay_buffer, av_packet, time_now))
                     fprintf(stderr, "gsr error: gsr_encoder_receive_packets: failed to add replay buffer data\n");
+                pthread_mutex_unlock(&self->replay_mutex);
             }
 
             pthread_mutex_lock(&self->file_write_mutex);
@@ -77,6 +131,11 @@ void gsr_encoder_receive_packets(gsr_encoder *self, AVCodecContext *codec_contex
                 else if(!recording_destination->has_received_keyframe)
                     continue;
 
+                if(recording_destination->first_frame_ts_filepath && !recording_destination->first_frame_ts_written) {
+                    gsr_write_first_frame_timestamp_file(recording_destination->first_frame_ts_filepath);
+                    recording_destination->first_frame_ts_written = true;
+                }
+
                 av_packet->pts = pts - recording_destination->start_pts;
                 av_packet->dts = pts - recording_destination->start_pts;
 
@@ -131,6 +190,8 @@ size_t gsr_encoder_add_recording_destination(gsr_encoder *self, AVCodecContext *
     recording_destination->stream = stream;
     recording_destination->start_pts = start_pts;
     recording_destination->has_received_keyframe = false;
+    recording_destination->first_frame_ts_filepath = NULL;
+    recording_destination->first_frame_ts_written = false;
 
     ++self->recording_destination_id_counter;
     ++self->num_recording_destinations;
@@ -144,6 +205,9 @@ bool gsr_encoder_remove_recording_destination(gsr_encoder *self, size_t id) {
     pthread_mutex_lock(&self->file_write_mutex);
     for(size_t i = 0; i < self->num_recording_destinations; ++i) {
         if(self->recording_destinations[i].id == id) {
+            free(self->recording_destinations[i].first_frame_ts_filepath);
+            self->recording_destinations[i].first_frame_ts_filepath = NULL;
+            self->recording_destinations[i].first_frame_ts_written = false;
             self->recording_destinations[i] = self->recording_destinations[self->num_recording_destinations - 1];
             --self->num_recording_destinations;
             found = true;
@@ -153,3 +217,26 @@ bool gsr_encoder_remove_recording_destination(gsr_encoder *self, size_t id) {
     pthread_mutex_unlock(&self->file_write_mutex);
     return found;
 }
+
+bool gsr_encoder_set_recording_destination_first_frame_ts_filepath(gsr_encoder *self, size_t id, const char *filepath) {
+    if(!filepath)
+        return false;
+
+    bool found = false;
+    pthread_mutex_lock(&self->file_write_mutex);
+    for(size_t i = 0; i < self->num_recording_destinations; ++i) {
+        if(self->recording_destinations[i].id == id) {
+            char *filepath_copy = strdup(filepath);
+            if(!filepath_copy)
+                break;
+
+            free(self->recording_destinations[i].first_frame_ts_filepath);
+            self->recording_destinations[i].first_frame_ts_filepath = filepath_copy;
+            self->recording_destinations[i].first_frame_ts_written = false;
+            found = true;
+            break;
+        }
+    }
+    pthread_mutex_unlock(&self->file_write_mutex);
+    return found;
+}

src/encoder/video/vaapi.c

@@ -245,8 +245,8 @@ static bool gsr_video_encoder_vaapi_start(gsr_video_encoder *encoder, AVCodecCon
             video_codec_context->width = FFALIGN(video_codec_context->width, 2);
             video_codec_context->height = FFALIGN(video_codec_context->height, 2);
         } else {
-            video_codec_context->width = FFALIGN(video_codec_context->width, 256);
-            video_codec_context->height = FFALIGN(video_codec_context->height, 256);
+            video_codec_context->width = FFALIGN(video_codec_context->width, 64);
+            video_codec_context->height = FFALIGN(video_codec_context->height, 16);
         }
     } else if(self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_AMD && video_codec_context->codec_id == AV_CODEC_ID_AV1) {
         // TODO: Dont do this for VCN 5 and forward which should fix this hardware bug

src/main.cpp

@@ -110,26 +110,23 @@ typedef struct {
     char *output_name;
     vec2i monitor_pos;
     vec2i monitor_size;
+    double monitor_scale_inverted;
 } 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);
-    }
+    const vec2i monitor_position = monitor->logical_pos;
+    const vec2i monitor_size = monitor->size;
+    const vec2i monitor_logical_size = monitor->logical_size;
 
-    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)
+    if(!data->output_name && data->position.x >= monitor_position.x && data->position.x <= monitor_position.x + monitor_logical_size.x
+        && data->position.y >= monitor_position.y && data->position.y <= monitor_position.y + monitor_logical_size.y)
     {
         data->output_name = strdup(monitor->name);
         data->monitor_pos = monitor_position;
         data->monitor_size = monitor_size;
+        data->monitor_scale_inverted = (double)monitor_size.x / (double)monitor_logical_size.x;
     }
 }
 
@@ -528,10 +525,13 @@ static AVCodecContext *create_video_codec_context(AVPixelFormat pix_fmt, const A
     return codec_context;
 }
 
-static void open_audio(AVCodecContext *audio_codec_context) {
+static void open_audio(AVCodecContext *audio_codec_context, const char *ffmpeg_audio_opts) {
     AVDictionary *options = nullptr;
     av_dict_set(&options, "strict", "experimental", 0);
 
+    if(ffmpeg_audio_opts)
+        av_dict_parse_string(&options, ffmpeg_audio_opts, "=", ";", 0);
+
     int ret;
     ret = avcodec_open2(audio_codec_context, audio_codec_context->codec, &options);
     if(ret < 0) {
@@ -678,6 +678,9 @@ static void open_video_software(AVCodecContext *codec_context, const args_parser
 
     av_dict_set(&options, "strict", "experimental", 0);
 
+    if(arg_parser.ffmpeg_video_opts)
+        av_dict_parse_string(&options, arg_parser.ffmpeg_video_opts, "=", ";", 0);
+
     int ret = avcodec_open2(codec_context, codec_context->codec, &options);
     if (ret < 0) {
         fprintf(stderr, "gsr error: Could not open video codec: %s\n", av_error_to_string(ret));
@@ -926,6 +929,9 @@ static void open_video_hardware(AVCodecContext *codec_context, bool low_power, c
 
     av_dict_set(&options, "strict", "experimental", 0);
 
+    if(arg_parser.ffmpeg_video_opts)
+        av_dict_parse_string(&options, arg_parser.ffmpeg_video_opts, "=", ";", 0);
+
     int ret = avcodec_open2(codec_context, codec_context->codec, &options);
     if (ret < 0) {
         fprintf(stderr, "gsr error: Could not open video codec: %s\n", av_error_to_string(ret));
@@ -1185,6 +1191,8 @@ struct CaptureSource {
     vec2i region_size = {0, 0};
     bool region_set = false;
     int64_t window_id = 0;
+    int camera_fps = 0;
+    vec2i camera_resolution = {0, 0};
 };
 
 struct VideoSource {
@@ -1193,9 +1201,9 @@ struct VideoSource {
     CaptureSource *capture_source;
 };
 
-static RecordingStartResult start_recording_create_streams(const char *filename, const char *container_format, AVCodecContext *video_codec_context, const std::vector<AudioTrack> &audio_tracks, bool hdr, std::vector<VideoSource> &video_sources) {
+static RecordingStartResult start_recording_create_streams(const char *filename, const args_parser &arg_parser, AVCodecContext *video_codec_context, const std::vector<AudioTrack> &audio_tracks, bool hdr, std::vector<VideoSource> &video_sources) {
     AVFormatContext *av_format_context;
-    avformat_alloc_output_context2(&av_format_context, nullptr, container_format, filename);
+    avformat_alloc_output_context2(&av_format_context, nullptr, arg_parser.container_format, filename);
 
     AVStream *video_stream = create_stream(av_format_context, video_codec_context);
     avcodec_parameters_from_context(video_stream->codecpar, video_codec_context);
@@ -1220,6 +1228,9 @@ static RecordingStartResult start_recording_create_streams(const char *filename,
     AVDictionary *options = nullptr;
     av_dict_set(&options, "strict", "experimental", 0);
 
+    if(arg_parser.ffmpeg_opts)
+        av_dict_parse_string(&options, arg_parser.ffmpeg_opts, "=", ";", 0);
+
     const int header_write_ret = avformat_write_header(av_format_context, &options);
     av_dict_free(&options);
     if(header_write_ret < 0) {
@@ -1282,48 +1293,60 @@ struct AudioPtsOffset {
     int stream_index = 0;
 };
 
-static void save_replay_async(AVCodecContext *video_codec_context, int video_stream_index, const std::vector<AudioTrack> &audio_tracks, gsr_replay_buffer *replay_buffer, std::string output_dir, const char *container_format, const std::string &file_extension, bool date_folders, bool hdr, std::vector<VideoSource> &video_sources, int current_save_replay_seconds) {
+static void save_replay_async(AVCodecContext *video_codec_context, int video_stream_index, const std::vector<AudioTrack> &audio_tracks, gsr_encoder *encoder, const args_parser &arg_parser, const std::string &file_extension, bool date_folders, bool hdr, std::vector<VideoSource> &video_sources, int current_save_replay_seconds) {
     if(save_replay_thread.valid())
         return;
 
-    const gsr_replay_buffer_iterator search_start_iterator = current_save_replay_seconds == save_replay_seconds_full ? gsr_replay_buffer_iterator{0, 0} : gsr_replay_buffer_find_packet_index_by_time_passed(replay_buffer, current_save_replay_seconds);
-    const gsr_replay_buffer_iterator video_start_iterator = gsr_replay_buffer_find_keyframe(replay_buffer, search_start_iterator, video_stream_index, false);
-    if(video_start_iterator.packet_index == (size_t)-1) {
-        fprintf(stderr, "gsr error: failed to save replay: failed to find a video keyframe. perhaps replay was saved too fast, before anything has been recorded\n");
-        return;
-    }
-
-    const int64_t video_pts_offset = gsr_replay_buffer_iterator_get_packet(replay_buffer, video_start_iterator)->pts;
-
-    std::vector<AudioPtsOffset> audio_pts_offsets;
-    audio_pts_offsets.reserve(audio_tracks.size());
-    for(const AudioTrack &audio_track : audio_tracks) {
-        const gsr_replay_buffer_iterator audio_start_iterator = gsr_replay_buffer_find_keyframe(replay_buffer, video_start_iterator, audio_track.stream_index, false);
-        const int64_t audio_pts_offset = audio_start_iterator.packet_index == (size_t)-1 ? 0 : gsr_replay_buffer_iterator_get_packet(replay_buffer, audio_start_iterator)->pts;
-        audio_pts_offsets.push_back(AudioPtsOffset{audio_pts_offset, audio_track.stream_index});
-    }
-
-    gsr_replay_buffer *cloned_replay_buffer = gsr_replay_buffer_clone(replay_buffer);
+    pthread_mutex_lock(&encoder->replay_mutex);
+    gsr_replay_buffer *cloned_replay_buffer = gsr_replay_buffer_clone(encoder->replay_buffer);
+    pthread_mutex_unlock(&encoder->replay_mutex);
     if(!cloned_replay_buffer) {
         // TODO: Return this error to mark the replay as failed
         fprintf(stderr, "gsr error: failed to save replay: failed to clone replay buffer\n");
         return;
     }
 
-    std::string output_filepath = create_new_recording_filepath_from_timestamp(output_dir, "Replay", file_extension, date_folders);
-    RecordingStartResult recording_start_result = start_recording_create_streams(output_filepath.c_str(), container_format, video_codec_context, audio_tracks, hdr, video_sources);
-    if(!recording_start_result.av_format_context)
+    const gsr_replay_buffer_iterator search_start_iterator = current_save_replay_seconds == save_replay_seconds_full ? gsr_replay_buffer_iterator{0, 0} : gsr_replay_buffer_find_packet_index_by_time_passed(cloned_replay_buffer, current_save_replay_seconds);
+    const gsr_replay_buffer_iterator video_start_iterator = gsr_replay_buffer_find_keyframe(cloned_replay_buffer, search_start_iterator, video_stream_index, false);
+    if(video_start_iterator.packet_index == (size_t)-1) {
+        fprintf(stderr, "gsr error: failed to save replay: failed to find a video keyframe. perhaps replay was saved too fast, before anything has been recorded\n");
+        pthread_mutex_lock(&encoder->replay_mutex);
+        gsr_replay_buffer_destroy(cloned_replay_buffer);
+        pthread_mutex_unlock(&encoder->replay_mutex);
         return;
+    }
+
+    const int64_t video_pts_offset = gsr_replay_buffer_iterator_get_packet(cloned_replay_buffer, video_start_iterator)->pts;
+
+    std::vector<AudioPtsOffset> audio_pts_offsets;
+    audio_pts_offsets.reserve(audio_tracks.size());
+    for(const AudioTrack &audio_track : audio_tracks) {
+        const gsr_replay_buffer_iterator audio_start_iterator = gsr_replay_buffer_find_keyframe(cloned_replay_buffer, video_start_iterator, audio_track.stream_index, false);
+        const int64_t audio_pts_offset = audio_start_iterator.packet_index == (size_t)-1 ? 0 : gsr_replay_buffer_iterator_get_packet(cloned_replay_buffer, audio_start_iterator)->pts;
+        audio_pts_offsets.push_back(AudioPtsOffset{audio_pts_offset, audio_track.stream_index});
+    }
+
+    std::string output_filepath = create_new_recording_filepath_from_timestamp(arg_parser.filename, "Replay", file_extension, date_folders);
+    RecordingStartResult recording_start_result = start_recording_create_streams(output_filepath.c_str(), arg_parser, video_codec_context, audio_tracks, hdr, video_sources);
+    if(!recording_start_result.av_format_context) {
+        pthread_mutex_lock(&encoder->replay_mutex);
+        gsr_replay_buffer_destroy(cloned_replay_buffer);
+        pthread_mutex_unlock(&encoder->replay_mutex);
+        return;
+    }
 
     save_replay_output_filepath = std::move(output_filepath);
 
-    save_replay_thread = std::async(std::launch::async, [video_stream_index, recording_start_result, video_start_iterator, video_pts_offset, audio_pts_offsets{std::move(audio_pts_offsets)}, video_codec_context, cloned_replay_buffer]() mutable {
+    save_replay_thread = std::async(std::launch::async, [video_stream_index, recording_start_result, video_start_iterator, video_pts_offset, audio_pts_offsets{std::move(audio_pts_offsets)}, video_codec_context, cloned_replay_buffer, encoder]() mutable {
         gsr_replay_buffer_iterator replay_iterator = video_start_iterator;
         for(;;) {
             AVPacket *replay_packet = gsr_replay_buffer_iterator_get_packet(cloned_replay_buffer, replay_iterator);
             uint8_t *replay_packet_data = NULL;
-            if(replay_packet)
+            if(replay_packet) {
+                pthread_mutex_lock(&encoder->replay_mutex);
                 replay_packet_data = gsr_replay_buffer_iterator_get_packet_data(cloned_replay_buffer, replay_iterator);
+                pthread_mutex_unlock(&encoder->replay_mutex);
+            }
 
             if(!replay_packet) {
                 fprintf(stderr, "gsr error: save_replay_async: no replay packet\n");
@@ -1386,7 +1409,10 @@ static void save_replay_async(AVCodecContext *video_codec_context, int video_str
         }
 
         stop_recording_close_streams(recording_start_result.av_format_context);
+
+        pthread_mutex_lock(&encoder->replay_mutex);
         gsr_replay_buffer_destroy(cloned_replay_buffer);
+        pthread_mutex_unlock(&encoder->replay_mutex);
     });
 }
 
@@ -1857,18 +1883,9 @@ static void output_monitor_info(const gsr_monitor *monitor, void *userdata) {
     ++options->num_monitors;
 }
 
-static void camera_query_callback(const char *path, gsr_capture_v4l2_supported_pixfmts supported_pixfmts, vec2i size, void *userdata) {
+static void camera_query_callback(const char *path, const gsr_capture_v4l2_supported_setup *setup, void *userdata) {
     (void)userdata;
-
-    char pixfmt_str[32];
-    if(supported_pixfmts.yuyv && supported_pixfmts.mjpeg)
-        snprintf(pixfmt_str, sizeof(pixfmt_str), "yuyv,mjpeg");
-    else if(supported_pixfmts.yuyv)
-        snprintf(pixfmt_str, sizeof(pixfmt_str), "yuyv");
-    else if(supported_pixfmts.mjpeg)
-        snprintf(pixfmt_str, sizeof(pixfmt_str), "mjpeg");
-
-    printf("%s|%dx%d|%s\n", path, size.x, size.y, pixfmt_str);
+    printf("%s|%ux%u@%uhz|%s\n", path, setup->resolution.width, setup->resolution.height, gsr_capture_v4l2_framerate_to_number(setup->framerate), gsr_capture_v4l2_pixfmt_to_string(setup->pixfmt));
 }
 
 static void list_supported_capture_options(const gsr_window *window, const char *card_path, bool list_monitors) {
@@ -2135,9 +2152,9 @@ static std::string validate_monitor_get_valid(const gsr_egl *egl, const char* wi
     return capture_source_result;
 }
 
-static std::string get_monitor_by_region_center(const gsr_egl *egl, vec2i region_position, vec2i region_size, vec2i *monitor_pos, vec2i *monitor_size) {
+static std::string get_monitor_by_region_center(const gsr_egl *egl, vec2i region_position, vec2i region_size, vec2i *monitor_pos, vec2i *monitor_size, double *monitor_scale_inverted) {
     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;
+    const gsr_connection_type connection_type = is_x11 ? GSR_CONNECTION_X11 : GSR_CONNECTION_WAYLAND;
 
     MonitorByPositionCallback data;
     data.window = egl->window;
@@ -2145,6 +2162,7 @@ static std::string get_monitor_by_region_center(const gsr_egl *egl, vec2i region
     data.output_name = NULL;
     data.monitor_pos = {0, 0};
     data.monitor_size = {0, 0};
+    data.monitor_scale_inverted = 1.0;
     for_each_active_monitor_output(egl->window, egl->card_path, connection_type, get_monitor_by_position_callback, &data);
 
     std::string result;
@@ -2154,6 +2172,7 @@ static std::string get_monitor_by_region_center(const gsr_egl *egl, vec2i region
     }
     *monitor_pos = data.monitor_pos;
     *monitor_size = data.monitor_size;
+    *monitor_scale_inverted = data.monitor_scale_inverted;
     return result;
 }
 
@@ -2221,18 +2240,25 @@ static gsr_capture* create_monitor_capture(const args_parser &arg_parser, gsr_eg
     }
 }
 
+static void monitor_output_callback_print_region(const gsr_monitor *monitor, void *userdata) {
+    const vec2i monitor_position = monitor->logical_pos;
+    const vec2i monitor_size = monitor->logical_size;
+    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);
+}
+
 static std::string region_get_data(gsr_egl *egl, vec2i *region_size, vec2i *region_position) {
     vec2i monitor_pos = {0, 0};
     vec2i monitor_size = {0, 0};
-    std::string window = get_monitor_by_region_center(egl, *region_position, *region_size, &monitor_pos, &monitor_size);
+    double monitor_scale_inverted = 1.0;
+    std::string window = get_monitor_by_region_center(egl, *region_position, *region_size, &monitor_pos, &monitor_size, &monitor_scale_inverted);
     if(window.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;
+        const gsr_connection_type connection_type = is_x11 ? GSR_CONNECTION_X11 : GSR_CONNECTION_WAYLAND;
         fprintf(stderr, "gsr 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);
+        for_each_active_monitor_output(egl->window, egl->card_path, connection_type, monitor_output_callback_print_region, &userdata);
         _exit(51);
     }
 
@@ -2243,6 +2269,12 @@ static std::string region_get_data(gsr_egl *egl, vec2i *region_size, vec2i *regi
     } else {
         region_position->x -= monitor_pos.x;
         region_position->y -= monitor_pos.y;
+        // Match drm plane coordinate space (1x scaling) to wayland coordinate space (which may have scaling set by user)
+        region_position->x *= monitor_scale_inverted;
+        region_position->y *= monitor_scale_inverted;
+
+        region_size->x *= monitor_scale_inverted;
+        region_size->y *= monitor_scale_inverted;
     }
     return window;
 }
@@ -2304,7 +2336,9 @@ static gsr_capture* create_capture_impl(const args_parser &arg_parser, gsr_egl *
         v4l2_params.output_resolution = arg_parser.output_resolution;
         v4l2_params.device_path = capture_source.name.c_str();
         v4l2_params.pixfmt = capture_source.v4l2_pixfmt;
-        v4l2_params.fps = arg_parser.fps;
+        v4l2_params.camera_fps = capture_source.camera_fps;
+        v4l2_params.camera_resolution.width = capture_source.camera_resolution.x;
+        v4l2_params.camera_resolution.height = capture_source.camera_resolution.y;
         capture = gsr_capture_v4l2_create(&v4l2_params);
         if(!capture)
             _exit(1);
@@ -2386,12 +2420,30 @@ static std::vector<VideoSource> create_video_sources(const args_parser &arg_pars
         }
     }
 
-    video_size = {0, 0};
+    vec2i start_pos = {99999, 99999};
+    vec2i end_pos = {-99999, -99999};
     for(const VideoSource &video_source : video_sources) {
-        video_size.x = std::max(video_size.x, video_source.metadata.video_size.x);
-        video_size.y = std::max(video_size.y, video_source.metadata.video_size.y);
+        // TODO: Skip scalar positions for now, but this should be handled in a better way.
+        // Maybe handle scalars at the next loop by multiplying video size by the scalar.
+        if(video_source.capture_source->pos.x_type == VVEC2I_TYPE_SCALAR || video_source.capture_source->pos.y_type == VVEC2I_TYPE_SCALAR
+            || (video_source.capture_source->size.x_type == VVEC2I_TYPE_SCALAR && video_source.capture_source->size.x != 100)
+            || (video_source.capture_source->size.y_type == VVEC2I_TYPE_SCALAR && video_source.capture_source->size.y != 100))
+        {
+            continue;
+        }
+        const vec2i video_source_start_pos = {video_source.capture_source->pos.x, video_source.capture_source->pos.y};
+        const vec2i video_source_end_pos = {video_source_start_pos.x + video_source.metadata.video_size.x, video_source_start_pos.y + video_source.metadata.video_size.y};
+
+        start_pos.x = std::min(start_pos.x, video_source_start_pos.x);
+        start_pos.y = std::min(start_pos.y, video_source_start_pos.y);
+
+        end_pos.x = std::max(end_pos.x, video_source_end_pos.x);
+        end_pos.y = std::max(end_pos.y, video_source_end_pos.y);
     }
 
+    video_size.x = std::max(0, end_pos.x - start_pos.x);
+    video_size.y = std::max(0, end_pos.y - start_pos.y);
+
     for(VideoSource &video_source : video_sources) {
         video_source.metadata.video_size = video_size;
     }
@@ -2777,6 +2829,7 @@ static void parse_capture_source_options(const std::string &capture_source_str,
                 fprintf(stderr, "gsr error: invalid capture target value for option y: \"%.*s\", expected a number\n", (int)size, sub);
                 _exit(1);
             }
+
         } else if(string_starts_with(sub, size, "width=")) {
             capture_source.size.x_type = sub[size - 1] == '%' ? VVEC2I_TYPE_SCALAR : VVEC2I_TYPE_PIXELS;
             sub += 6;
@@ -2836,8 +2889,29 @@ static void parse_capture_source_options(const std::string &capture_source_str,
 
             if(vflip)
                 capture_source.flip |= GSR_FLIP_VERTICAL;
+        } else if(string_starts_with(sub, size, "camera_fps=")) {
+            sub += 11;
+            size -= 11;
+            if(!string_to_int(sub, size, &capture_source.camera_fps)) {
+                fprintf(stderr, "gsr error: invalid capture target value for option camera_fps: \"%.*s\", expected a number\n", (int)size, sub);
+                _exit(1);
+            }
+        } else if(string_starts_with(sub, size, "camera_width=")) {
+            sub += 13;
+            size -= 13;
+            if(!string_to_int(sub, size, &capture_source.camera_resolution.x)) {
+                fprintf(stderr, "gsr error: invalid capture target value for option camera_width: \"%.*s\", expected a number\n", (int)size, sub);
+                _exit(1);
+            }
+        } else if(string_starts_with(sub, size, "camera_height=")) {
+            sub += 14;
+            size -= 14;
+            if(!string_to_int(sub, size, &capture_source.camera_resolution.y)) {
+                fprintf(stderr, "gsr error: invalid capture target value for option camera_height: \"%.*s\", expected a number\n", (int)size, sub);
+                _exit(1);
+            }
         } else {
-            fprintf(stderr, "gsr error: invalid capture target option \"%.*s\", expected x, y, width, height, halign, valign, pixfmt, hflip or vflip\n", (int)size, sub);
+            fprintf(stderr, "gsr error: invalid capture target option \"%.*s\", expected x, y, width, height, halign, valign, pixfmt, hflip, vflip, camera_fps, camera_width or camera_height\n", (int)size, sub);
             _exit(1);
         }
 
@@ -2847,6 +2921,7 @@ static void parse_capture_source_options(const std::string &capture_source_str,
 
 static std::vector<CaptureSource> parse_capture_source_arg(const char *capture_source_arg, const args_parser &arg_parser) {
     std::vector<CaptureSource> requested_capture_sources;
+    const bool has_multiple_capture_sources = strchr(capture_source_arg, '|') != nullptr;
 
     split_string(capture_source_arg, '|', [&](const char *sub, size_t size) {
         if(size == 0)
@@ -2888,12 +2963,10 @@ static std::vector<CaptureSource> parse_capture_source_arg(const char *capture_s
             }
         }
 
-        /* We want good default values for v4l2 (webcam) capture, by setting webcam at bottom right, offset by -10%,-10% pixels and at size 30%,30% */
-        if(capture_source.type == GSR_CAPTURE_SOURCE_TYPE_V4L2 && !requested_capture_sources.empty()) {
+        if(has_multiple_capture_sources) {
             capture_source.halign = GSR_CAPTURE_ALIGN_START;
-            capture_source.valign = GSR_CAPTURE_ALIGN_END;
+            capture_source.valign = GSR_CAPTURE_ALIGN_START;
             capture_source.pos = {0, 0, VVEC2I_TYPE_PIXELS, VVEC2I_TYPE_PIXELS};
-            capture_source.size = {30, 30, VVEC2I_TYPE_SCALAR, VVEC2I_TYPE_SCALAR};
         }
 
         parse_capture_source_options(std::string(substr_start, size), capture_source);
@@ -3258,12 +3331,12 @@ static gsr_video_codec select_appropriate_video_codec_automatically(vec2i video_
         fprintf(stderr, "gsr info: using h264 encoder because a codec was not specified\n");
         return GSR_VIDEO_CODEC_H264;
     } else if(supported_video_codecs->hevc.supported && codec_supports_resolution(supported_video_codecs->hevc.max_resolution, video_size)) {
-        fprintf(stderr, "gsr info: using hevc encoder because a codec was not specified and h264 supported max resolution (%dx%d) is less than capture resolution (%dx%d)\n",
+        fprintf(stderr, "gsr info: using hevc encoder because a codec was not specified and h264 supported max resolution (%dx%d) is less than the capture resolution (%dx%d)\n",
             supported_video_codecs->h264.max_resolution.x, supported_video_codecs->h264.max_resolution.y,
             video_size.x, video_size.y);
         return GSR_VIDEO_CODEC_HEVC;
     } else if(supported_video_codecs->av1.supported && codec_supports_resolution(supported_video_codecs->av1.max_resolution, video_size)) {
-        fprintf(stderr, "gsr info: using av1 encoder because a codec was not specified and hevc supported max resolution (%dx%d) is less than capture resolution (%dx%d)\n",
+        fprintf(stderr, "gsr info: using av1 encoder because a codec was not specified and hevc supported max resolution (%dx%d) is less than the capture resolution (%dx%d)\n",
             supported_video_codecs->hevc.max_resolution.x, supported_video_codecs->hevc.max_resolution.y,
             video_size.x, video_size.y);
         return GSR_VIDEO_CODEC_AV1;
@@ -3301,7 +3374,6 @@ static const AVCodec* select_video_codec_with_fallback(vec2i video_size, args_pa
         }
     }
 
-    // TODO: Allow hevc, vp9 and av1 in (enhanced) flv (supported since ffmpeg 6.1)
     if(LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(60, 10, 100) && strcmp(file_extension, "flv") == 0) {
         if(args_parser->video_codec != GSR_VIDEO_CODEC_H264) {
             args_parser->video_codec = GSR_VIDEO_CODEC_H264;
@@ -3430,7 +3502,7 @@ static bool get_image_format_from_filename(const char *filename, gsr_image_forma
 }
 
 // TODO: replace this with start_recording_create_steams
-static bool av_open_file_write_header(AVFormatContext *av_format_context, const char *filename) {
+static bool av_open_file_write_header(AVFormatContext *av_format_context, const char *filename, const char *ffmpeg_opts) {
     int ret = avio_open(&av_format_context->pb, filename, AVIO_FLAG_WRITE);
     if(ret < 0) {
         fprintf(stderr, "gsr error: Could not open '%s': %s\n", filename, av_error_to_string(ret));
@@ -3439,7 +3511,9 @@ static bool av_open_file_write_header(AVFormatContext *av_format_context, const
 
     AVDictionary *options = nullptr;
     av_dict_set(&options, "strict", "experimental", 0);
-    //av_dict_set_int(&av_format_context->metadata, "video_full_range_flag", 1, 0);
+
+    if(ffmpeg_opts)
+        av_dict_parse_string(&options, ffmpeg_opts, "=", ";", 0);
 
     ret = avformat_write_header(av_format_context, &options);
     if(ret < 0)
@@ -3587,13 +3661,6 @@ int main(int argc, char **argv) {
     // If this is set to 1 then cuGraphicsGLRegisterImage will fail for egl context with error: invalid OpenGL or DirectX context,
     // so we overwrite it
     setenv("__GL_THREADED_OPTIMIZATIONS", "0", true);
-    // Forces low latency encoding mode. Use this environment variable until vaapi supports setting this as a parameter.
-    // The downside of this is that it always uses maximum power, which is not ideal for replay mode that runs on system startup.
-    // This option was added in mesa 24.1.4, released in july 17, 2024.
-    // TODO: Add an option to enable/disable this?
-    // Seems like the performance issue is not in encoding, but rendering the frame.
-    // Some frames end up taking 10 times longer. Seems to be an issue with amd gpu power management when letting the application sleep on the cpu side?
-    setenv("AMD_DEBUG", "lowlatencyenc", true);
     // Some people set this to nvidia (for nvdec) or vdpau (for nvidia vdpau), which breaks gpu screen recorder since
     // nvidia doesn't support vaapi and nvidia-vaapi-driver doesn't support encoding yet.
     // Let vaapi find the right vaapi driver instead of forcing a specific one.
@@ -3620,6 +3687,15 @@ int main(int argc, char **argv) {
     if(!args_parser_parse(&arg_parser, argc, argv, &arg_handlers, NULL))
         _exit(1);
 
+    if(!arg_parser.low_power) {
+        // Forces low latency encoding mode. Use this environment variable until vaapi supports setting this as a parameter.
+        // The downside of this is that it always uses maximum power, which is not ideal for replay mode that runs on system startup.
+        // This option was added in mesa 24.1.4, released in july 17, 2024.
+        // Seems like the performance issue is not in encoding, but rendering the frame.
+        // Some frames end up taking 10 times longer. Seems to be an issue with amd gpu power management when letting the application sleep on the cpu side?
+        setenv("AMD_DEBUG", "lowlatencyenc", true);
+    }
+
     std::vector<CaptureSource> capture_sources = parse_capture_source_arg(arg_parser.capture_source, arg_parser);
     if(capture_sources.empty()) {
         fprintf(stderr, "gsr error: option -w can't be empty. You need to capture video from at least one source\n");
@@ -3912,7 +3988,11 @@ int main(int argc, char **argv) {
 
     if(video_stream) {
         avcodec_parameters_from_context(video_stream->codecpar, video_codec_context);
-        gsr_encoder_add_recording_destination(&encoder, video_codec_context, av_format_context, video_stream, 0);
+        const size_t video_destination_id = gsr_encoder_add_recording_destination(&encoder, video_codec_context, av_format_context, video_stream, 0);
+        if(arg_parser.write_first_frame_ts && video_destination_id != (size_t)-1) {
+            std::string ts_filepath = std::string(arg_parser.filename) + ".ts";
+            gsr_encoder_set_recording_destination_first_frame_ts_filepath(&encoder, video_destination_id, ts_filepath.c_str());
+        }
     }
 
     int audio_max_frame_size = 1024;
@@ -3931,7 +4011,7 @@ int main(int argc, char **argv) {
         if(audio_stream && !merged_audio_inputs.track_name.empty())
             av_dict_set(&audio_stream->metadata, "title", merged_audio_inputs.track_name.c_str(), 0);
 
-        open_audio(audio_codec_context);
+        open_audio(audio_codec_context, arg_parser.ffmpeg_audio_opts);
         if(audio_stream)
             avcodec_parameters_from_context(audio_stream->codecpar, audio_codec_context);
 
@@ -3989,7 +4069,7 @@ int main(int argc, char **argv) {
     //av_dump_format(av_format_context, 0, filename, 1);
 
     if(!is_replaying) {
-        if(!av_open_file_write_header(av_format_context, arg_parser.filename))
+        if(!av_open_file_write_header(av_format_context, arg_parser.filename, arg_parser.ffmpeg_opts))
             _exit(1);
     }
 
@@ -4270,6 +4350,9 @@ int main(int argc, char **argv) {
         should_stop_error = false;
         bool damaged = false;
 
+        if(use_damage_tracking)
+            damaged = gsr_damage_is_damaged(&damage);
+
         for(VideoSource &video_source : video_sources) {
             gsr_capture_tick(video_source.capture);
 
@@ -4291,11 +4374,9 @@ int main(int argc, char **argv) {
                 video_source.capture_source->window_id = damage_target_window;
             }
 
-            if(use_damage_tracking)
-                damaged = gsr_damage_is_damaged(&damage);
-            else if(video_source.capture->is_damaged)
-                damaged = video_source.capture->is_damaged(video_source.capture);
-            else
+            if(video_source.capture->is_damaged)
+                damaged |= video_source.capture->is_damaged(video_source.capture);
+            else if(!use_damage_tracking)
                 damaged = true;
         }
 
@@ -4447,9 +4528,14 @@ int main(int argc, char **argv) {
                 std::lock_guard<std::mutex> lock(audio_filter_mutex);
                 replay_recording_items.clear();
                 replay_recording_filepath = create_new_recording_filepath_from_timestamp(arg_parser.replay_recording_directory, "Video", file_extension, arg_parser.date_folders);
-                replay_recording_start_result = start_recording_create_streams(replay_recording_filepath.c_str(), arg_parser.container_format, video_codec_context, audio_tracks, hdr, video_sources);
+                replay_recording_start_result = start_recording_create_streams(replay_recording_filepath.c_str(), arg_parser, video_codec_context, audio_tracks, hdr, video_sources);
                 if(replay_recording_start_result.av_format_context) {
                     const size_t video_recording_destination_id = gsr_encoder_add_recording_destination(&encoder, video_codec_context, replay_recording_start_result.av_format_context, replay_recording_start_result.video_stream, video_frame->pts);
+                    if(arg_parser.write_first_frame_ts && video_recording_destination_id != (size_t)-1) {
+                        std::string ts_filepath = replay_recording_filepath + ".ts";
+                        gsr_encoder_set_recording_destination_first_frame_ts_filepath(&encoder, video_recording_destination_id, ts_filepath.c_str());
+                    }
+
                     if(video_recording_destination_id != (size_t)-1)
                         replay_recording_items.push_back(video_recording_destination_id);
 
@@ -4509,10 +4595,13 @@ int main(int argc, char **argv) {
 
             save_replay_seconds = 0;
             save_replay_output_filepath.clear();
-            save_replay_async(video_codec_context, VIDEO_STREAM_INDEX, audio_tracks, encoder.replay_buffer, arg_parser.filename, arg_parser.container_format, file_extension, arg_parser.date_folders, hdr, video_sources, current_save_replay_seconds);
+            save_replay_async(video_codec_context, VIDEO_STREAM_INDEX, audio_tracks, &encoder, arg_parser, file_extension, arg_parser.date_folders, hdr, video_sources, current_save_replay_seconds);
 
-            if(arg_parser.restart_replay_on_save && current_save_replay_seconds == save_replay_seconds_full)
+            if(arg_parser.restart_replay_on_save && current_save_replay_seconds == save_replay_seconds_full) {
+                pthread_mutex_lock(&encoder.replay_mutex);
                 gsr_replay_buffer_clear(encoder.replay_buffer);
+                pthread_mutex_unlock(&encoder.replay_mutex);
+            }
         }
 
         const double time_at_frame_end = clock_get_monotonic_seconds() - paused_time_offset;

src/replay_buffer/replay_buffer.c

@@ -16,48 +16,14 @@ gsr_replay_buffer* gsr_replay_buffer_create(gsr_replay_storage replay_storage, c
             replay_buffer = gsr_replay_buffer_disk_create(replay_directory, replay_buffer_time);
             break;
     }
-
-    replay_buffer->mutex_initialized = false;
-    replay_buffer->original_replay_buffer = NULL;
-    if(pthread_mutex_init(&replay_buffer->mutex, NULL) != 0) {
-        gsr_replay_buffer_destroy(replay_buffer);
-        return NULL;
-    }
-
-    replay_buffer->mutex_initialized = true;
     return replay_buffer;
 }
 
 void gsr_replay_buffer_destroy(gsr_replay_buffer *self) {
     self->destroy(self);
-    if(self->mutex_initialized && !self->original_replay_buffer) {
-        pthread_mutex_destroy(&self->mutex);
-        self->mutex_initialized = false;
-    }
-    self->original_replay_buffer = NULL;
     free(self);
 }
 
-void gsr_replay_buffer_lock(gsr_replay_buffer *self) {
-    if(self->original_replay_buffer) {
-        gsr_replay_buffer_lock(self->original_replay_buffer);
-        return;
-    }
-
-    if(self->mutex_initialized)
-        pthread_mutex_lock(&self->mutex);
-}
-
-void gsr_replay_buffer_unlock(gsr_replay_buffer *self) {
-    if(self->original_replay_buffer) {
-        gsr_replay_buffer_unlock(self->original_replay_buffer);
-        return;
-    }
-
-    if(self->mutex_initialized)
-        pthread_mutex_unlock(&self->mutex);
-}
-
 bool gsr_replay_buffer_append(gsr_replay_buffer *self, const AVPacket *av_packet, double timestamp) {
     return self->append(self, av_packet, timestamp);
 }

src/replay_buffer/replay_buffer_disk.c

@@ -94,7 +94,6 @@ static void gsr_replay_buffer_file_unref(gsr_replay_buffer_file *self, const cha
 
 static void gsr_replay_buffer_disk_clear(gsr_replay_buffer *replay_buffer) {
     gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
-    gsr_replay_buffer_lock(&self->replay_buffer);
 
     for(size_t i = 0; i < self->num_files; ++i) {
         gsr_replay_buffer_file_unref(self->files[i], self->replay_directory);
@@ -107,7 +106,6 @@ static void gsr_replay_buffer_disk_clear(gsr_replay_buffer *replay_buffer) {
     }
 
     self->storage_num_bytes_written = 0;
-    gsr_replay_buffer_unlock(&self->replay_buffer);
 }
 
 static void gsr_replay_buffer_disk_destroy(gsr_replay_buffer *replay_buffer) {
@@ -197,7 +195,6 @@ static void gsr_replay_buffer_disk_remove_first_file(gsr_replay_buffer_disk *sel
 static bool gsr_replay_buffer_disk_append(gsr_replay_buffer *replay_buffer, const AVPacket *av_packet, double timestamp) {
     gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
     bool success = false;
-    gsr_replay_buffer_lock(&self->replay_buffer);
 
     if(self->storage_fd <= 0) {
         if(!gsr_replay_buffer_disk_create_next_file(self, timestamp))
@@ -215,7 +212,6 @@ static bool gsr_replay_buffer_disk_append(gsr_replay_buffer *replay_buffer, cons
     success = data_written;
 
     done:
-    gsr_replay_buffer_unlock(&self->replay_buffer);
     return success;
 }
 
@@ -265,11 +261,7 @@ static gsr_replay_buffer* gsr_replay_buffer_disk_clone(gsr_replay_buffer *replay
         return NULL;
 
     gsr_replay_buffer_disk_set_impl_funcs(destination);
-    gsr_replay_buffer_lock(&self->replay_buffer);
 
-    destination->replay_buffer.original_replay_buffer = replay_buffer;
-    destination->replay_buffer.mutex = self->replay_buffer.mutex;
-    destination->replay_buffer.mutex_initialized = self->replay_buffer.mutex_initialized;
     destination->replay_buffer_time = self->replay_buffer_time;
     destination->storage_counter = self->storage_counter;
     destination->storage_num_bytes_written = self->storage_num_bytes_written;
@@ -283,7 +275,6 @@ static gsr_replay_buffer* gsr_replay_buffer_disk_clone(gsr_replay_buffer *replay
     snprintf(destination->replay_directory, sizeof(destination->replay_directory), "%s", self->replay_directory);
     destination->owns_directory = false;
 
-    gsr_replay_buffer_unlock(&self->replay_buffer);
     return (gsr_replay_buffer*)destination;
 }
 
@@ -319,11 +310,9 @@ static size_t gsr_replay_buffer_file_find_packet_index_by_time_passed(const gsr_
 /* Binary search */
 static gsr_replay_buffer_iterator gsr_replay_buffer_disk_find_file_index_by_time_passed(gsr_replay_buffer *replay_buffer, int seconds) {
     gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
-    gsr_replay_buffer_lock(&self->replay_buffer);
 
     const double now = clock_get_monotonic_seconds();
     if(self->num_files == 0) {
-        gsr_replay_buffer_unlock(&self->replay_buffer);
         return (gsr_replay_buffer_iterator){0, 0};
     }
 
@@ -352,14 +341,12 @@ static gsr_replay_buffer_iterator gsr_replay_buffer_disk_find_file_index_by_time
     const gsr_replay_buffer_file *file = self->files[file_index];
     const size_t packet_index = gsr_replay_buffer_file_find_packet_index_by_time_passed(file, seconds);
 
-    gsr_replay_buffer_unlock(&self->replay_buffer);
     return (gsr_replay_buffer_iterator){packet_index, file_index};
 }
 
 static gsr_replay_buffer_iterator gsr_replay_buffer_disk_find_keyframe(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index) {
     gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
     gsr_replay_buffer_iterator keyframe_iterator = {(size_t)-1, 0};
-    gsr_replay_buffer_lock(&self->replay_buffer);
     size_t packet_index = start_iterator.packet_index;
     for(size_t file_index = start_iterator.file_index; file_index < self->num_files; ++file_index) {
         const gsr_replay_buffer_file *file = self->files[file_index];
@@ -374,7 +361,6 @@ static gsr_replay_buffer_iterator gsr_replay_buffer_disk_find_keyframe(gsr_repla
         packet_index = 0;
     }
     done:
-    gsr_replay_buffer_unlock(&self->replay_buffer);
     return keyframe_iterator;
 }
 

src/replay_buffer/replay_buffer_ram.c

@@ -54,7 +54,6 @@ static void gsr_av_packet_ram_unref(gsr_av_packet_ram *self) {
 
 static void gsr_replay_buffer_ram_destroy(gsr_replay_buffer *replay_buffer) {
     gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
-    gsr_replay_buffer_lock(&self->replay_buffer);
     for(size_t i = 0; i < self->num_packets; ++i) {
         if(self->packets[i]) {
             gsr_av_packet_ram_unref(self->packets[i]);
@@ -62,7 +61,6 @@ static void gsr_replay_buffer_ram_destroy(gsr_replay_buffer *replay_buffer) {
         }
     }
     self->num_packets = 0;
-    gsr_replay_buffer_unlock(&self->replay_buffer);
 
     if(self->packets) {
         free(self->packets);
@@ -75,12 +73,9 @@ static void gsr_replay_buffer_ram_destroy(gsr_replay_buffer *replay_buffer) {
 
 static bool gsr_replay_buffer_ram_append(gsr_replay_buffer *replay_buffer, const AVPacket *av_packet, double timestamp) {
     gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
-    gsr_replay_buffer_lock(&self->replay_buffer);
     gsr_av_packet_ram *packet = gsr_av_packet_ram_create(av_packet, timestamp);
-    if(!packet) {
-        gsr_replay_buffer_unlock(&self->replay_buffer);
+    if(!packet)
         return false;
-    }
 
     if(self->packets[self->index]) {
         gsr_av_packet_ram_unref(self->packets[self->index]);
@@ -93,13 +88,11 @@ static bool gsr_replay_buffer_ram_append(gsr_replay_buffer *replay_buffer, const
     if(self->num_packets > self->capacity_num_packets)
         self->num_packets = self->capacity_num_packets;
 
-    gsr_replay_buffer_unlock(&self->replay_buffer);
     return true;
 }
 
 static void gsr_replay_buffer_ram_clear(gsr_replay_buffer *replay_buffer) {
     gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
-    gsr_replay_buffer_lock(&self->replay_buffer);
     for(size_t i = 0; i < self->num_packets; ++i) {
         if(self->packets[i]) {
             gsr_av_packet_ram_unref(self->packets[i]);
@@ -108,7 +101,6 @@ static void gsr_replay_buffer_ram_clear(gsr_replay_buffer *replay_buffer) {
     }
     self->num_packets = 0;
     self->index = 0;
-    gsr_replay_buffer_unlock(&self->replay_buffer);
 }
 
 static gsr_av_packet_ram* gsr_replay_buffer_ram_get_packet_at_index(gsr_replay_buffer *replay_buffer, size_t index) {
@@ -141,17 +133,12 @@ static gsr_replay_buffer* gsr_replay_buffer_ram_clone(gsr_replay_buffer *replay_
         return NULL;
 
     gsr_replay_buffer_ram_set_impl_funcs(destination);
-    gsr_replay_buffer_lock(&self->replay_buffer);
 
-    destination->replay_buffer.original_replay_buffer = replay_buffer;
-    destination->replay_buffer.mutex = self->replay_buffer.mutex;
-    destination->replay_buffer.mutex_initialized = self->replay_buffer.mutex_initialized;
     destination->capacity_num_packets = self->capacity_num_packets;
     destination->index = self->index;
     destination->packets = calloc(destination->capacity_num_packets, sizeof(gsr_av_packet_ram*));
     if(!destination->packets) {
         free(destination);
-        gsr_replay_buffer_unlock(&self->replay_buffer);
         return NULL;
     }
 
@@ -160,18 +147,15 @@ static gsr_replay_buffer* gsr_replay_buffer_ram_clone(gsr_replay_buffer *replay_
         destination->packets[i] = gsr_av_packet_ram_ref(self->packets[i]);
     }
 
-    gsr_replay_buffer_unlock(&self->replay_buffer);
     return (gsr_replay_buffer*)destination;
 }
 
 /* Binary search */
 static gsr_replay_buffer_iterator gsr_replay_buffer_ram_find_packet_index_by_time_passed(gsr_replay_buffer *replay_buffer, int seconds) {
     gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
-    gsr_replay_buffer_lock(&self->replay_buffer);
 
     const double now = clock_get_monotonic_seconds();
     if(self->num_packets == 0) {
-        gsr_replay_buffer_unlock(&self->replay_buffer);
         return (gsr_replay_buffer_iterator){0, 0};
     }
 
@@ -194,14 +178,12 @@ static gsr_replay_buffer_iterator gsr_replay_buffer_ram_find_packet_index_by_tim
         }
     }
 
-    gsr_replay_buffer_unlock(&self->replay_buffer);
     return (gsr_replay_buffer_iterator){index, 0};
 }
 
 static gsr_replay_buffer_iterator gsr_replay_buffer_ram_find_keyframe(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index) {
     gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
     size_t keyframe_index = (size_t)-1;
-    gsr_replay_buffer_lock(&self->replay_buffer);
     for(size_t i = start_iterator.packet_index; i < self->num_packets; ++i) {
         const gsr_av_packet_ram *packet = gsr_replay_buffer_ram_get_packet_at_index(replay_buffer, i);
         if((packet->packet.flags & AV_PKT_FLAG_KEY) && (invert_stream_index ? packet->packet.stream_index != stream_index : packet->packet.stream_index == stream_index)) {
@@ -209,7 +191,6 @@ static gsr_replay_buffer_iterator gsr_replay_buffer_ram_find_keyframe(gsr_replay
             break;
         }
     }
-    gsr_replay_buffer_unlock(&self->replay_buffer);
     return (gsr_replay_buffer_iterator){keyframe_index, 0};
 }
 

src/sound.cpp

@@ -59,17 +59,26 @@ struct pa_handle {
     std::mutex reconnect_mutex;
     DeviceType device_type;
     char stream_name[256];
+    char node_name[256];
     bool reconnect;
     double reconnect_last_tried_seconds;
 
     char device_name[DEVICE_NAME_MAX_SIZE];
     char default_output_device_name[DEVICE_NAME_MAX_SIZE];
     char default_input_device_name[DEVICE_NAME_MAX_SIZE];
+
+    pa_proplist *proplist;
+    bool connected;
 };
 
 static void pa_sound_device_free(pa_handle *p) {
     assert(p);
 
+    if(p->proplist) {
+        pa_proplist_free(p->proplist);
+        p->proplist = NULL;
+    }
+
     if (p->stream) {
         pa_stream_unref(p->stream);
         p->stream = NULL;
@@ -186,6 +195,7 @@ static pa_handle* pa_sound_device_new(const char *server,
     p = pa_xnew0(pa_handle, 1);
     p->attr = *attr;
     p->ss = *ss;
+    snprintf(p->node_name, sizeof(p->node_name), "%s", name);
     snprintf(p->stream_name, sizeof(p->stream_name), "%s", stream_name);
 
     p->reconnect = true;
@@ -206,17 +216,17 @@ static pa_handle* pa_sound_device_new(const char *server,
     p->output_length = buffer_size;
     p->output_index = 0;
 
-    pa_proplist *proplist = pa_proplist_new();
-    pa_proplist_sets(proplist, PA_PROP_MEDIA_ROLE, "production");
+    p->proplist = pa_proplist_new();
+    pa_proplist_sets(p->proplist, PA_PROP_MEDIA_ROLE, "production");
     if(strcmp(device_name, "") == 0) {
-        pa_proplist_sets(proplist, "node.autoconnect", "false");
-        pa_proplist_sets(proplist, "node.dont-reconnect", "true");
+        pa_proplist_sets(p->proplist, "node.autoconnect", "false");
+        pa_proplist_sets(p->proplist, "node.dont-reconnect", "true");
     }
 
     if (!(p->mainloop = pa_mainloop_new()))
         goto fail;
 
-    if (!(p->context = pa_context_new_with_proplist(pa_mainloop_get_api(p->mainloop), name, proplist)))
+    if (!(p->context = pa_context_new_with_proplist(pa_mainloop_get_api(p->mainloop), p->node_name, p->proplist)))
         goto fail;
 
     if (pa_context_connect(p->context, server, PA_CONTEXT_NOFLAGS, NULL) < 0) {
@@ -246,17 +256,58 @@ static pa_handle* pa_sound_device_new(const char *server,
     if(pa)
         pa_operation_unref(pa);
 
-    pa_proplist_free(proplist);
+    p->connected = true;
     return p;
 
 fail:
     if (rerror)
         *rerror = error;
     pa_sound_device_free(p);
-    pa_proplist_free(proplist);
     return NULL;
 }
 
+static void pa_sound_device_update_context_status(pa_handle *p) {
+    if(p->connected || !p->context || pa_context_get_state(p->context) != PA_CONTEXT_READY)
+        return;
+
+    p->connected = true;
+    pa_context_set_subscribe_callback(p->context, subscribe_cb, p);
+    pa_operation *pa = pa_context_subscribe(p->context, PA_SUBSCRIPTION_MASK_SERVER, NULL, NULL);
+    if(pa)
+        pa_operation_unref(pa);
+}
+
+static bool pa_sound_device_handle_context_recreate(pa_handle *p) {
+    if(p->context) {
+        pa_context_disconnect(p->context);
+        pa_context_unref(p->context);
+        p->context = NULL;
+        p->connected = false;
+    }
+
+    if (!(p->context = pa_context_new_with_proplist(pa_mainloop_get_api(p->mainloop), p->node_name, p->proplist))) {
+        fprintf(stderr, "gsr error: pa_context_new_with_proplist failed\n");
+        goto fail;
+    }
+
+    if(pa_context_connect(p->context, nullptr, PA_CONTEXT_NOFLAGS, NULL) < 0) {
+        fprintf(stderr, "gsr error: pa_context_connect failed\n");
+        goto fail;
+    }
+
+    pa_mainloop_iterate(p->mainloop, 0, NULL);
+    pa_sound_device_update_context_status(p);
+    return true;
+
+    fail:
+    if(p->context) {
+        pa_context_disconnect(p->context);
+        pa_context_unref(p->context);
+        p->context = NULL;
+    }
+    return false;
+}
+
 static bool pa_sound_device_should_reconnect(pa_handle *p, double now, char *device_name, size_t device_name_size) {
     std::lock_guard<std::mutex> lock(p->reconnect_mutex);
 
@@ -276,7 +327,6 @@ static bool pa_sound_device_should_reconnect(pa_handle *p, double now, char *dev
 }
 
 static bool pa_sound_device_handle_reconnect(pa_handle *p, char *device_name, size_t device_name_size, double now) {
-    int r;
     if(!pa_sound_device_should_reconnect(p, now, device_name, device_name_size))
         return true;
 
@@ -284,6 +334,10 @@ static bool pa_sound_device_handle_reconnect(pa_handle *p, char *device_name, si
         pa_stream_disconnect(p->stream);
         pa_stream_unref(p->stream);
         p->stream = NULL;
+
+        pa_sound_device_handle_context_recreate(p);
+        if(!p->connected)
+            return false;
     }
 
     if(!(p->stream = pa_stream_new(p->context, p->stream_name, &p->ss, NULL))) {
@@ -291,8 +345,8 @@ static bool pa_sound_device_handle_reconnect(pa_handle *p, char *device_name, si
         return false;
     }
 
-    r = pa_stream_connect_record(p->stream, device_name, &p->attr,
-        (pa_stream_flags_t)(PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_ADJUST_LATENCY|PA_STREAM_AUTO_TIMING_UPDATE));
+    const int r = pa_stream_connect_record(p->stream, device_name, &p->attr,
+        (pa_stream_flags_t)(PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_ADJUST_LATENCY|PA_STREAM_AUTO_TIMING_UPDATE|PA_STREAM_DONT_MOVE));
 
     if(r < 0) {
         //pa_context_errno(p->context);
@@ -320,6 +374,15 @@ static int pa_sound_device_read(pa_handle *p, double timeout_seconds) {
 
     pa_mainloop_iterate(p->mainloop, 0, NULL);
 
+    if(!p->context) {
+        if(!pa_sound_device_handle_context_recreate(p))
+            goto fail;
+    }
+
+    pa_sound_device_update_context_status(p);
+    if(!p->connected)
+        goto fail;
+
     if(!pa_sound_device_handle_reconnect(p, device_name, sizeof(device_name), start_time) || !p->stream)
         goto fail;
 

src/utils.c

@@ -121,6 +121,8 @@ void for_each_active_monitor_output_x11_not_cached(Display *display, active_moni
                         .name_len = out_info->nameLen,
                         .pos = { .x = crt_info->x, .y = crt_info->y },
                         .size = monitor_size,
+                        .logical_pos = { .x = crt_info->x, .y = crt_info->y },
+                        .logical_size = monitor_size,
                         .connector_id = x11_output_get_connector_id(display, screen_res->outputs[i], randr_connector_id_atom),
                         .rotation = rotation,
                         .monitor_identifier = out_info->crtc
@@ -229,6 +231,8 @@ static void for_each_active_monitor_output_drm(const char *card_path, active_mon
                     .name_len = display_name_len,
                     .pos = { .x = crtc->x, .y = crtc->y },
                     .size = { .x = (int)crtc->width, .y = (int)crtc->height },
+                    .logical_pos = { .x = crtc->x, .y = crtc->y },
+                    .logical_size = { .x = (int)crtc->width, .y = (int)crtc->height },
                     .connector_id = connector->connector_id,
                     .rotation = GSR_MONITOR_ROT_0,
                     .monitor_identifier = connector_type_index_name != -1 ? monitor_identifier_from_type_and_count(connector_type_index_name, connector->connector_type_id) : 0
@@ -264,6 +268,8 @@ static void get_monitor_by_name_callback(const gsr_monitor *monitor, void *userd
     if(!data->found_monitor && strcmp(data->name, monitor->name) == 0) {
         data->monitor->pos = monitor->pos;
         data->monitor->size = monitor->size;
+        data->monitor->logical_pos = monitor->logical_pos;
+        data->monitor->logical_size = monitor->logical_size;
         data->monitor->connector_id = monitor->connector_id;
         data->monitor->rotation = monitor->rotation;
         data->monitor->monitor_identifier = monitor->monitor_identifier;
@@ -631,7 +637,9 @@ unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal
     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->glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
+    // Needed for hevc_10bit for nvenc (cuGraphicsGLRegisterImage)
+    egl->glTexStorage2D(GL_TEXTURE_2D, 1, internal_format, width, height);
 
     egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
     egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);

src/window/wayland.c

@@ -21,6 +21,7 @@ typedef struct {
     struct zxdg_output_v1 *xdg_output;
     vec2i pos;
     vec2i size;
+    vec2i logical_size;
     int32_t transform;
     char *name;
 } gsr_wayland_output;
@@ -123,6 +124,7 @@ static void registry_add_object(void *data, struct wl_registry *registry, uint32
             .output = wl_registry_bind(registry, name, &wl_output_interface, 4),
             .pos = { .x = 0, .y = 0 },
             .size = { .x = 0, .y = 0 },
+            .logical_size = { .x = 0, .y = 0 },
             .transform = 0,
             .name = NULL,
         };
@@ -160,10 +162,10 @@ static void xdg_output_logical_position(void *data, struct zxdg_output_v1 *zxdg_
 }
 
 static void xdg_output_handle_logical_size(void *data, struct zxdg_output_v1 *xdg_output, int32_t width, int32_t height) {
-    (void)data;
     (void)xdg_output;
-    (void)width;
-    (void)height;
+    gsr_wayland_output *gsr_xdg_output = data;
+    gsr_xdg_output->logical_size.x = width;
+    gsr_xdg_output->logical_size.y = height;
 }
 
 static void xdg_output_handle_done(void *data, struct zxdg_output_v1 *xdg_output) {
@@ -206,6 +208,42 @@ static void gsr_window_wayland_set_monitor_outputs_from_xdg_output(gsr_window_wa
     wl_display_roundtrip(self->display);
 }
 
+// static int monitor_sort_x_pos(const void* a, const void* b) {
+//     const gsr_wayland_output *arg1 = *(const gsr_wayland_output**)a;
+//     const gsr_wayland_output *arg2 = *(const gsr_wayland_output**)b;
+//     return arg1->logical_pos.x - arg2->logical_pos.x;
+// }
+
+// static int monitor_sort_y_pos(const void* a, const void* b) {
+//     const gsr_wayland_output *arg1 = *(const gsr_wayland_output**)a;
+//     const gsr_wayland_output *arg2 = *(const gsr_wayland_output**)b;
+//     return arg1->logical_pos.y - arg2->logical_pos.y;
+// }
+
+static void gsr_window_wayland_set_monitor_real_positions(gsr_window_wayland *self) {
+    gsr_wayland_output *sorted_outputs[GSR_MAX_OUTPUTS];
+    for(int i = 0; i < self->num_outputs; ++i) {
+        sorted_outputs[i] = &self->outputs[i];
+    }
+
+    // TODO: set correct physical positions
+
+    // qsort(sorted_outputs, self->num_outputs, sizeof(gsr_wayland_output*), monitor_sort_x_pos);
+    // int x_pos = 0;
+    // for(int i = 0; i < self->num_outputs; ++i) {
+    //     fprintf(stderr, "monitor: %s\n", sorted_outputs[i]->name);
+    //     sorted_outputs[i]->pos.x = x_pos;
+    //     x_pos += sorted_outputs[i]->logical_size.x;
+    // }
+
+    // qsort(sorted_outputs, self->num_outputs, sizeof(gsr_wayland_output*), monitor_sort_y_pos);
+    // int y_pos = 0;
+    // for(int i = 0; i < self->num_outputs; ++i) {
+    //     sorted_outputs[i]->pos.y = y_pos;
+    //     y_pos += sorted_outputs[i]->logical_size.y;
+    // }
+}
+
 static void gsr_window_wayland_deinit(gsr_window_wayland *self) {
     if(self->window) {
         wl_egl_window_destroy(self->window);
@@ -273,6 +311,7 @@ static bool gsr_window_wayland_init(gsr_window_wayland *self) {
     wl_display_roundtrip(self->display);
 
     gsr_window_wayland_set_monitor_outputs_from_xdg_output(self);
+    gsr_window_wayland_set_monitor_real_positions(self);
 
     if(!self->compositor) {
         fprintf(stderr, "gsr error: gsr_window_wayland_init failed: failed to find compositor\n");
@@ -337,6 +376,16 @@ static gsr_monitor_rotation wayland_transform_to_gsr_rotation(int32_t rot) {
     return GSR_MONITOR_ROT_0;
 }
 
+static vec2i get_monitor_size_rotated(int width, int height, gsr_monitor_rotation rotation) {
+    vec2i size = { .x = width, .y = height };
+    if(rotation == GSR_MONITOR_ROT_90 || rotation == GSR_MONITOR_ROT_270) {
+        int tmp_x = size.x;
+        size.x = size.y;
+        size.y = tmp_x;
+    }
+    return size;
+}
+
 static void gsr_window_wayland_for_each_active_monitor_output_cached(const gsr_window *window, active_monitor_callback callback, void *userdata) {
     const gsr_window_wayland *self = window->priv;
     for(int i = 0; i < self->num_outputs; ++i) {
@@ -344,15 +393,26 @@ static void gsr_window_wayland_for_each_active_monitor_output_cached(const gsr_w
         if(!output->name)
             continue;
 
+        const gsr_monitor_rotation rotation = wayland_transform_to_gsr_rotation(output->transform);
+
+        vec2i size = { .x = output->size.x, .y = output->size.y };
+        size = get_monitor_size_rotated(size.x, size.y, rotation);
+
+        vec2i logical_size = { .x = output->logical_size.x, .y = output->logical_size.y };
+        if(logical_size.x == 0 || logical_size.y == 0)
+            logical_size = size;
+
         const int connector_type_index = get_connector_type_by_name(output->name);
         const int connector_type_id = get_connector_type_id_by_name(output->name);
         const gsr_monitor monitor = {
             .name = output->name,
             .name_len = strlen(output->name),
             .pos = { .x = output->pos.x, .y = output->pos.y },
-            .size = { .x = output->size.x, .y = output->size.y },
+            .size = size,
+            .logical_pos = { .x = output->pos.x, .y = output->pos.y },
+            .logical_size = logical_size,
             .connector_id = 0,
-            .rotation = wayland_transform_to_gsr_rotation(output->transform),
+            .rotation = rotation,
             .monitor_identifier = (connector_type_index != -1 && connector_type_id != -1) ? monitor_identifier_from_type_and_count(connector_type_index, connector_type_id) : 0
         };
         callback(&monitor, userdata);

src/window/x11.c

@@ -121,6 +121,8 @@ static void gsr_window_x11_for_each_active_monitor_output_cached(const gsr_windo
             .name_len = strlen(output->name),
             .pos = output->pos,
             .size = output->size,
+            .logical_pos = output->pos,
+            .logical_size = output->size,
             .connector_id = output->connector_id,
             .rotation = output->rotation,
             .monitor_identifier = output->monitor_identifier