Add void linux to README, update pkill command

Fixes portal capture failing on some systems

README.md

@@ -14,7 +14,7 @@ This is a cli-only tool, if you want an UI for this check out [GPU Screen Record
 Supported video codecs:
 * H264 (default)
 * HEVC (Optionally with HDR)
-* AV1 (Optionally with HDR. Not currently supported on NVIDIA if you use GPU Screen Recorder flatpak)
+* AV1 (Optionally with HDR. Not currently supported on NVIDIA in the flatpak version of GPU Screen Recorder)
 * VP8
 * VP9
 
@@ -27,40 +27,16 @@ Supported image formats:
 * PNG
 
 This software works on X11 and Wayland on AMD, Intel and NVIDIA.
-### TEMPORARY ISSUES
-1) Videos are in variable framerate format. Use MPV to play such videos, otherwise you might experience stuttering in the video if you are using a buggy video player. You can try saving the video into a .mkv file instead as some software may have better support for .mkv files (such as kdenlive). You can use the "-fm cfr" option to to use constant framerate mode.
-2) FLAC audio codec is disabled at the moment because of temporary issues.
-### AMD/Intel/Wayland root permission
-When recording a window or when using the `-w portal` option no special user permission is required,
-however when recording a monitor the program needs root permission (to access KMS).\
-This is safe in GPU Screen Recorder as the part that needs root access has been moved to its own small program that only does one thing.\
-For you as a user this only means that if you installed GPU Screen Recorder as a flatpak then a prompt asking for root password will show up once when you start recording.
-# Performance
-On a system with a i5 4690k CPU and a GTX 1080 GPU:\
-When recording Legend of Zelda Breath of the Wild at 4k, fps drops from 30 to 7 when using OBS Studio + nvenc, however when using this screen recorder the fps remains at 30.\
-When recording GTA V at 4k on highest settings, fps drops from 60 to 23 when using obs-nvfbc + nvenc, however when using this screen recorder the fps only drops to 58.\
-GPU Screen Recorder also produces much smoother videos than OBS when GPU utilization is close to 100%, see comparison here: [https://www.youtube.com/watch?v=zfj4sNVLLLg](https://www.youtube.com/watch?v=zfj4sNVLLLg) and [https://www.youtube.com/watch?v=aK67RSZw2ZQ](https://www.youtube.com/watch?v=aK67RSZw2ZQ).\
-GPU Screen Recorder has much better performance than OBS Studio even with version 30.2 that does "zero-copy" recording and encoding, see: [https://www.youtube.com/watch?v=jdroRjibsDw](https://www.youtube.com/watch?v=jdroRjibsDw).\
-It is recommended to save the video to a SSD because of the large file size, which a slow HDD might not be fast enough to handle. Using variable framerate mode (-fm vfr) which is the default is also recommended as this reduces encoding load. Ultra quality is also overkill most of the time, very high (the default) or lower quality is usually enough.\
-Note that for best performance you should close other screen recorders such as OBS Studio when using GPU Screen Recorder even if they are not recording, since they can affect performance even when idle. This is the case with OBS Studio.
-## Note about optimal performance on NVIDIA
-NVIDIA driver has a "feature" (read: bug) where it will downclock memory transfer rate when a program uses cuda (or nvenc, which uses cuda), such as GPU Screen Recorder. To work around this bug, GPU Screen Recorder can overclock your GPU memory transfer rate to it's normal optimal level.\
-To enable overclocking for optimal performance use the `-oc` option when running GPU Screen Recorder. You also need to have "Coolbits" NVIDIA X setting set to "12" to enable overclocking. You can automatically add this option if you run `sudo nvidia-xconfig --cool-bits=12` and then reboot your computer.\
-Note that this only works when Xorg server is running as root, and using this option will only give you a performance boost if the game you are recording is bottlenecked by your GPU.\
-Note! use at your own risk!
-# VRR/G-SYNC
-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.
 
 # Installation
-If you are running an Arch Linux based distro then you can find gpu screen recorder on aur under the name gpu-screen-recorder (`yay -S gpu-screen-recorder`).\
+If you are running an Arch Linux based distro then you can find gpu screen recorder in the official repositories under the name gpu-screen-recorder (`sudo pacman -S gpu-screen-recorder`).\
 If you are running another distro then you can run `sudo ./install.sh`, but you need to manually install the dependencies, as described below.\
-You can also install gpu screen recorder ([the gtk gui version](https://git.dec05eba.com/gpu-screen-recorder-gtk/)) from [flathub](https://flathub.org/apps/details/com.dec05eba.gpu_screen_recorder), which is the easiest method
+You can also install gpu screen recorder ([the ui version](https://git.dec05eba.com/gpu-screen-recorder-gtk/)) from [flathub](https://flathub.org/apps/details/com.dec05eba.gpu_screen_recorder), which is the easiest method
 to install GPU Screen Recorder on non-arch based distros.\
-If you install GPU Screen Recorder flatpak, which is the gtk gui version then you can still run GPU Screen Recorder command line by using the flatpak command option, for example `flatpak run --command=gpu-screen-recorder com.dec05eba.gpu_screen_recorder -w screen -f 60 -o video.mp4`. Note that if you want to record your monitor on AMD/Intel then you need to install the flatpak system-wide (like so: `flatpak install flathub --system com.dec05eba.gpu_screen_recorder`).
+If you install GPU Screen Recorder flatpak, which is the gtk gui version then you can still run GPU Screen Recorder command line by using the flatpak command option, for example `flatpak run --command=gpu-screen-recorder com.dec05eba.gpu_screen_recorder -w screen -f 60 -o video.mp4`. Note that if you want to record your monitor on AMD/Intel then you need to install the flatpak system-wide (like so: `flatpak install --system com.dec05eba.gpu_screen_recorder`).
 
 ## Unofficial install methods
-The only official ways to install GPU Screen Recorder is either from source, AUR or flathub. Other sources may be out of date and missing features or may not work correctly.\
+The only official ways to install GPU Screen Recorder is either from source, arch linux extra repository or flathub. Other sources may be out of date and missing features or may not work correctly.\
 If you install GPU Screen Recorder from somewhere else and have an issue then try installing it from one of the official sources before reporting it as an issue.\
 If you still prefer to install GPU Screen Recorder with a package manager instead of from source or as a flatpak then you may be able to find a package for your distro.\
 Here are some known unofficial packages:
@@ -72,6 +48,7 @@ Here are some known unofficial packages:
 * Solus: [gpu-screen-recorder](https://github.com/getsolus/packages/tree/main/packages/g/gpu-screen-recorder)
 * Nobara: [Nobara wiki](https://wiki.nobaraproject.org/en/general-usage/additional-software/GPU-Screen-Recorder)
 * AppImage [AppImage GitHub releases](https://github.com/pkgforge-dev/gpu-screen-recorder-AppImage/releases)
+* Void Linux: [gpu-screen-recorder](https://voidlinux.org/packages/?arch=x86_64&q=gpu-screen-recorder) (Make sure to read the README in the package)
 
 # Dependencies
 GPU Screen Recorder uses meson build system so you need to install `meson` to build GPU Screen Recorder.
@@ -79,17 +56,24 @@ GPU Screen Recorder uses meson build system so you need to install `meson` to bu
 ## Build dependencies
 These are the dependencies needed to build GPU Screen Recorder:
 
-* vulkan-headers
-* ffmpeg (libavcodec, libavformat, libavutil, libswresample, libavfilter)
 * x11 (libx11, libxcomposite, libxrandr, libxfixes, libxdamage)
-* libpulse
+* wayland (wayland-client, wayland-egl, wayland-scanner)
+* ffmpeg (libavcodec, libavformat, libavutil, libswresample, libavfilter)
 * libva (and libva-drm)
+* libpulse
 * libdrm
 * libcap
-* wayland (wayland-client, wayland-egl, wayland-scanner)
+* vulkan-headers
+* linux-api-headers
+
+## Optional dependencies
+When building GPU Screen Recorder with portal support (`-Dportal=true` meson option, which is enabled by default) these dependencies are also needed:
+* libdbus
+* libpipewire (and libspa which is usually part of libpipewire)
 
 ## Runtime dependencies
 * libglvnd (which provides libgl, libglx and libegl) is needed. Your system needs to support at least OpenGL ES 3.0 (released in 2012)
+* libturbojpeg (aka libjpeg-turbo) is needed when capturing camera with mjpeg pixel format option
 
 There are also additional dependencies needed at runtime depending on your GPU vendor:
 
@@ -99,7 +83,7 @@ There are also additional dependencies needed at runtime depending on your GPU v
 
 ### Intel
 * mesa
-* vaapi (intel-media-driver/libva-intel-driver/linux-firmware-intel, depending on which intel iGPU you have)
+* vaapi (intel-media-driver/libva-intel-driver/linux-firmware-intel, depending on which intel GPU you have)
 
 ### NVIDIA
 * cuda runtime (libcuda.so.1) (libnvidia-compute)
@@ -107,18 +91,13 @@ There are also additional dependencies needed at runtime depending on your GPU v
 * nvfbc (libnvidia-fbc1, when recording the screen on x11)
 * xnvctrl (libxnvctrl0, when using the `-oc` option)
 
-## Optional dependencies
-When building GPU Screen Recorder with portal support (`-Dportal=true` meson option, which is enabled by default) these dependencies are also needed:
-* libdbus
-* libpipewire (and libspa which is usually part of libpipewire)
-
 # How to use
 Run `gpu-screen-recorder --help` to see all options and also examples.\
 There is also a gui for the gpu screen recorder called [GPU Screen Recorder GTK](https://git.dec05eba.com/gpu-screen-recorder-gtk/).\
 There is also a new alternative UI for GPU Screen Recorder in the style of ShadowPlay called [GPU Screen Recorder UI](https://git.dec05eba.com/gpu-screen-recorder-ui/).
 ## Recording
 Here is an example of how to record your monitor and the default audio output: `gpu-screen-recorder -w screen -f 60 -a default_output -o ~/Videos/test_video.mp4`.
-Yyou can stop and save the recording with `Ctrl+C` or by running `pkill -SIGINT -f gpu-screen-recorder`.
+Yyou can stop and save the recording with `Ctrl+C` or by running `pkill -SIGINT -f "^gpu-screen-recorder"`.
 You can see a list of capture options to record if you run `gpu-screen-recorder --list-capture-options`. This will list possible capture options and monitor names, for example:\
 ```
   window
@@ -126,11 +105,8 @@ You can see a list of capture options to record if you run `gpu-screen-recorder
 ```
 in this case you could record a window or a monitor with the name `DP-1`.\
 To list available audio devices that you can use you can run `gpu-screen-recorder --list-audio-devices` and the name to use is on the left size of the `|`.\
-To list available audio application names that you can use you can run `gpu-screen-recorder --list-application-audio`.
-## Streaming
-Streaming works the same way as recording, but the `-o` argument should be path to the live streaming service you want to use (including your live streaming key). Take a look at `scripts/twitch-stream.sh` to see an example of how to stream to twitch.\
-GPU Screen Recorder uses Ffmpeg so GPU Screen Recorder supports all protocols that Ffmpeg supports.\
-If you want to reduce latency one thing you can do is to use the `-keyint` option, for example `-keyint 0.5`. Lower value means lower latency at the cost of increased bitrate/decreased quality.
+To list available audio application names that you can use you can run `gpu-screen-recorder --list-application-audio`.\
+You can run `gpu-screen-recorder --info` to list more information about the system, such as the device that is used for capture and video encoding and supported codecs. These commands can be parsed by scripts/programs.
 ## Replay mode
 Run `gpu-screen-recorder` with the `-c mp4` and `-r` option, for example: `gpu-screen-recorder -w screen -f 60 -r 30 -c mp4 -o ~/Videos`. Note that in this case, `-o` should point to a directory.\
 If `-df yes` is set, replays are save in folders based on the date.
@@ -141,14 +117,18 @@ This can be used for example to show a notification when a replay has been saved
 The replay buffer is stored in ram (as encoded video) by default, so don't use a too large replay time and/or video quality unless you have enough ram to store it.\
 You can use the `-replay-storage disk` option to store the replay buffer on disk instead of ram (in the same location as the output video).\
 By default videos are recorded with constant quality, but with replay mode you might want to record in constant bitrate mode instead for consistent ram/disk usage in high motion scenes. You can do that by using the `-bm cbr` option (along with `-q` option, for example `-bm cbr -q 20000`).
+## Streaming
+Streaming works the same way as recording, but the `-o` argument should be path to the live streaming service you want to use (including your live streaming key). Take a look at `scripts/twitch-stream.sh` to see an example of how to stream to twitch.\
+GPU Screen Recorder uses Ffmpeg so GPU Screen Recorder supports all protocols that Ffmpeg supports.\
+If you want to reduce latency one thing you can do is to use the `-keyint` option, for example `-keyint 0.5`. Lower value means lower latency at the cost of increased bitrate/decreased quality.
 ## Recording while using replay/streaming
-You can record a regular video while using replay/streaming by launching GPU Screen Recorder with the `-ro` option to specify a directory where to save the recording.\
-To start/stop (and save) recording use the SIGRTMIN signal, for example `pkill -SIGRTMIN -f gpu-screen-recorder`. The name of the video will be displayed in stdout when saving the video.\
+You can record a regular video while using replay/streaming by launching GPU Screen Recorder with the `-ro` option to specify a directory where to save the recording (for example: `gpu-screen-recorder -w screen -c mp4 -r 60 -o "$HOME/Videos/replays" -ro "$HOME/Videos/recordings"`).\
+To start/stop (and save) recording use the SIGRTMIN signal, for example `pkill -SIGRTMIN -f "^gpu-screen-recorder"`. The path to the video will be displayed in stdout when saving the video.\
 This way of recording while using replay/streaming is more efficient than running GPU Screen Recorder multiple times since this way it only records the screen and encodes the video once.
 ## Controlling GPU Screen Recorder remotely
-To save a video in replay mode, you need to send signal SIGUSR1 to gpu screen recorder. You can do this by running `pkill -SIGUSR1 -f gpu-screen-recorder`.\
-To stop recording send SIGINT to gpu screen recorder. You can do this by running `pkill -SIGINT -f gpu-screen-recorder` or pressing `Ctrl-C` in the terminal that runs gpu screen recorder. When recording a regular non-replay video this will also save the video.\
-To pause/unpause recording send SIGUSR2 to gpu screen recorder. You can do this by running `pkill -SIGUSR2 -f gpu-screen-recorder`. This is only applicable and useful when recording (not streaming nor replay).\
+To save a video in replay mode, you need to send signal SIGUSR1 to gpu screen recorder. You can do this by running `pkill -SIGUSR1 -f "^gpu-screen-recorder"`.\
+To stop recording send SIGINT to gpu screen recorder. You can do this by running `pkill -SIGINT -f "^gpu-screen-recorder"` or pressing `Ctrl-C` in the terminal that runs gpu screen recorder. When recording a regular non-replay video this will also save the video.\
+To pause/unpause recording send SIGUSR2 to gpu screen recorder. You can do this by running `pkill -SIGUSR2 -f "^gpu-screen-recorder"`. This is only applicable and useful when recording (not streaming nor replay).\
 There are more signals to control GPU Screen Recorder. Run `gpu-screen-recorder --help` to list them all (under `NOTES` section).
 ## Simple way to run replay without gui
 Run the script `scripts/start-replay.sh` to start replay and then `scripts/save-replay.sh` to save a replay and `scripts/stop-replay.sh` to stop the replay. The videos are saved to `$HOME/Videos`.
@@ -156,7 +136,7 @@ You can use these scripts to start replay at system startup if you add `scripts/
 hotkey settings on your system and choose a hotkey to run the script `scripts/save-replay.sh`. Modify `scripts/start-replay.sh` if you want to use other replay options.
 ## Run replay on system startup
 If you installed GPU Screen Recorder from AUR or from source and you are running a distro that uses systemd then you will have a systemd service installed that can be started with `systemctl enable --now --user gpu-screen-recorder`. This systemd service runs GPU Screen Recorder on system startup.\
-It's configured with `$HOME/.config/gpu-screen-recorder.env` (create it if it doesn't exist). You can look at [extra/gpu-screen-recorder.env](https://git.dec05eba.com/gpu-screen-recorder/plain/extra/gpu-screen-recorder.env) to see an example.
+It's configured with `$HOME/.config/gpu-screen-recorder/gpu-screen-recorder.env` (create it if it doesn't exist). You can look at [extra/gpu-screen-recorder.env](https://git.dec05eba.com/gpu-screen-recorder/plain/extra/gpu-screen-recorder.env) to see an example.
 You can see which variables that you can use in the `gpu-screen-recorder.env` file by looking at the `extra/gpu-screen-recorder.service` file. Note that all of the variables are optional, you only have to set the ones that are you interested in.
 You can use the `scripts/save-replay.sh` script to save a replay and by default the systemd service saves videos in `$HOME/Videos`.
 ## Run a script when a video is saved
@@ -174,13 +154,47 @@ If you record at your monitors refresh rate and enabled vsync in a game then the
 This is an issue in some games.
 If you experience this issue then you might want to either disable vsync in the game or use the `-fm content` option to sync capture to the content on the screen. For example: `gpu-screen-recorder -w screen -fm content -o video.mp4`.\
 Note that this option is currently only available on X11, or with desktop portal capture on Wayland (`-w portal`).
+
+# Performance
+On a system with an i5 4690k CPU and a GTX 1080 GPU:\
+When recording Legend of Zelda Breath of the Wild at 4k, fps drops from 30 to 7 when using OBS Studio + nvenc, however when using this screen recorder the fps remains at 30.\
+When recording GTA V at 4k on highest settings, fps drops from 60 to 23 when using obs-nvfbc + nvenc, however when using this screen recorder the fps only drops to 58.\
+On a system with an AMD Ryzen 9 5900X CPU and an RX 7800XT GPU I don't see any fps drop at all, even when recording at 4k 60fps with AV1 codec with 10-bit colors.\
+GPU Screen Recorder also produces much smoother videos than OBS when GPU utilization is close to 100%, see comparison here: [https://www.youtube.com/watch?v=zfj4sNVLLLg](https://www.youtube.com/watch?v=zfj4sNVLLLg) and [https://www.youtube.com/watch?v=aK67RSZw2ZQ](https://www.youtube.com/watch?v=aK67RSZw2ZQ).\
+GPU Screen Recorder has much better performance than OBS Studio even with version 30.2 that does "zero-copy" recording and encoding, see: [https://www.youtube.com/watch?v=jdroRjibsDw](https://www.youtube.com/watch?v=jdroRjibsDw).\
+It is recommended to save the video to a SSD because of the large file size, which a slow HDD might not be fast enough to handle. Using variable framerate mode (-fm vfr) which is the default is also recommended as this reduces encoding load. Ultra quality is also overkill most of the time, very high (the default) or lower quality is usually enough.\
+Note that for best performance you should close other screen recorders such as OBS Studio when using GPU Screen Recorder even if they are not recording, since they can affect performance even when idle. This is the case with OBS Studio.
+## Note about optimal performance on NVIDIA
+NVIDIA driver has a "feature" (read: bug) where it will downclock memory transfer rate when a program uses cuda (or nvenc, which uses cuda), such as GPU Screen Recorder. To work around this bug, GPU Screen Recorder can overclock your GPU memory transfer rate to it's normal optimal level.\
+To enable overclocking for optimal performance use the `-oc` option when running GPU Screen Recorder. You also need to have "Coolbits" NVIDIA X setting set to "12" to enable overclocking. You can automatically add this option if you run `sudo nvidia-xconfig --cool-bits=12` and then reboot your computer.\
+Note that this only works when Xorg server is running as root, and using this option will only give you a performance boost if the game you are recording is bottlenecked by your GPU.\
+Note! use at your own risk!
+
 # Issues
 ## NVIDIA
 Nvidia drivers have an issue where CUDA breaks if CUDA is running when suspend/hibernation happens, and it remains broken until you reload the nvidia driver. `extra/gsr-nvidia.conf` will be installed by default when you install GPU Screen Recorder and that should fix this issue. If this doesn't fix the issue for you then your distro may use a different path for modprobe files. In that case you have to install that `extra/gsr-nvidia.conf` yourself into that location.
 You have to reboot your computer after installing GPU Screen Recorder for the first time for the fix to have any effect.
+
+## TEMPORARY ISSUES
+1) Videos are in variable framerate format. Use MPV to play such videos, otherwise you might experience stuttering in the video if you are using a buggy video player. You can try saving the video into a .mkv file instead as some software may have better support for .mkv files (such as kdenlive). You can use the "-fm cfr" option to to use constant framerate mode.
+2) FLAC audio codec is disabled at the moment because of temporary issues.
+
 # Examples
 Look at the [scripts](https://git.dec05eba.com/gpu-screen-recorder/tree/scripts) directory for script examples. For example if you want to automatically save a recording/replay into a folder with the same name as the game you are recording.
 
+# AMD/Intel/Wayland root permission
+When recording a window or when using the `-w portal` option no special user permission is required,
+however when recording a monitor the program needs root permission (to access KMS).\
+This is safe in GPU Screen Recorder as the part that needs root access has been moved to its own small program that only does one thing.\
+For you as a user this only means that if you installed GPU Screen Recorder as a flatpak then a prompt asking for root password will show up once when you start recording.
+
+# VRR/G-SYNC
+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).
 
@@ -196,11 +210,13 @@ Newer ffmpeg versions don't support older nvidia cards. Try installing GPU Scree
 ## I get a black screen/glitches while live streaming
 It seems like ffmpeg earlier than version 6.1 has some type of bug. Install ffmpeg version 6.1 or later and then reinstall GPU Screen Recorder to fix this issue. The flatpak version of GPU Screen Recorder comes with a newer version of ffmpeg so no extra steps are needed.
 ## I can't play the video in my browser directly or in discord
-Browsers and discord don't support hevc video codec at the moment. Choose h264 video codec instead with the -k h264 option.
+Browsers and discord don't support hevc video codec at the moment. You can instead choose h264 video codec with the -k h264 option or av1 video codec with the -k av1 option.
 Note that websites such as youtube support hevc so there is no need to choose h264 video codec if you intend to upload the video to youtube or if you want to play the video locally or if you intend to
 edit the video with a video editor. Hevc allows for better video quality (especially at lower file sizes) so hevc (or av1) is recommended for source videos.
 ## I get a black bar/distorted colors on the sides in the video
-This is mostly an issue on AMD. For av1 it's a hardware issue, see: https://gitlab.freedesktop.org/mesa/mesa/-/issues/9185. For hevc it's a software issue in the AMD driver that hasn't been fixed yet. This issue happens at certain video resolutions. If you get this issue then a workaround is to record with h264 video codec instead (using the -k h264 option).
+This is mostly an issue on AMD. For av1 it's a hardware issue, see: https://gitlab.freedesktop.org/mesa/mesa/-/issues/9185. For hevc it's a software issue in ffmpeg that was fixed in ffmpeg version 8.\
+If your ffmpeg version is older than 8 then you can use the flatpak version of GPU Screen Recorder which comes with ffmpeg version >= 8.\
+Alternatively you can record with h264 codec (-k h264, which is also the default codec) to workaround this issue.
 ## The video doesn't display or has a green/yellow overlay
 This can happen if your video player is missing the H264/HEVC video codecs. Either install the codecs or use mpv.
 ## I get stutter in the video
@@ -222,10 +238,29 @@ You have to use external software for that, such as Easy Effects or NoiseTorch.
 It's not really possible except in some cases. You can only record with the GPU that is displaying the graphics on your monitor.\
 Some laptops have display adapters that connect external monitors directly to the external GPU (if you have one)
 and on Wayland the external GPU will display the graphics for that monitor.
-In that case you can record the monitor with the external GPU by launching GPU Screen Recorder with [prime-run or by setting the DRI_PRIME environment variable](https://wiki.archlinux.org/title/PRIME) depending on your GPU brand.\
+In that case you can record the monitor with the external GPU by launching GPU Screen Recorder with [prime-run or by setting the DRI_PRIME environment variable](https://wiki.archlinux.org/title/PRIME) depending on your GPU brand.
+Alternatively you can capture with the desktop portal option (`-w portal`), which should allow you to capture any monitor.\
 However if you really want to change which GPU you want to record and encode with with then you can instead configure your display server (Xorg or Wayland compositor) to run with that GPU,
 then GPU Screen Recorder will automatically use that same GPU for recording and encoding.
 ## The rotation of the video is incorrect when the monitor is rotated when using desktop portal capture
 This is a bug in kde plasma wayland. When using desktop portal capture and the monitor is rotated and a window is made fullscreen kde plasma wayland will give incorrect rotation to GPU Screen Recorder.
 This also affects other screen recording software such as obs studio.\
 Capture a monitor directly instead to workaround this issue until kde plasma devs fix it, or use another wayland compositor that doesn't have this issue.
+## System notifications get disabled when recording with desktop portal option
+Some desktop environments such as KDE Plasma turn off notifications when you record the screen with the desktop portal option. You can disable this by going into KDE Plasma settings -> search for notifications and then under "Do Not Disturb mode" untick "During screen sharing".
+## The recorded video lags or I get dropped frames in the video
+This is likely not an issue in the recorded video itself, but the video player you use. GPU Screen Recorder doesn't record by dropping frames. Some video players don't play videos with hardware acceleration by default,
+especially if you record with HEVC/AV1 video codec. In such cases it's recommended to play the video with mpv instead with hardware acceleration enabled (for example: `mpv --vo=gpu --hwdec=auto video.mp4`).
+Some corporate distros such as Fedora (or some Fedora based distros) also disable hardware accelerated video codecs on AMD/Intel GPUs, so you might need to install mpv (or another video player) with flathub instead, which bypasses this restriction.
+## My cursor is flickering in the recorded video
+This is likely an AMD gpu driver issue. It only happens to certain generations of AMD GPUs. On Wayland you can record with the desktop portal option (`-w portal`) to workaround this issue.
+This issue hasn't been observed on X11 yet, but if you do observe it you can either record a window (`-w $(xdotool selectwindow)`) or change your xorg config to use software cursor instead (Add `Option "SWcursor" "true"` under modesetting "Device" section in your xorg config file).
+## Password prompt shows up when I try to record my screen
+If GPU Screen Recorder is installed with -Dcapabilities=true (which is the default option) then `gsr-kms-server` is installed with admin capabilities.
+This removes a password prompt when recording a monitor with the `-w monitor` option (for example `-w screen`). However if the root user is disabled on the system then the password prompt will show up anyways.
+If the root user is disabled on your system then you can instead record with `-w focused` or `-w window_id` on X11 or `-w portal` on Wayland.
+## GPU usage is high on my laptop
+GPU usage on battery powered devices is misleading. For example Intel iGPUs has multiple performance levels and the GPU usage reported on the system is the GPU usage at the current performance level.
+The performance level changes depending on the GPU load, so it may say that GPU usage is 80%, but the actual GPU usage may be 5%.
+## The video is too dark when capturing full-range video or 10-bit video
+This is an issue in some broken video players such as vlc. Play the video with a video player such as mpv (or a mpv frontend such as celluloid) or a browser instead.

TODO

@@ -4,12 +4,8 @@ See https://trac.ffmpeg.org/wiki/EncodingForStreamingSites for optimizing stream
 Look at VK_EXT_external_memory_dma_buf.
 Use mov+faststart.
 Allow recording all monitors/selected monitor without nvfbc by recording the compositor proxy window and only recording the part that matches the monitor(s).
-Support amf and qsv.
 Disable flipping on nvidia? this might fix some stuttering issues on some setups. See NvCtrlGetAttribute/NvCtrlSetAttributeAndGetStatus NV_CTRL_SYNC_TO_VBLANK https://github.com/NVIDIA/nvidia-settings/blob/d5f022976368cbceb2f20b838ddb0bf992f0cfb9/src/gtk%2B-2.x/ctkopengl.c.
-Replays seem to have some issues with audio/video. Why?
 Cleanup unused gl/egl functions, macro, etc.
-Set audio track name to audio device name (if not merge of multiple audio devices).
-Add support for webcam, but only really for amd/intel because amd/intel can get drm fd access to webcam, nvidia cant. This allows us to create an opengl texture directly from the webcam fd for optimal performance.
 Reverse engineer nvapi so we can disable "force p2 state" on linux too (nvapi profile api with the settings id 0x50166c5e).
 Support yuv444p on amd/intel.
 fix yuv444 for hevc.
@@ -30,9 +26,6 @@ Window capture doesn't work properly in _control_ game after going from pause me
 Monitor capture on steam deck is slightly below the game fps, but only when capturing on the steam deck screen. If capturing on another monitor, there is no issue.
     Is this related to the dma buf rotation issue? different modifier being slow? does this always happen?
 
-Fallback to vaapi copy in kms if opengl version fails. This can happen on steam deck for some reason (driver bug?). Also vaapi copy uses less gpu since it uses video codec unit to copy.
-Test if vaapi copy version uses less memory than opengl version.
-
 Intel is a bit weird with monitor capture and multiple monitors. If one of the monitors is rotated then all the kms will be rotated as well.
     Is that only the case when the primary monitor is rotated? Also the primary monitor becomes position 0, 0 so crtc (x11 randr) position doesn't match the drm pos. Maybe get monitor position and size from drm instead.
     How about if multiple monitors are rotated?
@@ -64,8 +57,6 @@ Remove follow focused option.
 
 Exit if X11/Wayland killed (if drm plane dead or something?)
 
-Use SRC_W and SRC_H for screen plane instead of crtc_w and crtc_h.
-
 Test if p2 state can be worked around by using pure nvenc api and overwriting cuInit/cuCtxCreate* to not do anything. Cuda might be loaded when using nvenc but it might not be used, with certain record options? (such as h264 p5).
     nvenc uses cuda when using b frames and rgb->yuv conversion, so convert the image ourselves instead.-
 
@@ -84,8 +75,6 @@ When vulkan encode is added, mention minimum nvidia driver required. (550.54.14?
 Investigate if there is a way to do gpu->gpu copy directly without touching system ram to enable video encoding on a different gpu. On nvidia this is possible with cudaMemcpyPeer, but how about from an intel/amd gpu to an nvidia gpu or the other way around or any combination of iGPU and dedicated GPU?
     Maybe something with clEnqueueMigrateMemObjects? on AMD something with DirectGMA maybe?
 
-Go back to using pure vaapi without opengl for video encoding? rotation (transpose) can be done if its done after (rgb to yuv) color conversion.
-
 Use lanczos resampling for better scaling quality. Lanczos resampling can also be used for YUV chroma for better color quality on small text.
 
 Flac is disabled because the frame sizes are too large which causes big audio/video desync.
@@ -101,7 +90,7 @@ Support vfr matching games exact fps all the time. On x11 use damage tracking, o
 Support selecting which gpu to use. This can be done in egl with eglQueryDevicesEXT and then eglGetPlatformDisplayEXT. This will automatically work on AMD and Intel as vaapi uses the same device. On nvidia we need to use eglQueryDeviceAttribEXT with EGL_CUDA_DEVICE_NV.
     Maybe on glx (nvidia x11 nvfbc) we need to use __NV_PRIME_RENDER_OFFLOAD, __NV_PRIME_RENDER_OFFLOAD_PROVIDER, __GLX_VENDOR_LIBRARY_NAME, __VK_LAYER_NV_optimus, VK_ICD_FILENAMES instead. Just look at prime-run /usr/bin/prime-run.
 
-When adding support for steam deck, add option to send video to another computer.
+Add option to send video to another computer.
 New gpu screen recorder gui should have the option to cut the video directly, maybe running an ffmpeg command or implementing that ourselves. Only support gpu screen recorder video files.
 
 Check if is software renderer by using eglQueryDisplayAttribEXT(egl_display, EGL_DEVICE_EXT..) eglQueryDeviceStringEXT(egl_device, EGL_EXTENSIONS) and check for "EGL_MESA_device_software".
@@ -138,8 +127,6 @@ Enable 2-pass encoding.
 
 Restart replay/update video resolution if monitor resolution changes.
 
-Fix pure vaapi copy on intel.
-
 Use nvidia low latency options for better encoding times.
 
 Test ideal async_depth value. Increasing async_depth also increased gpu memory usage a lot (from 100mb to 500mb when moving from async_depth 2 to 16) at 4k resolution. Setting it to 8 increases it by 200mb which might be ok.
@@ -189,13 +176,6 @@ Use wayland color management protocol when it's available: https://gitlab.freede
 Use different exit codes for different errors. Use one for invalid -w option, another one for invalid -a option for audio devices, etc. This is to make UI error reporting better.
     Document these exit codes in an exit code .md file, or finally create a manpage where this can be documented.
 
-Ffmpeg fixed black bars in videos on amd when using hevc and when recording at some resolutions, such as 1080p:
-    https://github.com/FFmpeg/FFmpeg/commit/bcfbf2bac8f9eeeedc407b40596f5c7aaa0d5b47
-    https://github.com/FFmpeg/FFmpeg/commit/d0facac679faf45d3356dff2e2cb382580d7a521
-    Disable gpu screen recorder black bar handling when using hevc on amd when the libavcodec version is the one that comes after those commits.
-    Also consider the mesa version, to see if the gpu supports this.
-    The version is libavcodec >= 61.28.100
-
 Use opengl compute shader instead of graphics shader. This might allow for better performance when games are using 100% of graphics unit which might fix issue with 100% gpu usage causing gpu screen recorder to run slow when not using vaapi to convert rgb to nv12(?).
 
 Always disable prime run/dri prime and list all monitors to record from from all cards.
@@ -209,8 +189,6 @@ Always disable prime run/dri prime and list all monitors to record from from all
 Allow flv av1 if recent ffmpeg version and streaming to youtube (and twitch?) and for custom services.
 Use explicit sync in pipewire video code: https://docs.pipewire.org/page_dma_buf.html.
 
-Support vaapi rotation. Support for it is added in mesa here: https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/32919.
-
 Replay (and recording?) fails to save properly sometimes (especially for long videos). This is noticable with mp4 files since they get corrupt and become unplayable.
     The entire video does seem to get saved (it's a large video file) and it seems to have the correct headers but it's not playable.
 
@@ -244,8 +222,6 @@ When webcam support is added also support v4l2loopback? this is done by using av
 
 Do proper exit, to call gsr_capture_destroy which will properly stop gsr-kms-server. Otherwise there can be zombie gsr-kms-server on error.
 
-Replace all scissors with clearing textures if the cursor hits the outside of the frame image.
-
 Cursor position might be slightly wrong on rotated monitor.
 
 External texture doesn't work on nvidia x11, probably because of glx context (requires gles es). External texture is not used on nvidia x11 right now so it's not an issue.
@@ -275,7 +251,8 @@ Add the option to set audio track name, for example with -a "track-name:blabla|d
 Maybe disable qp/vbr for replay. In that case we can preallocate all replay data (for both ram and disk) and write to that directly when receiving packet (dont do that when also recording at the same time).
     That could improve performance/disk write optimization and maybe even reduce ram usage because of less blocks/fragmentation.
 
-When rpc is added add the option to add/remove audio devices/app audio and also overlays (from new capture sources).
+When rpc is added add the option to add/remove audio devices/app audio and also overlays (from new capture sources). It should also be possible to save a replay of any duration (below duration set with -r).
+    Have an rpc info/status command that just returns the status. This is to check if gpu screen recorder is running.
 
 Support hdr screenshot.
 
@@ -311,12 +288,9 @@ Disable GL_DEPTH_TEST, GL_CULL_FACE.
 
 kde plasma portal capture for screenshot doesn't work well because the portal ui is still visible when taking a screenshot because of its animation.
 
-It's possible for microphone audio to get desynced when recording together with desktop audio, when not recording app audio as well.
-    Test recording desktop audio and microphone audio together (-a "default_output|default_input") for around 30 minutes.
-
 We can use dri2connect/dri3open to get the /dev/dri/card device. Note that this doesn't work on nvidia x11.
 
-Add support for QVBR (QP with target bitrate).
+Add support for QVBR (QP with target bitrate). Maybe use VBR instead, since nvidia doesn't support QVBR and neither does vulkan.
 
 KDE Plasma Wayland seems to use overlay planes now in non-fullscreen mode(limited to 1 overlay plane per gpu). Check if this is the case in the latest kde on arch linux.
     If it is, then support it in kms capture.
@@ -331,7 +305,103 @@ Set top level window argument for portal capture. Same for gpu-screen-recorder-g
 
 Remove unix domain socket code from kms-client/server and use socketpair directly. To make this possible always execute the kms server permission setup in flatpak, before starting recording (in gpu-screen-recorder-gtk).
 
-Application audio capture isn't good enough. It creates a sink that for some automatically gets selected as the default output device and it's visible as an output device.
-    When shutting down gpu screen recorder it will also cause audio applications to pause.
-    Fix some of these issues by setting gsr-app-sink media class to "Stream/Input/Audio" and node.virtual=true.
-    However that causes pulseaudio to be unable to record from gsr-app-sink, and it ends up being stuck in pa_sound_device_handle_reconnect in the loop with pa_mainloop_iterate.
+Add -k best/best_hdr/best_10bit option, to automatically choose the best codec (prefer av1, then hevc and then h264. For webm files choose vp9 and then vp8).
+
+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.
+
+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.
+
+After adding rpc, make it possible to add/remove audio and video. The same number of audio tracks should remain, but the audio devices/app should be possible to configure. You should be able to configure the capture sources however you want.
+
+It takes a while to shutdown gpu screen recorder when using replay with a long replay time (when the replay buffer is for example 6gb). Maybe this has to do with cleaning up so much memory. Try if _exit(0) is faster, ignoring cleanup of anything (assuming the gpu driver is happy with that, nvidia doesn't like such things. GPU drivers are often buggy when it comes to automatic cleanup).
+
+Support desktop portal hdr capture when this gets merged: https://invent.kde.org/plasma/kwin/-/merge_requests/8293 note that it only works with pipewire >= 1.5.81. If codec is set to non-hdr codec when use desktop portal without hdr (convert to sdr, remove the code that forces non-hdr equivalent of the codec). Update gsr-gtk and gsr-ui accordingly.
+
+Add option to save screenshot as .qoi. Use that then in gsr-ui for the background for the window (capture the monitor that the ui is going to show on). Do that on cosmic and hyprland, which are unable to display things behind the fullscreen window.
+
+Support pausing recording when recording while replay/streaming.
+
+Maybe use VK_VALVE_video_encode_rgb_conversion with vulkan encoding for shader-less rgb to yuv conversion. That would allow screen capture with no gpu processing.
+
+Cursor sometimes doesn't have color when capturing region scaled (on kde plasma wayland at least).
+
+Remove drm_monitor_get_display_server_data and do that work in the drm monitor query.
+
+In gpu screen recorder --info output codec max resolutions. This allows for better error messages in ui frontends and easier and better error handling.
+
+Set minimum fps for live stream or piping or always.
+
+Support youtube sso.
+
+Remove -fm content (support it but remove it from documentation and output deprecation notice when its used) and use it when using -fm vbr (which is the default option).
+    But first -fm content needs to be support on wayland as well, by checking if there is a difference between frames (checksum the frame content).
+    -fm content also needs to have a minimum fps to prevent live stream from timing out when nothing changes on the screen.
+
+There is a leak in nvfbc. When a monitor is turned off and then on there will be an x11 display leak inside nvfbc. This seems to be a bug in nvfbc.
+    Right now a mitigation has been added to not try to recreate the nvfbc session if the capture target (monitor) isn't connected (predict if nvfbc session create will fail).
+    One possible reason this happens is because bExternallyManagedContext is set to true.
+    This also means that nvfbc leaks connection when destroying nvfbc, even if the monitor is connected (this is not an issue right now because exit is done, but if gsr was turned into a library it would be).
+
+Add option to set audio source volume, maybe by doing for example: -a "default_input|app:firefox;volume=50"
+
+Optimize v4l2 mjpeg by decompressing to yuv (tjDecompressToYUV) instead of rgb. This would allow removing the yuv to rgb conversion on cpu step (and rgb to yuv on the gpu as well) as well as reducing the cpu->gpu image data bandwidth as yuv is compressed.
+
+Do jpeg decoding on the gpu for v4l2 mjpeg capture (see https://github.com/negge/jpeg_gpu). Or use jpeg decoding from vaapi/nvdec.
+
+Support other v4l2 pixel formats, such as h264 and rgb/bgr. High-end cameras use h264 for high resolution high framerate option (4k 60fps or higher).
+
+AV1 medium quality on nvidia seems to be very high quality. The quality needs to be rescaled. Need to test on nvidia av1 gpu, but I dont have any such gpu.
+
+Support multiple -w, to record different sources to different video tracks. For example gameplay to video track 1 and webcam to video track 2.
+
+Update man page with info about v4l2 and new region capture format. Mention that -region is deprecated.
+
+Make multiple -w portal work with -restore-portal-session.
+
+Play with DRM_FORMAT_MOD_LINEAR or other linear formats to avoid cuda copy. If it's already in linear format then instead check the format of the target texture and use the same format.
+
+Give early error when using invalid v4l2 path like with monitor. Use gsr_capture_v4l2_list_devices for query. Or maybe remove the early error for monitor to simplify the code.
+
+Support camera capture with pipewire to support multiple applications recording camera at the same time. Might not be as efficient as V4L2.
+
+Taking a screenshot of camera with mjpeg doesn't work correctly because it updates buffer asynchronously. v4l2 capture should only return 0 if the copy of the data to the texture has finished.
+
+Make capture from multiple sources work on nvidia x11 when capturing monitor + window. It doesn't work right now because monitor requires glx (nvfbc) while window requires egl.
+
+Support v4l2 mplane on devices where it's supported (where it's more efficient). My camera doesn't support mplane.
+
+Implement v4l2 yuyv nvidia capture by capturing rg88 yuyv to rgb as is done now for screenshot, but also do that for video by creating an intermediate rgb texture for the camera. Then render that rgb texture to the video texture.
+    This is needed to properly scale the yuyv texture without messing it up (the texture indexing).
+
+Set v4l2 camera fps to video output fps (if lower than the camera fps) and the same for resolution.
+
+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.
+
+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.
+
+Add option to capture all monitors automatically.
+
+Make -w optional, to only capture audio.
+
+Use GL_RGBA16F or GL_RGBA32F for hdr, that allows color values to be outside the 0.0 to 1.0 range.
+
+https://registry.khronos.org/EGL/extensions/EXT/EGL_EXT_surface_SMPTE2086_metadata.txt
+
+Doesn't work: sibs run --args -w "/dev/video0;camera_width=800;camera_height=600;pixfmt=yuyv" -fm content -o video.mp4

extra/gpu-screen-recorder.service

@@ -3,6 +3,7 @@ Description=GPU Screen Recorder Service
 
 [Service]
 EnvironmentFile=-%h/.config/gpu-screen-recorder.env
+EnvironmentFile=-%h/.config/gpu-screen-recorder/gpu-screen-recorder.env
 Environment=WINDOW=screen
 Environment=CONTAINER=mp4
 Environment=QUALITY=40000

gpu-screen-recorder.1

@@ -0,0 +1,621 @@
+.TH GPU-SCREEN-RECORDER 1 "2025-12-22" "5.10.2" "GPU Screen Recorder Manual"
+.SH NAME
+gpu-screen-recorder \- The fastest screen recording tool for Linux
+.SH SYNOPSIS
+.B gpu-screen-recorder
+.B \-w
+.I window_id|monitor|focused|portal|region|v4l2_device_path
+.RI [ options ]
+.B \-o
+.I output_file
+.PP
+.B gpu-screen-recorder
+.B \-\-help
+|
+.B \-\-version
+|
+.B \-\-info
+|
+.B \-\-list\-capture\-options
+|
+.B \-\-list\-monitors
+|
+.B \-\-list\-v4l2\-devices
+|
+.B \-\-list\-audio\-devices
+|
+.B \-\-list\-application\-audio
+.SH DESCRIPTION
+.B gpu-screen-recorder
+is the fastest screen recording tool for Linux. It uses the GPU
+only to record the screen to minimize system performance impact. It supports recording,
+live streaming, instant replay (similar to NVIDIA ShadowPlay), and
+screenshot capture. The tool works on both X11 and Wayland with AMD,
+Intel, and NVIDIA graphics cards.
+.PP
+Key features include:
+.RS
+.IP \(bu 3
+GPU-accelerated encoding using H264, HEVC, AV1, VP8, or VP9 codecs
+.IP \(bu 3
+Support for HDR recording (HEVC HDR and AV1 HDR)
+.IP \(bu 3
+Instant replay buffer (last N seconds recording)
+.IP \(bu 3
+Live streaming capabilities
+.IP \(bu 3
+Audio recording from devices and applications (PipeWire required for app audio)
+.IP \(bu 3
+Plugin system for custom graphics overlay
+.IP \(bu 3
+Minimal performance impact compared to traditional screen recorders
+.RE
+.SH OPTIONS
+.SS Capture Options
+.TP
+.BI \-w " window_id|monitor|focused|portal|region|v4l2_device_path"
+Specify what to record.
+Formats:
+.RS
+.IP \(bu 3
+.B window
+- Record a specific window (use window ID) (X11 only)
+.IP \(bu 3
+.B screen
+- Record the first monitor found
+.IP \(bu 3
+.B screen\-direct
+- NVIDIA X11 only, for VRR/G-SYNC support (not recommended due to driver issues)
+.IP \(bu 3
+.B focused
+- Record the currently focused window (X11 only) (use with -s option)
+.IP \(bu 3
+.B portal
+- Use xdg-desktop-portal with PipeWire (Wayland only)
+.IP \(bu 3
+.B region
+- Record a specific region (use with
+.B \-region
+option)
+.IP \(bu 3
+Monitor name (e.g.,
+.BR DP\-1 )
+- Record specific monitor
+.IP \(bu 3
+V4L2 device path (e.g.,
+.BR /dev/video0 )
+- Record camera device (V4L2).
+
+Other applications can't use the camera when GPU Screen Recorder is using the camera and GPU Screen Recorder may not be able to use the camera if another application is already using the camera
+.IP \(bu 3
+Combine sources with | (e.g.,
+.BR "monitor:screen|v4l2:/dev/video0" )
+.RE
+.PP
+Run
+.B \-\-list\-capture\-options
+to list available capture sources.
+.PP
+Additional options can be passed to each capture source by splitting capture source with
+.B ;
+for example
+.BR "screen;x=50;y=50".
+.br
+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 % 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 % 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 % 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 % 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
+.BR "start",
+.B center
+or
+.BR "end".
+
+Set to
+.B center
+by default when using one capture source, otherwise it's set to
+.B start
+by default.
+.IP \(bu 3
+.B valign
+- The vertical alignment, should be either
+.BR "start",
+.B center
+or
+.BR "end".
+
+Set to
+.B center
+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
+.B "true"
+or
+.BR "false".
+Set to
+.B false
+by default
+.IP \(bu 3
+.B vflip
+- If the source should be flipped vertically, should be either
+.B "true"
+or
+.BR "false".
+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, should be either
+.BR "auto",
+.B yuyv
+or
+.BR "mjpeg".
+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"
+Specify region to capture when using
+.BR \-w " region."
+Format is width x height + X offset + Y offset. Set width and height to 0 to capture the whole monitor that contains the position.
+
+It is compatible with tools such as slop (X11) and slurp (Wayland).
+.TP
+.BI \-c " container_format"
+Container format (mp4, mkv, flv, webm). Defaults to extension from
+.B \-o
+filename.
+.TP
+.BI \-s " WxH"
+Output resolution limit (e.g., 1920x1080). Use 0x0 for original resolution.
+Required for
+.BR \-w " focused."
+.TP
+.BI \-f " fps"
+Frame rate (default: 60). For variable frame rate mode, this is maximum FPS.
+.TP
+.BI \-cursor " yes|no"
+Record cursor (default: yes).
+.TP
+.BI \-restore\-portal\-session " yes|no"
+Restore previous portal session (used with -w portal option, default: no).
+.SS Audio Options
+.TP
+.BI \-a " audio_source"
+Audio device or application to record. Can be specified multiple times.
+Formats:
+.RS
+.IP \(bu 3
+.B default_output
+- Default output device
+.IP \(bu 3
+.B default_input
+- Default input device
+.IP \(bu 3
+.B device:name
+- Specific device
+.IP \(bu 3
+.B app:name
+- Application audio (case-insensitive)
+.IP \(bu 3
+.B app\-inverse:name
+- All applications except specified
+.IP \(bu 3
+Combine sources with | (e.g.,
+.BR "default_output|app:firefox" )
+.RE
+.PP
+Run
+.B \-\-list\-audio\-devices
+to list available audio devices.
+.br
+Run
+.B \-\-list\-application\-audio
+to list available applications for audio capture.
+.TP
+.BI \-ac " aac|opus|flac"
+Audio codec (default: opus for mp4/mkv, aac otherwise). FLAC temporarily disabled.
+.TP
+.BI \-ab " bitrate"
+Audio bitrate in kbps (default: 128 for opus/flac, 160 for aac). 0 = automatic.
+.SS Video Quality Options
+.TP
+.BI \-k " codec"
+Video codec:
+.BR auto ", " h264 ", " hevc ", " av1 ", " vp8 ", " vp9 ", " hevc_hdr ", " av1_hdr ", " hevc_10bit ", " av1_10bit
+(default: auto → h264). HDR options not available on X11 or portal capture.
+
+10-bit capture reduces banding but may not be supported properly by all video players.
+.TP
+.BI \-q " quality"
+Quality preset (medium, high, very_high, ultra) for QP/VBR mode, or bitrate (kbps) for CBR mode (default: very_high).
+.TP
+.BI \-bm " auto|qp|vbr|cbr"
+Bitrate mode (default: auto → qp). CBR recommended for replay buffer and live streaming.
+
+QP means to capture with constant quality, even in motion, while VBR and CBR means to capture with constant size.
+.TP
+.BI \-fm " cfr|vfr|content"
+Frame rate mode: cfr (constant), vfr (variable), or content (match content) (default: vfr). Content mode is only available on X11 or portal.
+
+Content mode syncs video to the captured content and is recommended for smoothest video when the game is running
+at the same frame rate or lower than what you are trying to record at.
+.TP
+.BI \-cr " limited|full"
+Color range (default: limited). Full range may cause issues with some video players/websites.
+.TP
+.BI \-tune " performance|quality"
+Encoding tune (default: performance). Currently NVIDIA only.
+.TP
+.BI \-keyint " seconds"
+Keyframe interval in seconds (default: 2.0). Affects seeking precision.
+.TP
+.BI \-encoder " gpu|cpu"
+Encoding device (default: gpu). CPU encoding only for H264.
+.TP
+.BI \-fallback\-cpu\-encoding " yes|no"
+Fallback to CPU if GPU encoding unavailable (default: no).
+.SS Replay Buffer Options
+.TP
+.BI \-r " seconds"
+Replay buffer duration (2-86400 seconds). When set, only saves on command.
+.TP
+.BI \-replay\-storage " ram|disk"
+Buffer storage location (default: ram). Disk mode may reduce SSD lifespan.
+.TP
+.BI \-restart\-replay\-on\-save " yes|no"
+Clear buffer after saving replay (default: no).
+.TP
+.BI \-df " yes|no"
+Organize replays in date-based folders (default: no).
+.SS Advanced Options
+.TP
+.BI \-oc " yes|no"
+Overclock NVIDIA memory (X11 only). Requires Coolbits=12. Use at own risk.
+.TP
+.BI \-p " plugin.so"
+Load plugin (.so file). Can be specified multiple times.
+.TP
+.BI \-sc " script_path"
+Script to run after saving video. Receives filepath and type ("regular", "replay", "screenshot").
+.TP
+.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 live streaming and when output is piped.
+.SS Output Options
+.TP
+.BI \-o " output"
+Output file path (or directory for replay mode). Required except when outputting to stdout.
+.TP
+.BI \-ro " directory"
+Output directory for regular recordings during replay/streaming mode.
+.SS Information Commands
+.TP
+.B \-\-help
+Show help message.
+.TP
+.B \-\-version
+Show version (5.10.2).
+.TP
+.B \-\-info
+Show system info (codecs, capture options).
+.TP
+.B \-\-list\-capture\-options
+List available capture sources (window, monitors, portal, v4l2 device path).
+.TP
+.B \-\-list\-monitors
+List available monitors.
+.TP
+.B \-\-list\-v4l2\-devices
+List available cameras devices (V4L2).
+.TP
+.B \-\-list\-audio\-devices
+List available audio devices.
+.TP
+.B \-\-list\-application\-audio
+List available applications for audio capture.
+.SH SIGNALS
+GPU Screen Recorder can be controlled via signals:
+.TP
+.B SIGINT (Ctrl+C)
+Stop and save recording (stop without save in replay mode).
+.TP
+.B SIGUSR1
+Save replay (replay mode only).
+.TP
+.B SIGUSR2
+Pause/unpause recording (not for streaming/replay).
+.TP
+.B SIGRTMIN
+Start/stop regular recording during replay/streaming.
+.TP
+.B SIGRTMIN+1
+Save last 10 seconds (replay mode).
+.TP
+.B SIGRTMIN+2
+Save last 30 seconds (replay mode).
+.TP
+.B SIGRTMIN+3
+Save last 60 seconds (replay mode).
+.TP
+.B SIGRTMIN+4
+Save last 5 minutes (replay mode).
+.TP
+.B SIGRTMIN+5
+Save last 10 minutes (replay mode).
+.TP
+.B SIGRTMIN+6
+Save last 30 minutes (replay mode).
+.PP
+Use
+.B pkill
+to send signals (e.g.,
+.BR "pkill -SIGUSR1 -f ""^gpu-screen-recorder""" ).
+.SH EXAMPLES
+Record monitor at 60 FPS with desktop audio:
+.PP
+.nf
+.RS
+gpu-screen-recorder -w screen -f 60 -a default_output -o video.mp4
+.RE
+.fi
+.PP
+Record monitor at 60 FPS with desktop audio and microphone:
+.PP
+.nf
+.RS
+gpu-screen-recorder -w screen -f 60 -a "default_output|default_input" -o video.mp4
+.RE
+.fi
+.PP
+Record specific window (X11 only):
+.PP
+.nf
+.RS
+gpu-screen-recorder -w $(xdotool selectwindow) -f 60 -o video.mp4
+.RE
+.fi
+.PP
+Instant replay (last 60 seconds):
+.PP
+.nf
+.RS
+gpu-screen-recorder -w screen -c mkv -r 60 -o ~/Videos
+.RE
+.fi
+.PP
+Record region using slop:
+.PP
+.nf
+.RS
+gpu-screen-recorder -w $(slop) -o video.mp4
+.RE
+.fi
+.PP
+Record region using slurp:
+.PP
+.nf
+.RS
+gpu-screen-recorder -w $(slurp -f "%wx%h+%x+%y") -o video.mp4
+.RE
+.fi
+.PP
+Instant replay and launch a script when saving replay:
+.PP
+.nf
+.RS
+gpu-screen-recorder -w screen -c mkv -r 60 -sc ./script.sh -o ~/Videos
+.RE
+.fi
+.PP
+Stream to Twitch with constant bitrate mode:
+.PP
+.nf
+.RS
+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
+Take screenshot:
+.PP
+.nf
+.RS
+gpu-screen-recorder -w screen -o screenshot.jpg
+.PP
+.RE
+.fi
+Record screen and camera:
+.PP
+.nf
+.RS
+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 and flipped horizontally:
+.PP
+.nf
+.RS
+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
+.TP
+.I ~/.config/gpu-screen-recorder/gpu-screen-recorder.env
+Environment variables for systemd service (optional).
+.TP
+.I /usr/lib/modprobe.d/gsr-nvidia.conf
+NVIDIA suspend/resume fix.
+.TP
+.I ~/.config/gpu-screen-recorder/restore_token
+Portal session token storage (default location).
+.SH TIPS
+.IP \(bu 3
+Some video editors don't support videos in variable frame rate mode.
+
+Change video container to .mkv or capture in constant frame rate mode instead to workaround this issue
+.IP \(bu 3
+Variable frame rate may cause issues in some video players (use MPV)
+.IP \(bu 3
+H.265/HEVC not supported in browsers/Discord (use H264 for sharing)
+.IP \(bu 3
+Some distros disable hardware codecs (use Flatpak version)
+.IP \(bu 3
+Use CBR mode (
+.B \-bm cbr
+) for replay buffer to control RAM usage
+.SH PERFORMANCE TIPS
+.IP \(bu 3
+Save to SSD (HDD may be too slow)
+.IP \(bu 3
+Close other screen recorders (including idle OBS)
+.SH KNOWN ISSUES
+.IP \(bu 3
+NVIDIA: CUDA breaks after suspend (install gsr-nvidia.conf fix)
+.IP \(bu 3
+AMD: Possible black bars colors with HEVC/AV1 (use H264 or FFmpeg >=8)
+.SH SEE ALSO
+.UR https://git.dec05eba.com/gpu-screen-recorder
+Project homepage
+.UE
+.br
+.UR https://git.dec05eba.com/gpu-screen-recorder/about
+Project readme, with more information
+.UE
+.br
+.UR https://git.dec05eba.com/gpu-screen-recorder-gtk
+GTK GUI version (deprecated)
+.UE
+.br
+.UR https://git.dec05eba.com/gpu-screen-recorder-ui
+ShadowPlay-style UI
+.UE
+.br
+.BR xdotool (1),
+.BR slop (1),
+.BR slurp (1),
+.SH AUTHORS
+Developed by dec05eba and contributors.
+.SH COPYRIGHT
+Copyright © dec05eba. Licensed under GPL3-only.
+.SH REPORTING BUGS
+Report bugs at
+.UR mailto:dec05eba@protonmail.com
+dec05eba@protonmail.com
+.UE .
+.UR https://git.dec05eba.com/?p=about
+See more information about reporting bugs at the gpu-screen-recorder website
+.UE .
+.br
+.UR https://git.dec05eba.com/gpu-screen-recorder/about/
+Before reporting a bug or an issue, please take a look at FAQ part of the README
+.UE .
+The bug or issue may have been previously reported or may not be related to gpu-screen-recorder.

gsr-kms-server.1

@@ -0,0 +1,65 @@
+.TH GSR\-KMS\-SERVER 1 "2025-12-22" "5.10.2" "GPU Screen Recorder KMS Server Manual"
+.SH NAME
+gsr\-kms\-server \- KMS (Kernel Mode Setting) server for GPU Screen Recorder
+.SH SYNOPSIS
+.B gsr\-kms\-server
+<\fIdomain_socket_path\fR> <\fIcard_path\fR>
+.SH DESCRIPTION
+\fBgsr\-kms\-server\fR is a companion daemon for GPU Screen Recorder that provides
+Kernel Mode Setting (KMS) access for screen capture in environments where
+direct DRM access is required. It acts as a local server that communicates
+via a Unix domain socket, allowing GPU Screen Recorder to capture screen
+content through the KMS interface.
+.PP
+This component is typically used when GPU Screen Recorder needs to access
+display hardware directly, bypassing the windowing system for more efficient
+or lower-level capture. It runs as a separate process and communicates with
+the main GPU Screen Recorder instance.
+.SH ARGUMENTS
+.TP
+.B \fIdomain_socket_path\fR
+Path to the Unix domain socket that the server will create and listen on.
+This socket is used for communication between GPU Screen Recorder and the
+KMS server. The path should be in a location where both processes have
+appropriate permissions to read and write.
+.TP
+.B \fIcard_path\fR
+Path to the DRM device file (typically \fI/dev/dri/cardX\fR) that the server
+will use for KMS operations. This corresponds to a specific graphics card
+in the system.
+.SH EXAMPLES
+Start the KMS server using card0 and create socket at /tmp/gsr-kms.sock:
+.RS
+.B gsr\-kms\-server /tmp/gsr\-kms.sock /dev/dri/card0
+.RE
+.PP
+Start the KMS server using card1 and create socket in a user-specific location:
+.RS
+.B gsr\-kms\-server ~/.cache/gsr\-kms.sock /dev/dri/card1
+.RE
+.SH NOTES
+.IP \(bu 3
+The \fBgsr-kms-server\fR typically runs with elevated permissions to access
+DRM devices, which requires root permission.
+.IP \(bu 3
+Only one instance should run per DRM card at a time.
+.IP \(bu 3
+The server will exit when the client disconnects or when terminated by a signal.
+.IP \(bu 3
+The socket file is created by the server and removed when the server exits.
+.SH FILES
+.TP
+.B /dev/dri/card*
+DRM device files for graphics cards
+.TP
+.B /tmp/gsr-kms.sock
+Typical location for the domain socket (user-configurable)
+.SH SEE ALSO
+.BR gpu\-screen\-recorder (1),
+.BR drm (4)
+.PP
+Project homepage: <https://git.dec05eba.com/gpu-screen-recorder/about/>
+.SH BUGS
+Report bugs at the project homepage.
+.SH AUTHORS
+gsr\-kms\-server was written by the GPU Screen Recorder contributors.

include/args_parser.h

@@ -8,7 +8,16 @@
 
 typedef struct gsr_egl gsr_egl;
 
-#define NUM_ARGS 31
+#define NUM_ARGS 37
+
+typedef enum {
+    GSR_CAPTURE_SOURCE_TYPE_WINDOW,
+    GSR_CAPTURE_SOURCE_TYPE_FOCUSED_WINDOW,
+    GSR_CAPTURE_SOURCE_TYPE_MONITOR,
+    GSR_CAPTURE_SOURCE_TYPE_REGION,
+    GSR_CAPTURE_SOURCE_TYPE_PORTAL,
+    GSR_CAPTURE_SOURCE_TYPE_V4L2
+} CaptureSourceType;
 
 typedef enum {
     ARG_TYPE_STRING,
@@ -52,7 +61,9 @@ typedef struct {
     void (*info)(void *userdata);
     void (*list_audio_devices)(void *userdata);
     void (*list_application_audio)(void *userdata);
+    void (*list_v4l2_devices)(void *userdata);
     void (*list_capture_options)(const char *card_path, void *userdata);
+    void (*list_monitors)(void *userdata);
 } args_handlers;
 
 typedef struct {
@@ -68,19 +79,26 @@ typedef struct {
     gsr_bitrate_mode bitrate_mode;
     gsr_video_quality video_quality;
     gsr_replay_storage replay_storage;
-    char window[64];
+
+    const char *capture_source;
     const char *container_format;
     const char *filename;
     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/capture.h

@@ -12,20 +12,34 @@ typedef struct AVFrame AVFrame;
 typedef struct AVMasteringDisplayMetadata AVMasteringDisplayMetadata;
 typedef struct AVContentLightMetadata AVContentLightMetadata;
 typedef struct gsr_capture gsr_capture;
+typedef struct gsr_capture_metadata gsr_capture_metadata;
 
-typedef struct {
-    int width;
-    int height;
+typedef enum {
+    GSR_CAPTURE_ALIGN_START,
+    GSR_CAPTURE_ALIGN_CENTER,
+    GSR_CAPTURE_ALIGN_END
+} gsr_capture_alignment;
+
+struct gsr_capture_metadata {
+    // Size of the video
+    vec2i video_size;
+    // The captured output gets scaled to this size. By default this will be the same size as the captured target
+    vec2i recording_size;
+    vec2i position;
     int fps;
-} gsr_capture_metadata;
+    gsr_capture_alignment halign;
+    gsr_capture_alignment valign;
+    gsr_flip flip;
+};
 
 struct gsr_capture {
-    /* These methods should not be called manually. Call gsr_capture_* instead. |capture_metdata->width| and |capture_metadata->height| should be set by this function */
+    /* These methods should not be called manually. Call gsr_capture_* instead. |capture_metadata->video_size| should be set by this function */
     int (*start)(gsr_capture *cap, gsr_capture_metadata *capture_metadata);
     void (*on_event)(gsr_capture *cap, gsr_egl *egl); /* can be NULL */
     void (*tick)(gsr_capture *cap); /* can be NULL. If there is an event then |on_event| is called before this */
     bool (*should_stop)(gsr_capture *cap, bool *err); /* can be NULL. If NULL, return false */
     bool (*capture_has_synchronous_task)(gsr_capture *cap); /* can be NULL. If this returns true then the time spent in |capture| is ignored for video/audio (capture is paused while the synchronous task happens) */
+    void (*pre_capture)(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion); /* can be NULL */
     int (*capture)(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion); /* Return 0 if the frame was captured */
     bool (*uses_external_image)(gsr_capture *cap); /* can be NULL. If NULL, return false */
     bool (*set_hdr_metadata)(gsr_capture *cap, AVMasteringDisplayMetadata *mastering_display_metadata, AVContentLightMetadata *light_metadata); /* can be NULL. If NULL, return false */

include/capture/kms.h

@@ -2,9 +2,13 @@
 #define GSR_CAPTURE_KMS_H
 
 #include "capture.h"
+#include "../cursor.h"
+#include "../../kms/kms_shared.h"
 
 typedef struct {
     gsr_egl *egl;
+    gsr_cursor *x11_cursor;
+    gsr_kms_response *kms_response;
     const char *display_to_capture; /* A copy is made of this */
     bool hdr;
     bool record_cursor;

include/capture/v4l2.h

@@ -0,0 +1,44 @@
+#ifndef GSR_CAPTURE_V4L2_H
+#define GSR_CAPTURE_V4L2_H
+
+#include "capture.h"
+
+typedef enum {
+    GSR_CAPTURE_V4L2_PIXFMT_AUTO,
+    GSR_CAPTURE_V4L2_PIXFMT_YUYV,
+    GSR_CAPTURE_V4L2_PIXFMT_MJPEG
+} gsr_capture_v4l2_pixfmt;
+
+typedef struct {
+    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;
+    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);
+
+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/capture/xcomposite.h

@@ -3,9 +3,11 @@
 
 #include "capture.h"
 #include "../vec2.h"
+#include "../cursor.h"
 
 typedef struct {
     gsr_egl *egl;
+    gsr_cursor *cursor;
     unsigned long window;
     bool follow_focused; /* If this is set then |window| is ignored */
     bool record_cursor;

include/capture/ximage.h

@@ -3,9 +3,11 @@
 
 #include "capture.h"
 #include "../vec2.h"
+#include "../cursor.h"
 
 typedef struct {
     gsr_egl *egl;
+    gsr_cursor *cursor;
     const char *display_to_capture; /* A copy is made of this */
     bool record_cursor;
     vec2i output_resolution;

include/color_conversion.h

@@ -6,13 +6,13 @@
 #include "vec2.h"
 #include <stdbool.h>
 
-#define GSR_COLOR_CONVERSION_MAX_COMPUTE_SHADERS 12
-#define GSR_COLOR_CONVERSION_MAX_GRAPHICS_SHADERS 6
+#define GSR_COLOR_CONVERSION_MAX_GRAPHICS_SHADERS 12
 #define GSR_COLOR_CONVERSION_MAX_FRAMEBUFFERS 2
 
 typedef enum {
     GSR_SOURCE_COLOR_RGB,
-    GSR_SOURCE_COLOR_BGR
+    GSR_SOURCE_COLOR_BGR,
+    GSR_SOURCE_COLOR_YUYV
 } gsr_source_color;
 
 typedef enum {
@@ -28,55 +28,48 @@ typedef enum {
     GSR_ROT_270
 } gsr_rotation;
 
+typedef enum {
+    GSR_FLIP_NONE       = 0,
+    GSR_FLIP_HORIZONTAL = (1 << 0),
+    GSR_FLIP_VERTICAL   = (1 << 1)
+} gsr_flip;
+
 typedef struct {
     int rotation_matrix;
     int offset;
 } gsr_color_graphics_uniforms;
 
-typedef struct {
-    int rotation_matrix;
-    int source_position;
-    int target_position;
-    int scale;
-} gsr_color_compute_uniforms;
-
 typedef struct {
     gsr_egl *egl;
 
     gsr_destination_color destination_color;
 
     unsigned int destination_textures[2];
+    vec2i destination_textures_size[2];
     int num_destination_textures;
 
     gsr_color_range color_range;
     bool load_external_image_shader;
-    bool force_graphics_shader;
 } gsr_color_conversion_params;
 
 typedef struct {
     gsr_color_conversion_params params;
-    gsr_color_compute_uniforms compute_uniforms[GSR_COLOR_CONVERSION_MAX_COMPUTE_SHADERS];
-    gsr_shader compute_shaders[GSR_COLOR_CONVERSION_MAX_COMPUTE_SHADERS];
 
-    /* These are only loader if compute shaders (of the same type) fail to load */
     gsr_color_graphics_uniforms graphics_uniforms[GSR_COLOR_CONVERSION_MAX_GRAPHICS_SHADERS];
     gsr_shader graphics_shaders[GSR_COLOR_CONVERSION_MAX_GRAPHICS_SHADERS];
 
-    bool compute_shaders_failed_to_load;
-    bool external_compute_shaders_failed_to_load;
-
     unsigned int framebuffers[GSR_COLOR_CONVERSION_MAX_FRAMEBUFFERS];
 
     unsigned int vertex_array_object_id;
     unsigned int vertex_buffer_object_id;
 
-    int max_local_size_dim;
+    bool schedule_clear;
 } gsr_color_conversion;
 
 int gsr_color_conversion_init(gsr_color_conversion *self, const gsr_color_conversion_params *params);
 void gsr_color_conversion_deinit(gsr_color_conversion *self);
 
-void gsr_color_conversion_draw(gsr_color_conversion *self, unsigned int texture_id, vec2i destination_pos, vec2i destination_size, vec2i source_pos, vec2i source_size, vec2i texture_size, gsr_rotation rotation, gsr_source_color source_color, bool external_texture, bool alpha_blending);
+void gsr_color_conversion_draw(gsr_color_conversion *self, unsigned int texture_id, vec2i destination_pos, vec2i destination_size, vec2i source_pos, vec2i source_size, vec2i texture_size, gsr_rotation rotation, gsr_flip flip, gsr_source_color source_color, bool external_texture);
 void gsr_color_conversion_clear(gsr_color_conversion *self);
 void gsr_color_conversion_read_destination_texture(gsr_color_conversion *self, int destination_texture_index, int x, int y, int width, int height, unsigned int color_format, unsigned int data_format, void *pixels);
 

include/damage.h

@@ -9,40 +9,62 @@
 typedef struct _XDisplay Display;
 typedef union _XEvent XEvent;
 
-typedef enum {
-    GSR_DAMAGE_TRACK_NONE,
-    GSR_DAMAGE_TRACK_WINDOW,
-    GSR_DAMAGE_TRACK_MONITOR
-} gsr_damage_track_type;
+#define GSR_DAMAGE_MAX_MONITORS 32
+#define GSR_DAMAGE_MAX_TRACKED_TARGETS 12
+
+typedef struct {
+    int64_t window_id;
+    vec2i window_pos;
+    vec2i window_size;
+    uint64_t damage;
+    int refcount;
+} gsr_damage_window;
+
+typedef struct {
+    char *monitor_name;
+    gsr_monitor *monitor;
+    int refcount;
+} gsr_damage_monitor;
 
 typedef struct {
     gsr_egl *egl;
     Display *display;
     bool track_cursor;
-    gsr_damage_track_type track_type;
 
     int damage_event;
     int damage_error;
-    uint64_t damage;
     bool damaged;
 
+    uint64_t monitor_damage;
+
     int randr_event;
     int randr_error;
 
-    uint64_t window;
-    //vec2i window_pos;
-    vec2i window_size;
+    gsr_cursor *cursor;
+    gsr_monitor monitors[GSR_DAMAGE_MAX_MONITORS];
+    int num_monitors;
 
-    gsr_cursor cursor; /* Relative to |window| */
-    gsr_monitor monitor;
-    char monitor_name[32];
+    gsr_damage_window windows_tracked[GSR_DAMAGE_MAX_TRACKED_TARGETS];
+    int num_windows_tracked;
+
+    gsr_damage_monitor monitors_tracked[GSR_DAMAGE_MAX_TRACKED_TARGETS];
+    int num_monitors_tracked;
+
+    int all_monitors_tracked_refcount;
+    vec2i cursor_pos;
 } gsr_damage;
 
-bool gsr_damage_init(gsr_damage *self, gsr_egl *egl, bool track_cursor);
+bool gsr_damage_init(gsr_damage *self, gsr_egl *egl, gsr_cursor *cursor, bool track_cursor);
 void gsr_damage_deinit(gsr_damage *self);
 
-bool gsr_damage_set_target_window(gsr_damage *self, uint64_t window);
-bool gsr_damage_set_target_monitor(gsr_damage *self, const char *monitor_name);
+/* This is reference counted */
+bool gsr_damage_start_tracking_window(gsr_damage *self, int64_t window);
+void gsr_damage_stop_tracking_window(gsr_damage *self, int64_t window);
+
+/* This is reference counted. If |monitor_name| is NULL then all monitors are tracked */
+bool gsr_damage_start_tracking_monitor(gsr_damage *self, const char *monitor_name);
+void gsr_damage_stop_tracking_monitor(gsr_damage *self, const char *monitor_name);
+
 void gsr_damage_on_event(gsr_damage *self, XEvent *xev);
 void gsr_damage_tick(gsr_damage *self);
 /* Also returns true if damage tracking is not available */

include/egl.h

@@ -118,8 +118,6 @@ typedef void(*__GLXextFuncPtr)(void);
 #define GL_TEXTURE_WRAP_T                       0x2803
 #define GL_TEXTURE_MAG_FILTER                   0x2800
 #define GL_TEXTURE_MIN_FILTER                   0x2801
-#define GL_TEXTURE_WIDTH                        0x1000
-#define GL_TEXTURE_HEIGHT                       0x1001
 #define GL_NEAREST                              0x2600
 #define GL_CLAMP_TO_EDGE                        0x812F
 #define GL_LINEAR                               0x2601
@@ -135,14 +133,12 @@ typedef void(*__GLXextFuncPtr)(void);
 #define GL_SCISSOR_TEST                         0x0C11
 #define GL_PACK_ALIGNMENT                       0x0D05
 #define GL_UNPACK_ALIGNMENT                     0x0CF5
-#define GL_READ_ONLY                            0x88B8
-#define GL_WRITE_ONLY                           0x88B9
-#define GL_READ_WRITE                           0x88BA
-#define GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS  0x90EB
 #define GL_TEXTURE0                             0x84C0
 #define GL_TEXTURE1                             0x84C1
 #define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT      0x00000020
 #define GL_ALL_BARRIER_BITS                     0xFFFFFFFF
+#define GL_PIXEL_UNPACK_BUFFER                  0x88EC
+#define GL_MAP_WRITE_BIT                        0x0002
 
 #define GL_VENDOR                               0x1F00
 #define GL_RENDERER                             0x1F01
@@ -152,7 +148,6 @@ typedef void(*__GLXextFuncPtr)(void);
 #define GL_INFO_LOG_LENGTH                      0x8B84
 #define GL_FRAGMENT_SHADER                      0x8B30
 #define GL_VERTEX_SHADER                        0x8B31
-#define GL_COMPUTE_SHADER                       0x91B9
 #define GL_COMPILE_STATUS                       0x8B81
 #define GL_LINK_STATUS                          0x8B82
 
@@ -260,7 +255,6 @@ struct gsr_egl {
     void (*glTexParameteri)(unsigned int target, unsigned int pname, int param);
     void (*glTexParameteriv)(unsigned int target, unsigned int pname, const int *params);
     void (*glTexParameterfv)(unsigned int target, unsigned int pname, const float *params);
-    void (*glGetTexLevelParameteriv)(unsigned int target, int level, unsigned int pname, int *params);
     void (*glTexImage2D)(unsigned int target, int level, int internalFormat, int width, int height, int border, unsigned int format, unsigned int type, const void *pixels);
     void (*glTexSubImage2D)(unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned format, unsigned type, const void *pixels);
     void (*glTexStorage2D)(unsigned int target, int levels, unsigned int internalformat, int width, int height);
@@ -268,7 +262,7 @@ struct gsr_egl {
     void (*glGenFramebuffers)(int n, unsigned int *framebuffers);
     void (*glBindFramebuffer)(unsigned int target, unsigned int framebuffer);
     void (*glDeleteFramebuffers)(int n, const unsigned int *framebuffers);
-    void (*glDispatchCompute)(unsigned int num_groups_x, unsigned int num_groups_y, unsigned int num_groups_z);
+    /* TODO: Note: this is only available since OpenGL ES 3.1 */
     void (*glMemoryBarrier)(unsigned int barriers);
     void (*glViewport)(int x, int y, int width, int height);
     void (*glFramebufferTexture2D)(unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level);
@@ -313,7 +307,7 @@ struct gsr_egl {
     void (*glScissor)(int x, int y, int width, int height);
     void (*glCreateBuffers)(int n, unsigned int *buffers);
     void (*glReadPixels)(int x, int y, int width, int height, unsigned int format, unsigned int type, void *pixels);
-    void* (*glMapBuffer)(unsigned int target, unsigned int access);
+    void* (*glMapBufferRange)(unsigned int target, intptr_t offset, ssize_t length, unsigned int access);
     unsigned char (*glUnmapBuffer)(unsigned int target);
     void (*glGetIntegerv)(unsigned int pname, int *params);
 };

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/encoder/video/video.h

@@ -15,7 +15,7 @@ struct gsr_video_encoder {
     void (*destroy)(gsr_video_encoder *encoder, AVCodecContext *video_codec_context);
     void (*copy_textures_to_frame)(gsr_video_encoder *encoder, AVFrame *frame, gsr_color_conversion *color_conversion); /* Can be NULL */
     /* |textures| should be able to fit 2 elements */
-    void (*get_textures)(gsr_video_encoder *encoder, unsigned int *textures, int *num_textures, gsr_destination_color *destination_color);
+    void (*get_textures)(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color);
 
     void *priv;
     bool started;
@@ -25,6 +25,6 @@ struct gsr_video_encoder {
 bool gsr_video_encoder_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame);
 void gsr_video_encoder_destroy(gsr_video_encoder *encoder, AVCodecContext *video_codec_context);
 void gsr_video_encoder_copy_textures_to_frame(gsr_video_encoder *encoder, AVFrame *frame, gsr_color_conversion *color_conversion);
-void gsr_video_encoder_get_textures(gsr_video_encoder *encoder, unsigned int *textures, int *num_textures, gsr_destination_color *destination_color);
+void gsr_video_encoder_get_textures(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color);
 
 #endif /* GSR_ENCODER_VIDEO_H */

include/image_writer.h

@@ -10,23 +10,14 @@ typedef enum {
     GSR_IMAGE_FORMAT_PNG
 } gsr_image_format;
 
-typedef enum {
-    GSR_IMAGE_WRITER_SOURCE_OPENGL,
-    GSR_IMAGE_WRITER_SOURCE_MEMORY
-} gsr_image_writer_source;
-
 typedef struct {
-    gsr_image_writer_source source;
     gsr_egl *egl;
     int width;
     int height;
     unsigned int texture;
-    const void *memory; /* Reference */
 } gsr_image_writer;
 
 bool gsr_image_writer_init_opengl(gsr_image_writer *self, gsr_egl *egl, int width, int height);
-/* |memory| is taken as a reference. The data is expected to be in rgba8 format (8 bit rgba) */
-bool gsr_image_writer_init_memory(gsr_image_writer *self, const void *memory, int width, int height);
 void gsr_image_writer_deinit(gsr_image_writer *self);
 
 /* Quality is between 1 and 100 where 100 is the max quality. Quality doesn't apply to lossless formats */

include/pipewire_audio.h

@@ -94,16 +94,12 @@ typedef struct {
     size_t num_requested_links;
     size_t requested_links_capacity_items;
 
-    struct pw_proxy **virtual_sink_proxies;
-    size_t num_virtual_sink_proxies;
-    size_t virtual_sink_proxies_capacity_items;
+    bool running;
 } gsr_pipewire_audio;
 
 bool gsr_pipewire_audio_init(gsr_pipewire_audio *self);
 void gsr_pipewire_audio_deinit(gsr_pipewire_audio *self);
 
-bool gsr_pipewire_audio_create_virtual_sink(gsr_pipewire_audio *self, const char *name);
-
 /*
     This function links audio source outputs from applications that match the name |app_names| to the input
     that matches the name |stream_name_input|.
@@ -138,6 +134,17 @@ bool gsr_pipewire_audio_add_link_from_apps_to_sink(gsr_pipewire_audio *self, con
 */
 bool gsr_pipewire_audio_add_link_from_apps_to_sink_inverted(gsr_pipewire_audio *self, const char **app_names, int num_app_names, const char *sink_name_input);
 
+/*
+    This function links audio source outputs from devices that match the name |source_names| to the input
+    that matches the name |stream_name_input|.
+    If a device or a new device starts outputting audio after this function is called and the device name matches
+    then it will automatically link the audio sources.
+    |source_names| and |stream_name_input| are case-insensitive matches.
+    |source_names| can include "default_output" or "default_input" to use the default output/input
+    and it will automatically switch when the default output/input is changed in system audio settings.
+*/
+bool gsr_pipewire_audio_add_link_from_sources_to_stream(gsr_pipewire_audio *self, const char **source_names, int num_source_names, const char *stream_name_input);
+
 /*
     This function links audio source outputs from devices that match the name |source_names| to the input
     that matches the name |sink_name_input|.

include/pipewire_video.h

@@ -58,6 +58,8 @@ typedef struct {
     uint64_t modifiers;
     bool using_external_image;
     gsr_monitor_rotation rotation;
+    int texture_width;
+    int texture_height;
 } gsr_map_texture_output;
 
 typedef struct {
@@ -77,8 +79,8 @@ typedef struct {
     struct spa_video_info format;
     int server_version_sync;
     bool negotiated;
-    bool renegotiated;
     bool damaged;
+    bool has_modifier;
 
     struct {
         bool visible;
@@ -110,6 +112,7 @@ typedef struct {
 
     bool paused;
     double paused_start_secs;
+    bool streaming;
 
     gsr_monitor_rotation rotation;
 } gsr_pipewire_video;

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/shader.h

@@ -11,7 +11,7 @@ typedef struct {
 } gsr_shader;
 
 /* |vertex_shader| or |fragment_shader| may be NULL */
-int gsr_shader_init(gsr_shader *self, gsr_egl *egl, const char *vertex_shader, const char *fragment_shader, const char *compute_shader);
+int gsr_shader_init(gsr_shader *self, gsr_egl *egl, const char *vertex_shader, const char *fragment_shader);
 void gsr_shader_deinit(gsr_shader *self);
 
 int gsr_shader_bind_attribute_location(gsr_shader *self, const char *attribute, int location);

include/sound.hpp

@@ -61,12 +61,12 @@ typedef enum {
 
 /*
     Get a sound device by name, returning the device into the |device| parameter.
-    |device_name| can be a device name or "default_output" or "default_input".
+    |device_name| can be a device name or "default_output", "default_input" or "" to not connect to any device (used for app audio for example).
     If the device name is "default_output" or "default_input" then it will automatically switch which
     device is records from when the default output/input is changed in the system audio settings.
     Returns 0 on success, or a negative value on failure.
 */
-int sound_device_get_by_name(SoundDevice *device, const char *device_name, const char *description, unsigned int num_channels, unsigned int period_frame_size, AudioFormat audio_format);
+int sound_device_get_by_name(SoundDevice *device, const char *node_name, const char *device_name, const char *description, unsigned int num_channels, unsigned int period_frame_size, AudioFormat audio_format);
 
 void sound_device_close(SoundDevice *device);
 

include/utils.h

@@ -9,12 +9,15 @@
 
 typedef struct AVCodecContext AVCodecContext;
 typedef struct AVFrame AVFrame;
+typedef struct gsr_capture_metadata gsr_capture_metadata;
 
 typedef struct {
     const char *name;
     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 */
@@ -55,7 +58,10 @@ int create_directory_recursive(char *path);
 void setup_dma_buf_attrs(intptr_t *img_attr, uint32_t format, uint32_t width, uint32_t height, const int *fds, const uint32_t *offsets, const uint32_t *pitches, const uint64_t *modifiers, int num_planes, bool use_modifier);
 
 vec2i scale_keep_aspect_ratio(vec2i from, vec2i to);
+vec2i gsr_capture_get_target_position(vec2i output_size, gsr_capture_metadata *capture_metadata);
 
 unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format, int filter);
 
+bool get_nvidia_driver_version(int *major, int *minor);
+
 #endif /* GSR_UTILS_H */

include/window_texture.h

@@ -11,6 +11,8 @@ typedef struct {
     unsigned int texture_id;
     int redirected;
     gsr_egl *egl;
+    unsigned int window_width;
+    unsigned int window_height;
 } WindowTexture;
 
 /* Returns 0 on success */

kms/client/kms_client.c

@@ -378,6 +378,7 @@ int gsr_kms_client_init(gsr_kms_client *self, const char *card_path) {
                 goto err;
             }
         }
+        poll_fd.revents = 0;
     }
     fprintf(stderr, "gsr info: gsr_kms_client_init: server connected\n");
 
@@ -470,6 +471,7 @@ int gsr_kms_client_get_kms(gsr_kms_client *self, gsr_kms_response *response) {
     response->version = 0;
     response->result = KMS_RESULT_FAILED_TO_SEND;
     response->err_msg[0] = '\0';
+    response->num_items = 0;
 
     gsr_kms_request request;
     request.version = GSR_KMS_PROTOCOL_VERSION;

kms/kms_shared.h

@@ -59,8 +59,8 @@ struct gsr_kms_response_item {
     gsr_kms_rotation rotation;
     int x;
     int y;
-    int crtc_w;
-    int crtc_h;
+    int src_w;
+    int src_h;
     struct hdr_output_metadata hdr_metadata;
 };
 

kms/server/kms_server.c

@@ -7,7 +7,6 @@
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
-#include <stdlib.h>
 #include <locale.h>
 
 #include <unistd.h>
@@ -141,21 +140,21 @@ typedef enum {
     PLANE_PROPERTY_Y          = 1 << 1,
     PLANE_PROPERTY_SRC_X      = 1 << 2,
     PLANE_PROPERTY_SRC_Y      = 1 << 3,
-    PLANE_PROPERTY_CRTC_W     = 1 << 4,
-    PLANE_PROPERTY_CRTC_H     = 1 << 5,
+    PLANE_PROPERTY_SRC_W      = 1 << 4,
+    PLANE_PROPERTY_SRC_H      = 1 << 5,
     PLANE_PROPERTY_IS_CURSOR  = 1 << 6,
     PLANE_PROPERTY_IS_PRIMARY = 1 << 7,
     PLANE_PROPERTY_ROTATION   = 1 << 8,
 } plane_property_mask;
 
 /* Returns plane_property_mask */
-static uint32_t plane_get_properties(int drmfd, uint32_t plane_id, int *x, int *y, int *src_x, int *src_y, int *crtc_w, int *crtc_h, gsr_kms_rotation *rotation) {
+static uint32_t plane_get_properties(int drmfd, uint32_t plane_id, int *x, int *y, int *src_x, int *src_y, int *src_w, int *src_h, gsr_kms_rotation *rotation) {
     *x = 0;
     *y = 0;
     *src_x = 0;
     *src_y = 0;
-    *crtc_w = 0;
-    *crtc_h = 0;
+    *src_w = 0;
+    *src_h = 0;
     *rotation = KMS_ROT_0;
 
     plane_property_mask property_mask = 0;
@@ -184,12 +183,12 @@ static uint32_t plane_get_properties(int drmfd, uint32_t plane_id, int *x, int *
         } else if((type & DRM_MODE_PROP_RANGE) && strcmp(prop->name, "SRC_Y") == 0) {
             *src_y = (int)(props->prop_values[i] >> 16);
             property_mask |= PLANE_PROPERTY_SRC_Y;
-        } else if((type & DRM_MODE_PROP_RANGE) && strcmp(prop->name, "CRTC_W") == 0) {
-            *crtc_w = props->prop_values[i];
-            property_mask |= PLANE_PROPERTY_CRTC_W;
-        } else if((type & DRM_MODE_PROP_RANGE) && strcmp(prop->name, "CRTC_H") == 0) {
-            *crtc_h = props->prop_values[i];
-            property_mask |= PLANE_PROPERTY_CRTC_H;
+        } else if((type & DRM_MODE_PROP_RANGE) && strcmp(prop->name, "SRC_W") == 0) {
+            *src_w = (int)(props->prop_values[i] >> 16);
+            property_mask |= PLANE_PROPERTY_SRC_W;
+        } else if((type & DRM_MODE_PROP_RANGE) && strcmp(prop->name, "SRC_H") == 0) {
+            *src_h = (int)(props->prop_values[i] >> 16);
+            property_mask |= PLANE_PROPERTY_SRC_H;
         } else if((type & DRM_MODE_PROP_ENUM) && strcmp(prop->name, "type") == 0) {
             const uint64_t current_enum_value = props->prop_values[i];
             for(int j = 0; j < prop->count_enums; ++j) {
@@ -351,9 +350,9 @@ static int kms_get_fb(gsr_drm *drm, gsr_kms_response *response) {
         // TODO: Check if dimensions have changed by comparing width and height to previous time this was called.
         // TODO: Support other plane formats than rgb (with multiple planes, such as direct YUV420 on wayland).
 
-        int x = 0, y = 0, src_x = 0, src_y = 0, crtc_w = 0, crtc_h = 0;
+        int x = 0, y = 0, src_x = 0, src_y = 0, src_w = 0, src_h = 0;
         gsr_kms_rotation rotation = KMS_ROT_0;
-        const uint32_t property_mask = plane_get_properties(drm->drmfd, plane->plane_id, &x, &y, &src_x, &src_y, &crtc_w, &crtc_h, &rotation);
+        const uint32_t property_mask = plane_get_properties(drm->drmfd, plane->plane_id, &x, &y, &src_x, &src_y, &src_w, &src_h, &rotation);
         if(!(property_mask & PLANE_PROPERTY_IS_PRIMARY) && !(property_mask & PLANE_PROPERTY_IS_CURSOR))
             continue;
 
@@ -392,13 +391,13 @@ static int kms_get_fb(gsr_drm *drm, gsr_kms_response *response) {
         if(property_mask & PLANE_PROPERTY_IS_CURSOR) {
             response->items[item_index].x = x;
             response->items[item_index].y = y;
-            response->items[item_index].crtc_w = 0;
-            response->items[item_index].crtc_h = 0;
+            response->items[item_index].src_w = 0;
+            response->items[item_index].src_h = 0;
         } else {
             response->items[item_index].x = src_x;
             response->items[item_index].y = src_y;
-            response->items[item_index].crtc_w = crtc_w;
-            response->items[item_index].crtc_h = crtc_h;
+            response->items[item_index].src_w = src_w;
+            response->items[item_index].src_h = src_h;
         }
         ++response->num_items;
 

meson.build

@@ -1,4 +1,4 @@
-project('gpu-screen-recorder', ['c', 'cpp'], version : '5.6.8', default_options : ['warning_level=2'])
+project('gpu-screen-recorder', ['c', 'cpp'], version : '5.12.5', default_options : ['warning_level=2'])
 
 add_project_arguments('-Wshadow', language : ['c', 'cpp'])
 if get_option('buildtype') == 'debug'
@@ -14,6 +14,7 @@ src = [
     'src/capture/xcomposite.c',
     'src/capture/ximage.c',
     'src/capture/kms.c',
+    'src/capture/v4l2.c',
     'src/encoder/encoder.c',
     'src/encoder/video/video.c',
     'src/encoder/video/nvenc.c',
@@ -115,6 +116,8 @@ executable('gsr-kms-server', 'kms/server/kms_server.c', dependencies : dependenc
 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.6.8"
+version = "5.12.5"
 platforms = ["posix"]
 
 [config]

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

@@ -187,246 +187,33 @@ static double args_get_double_by_key(Arg *args, int num_args, const char *key, d
     }
 }
 
-static void usage_header() {
+static void usage_header(void) {
     const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
     const char *program_name = inside_flatpak ? "flatpak run --command=gpu-screen-recorder com.dec05eba.gpu_screen_recorder" : "gpu-screen-recorder";
-    printf("usage: %s -w <window_id|monitor|focused|portal|region> [-c <container_format>] [-s WxH] [-region WxH+X+Y] [-f <fps>] [-a <audio_input>] "
+    printf("usage: %s -w <window_id|monitor|focused|portal|region|v4l2_device_path> [-c <container_format>] [-s WxH] [-region WxH+X+Y] [-f <fps>] [-a <audio_input>] "
            "[-q <quality>] [-r <replay_buffer_size_sec>] [-replay-storage ram|disk] [-restart-replay-on-save yes|no] "
            "[-k h264|hevc|av1|vp8|vp9|hevc_hdr|av1_hdr|hevc_10bit|av1_10bit] [-ac aac|opus|flac] [-ab <bitrate>] [-oc yes|no] [-fm cfr|vfr|content] "
            "[-bm auto|qp|vbr|cbr] [-cr limited|full] [-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] "
-           "[-o <output_file>] [-ro <output_directory>] [--list-capture-options [card_path]] [--list-audio-devices] [--list-application-audio] "
+           "[-fallback-cpu-encoding yes|no] [-o <output_file>] [-ro <output_directory>] [-ffmpeg-opts <options>] [--list-capture-options [card_path]] "
+           "[--list-monitors] [--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);
 }
 
-static void usage_full() {
+static void usage_full(void) {
     const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
-    const char *program_name = inside_flatpak ? "flatpak run --command=gpu-screen-recorder com.dec05eba.gpu_screen_recorder" : "gpu-screen-recorder";
     usage_header();
     printf("\n");
-    printf("OPTIONS:\n");
-    printf("  -w    Window id to record, a display (monitor name), \"screen\", \"screen-direct\", \"focused\", \"portal\" or \"region\".\n");
-    printf("        If this is \"portal\" then xdg desktop screencast portal with PipeWire will be used. Portal option is only available on Wayland.\n");
-    printf("        If you select to save the session (token) in the desktop portal capture popup then the session will be saved for the next time you use \"portal\",\n");
-    printf("        but the session will be ignored unless you run GPU Screen Recorder with the '-restore-portal-session yes' option.\n");
-    printf("        If this is \"region\" then the region specified by the -region option is recorded.\n");
-    printf("        If this is \"screen\" then the first monitor found is recorded.\n");
-    printf("        \"screen-direct\" can only be used on Nvidia X11, to allow recording without breaking VRR (G-SYNC). This also records all of your monitors.\n");
-    printf("        Using this \"screen-direct\" option is not recommended unless you use VRR (G-SYNC) as there are Nvidia driver issues that can cause your system or games to freeze/crash.\n");
-    printf("        The \"screen-direct\" option is not needed on AMD, Intel nor Nvidia on Wayland as VRR works properly in those cases.\n");
-    printf("        Run GPU Screen Recorder with the --list-capture-options option to list valid values for this option.\n");
-    printf("\n");
-    printf("  -c    Container format for output file, for example mp4, or flv. Only required if no output file is specified or if recording in replay buffer mode.\n");
-    printf("        If an output file is specified and -c is not used then the container format is determined from the output filename extension.\n");
-    printf("        Only containers that support h264, hevc, av1, vp8 or vp9 are supported, which means that only mp4, mkv, flv, webm (and some others) are supported.\n");
-    printf("\n");
-    printf("  -s    The output resolution limit of the video in the format WxH, for example 1920x1080. If this is 0x0 then the original resolution is used. Optional, except when -w is \"focused\".\n");
-    printf("        Note: the captured content is scaled to this size. The output resolution might not be exactly as specified by this option. The original aspect ratio is respected so the resolution will match that.\n");
-    printf("        The video encoder might also need to add padding, which will result in black bars on the sides of the video. This is especially an issue on AMD.\n");
-    printf("\n");
-    printf("  -region\n");
-    printf("        The region to capture, only to be used with -w region. This is in format WxH+X+Y, which is compatible with tools such as slop (X11) and slurp (kde plasma, wlroots and hyprland).\n");
-    printf("        The region can be inside any monitor. If width and height are 0 (for example 0x0+500+500) then the entire monitor that the region is inside in will be recorded.\n");
-    printf("        Note: currently the region can't span multiple monitors.\n");
-    printf("\n");
-    printf("  -f    Frame rate to record at. Recording will only capture frames at this target frame rate.\n");
-    printf("        For constant frame rate mode this option is the frame rate every frame will be captured at and if the capture frame rate is below this target frame rate then the frames will be duplicated.\n");
-    printf("        For variable frame rate mode this option is the max frame rate and if the capture frame rate is below this target frame rate then frames will not be duplicated.\n");
-    printf("        Content frame rate is similar to variable frame rate mode, except the frame rate will match the frame rate of the captured content when possible, but not capturing above the frame rate set in this -f option.\n");
-    printf("        Optional, set to 60 by default.\n");
-    printf("\n");
-    printf("  -a    Audio device or application to record from (pulse audio device). Can be specified multiple times. Each time this is specified a new audio track is added for the specified audio device or application.\n");
-    printf("        The audio device can also be \"default_output\" in which case the default output device is used, or \"default_input\" in which case the default input device is used.\n");
-    printf("        Multiple audio sources can be merged into one audio track by using \"|\" as a separator into one -a argument, for example: -a \"default_output|default_input\".\n");
-    printf("        The audio name can also be prefixed with \"device:\", for example: -a \"device:default_output\".\n");
-    printf("        To record audio from an application then prefix the audio name with \"app:\", for example: -a \"app:Brave\". The application name is case-insensitive.\n");
-    printf("        To record audio from all applications except the provided ones prefix the audio name with \"app-inverse:\", for example: -a \"app-inverse:Brave\".\n");
-    printf("        \"app:\" and \"app-inverse:\" can't be mixed in one audio track.\n");
-    printf("        One audio track can contain both audio devices and application audio, for example: -a \"default_output|device:alsa_output.pci-0000_00_1b.0.analog-stereo.monitor|app:Brave\".\n");
-    printf("        Recording application audio is only possible when the sound server on the system is PipeWire.\n");
-    printf("        If the audio name is an empty string then the argument is ignored.\n");
-    printf("        Optional, no audio track is added by default.\n");
-    printf("        Run GPU Screen Recorder with the --list-audio-devices option to list valid audio device names.\n");
-    printf("        Run GPU Screen Recorder with the --list-application-audio option to list valid application names. It's possible to use an application name that is not listed in --list-application-audio,\n");
-    printf("        for example when trying to record audio from an application that hasn't started yet.\n");
-    printf("\n");
-    printf("  -q    Video quality. Should be either 'medium', 'high', 'very_high' or 'ultra' when using '-bm qp' or '-bm vbr' options, and '-bm qp' is the default option used.\n");
-    printf("        'high' is the recommended option when live streaming or when you have a slower harddrive.\n");
-    printf("        When using '-bm cbr' option then this is option is instead used to specify the video bitrate in kbps.\n");
-    printf("        Optional when using '-bm qp' or '-bm vbr' options, set to 'very_high' be default.\n");
-    printf("        Required when using '-bm cbr' option.\n");
-    printf("\n");
-    printf("  -r    Replay buffer time in seconds. If this is set, then only the last seconds as set by this option will be stored\n");
-    printf("        and the video will only be saved when the gpu-screen-recorder is closed. This feature is similar to Nvidia's instant replay feature This option has be between 2 and 86400.\n");
-    printf("        Note that the video data is stored in RAM (unless -replay-storage disk is used), so don't use too long replay buffer time and use constant bitrate option (-bm cbr) to prevent RAM usage from going too high in busy scenes.\n");
-    printf("        Optional, disabled by default.\n");
-    printf("\n");
-    printf("  -replay-storage\n");
-    printf("        Specify where temporary replay is stored. Should be either 'ram' or 'disk'. If set to 'disk' then replay data is stored in temporary files in the same directory as -o.\n");
-    printf("        Preferably avoid setting this to 'disk' unless -o is set to a HDD, as constant writes to a SSD can reduce the life-time of the SSD.\n");
-    printf("        Optional, set to 'ram' by default.\n");
-    printf("\n");
-    printf("  -restart-replay-on-save\n");
-    printf("        Restart replay on save. For example if this is set to 'no' and replay time (-r) is set to 60 seconds and a replay is saved once then the first replay video is 60 seconds long\n");
-    printf("        and if a replay is saved 10 seconds later then the second replay video will also be 60 seconds long and contain 50 seconds of the previous video as well.\n");
-    printf("        If this is set to 'yes' then after a replay is saved the replay buffer data is cleared and the second replay will start from that point onward.\n");
-    printf("        The replay is only restarted when saving a full replay (SIGUSR1 signal)\n");
-    printf("        Optional, set to 'no' by default.\n");
-    printf("\n");
-    printf("  -k    Video codec to use. Should be either 'auto', 'h264', 'hevc', 'av1', 'vp8', 'vp9', 'hevc_hdr', 'av1_hdr', 'hevc_10bit' or 'av1_10bit'.\n");
-    printf("        Optional, set to 'auto' by default which defaults to 'h264'. Forcefully set to 'h264' if the file container type is 'flv'.\n");
-    printf("        'hevc_hdr' and 'av1_hdr' option is not available on X11 nor when using the portal capture option.\n");
-    printf("        'hevc_10bit' and 'av1_10bit' options allow you to select 10 bit color depth which can reduce banding and improve quality in darker areas, but not all video players support 10 bit color depth\n");
-    printf("        and if you upload the video to a website the website might reduce 10 bit to 8 bit.\n");
-    printf("        Note that when using 'hevc_hdr' or 'av1_hdr' the color depth is also 10 bits.\n");
-    printf("\n");
-    printf("  -ac   Audio codec to use. Should be either 'aac', 'opus' or 'flac'. Optional, set to 'opus' for .mp4/.mkv files, otherwise set to 'aac'.\n");
-    printf("        'opus' and 'flac' is only supported by .mp4/.mkv files. 'opus' is recommended for best performance and smallest audio size.\n");
-    printf("        Flac audio codec is option is disable at the moment because of a temporary issue.\n");
-    printf("\n");
-    printf("  -ab   Audio bitrate in kbps. If this is set to 0 then it's the same as if it's absent, in which case the bitrate is determined automatically depending on the audio codec.\n");
-    printf("        Optional, by default the bitrate is 128kbps for opus and flac and 160kbps for aac.\n");
-    printf("\n");
-    printf("  -oc   Overclock memory transfer rate to the maximum performance level. This only applies to NVIDIA on X11 and exists to overcome a bug in NVIDIA driver where performance level\n");
-    printf("        is dropped when you record a game. Only needed if you are recording a game that is bottlenecked by GPU. The same issue exists on Wayland but overclocking is not possible on Wayland.\n");
-    printf("        Works only if your have \"Coolbits\" set to \"12\" in NVIDIA X settings, see README for more information. Note! use at your own risk! Optional, disabled by default.\n");
-    printf("\n");
-    printf("  -fm   Framerate mode. Should be either 'cfr' (constant frame rate), 'vfr' (variable frame rate) or 'content'. Optional, set to 'vfr' by default.\n");
-    printf("        'vfr' is recommended for recording for less issue with very high system load but some applications such as video editors may not support it properly.\n");
-    printf("        'content' is currently only supported on X11 or when using portal capture option. The 'content' option matches the recording frame rate to the captured content.\n");
-    printf("\n");
-    printf("  -bm   Bitrate mode. Should be either 'auto', 'qp' (constant quality), 'vbr' (variable bitrate) or 'cbr' (constant bitrate). Optional, set to 'auto' by default which defaults to 'qp' on all devices\n");
-    printf("        except steam deck that has broken drivers and doesn't support qp.\n");
-    printf("        Note: 'vbr' option is not supported when using '-encoder cpu' option.\n");
-    printf("\n");
-    printf("  -cr   Color range. Should be either 'limited' (aka mpeg) or 'full' (aka jpeg). Optional, set to 'limited' by default.\n");
-    printf("        Limited color range means that colors are in range 16-235 (4112-60395 for hdr) while full color range means that colors are in range 0-255 (0-65535 for hdr).\n");
-    printf("        Note that some buggy video players (such as vlc) are unable to correctly display videos in full color range and when upload the video to websites the website\n");
-    printf("        might re-encoder the video to make the video limited color range.\n");
-    printf("\n");
-    printf("  -tune\n");
-    printf("        Tune for performance or quality. Should be either 'performance' or 'quality'. At the moment this option only has an effect on Nvidia where setting this to quality\n");
-    printf("        sets options such as preset, multipass and b frames. Optional, set to 'performance' by default.\n");
-    printf("\n");
-    printf("  -df   Organise replays in folders based on the current date.\n");
-    printf("\n");
-    printf("  -sc   Run a script on the saved video file (asynchronously). The first argument to the script is the filepath to the saved video/screenshot file and the second argument is the recording type (either \"regular\", \"replay\" or \"screenshot\").\n");
-    printf("        Not applicable for live streams.\n");
-    printf("        Note: the script has to be executable.\n");
-    printf("\n");
-    printf("  -p    A plugin (.so) to load. This can be specified multiple times to load multiple plugins.\n");
-    printf("\n");
-    printf("  -cursor\n");
-    printf("        Record cursor. Optional, set to 'yes' by default.\n");
-    printf("\n");
-    printf("  -keyint\n");
-    printf("        Specifies the keyframe interval in seconds, the max amount of time to wait to generate a keyframe. Keyframes can be generated more often than this.\n");
-    printf("        This also affects seeking in the video and may affect how the replay video is cut. If this is set to 10 for example then you can only seek in 10-second chunks in the video.\n");
-    printf("        Setting this to a higher value reduces the video file size if you are ok with the previously described downside. This option is expected to be a floating point number.\n");
-    printf("        By default this value is set to 2.0.\n");
-    printf("\n");
-    printf("  -restore-portal-session\n");
-    printf("        If GPU Screen Recorder should use the same capture option as the last time. Using this option removes the popup asking what you want to record the next time you record with '-w portal'\n");
-    printf("        if you selected the option to save session (token) in the desktop portal screencast popup.\n");
-    printf("        This option may not have any effect on your Wayland compositor and your systems desktop portal needs to support ScreenCast version 5 or later. Optional, set to 'no' by default.\n");
-    printf("\n");
-    printf("  -portal-session-token-filepath\n");
-    printf("        This option is used together with -restore-portal-session option to specify the file path to save/restore the portal session token to/from.\n");
-    printf("        This can be used to remember different portal capture options depending on different recording option (such as recording/replay).\n");
-    printf("        Optional, set to \"$XDG_CONFIG_HOME/gpu-screen-recorder/restore_token\" by default ($XDG_CONFIG_HOME defaults to \"$HOME/.config\").\n");
-    printf("        Note: the directory to the portal session token file is created automatically if it doesn't exist.\n");
-    printf("\n");
-    printf("  -encoder\n");
-    printf("        Which device should be used for video encoding. Should either be 'gpu' or 'cpu'. 'cpu' option currently only work with h264 codec option (-k).\n");
-    printf("        Optional, set to 'gpu' by default.\n");
-    printf("\n");
-    printf("  --info\n");
-    printf("        List info about the system. Lists the following information (prints them to stdout and exits):\n");
-    printf("        Supported video codecs (h264, h264_software, hevc, hevc_hdr, hevc_10bit, av1, av1_hdr, av1_10bit, vp8, vp9) and image codecs (jpeg, png) (if supported).\n");
-    printf("        Supported capture options (window, focused, screen, monitors and portal, if supported by the system).\n");
-    printf("        If opengl initialization fails then the program exits with 22, if no usable drm device is found then it exits with 23. On success it exits with 0.\n");
-    printf("\n");
-    printf("  --list-capture-options\n");
-    printf("        List available capture options. Lists capture options in the following format (prints them to stdout and exits):\n");
-    printf("          <option>\n");
-    printf("          <monitor_name>|<resolution>\n");
-    printf("        For example:\n");
-    printf("          window\n");
-    printf("          DP-1|1920x1080\n");
-    printf("        The <option> and <monitor_name> is the name that can be passed to GPU Screen Recorder with the -w option.\n");
-    printf("        --list-capture-options optionally accepts a card path (\"/dev/dri/cardN\") which can improve the performance of running this command.\n");
-    printf("\n");
-    printf("  --list-audio-devices\n");
-    printf("        List audio devices. Lists audio devices in the following format (prints them to stdout and exits):\n");
-    printf("          <audio_device_name>|<audio_device_name_in_human_readable_format>\n");
-    printf("        For example:\n");
-    printf("          bluez_input.88:C9:E8:66:A2:27|WH-1000XM4\n");
-    printf("          alsa_output.pci-0000_0c_00.4.iec958-stereo|Monitor of Starship/Matisse HD Audio Controller Digital Stereo (IEC958)\n");
-    printf("        The <audio_device_name> is the name that can be passed to GPU Screen Recorder with the -a option.\n");
-    printf("\n");
-    printf("  --list-application-audio\n");
-    printf("        Lists applications that you can record from (prints them to stdout and exits), for example:\n");
-    printf("          firefox\n");
-    printf("          csgo\n");
-    printf("        These names are the application audio names that can be passed to GPU Screen Recorder with the -a option.\n");
-    printf("\n");
-    printf("  --version\n");
-    printf("        Print version (%s) and exit\n", GSR_VERSION);
-    printf("\n");
-    //fprintf(stderr, "  -pixfmt  The pixel format to use for the output video. yuv420 is the most common format and is best supported, but the color is compressed, so colors can look washed out and certain colors of text can look bad. Use yuv444 for no color compression, but the video may not work everywhere and it may not work with hardware video decoding. Optional, set to 'yuv420' by default\n");
-    printf("  -o    The output file path. If omitted then the encoded data is sent to stdout. Required in replay mode (when using -r).\n");
-    printf("        In replay mode this has to be a directory instead of a file.\n");
-    printf("        Note: the directory to the file is created automatically if it doesn't already exist.\n");
-    printf("\n");
-    printf("  -ro   The output directory for regular recordings in replay/streaming mode. Required to start recording in replay/streaming mode.\n");
-    printf("        Note: the directory to the file is created automatically if it doesn't already exist.\n");
-    printf("\n");
-    printf("  -v    Prints fps and damage info once per second. Optional, set to 'yes' by default.\n");
-    printf("\n");
-    printf("  -gl-debug\n");
-    printf("        Print opengl debug output. Optional, set to 'no' by default.\n");
-    printf("\n");
-    printf("  -h, --help\n");
-    printf("        Show this help.\n");
-    printf("\n");
     printf("NOTES:\n");
-    printf("  Send signal SIGINT to gpu-screen-recorder (Ctrl+C, or pkill -SIGINT -f gpu-screen-recorder) to stop and save the recording. When in replay mode this stops recording without saving.\n");
-    printf("  Send signal SIGUSR2 to gpu-screen-recorder (pkill -SIGUSR2 -f gpu-screen-recorder) to pause/unpause recording. Only applicable when recording (not streaming nor replay).\n");
-    printf("  Send signal SIGUSR1 to gpu-screen-recorder (pkill -SIGUSR1 -f gpu-screen-recorder) to save a replay (when in replay mode).\n");
-    printf("  Send signal SIGRTMIN+1 to gpu-screen-recorder (pkill -SIGRTMIN+1 -f gpu-screen-recorder) to save a replay of the last 10 seconds (when in replay mode).\n");
-    printf("  Send signal SIGRTMIN+2 to gpu-screen-recorder (pkill -SIGRTMIN+2 -f gpu-screen-recorder) to save a replay of the last 30 seconds (when in replay mode).\n");
-    printf("  Send signal SIGRTMIN+3 to gpu-screen-recorder (pkill -SIGRTMIN+3 -f gpu-screen-recorder) to save a replay of the last 60 seconds (when in replay mode).\n");
-    printf("  Send signal SIGRTMIN+4 to gpu-screen-recorder (pkill -SIGRTMIN+4 -f gpu-screen-recorder) to save a replay of the last 5 minutes (when in replay mode).\n");
-    printf("  Send signal SIGRTMIN+5 to gpu-screen-recorder (pkill -SIGRTMIN+5 -f gpu-screen-recorder) to save a replay of the last 10 minutes (when in replay mode).\n");
-    printf("  Send signal SIGRTMIN+6 to gpu-screen-recorder (pkill -SIGRTMIN+6 -f gpu-screen-recorder) to save a replay of the last 30 minutes (when in replay mode).\n");
-    printf("  Send signal SIGRTMIN to gpu-screen-recorder (pkill -SIGRTMIN -f gpu-screen-recorder) to start/stop recording a regular video when in replay/streaming mode.\n");
-    printf("\n");
-    printf("EXAMPLES:\n");
-    printf("  %s -w screen -o video.mp4\n", program_name);
-    printf("  %s -w screen -f 60 -a default_output -o video.mp4\n", program_name);
-    printf("  %s -w screen -f 60 -a default_output -a default_input -o video.mp4\n", program_name);
-    printf("  %s -w $(xdotool selectwindow) -f 60 -a default_output -o video.mp4\n", program_name);
-    printf("  %s -w screen -f 60 -a \"default_output|default_input\" -o video.mp4\n", program_name);
-    printf("  %s -w screen -f 60 -a default_output -c mkv -r 60 -o \"$HOME/Videos\"\n", program_name);
-    printf("  %s -w screen -f 60 -a default_output -c mkv -r 1800 -replay-storage disk -bm cbr -q 40000 -o \"$HOME/Videos\"\n", program_name);
-    printf("  %s -w screen -f 60 -a default_output -c mkv -sc ./script.sh -r 60 -o \"$HOME/Videos\"\n", program_name);
-    printf("  %s -w portal -f 60 -a default_output -restore-portal-session yes -o video.mp4\n", program_name);
-    printf("  %s -w screen -f 60 -a default_output -bm cbr -q 15000 -o video.mp4\n", program_name);
-    printf("  %s -w screen -f 60 -a \"app:firefox|app:csgo\" -o video.mp4\n", program_name);
-    printf("  %s -w screen -f 60 -a \"app-inverse:firefox|app-inverse:csgo\" -o video.mp4\n", program_name);
-    printf("  %s -w screen -f 60 -a \"default_input|app-inverse:Brave\" -o video.mp4\n", program_name);
-    printf("  %s -w screen -o image.jpg\n", program_name);
-    printf("  %s -w screen -q medium -o image.jpg\n", program_name);
-    printf("  %s -w region -region 640x480+100+100 -o video.mp4\n", program_name);
-    printf("  %s -w region -region $(slop) -o video.mp4\n", program_name);
-    printf("  %s -w region -region $(slurp -f \"%%wx%%h+%%x+%%y\") -o video.mp4\n", program_name);
-    printf("  %s -w screen -p ./plugin.so -o video.mp4\n", program_name);
-    //fprintf(stderr, "  gpu-screen-recorder -w screen -f 60 -q ultra -pixfmt yuv444 -o video.mp4\n");
+    if(inside_flatpak)
+        printf("  Run \"man /var/lib/flatpak/app/com.dec05eba.gpu_screen_recorder/current/active/files/share/man/man1/gpu-screen-recorder.1\" to open the man page for GPU Screen Recorder to see an explanation for each option and examples\n");
+    else
+        printf("  Run \"man gpu-screen-recorder.1\" to open the man page for GPU Screen Recorder to see an explanation for each option and examples\n");
     fflush(stdout);
 }
 
-static void usage() {
+static void usage(void) {
     usage_header();
 }
 
@@ -460,8 +247,7 @@ static bool args_parser_set_values(args_parser *self) {
     self->bitrate_mode = (gsr_bitrate_mode)args_get_enum_by_key(self->args, NUM_ARGS, "-bm", GSR_BITRATE_MODE_AUTO);
     self->replay_storage = (gsr_replay_storage)args_get_enum_by_key(self->args, NUM_ARGS, "-replay-storage", GSR_REPLAY_STORAGE_RAM);
 
-    const char *window = args_get_value_by_key(self->args, NUM_ARGS, "-w");
-    snprintf(self->window, sizeof(self->window), "%s", window);
+    self->capture_source = args_get_value_by_key(self->args, NUM_ARGS, "-w");
     self->verbose = args_get_boolean_by_key(self->args, NUM_ARGS, "-v", true);
     self->gl_debug = args_get_boolean_by_key(self->args, NUM_ARGS, "-gl-debug", false);
     self->record_cursor = args_get_boolean_by_key(self->args, NUM_ARGS, "-cursor", true);
@@ -469,6 +255,9 @@ static bool args_parser_set_values(args_parser *self) {
     self->restore_portal_session = args_get_boolean_by_key(self->args, NUM_ARGS, "-restore-portal-session", false);
     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;
@@ -548,14 +337,9 @@ static bool args_parser_set_values(args_parser *self) {
         }
     }
 
-    const char *output_resolution_str = args_get_value_by_key(self->args, NUM_ARGS, "-s");
-    if(!output_resolution_str && strcmp(self->window, "focused") == 0) {
-        fprintf(stderr, "gsr error: option -s is required when using '-w focused' option\n");
-        usage();
-        return false;
-    }
-
     self->output_resolution = (vec2i){0, 0};
+
+    const char *output_resolution_str = args_get_value_by_key(self->args, NUM_ARGS, "-s");
     if(output_resolution_str) {
         if(sscanf(output_resolution_str, "%dx%d", &self->output_resolution.x, &self->output_resolution.y) != 2) {
             fprintf(stderr, "gsr error: invalid value for option -s '%s', expected a value in format WxH\n", output_resolution_str);
@@ -574,26 +358,14 @@ static bool args_parser_set_values(args_parser *self) {
     self->region_position = (vec2i){0, 0};
     const char *region_str = args_get_value_by_key(self->args, NUM_ARGS, "-region");
     if(region_str) {
-        if(strcmp(self->window, "region") != 0) {
-            fprintf(stderr, "gsr error: option -region can only be used when option '-w region' is used\n");
-            usage();
-            return false;
-        }
-
         if(sscanf(region_str, "%dx%d+%d+%d", &self->region_size.x, &self->region_size.y, &self->region_position.x, &self->region_position.y) != 4) {
             fprintf(stderr, "gsr error: invalid value for option -region '%s', expected a value in format WxH+X+Y\n", region_str);
             usage();
             return false;
         }
 
-        if(self->region_size.x < 0 || self->region_size.y < 0 || self->region_position.x < 0 || self->region_position.y < 0) {
-            fprintf(stderr, "gsr error: invalid value for option -region '%s', expected width, height, x and y to be greater or equal to 0\n", region_str);
-            usage();
-            return false;
-        }
-    } else {
-        if(strcmp(self->window, "region") == 0) {
-            fprintf(stderr, "gsr error: option -region is required when '-w region' is used\n");
+        if(self->region_size.x < 0 || self->region_size.y < 0) {
+            fprintf(stderr, "gsr error: invalid value for option -region '%s', expected width and height to be greater or equal to 0\n", region_str);
             usage();
             return false;
         }
@@ -662,18 +434,22 @@ 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");
 
-    const bool is_portal_capture = strcmp(self->window, "portal") == 0;
-    if(!self->restore_portal_session && is_portal_capture)
-        fprintf(stderr, "gsr info: option '-w portal' was used without '-restore-portal-session yes'. The previous screencast session will be ignored\n");
-
     if(self->is_livestream && self->recording_saved_script) {
         fprintf(stderr, "gsr warning: live stream detected, -sc script is ignored\n");
         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;
 }
 
@@ -706,6 +482,11 @@ bool args_parser_parse(args_parser *self, int argc, char **argv, const args_hand
         return true;
     }
 
+    if(argc == 2 && strcmp(argv[1], "--list-v4l2-devices") == 0) {
+        arg_handlers->list_v4l2_devices(userdata);
+        return true;
+    }
+
     if(strcmp(argv[1], "--list-capture-options") == 0) {
         if(argc == 2) {
             arg_handlers->list_capture_options(NULL, userdata);
@@ -720,6 +501,11 @@ bool args_parser_parse(args_parser *self, int argc, char **argv, const args_hand
         }
     }
 
+    if(strcmp(argv[1], "--list-monitors") == 0) {
+        arg_handlers->list_monitors(userdata);
+        return true;
+    }
+
     if(argc == 2 && strcmp(argv[1], "--version") == 0) {
         arg_handlers->version(userdata);
         return true;
@@ -755,8 +541,14 @@ bool args_parser_parse(args_parser *self, int argc, char **argv, const args_hand
     self->args[arg_index++] = (Arg){ .key = "-restore-portal-session",        .optional = true,  .list = false, .type = ARG_TYPE_BOOLEAN };
     self->args[arg_index++] = (Arg){ .key = "-portal-session-token-filepath", .optional = true,  .list = false, .type = ARG_TYPE_STRING  };
     self->args[arg_index++] = (Arg){ .key = "-encoder",                       .optional = true,  .list = false, .type = ARG_TYPE_ENUM, .enum_values = video_encoder_enums, .num_enum_values = sizeof(video_encoder_enums)/sizeof(ArgEnum) };
+    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) {
@@ -918,12 +710,6 @@ bool args_parser_validate_with_gl_info(args_parser *self, gsr_egl *egl) {
         return false;
     }
 
-    const bool is_portal_capture = strcmp(self->window, "portal") == 0;
-    if(video_codec_is_hdr(self->video_codec) && is_portal_capture) {
-        fprintf(stderr, "gsr warning: portal capture option doesn't support hdr yet (PipeWire doesn't support hdr), the video will be tonemapped from hdr to sdr\n");
-        self->video_codec = hdr_video_codec_to_sdr_video_codec(self->video_codec);
-    }
-
     return true;
 }
 

src/capture/kms.c

@@ -3,7 +3,6 @@
 #include "../../include/color_conversion.h"
 #include "../../include/cursor.h"
 #include "../../include/window/window.h"
-#include "../../kms/client/kms_client.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -30,15 +29,13 @@ typedef struct {
 
 typedef struct {
     gsr_capture_kms_params params;
-    
-    gsr_kms_client kms_client;
-    gsr_kms_response kms_response;
 
     vec2i capture_pos;
     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;
@@ -51,7 +48,6 @@ typedef struct {
     bool hdr_metadata_set;
 
     bool is_x11;
-    gsr_cursor x11_cursor;
 
     //int drm_fd;
     //uint64_t prev_sequence;
@@ -61,21 +57,12 @@ typedef struct {
     vec2i prev_plane_size;
 
     double last_time_monitor_check;
-} gsr_capture_kms;
 
-static void gsr_capture_kms_cleanup_kms_fds(gsr_capture_kms *self) {
-    for(int i = 0; i < self->kms_response.num_items; ++i) {
-        for(int j = 0; j < self->kms_response.items[i].num_dma_bufs; ++j) {
-            gsr_kms_response_dma_buf *dma_buf = &self->kms_response.items[i].dma_buf[j];
-            if(dma_buf->fd > 0) {
-                close(dma_buf->fd);
-                dma_buf->fd = -1;
-            }
-        }
-        self->kms_response.items[i].num_dma_bufs = 0;
-    }
-    self->kms_response.num_items = 0;
-}
+    bool capture_is_combined_plane;
+    gsr_kms_response_item *drm_fd;
+    vec2i output_size;
+    vec2i target_pos;
+} gsr_capture_kms;
 
 static void gsr_capture_kms_stop(gsr_capture_kms *self) {
     if(self->input_texture_id) {
@@ -97,10 +84,6 @@ static void gsr_capture_kms_stop(gsr_capture_kms *self) {
     //     close(self->drm_fd);
     //     self->drm_fd = -1;
     // }
-
-    gsr_capture_kms_cleanup_kms_fds(self);
-    gsr_kms_client_deinit(&self->kms_client);
-    gsr_cursor_deinit(&self->x11_cursor);
 }
 
 static int max_int(int a, int b) {
@@ -155,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,16 +155,8 @@ static int gsr_capture_kms_start(gsr_capture *cap, gsr_capture_metadata *capture
     gsr_monitor monitor;
     self->monitor_id.num_connector_ids = 0;
 
-    int kms_init_res = gsr_kms_client_init(&self->kms_client, self->params.egl->card_path);
-    if(kms_init_res != 0)
-        return kms_init_res;
-
     self->is_x11 = gsr_window_get_display_server(self->params.egl->window) == GSR_DISPLAY_SERVER_X11;
     const gsr_connection_type connection_type = self->is_x11 ? GSR_CONNECTION_X11 : GSR_CONNECTION_DRM;
-    if(self->is_x11) {
-        Display *display = gsr_window_get_display(self->params.egl->window);
-        gsr_cursor_init(&self->x11_cursor, self->params.egl, display);
-    }
 
     MonitorCallbackUserdata monitor_callback_userdata = {
         &self->monitor_id,
@@ -198,40 +173,28 @@ 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);
-        capture_metadata->width = self->params.output_resolution.x;
-        capture_metadata->height = self->params.output_resolution.y;
+        capture_metadata->video_size = self->params.output_resolution;
     } else if(self->params.region_size.x > 0 && self->params.region_size.y > 0) {
-        capture_metadata->width = self->params.region_size.x;
-        capture_metadata->height = self->params.region_size.y;
+        capture_metadata->video_size = self->params.region_size;
     } else {
-        capture_metadata->width = self->capture_size.x;
-        capture_metadata->height = self->capture_size.y;
+        capture_metadata->video_size = self->capture_size;
     }
 
     self->last_time_monitor_check = clock_get_monotonic_seconds();
     return 0;
 }
 
-static void gsr_capture_kms_on_event(gsr_capture *cap, gsr_egl *egl) {
-    gsr_capture_kms *self = cap->priv;
-    if(!self->is_x11)
-        return;
-
-    XEvent *xev = gsr_window_get_event_data(egl->window);
-    gsr_cursor_on_event(&self->x11_cursor, xev);
-}
-
 // TODO: This is disabled for now because we want to be able to record at a framerate higher than the monitor framerate
 // static void gsr_capture_kms_tick(gsr_capture *cap) {
 //     gsr_capture_kms *self = cap->priv;
@@ -397,14 +360,14 @@ static gsr_kms_response_item* find_monitor_drm(gsr_capture_kms *self, bool *capt
     gsr_kms_response_item *drm_fd = NULL;
 
     for(int i = 0; i < self->monitor_id.num_connector_ids; ++i) {
-        drm_fd = find_drm_by_connector_id(&self->kms_response, self->monitor_id.connector_ids[i]);
+        drm_fd = find_drm_by_connector_id(self->params.kms_response, self->monitor_id.connector_ids[i]);
         if(drm_fd)
             break;
     }
 
     // Will never happen on wayland unless the target monitor has been disconnected
     if(!drm_fd && self->is_x11) {
-        drm_fd = find_largest_drm(&self->kms_response);
+        drm_fd = find_largest_drm(self->params.kms_response);
         *capture_is_combined_plane = true;
     }
 
@@ -412,7 +375,7 @@ static gsr_kms_response_item* find_monitor_drm(gsr_capture_kms *self, bool *capt
 }
 
 static gsr_kms_response_item* find_cursor_drm_if_on_monitor(gsr_capture_kms *self, uint32_t monitor_connector_id, bool capture_is_combined_plane) {
-    gsr_kms_response_item *cursor_drm_fd = find_cursor_drm(&self->kms_response, monitor_connector_id);
+    gsr_kms_response_item *cursor_drm_fd = find_cursor_drm(self->params.kms_response, monitor_connector_id);
     if(!capture_is_combined_plane && cursor_drm_fd && cursor_drm_fd->connector_id != monitor_connector_id)
         cursor_drm_fd = NULL;
     return cursor_drm_fd;
@@ -431,7 +394,7 @@ static gsr_monitor_rotation sub_rotations(gsr_monitor_rotation rot1, gsr_monitor
     return remainder_int(rot1 - rot2, 4);
 }
 
-static void render_drm_cursor(gsr_capture_kms *self, gsr_color_conversion *color_conversion, const gsr_kms_response_item *cursor_drm_fd, vec2i target_pos, vec2i output_size, vec2i framebuffer_size) {
+static void render_drm_cursor(gsr_capture_kms *self, gsr_color_conversion *color_conversion, gsr_capture_metadata *capture_metadata, const gsr_kms_response_item *cursor_drm_fd, vec2i target_pos, vec2i output_size, vec2i framebuffer_size) {
     const vec2d scale = {
         self->capture_size.x == 0 ? 0 : (double)output_size.x / (double)self->capture_size.x,
         self->capture_size.y == 0 ? 0 : (double)output_size.y / (double)self->capture_size.y
@@ -441,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) {
@@ -508,13 +471,13 @@ static void render_drm_cursor(gsr_capture_kms *self, gsr_color_conversion *color
     gsr_color_conversion_draw(color_conversion, self->cursor_texture_id,
         cursor_pos, (vec2i){cursor_size.x * scale.x, cursor_size.y * scale.y},
         (vec2i){0, 0}, cursor_size, cursor_size,
-        gsr_monitor_rotation_to_rotation(rotation), GSR_SOURCE_COLOR_RGB, cursor_texture_id_is_external, true);
+        gsr_monitor_rotation_to_rotation(rotation), capture_metadata->flip, GSR_SOURCE_COLOR_RGB, cursor_texture_id_is_external);
 
     self->params.egl->glDisable(GL_SCISSOR_TEST);
 }
 
-static void render_x11_cursor(gsr_capture_kms *self, gsr_color_conversion *color_conversion, vec2i capture_pos, vec2i target_pos, vec2i output_size) {
-    if(!self->x11_cursor.visible)
+static void render_x11_cursor(gsr_capture_kms *self, gsr_color_conversion *color_conversion, gsr_capture_metadata *capture_metadata, vec2i capture_pos, vec2i target_pos, vec2i output_size) {
+    if(!self->params.x11_cursor->visible)
         return;
 
     const vec2d scale = {
@@ -522,30 +485,27 @@ static void render_x11_cursor(gsr_capture_kms *self, gsr_color_conversion *color
         self->capture_size.y == 0 ? 0 : (double)output_size.y / (double)self->capture_size.y
     };
 
-    Display *display = gsr_window_get_display(self->params.egl->window);
-    gsr_cursor_tick(&self->x11_cursor, DefaultRootWindow(display));
-
     const vec2i cursor_pos = {
-        target_pos.x + (self->x11_cursor.position.x - self->x11_cursor.hotspot.x - capture_pos.x) * scale.x,
-        target_pos.y + (self->x11_cursor.position.y - self->x11_cursor.hotspot.y - capture_pos.y) * scale.y
+        target_pos.x + (self->params.x11_cursor->position.x - self->params.x11_cursor->hotspot.x - capture_pos.x) * scale.x,
+        target_pos.y + (self->params.x11_cursor->position.y - self->params.x11_cursor->hotspot.y - capture_pos.y) * scale.y
     };
 
     self->params.egl->glEnable(GL_SCISSOR_TEST);
     self->params.egl->glScissor(target_pos.x, target_pos.y, output_size.x, output_size.y);
 
-    gsr_color_conversion_draw(color_conversion, self->x11_cursor.texture_id,
-        cursor_pos, (vec2i){self->x11_cursor.size.x * scale.x, self->x11_cursor.size.y * scale.y},
-        (vec2i){0, 0}, self->x11_cursor.size, self->x11_cursor.size,
-        GSR_ROT_0, GSR_SOURCE_COLOR_RGB, false, true);
+    gsr_color_conversion_draw(color_conversion, self->params.x11_cursor->texture_id,
+        cursor_pos, (vec2i){self->params.x11_cursor->size.x * scale.x, self->params.x11_cursor->size.y * scale.y},
+        (vec2i){0, 0}, self->params.x11_cursor->size, self->params.x11_cursor->size,
+        GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false);
 
     self->params.egl->glDisable(GL_SCISSOR_TEST);
 }
 
 static void gsr_capture_kms_update_capture_size_change(gsr_capture_kms *self, gsr_color_conversion *color_conversion, vec2i target_pos, const gsr_kms_response_item *drm_fd) {
-    if(target_pos.x != self->prev_target_pos.x || target_pos.y != self->prev_target_pos.y || drm_fd->crtc_w != self->prev_plane_size.x || drm_fd->crtc_h != self->prev_plane_size.y) {
+    if(target_pos.x != self->prev_target_pos.x || target_pos.y != self->prev_target_pos.y || drm_fd->src_w != self->prev_plane_size.x || drm_fd->src_h != self->prev_plane_size.y) {
         self->prev_target_pos = target_pos;
         self->prev_plane_size = self->capture_size;
-        gsr_color_conversion_clear(color_conversion);
+        color_conversion->schedule_clear = true;
     }
 }
 
@@ -580,62 +540,60 @@ 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 int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
+static void gsr_capture_kms_pre_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
     gsr_capture_kms *self = cap->priv;
 
-    gsr_capture_kms_cleanup_kms_fds(self);
-
-    if(gsr_kms_client_get_kms(&self->kms_client, &self->kms_response) != 0) {
-        fprintf(stderr, "gsr error: gsr_capture_kms_capture: failed to get kms, error: %d (%s)\n", self->kms_response.result, self->kms_response.err_msg);
-        return -1;
-    }
-
-    if(self->kms_response.num_items == 0) {
+    if(self->params.kms_response->num_items == 0) {
         static bool error_shown = false;
         if(!error_shown) {
             error_shown = true;
-            fprintf(stderr, "gsr error: no drm found, capture will fail\n");
+            fprintf(stderr, "gsr error: gsr_capture_kms_pre_capture: no drm found, capture will fail\n");
         }
-        return -1;
+        return;
     }
 
     gsr_capture_kms_update_connector_ids(self);
 
-    bool capture_is_combined_plane = false;
-    const gsr_kms_response_item *drm_fd = find_monitor_drm(self, &capture_is_combined_plane);
-    if(!drm_fd) {
-        gsr_capture_kms_cleanup_kms_fds(self);
-        return -1;
-    }
+    self->capture_is_combined_plane = false;
+    self->drm_fd = find_monitor_drm(self, &self->capture_is_combined_plane);
+    if(!self->drm_fd)
+        return;
 
-    if(drm_fd->has_hdr_metadata && self->params.hdr && hdr_metadata_is_supported_format(&drm_fd->hdr_metadata))
-        gsr_kms_set_hdr_metadata(self, drm_fd);
+    if(self->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){ drm_fd->crtc_w, drm_fd->crtc_h });
-    const vec2i original_frame_size = self->capture_size;
+    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;
 
-    const bool is_scaled = self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0;
-    vec2i output_size = is_scaled ? self->params.output_resolution : self->capture_size;
-    output_size = scale_keep_aspect_ratio(self->capture_size, output_size);
+    self->output_size = scale_keep_aspect_ratio(self->capture_size, capture_metadata->recording_size);
+    self->target_pos = gsr_capture_get_target_position(self->output_size, capture_metadata);
+    gsr_capture_kms_update_capture_size_change(self, color_conversion, self->target_pos, self->drm_fd);
+}
 
-    const vec2i target_pos = { max_int(0, capture_metadata->width / 2 - output_size.x / 2), max_int(0, capture_metadata->height / 2 - output_size.y / 2) };
-    gsr_capture_kms_update_capture_size_change(self, color_conversion, target_pos, drm_fd);
+static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
+    (void)capture_metadata;
+    gsr_capture_kms *self = cap->priv;
+
+    if(self->params.kms_response->num_items == 0)
+        return -1;
 
     vec2i capture_pos = self->capture_pos;
-    if(!capture_is_combined_plane)
-        capture_pos = (vec2i){drm_fd->x, drm_fd->y};
+    if(!self->capture_is_combined_plane)
+        capture_pos = (vec2i){self->drm_fd->x, self->drm_fd->y};
 
     capture_pos.x += self->params.region_position.x;
     capture_pos.y += self->params.region_position.y;
@@ -643,22 +601,19 @@ static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *captu
     //self->params.egl->glFlush();
     //self->params.egl->glFinish();
 
-    EGLImage image = gsr_capture_kms_create_egl_image_with_fallback(self, drm_fd);
+    EGLImage image = gsr_capture_kms_create_egl_image_with_fallback(self, self->drm_fd);
     if(image) {
         gsr_capture_kms_bind_image_to_input_texture_with_fallback(self, image);
         self->params.egl->eglDestroyImage(self->params.egl->egl_display, image);
     }
 
-    const gsr_monitor_rotation plane_rotation = kms_rotation_to_gsr_monitor_rotation(drm_fd->rotation);
-    const gsr_monitor_rotation rotation = 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,
-        target_pos, output_size,
-        capture_pos, self->capture_size, original_frame_size,
-        gsr_monitor_rotation_to_rotation(rotation), GSR_SOURCE_COLOR_RGB, self->external_texture_fallback, false);
+        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(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, drm_fd->connector_id, capture_is_combined_plane);
+        gsr_kms_response_item *cursor_drm_fd = find_cursor_drm_if_on_monitor(self, self->drm_fd->connector_id, self->capture_is_combined_plane);
         // The cursor is handled by x11 on x11 instead of using the cursor drm plane because on prime systems with a dedicated nvidia gpu
         // the cursor plane is not available when the cursor is on the monitor controlled by the nvidia device.
         // TODO: This doesn't work properly with software cursor on x11 since it will draw the x11 cursor on top of the cursor already in the framebuffer.
@@ -667,18 +622,16 @@ static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *captu
             vec2i cursor_monitor_offset = self->capture_pos;
             cursor_monitor_offset.x += self->params.region_position.x;
             cursor_monitor_offset.y += self->params.region_position.y;
-            render_x11_cursor(self, color_conversion, cursor_monitor_offset, target_pos, output_size);
+            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){ drm_fd->crtc_w, drm_fd->crtc_h });
-            render_drm_cursor(self, color_conversion, cursor_drm_fd, target_pos, output_size, framebuffer_size);
+            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);
         }
     }
 
     //self->params.egl->glFlush();
     //self->params.egl->glFinish();
 
-    gsr_capture_kms_cleanup_kms_fds(self);
-
     return 0;
 }
 
@@ -770,9 +723,9 @@ gsr_capture* gsr_capture_kms_create(const gsr_capture_kms_params *params) {
     
     *cap = (gsr_capture) {
         .start = gsr_capture_kms_start,
-        .on_event = gsr_capture_kms_on_event,
         //.tick = gsr_capture_kms_tick,
         .should_stop = gsr_capture_kms_should_stop,
+        .pre_capture = gsr_capture_kms_pre_capture,
         .capture = gsr_capture_kms_capture,
         .uses_external_image = gsr_capture_kms_uses_external_image,
         .set_hdr_metadata = gsr_capture_kms_set_hdr_metadata,

src/capture/nvfbc.c

@@ -13,6 +13,7 @@
 #include <assert.h>
 
 #include <X11/Xlib.h>
+#include <X11/extensions/Xrandr.h>
 
 typedef struct {
     gsr_capture_nvfbc_params params;
@@ -55,40 +56,6 @@ static uint32_t get_output_id_from_display_name(NVFBC_RANDR_OUTPUT_INFO *outputs
     return 0;
 }
 
-/* TODO: Test with optimus and open kernel modules */
-static bool get_driver_version(int *major, int *minor) {
-    *major = 0;
-    *minor = 0;
-
-    FILE *f = fopen("/proc/driver/nvidia/version", "rb");
-    if(!f) {
-        fprintf(stderr, "gsr warning: failed to get nvidia driver version (failed to read /proc/driver/nvidia/version)\n");
-        return false;
-    }
-
-    char buffer[2048];
-    size_t bytes_read = fread(buffer, 1, sizeof(buffer) - 1, f);
-    buffer[bytes_read] = '\0';
-
-    bool success = false;
-    const char *p = strstr(buffer, "Kernel Module");
-    if(p) {
-        p += 13;
-        int driver_major_version = 0, driver_minor_version = 0;
-        if(sscanf(p, "%d.%d", &driver_major_version, &driver_minor_version) == 2) {
-            *major = driver_major_version;
-            *minor = driver_minor_version;
-            success = true;
-        }
-    }
-
-    if(!success)
-        fprintf(stderr, "gsr warning: failed to get nvidia driver version\n");
-
-    fclose(f);
-    return success;
-}
-
 static bool version_at_least(int major, int minor, int expected_major, int expected_minor) {
     return major > expected_major || (major == expected_major && minor >= expected_minor);
 }
@@ -288,7 +255,7 @@ static int gsr_capture_nvfbc_start(gsr_capture *cap, gsr_capture_metadata *captu
     self->supports_direct_cursor = false;
     int driver_major_version = 0;
     int driver_minor_version = 0;
-    if(self->params.direct_capture && get_driver_version(&driver_major_version, &driver_minor_version)) {
+    if(self->params.direct_capture && get_nvidia_driver_version(&driver_major_version, &driver_minor_version)) {
         fprintf(stderr, "gsr info: detected nvidia version: %d.%d\n", driver_major_version, driver_minor_version);
 
         // TODO:
@@ -317,16 +284,14 @@ static int gsr_capture_nvfbc_start(gsr_capture *cap, gsr_capture_metadata *captu
         goto error_cleanup;
     }
 
-    capture_metadata->width = self->tracking_width;
-    capture_metadata->height = self->tracking_height;
+    capture_metadata->video_size.x = self->tracking_width;
+    capture_metadata->video_size.y = self->tracking_height;
 
     if(self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0) {
-        self->params.output_resolution = scale_keep_aspect_ratio((vec2i){capture_metadata->width, capture_metadata->height}, self->params.output_resolution);
-        capture_metadata->width = self->params.output_resolution.x;
-        capture_metadata->height = self->params.output_resolution.y;
+        self->params.output_resolution = scale_keep_aspect_ratio(capture_metadata->video_size, self->params.output_resolution);
+        capture_metadata->video_size = self->params.output_resolution;
     } else if(self->params.region_size.x > 0 && self->params.region_size.y > 0) {
-        capture_metadata->width = self->params.region_size.x;
-        capture_metadata->height = self->params.region_size.y;
+        capture_metadata->video_size = self->params.region_size;
     }
 
     return 0;
@@ -336,6 +301,35 @@ static int gsr_capture_nvfbc_start(gsr_capture *cap, gsr_capture_metadata *captu
     return -1;
 }
 
+static bool gsr_capture_nvfbc_is_capture_monitor_connected(gsr_capture_nvfbc *self) {
+    Display *dpy = gsr_window_get_display(self->params.egl->window);
+    int num_monitors = 0;
+    XRRMonitorInfo *monitors = XRRGetMonitors(dpy, DefaultRootWindow(dpy), True, &num_monitors);
+    if(!monitors)
+        return false;
+
+    bool capture_monitor_connected = false;
+    if(strcmp(self->params.display_to_capture, "screen") == 0) {
+        capture_monitor_connected = num_monitors > 0;
+    } else {
+        for(int i = 0; i < num_monitors; ++i) {
+            char *monitor_name = XGetAtomName(dpy, monitors[i].name);
+            if(!monitor_name)
+                continue;
+
+            if(strcmp(monitor_name, self->params.display_to_capture) == 0) {
+                capture_monitor_connected = true;
+                XFree(monitor_name);
+                break;
+            }
+            XFree(monitor_name);
+        }
+    }
+
+    XRRFreeMonitors(monitors);
+    return capture_monitor_connected;
+}
+
 static int gsr_capture_nvfbc_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
     gsr_capture_nvfbc *self = cap->priv;
 
@@ -344,6 +338,13 @@ static int gsr_capture_nvfbc_capture(gsr_capture *cap, gsr_capture_metadata *cap
         const double now = clock_get_monotonic_seconds();
         if(now - self->nvfbc_dead_start >= nvfbc_recreate_retry_time_seconds) {
             self->nvfbc_dead_start = now;
+            /*
+                Do not attempt to recreate the nvfbc session if the monitor isn't turned on/connected.
+                This is to predict if the nvfbc session create below will fail since if it fails it leaks an x11 display (a bug in the nvidia driver).
+            */
+            if(!gsr_capture_nvfbc_is_capture_monitor_connected(self))
+                return 0;
+
             gsr_capture_nvfbc_destroy_session_and_handle(self);
 
             if(gsr_capture_nvfbc_setup_handle(self) != 0) {
@@ -356,6 +357,7 @@ static int gsr_capture_nvfbc_capture(gsr_capture *cap, gsr_capture_metadata *cap
                 return -1;
             }
 
+            fprintf(stderr, "gsr info: gsr_capture_nvfbc_capture: recreated nvfbc session after modeset recovery\n");
             self->nvfbc_needs_recreate = false;
         } else {
             return 0;
@@ -367,11 +369,8 @@ static int gsr_capture_nvfbc_capture(gsr_capture *cap, gsr_capture_metadata *cap
     if(self->params.region_size.x > 0 && self->params.region_size.y > 0)
         frame_size = self->params.region_size;
 
-    const bool is_scaled = self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0;
-    vec2i output_size = is_scaled ? self->params.output_resolution : frame_size;
-    output_size = scale_keep_aspect_ratio(frame_size, output_size);
-
-    const vec2i target_pos = { max_int(0, capture_metadata->width / 2 - output_size.x / 2), max_int(0, capture_metadata->height / 2 - output_size.y / 2) };
+    const vec2i output_size = scale_keep_aspect_ratio(frame_size, capture_metadata->recording_size);
+    const vec2i target_pos = gsr_capture_get_target_position(output_size, capture_metadata);
 
     NVFBC_FRAME_GRAB_INFO frame_info;
     memset(&frame_info, 0, sizeof(frame_info));
@@ -397,7 +396,7 @@ static int gsr_capture_nvfbc_capture(gsr_capture *cap, gsr_capture_metadata *cap
     gsr_color_conversion_draw(color_conversion, self->setup_params.dwTextures[grab_params.dwTextureIndex],
         target_pos, (vec2i){output_size.x, output_size.y},
         self->params.region_position, frame_size, original_frame_size,
-        GSR_ROT_0, GSR_SOURCE_COLOR_BGR, false, false);
+        GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_BGR, false);
 
     //self->params.egl->glFlush();
     //self->params.egl->glFinish();

src/capture/portal.c

@@ -35,6 +35,7 @@ typedef struct {
 
     bool should_stop;
     bool stop_is_error;
+    bool do_capture;
 } gsr_capture_portal;
 
 static void gsr_capture_portal_cleanup_plane_fds(gsr_capture_portal *self) {
@@ -293,12 +294,10 @@ static int gsr_capture_portal_start(gsr_capture *cap, gsr_capture_metadata *capt
     }
 
     if(self->params.output_resolution.x == 0 && self->params.output_resolution.y == 0) {
-        capture_metadata->width = self->capture_size.x;
-        capture_metadata->height = self->capture_size.y;
+        capture_metadata->video_size = self->capture_size;
     } else {
         self->params.output_resolution = scale_keep_aspect_ratio(self->capture_size, self->params.output_resolution);
-        capture_metadata->width = self->params.output_resolution.x;
-        capture_metadata->height = self->params.output_resolution.y;
+        capture_metadata->video_size = self->params.output_resolution;
     }
 
     return 0;
@@ -322,22 +321,22 @@ static bool fourcc_has_alpha(uint32_t fourcc) {
     return false;
 }
 
-static int gsr_capture_portal_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
-    (void)color_conversion;
+static void gsr_capture_portal_pre_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
     gsr_capture_portal *self = cap->priv;
+    self->do_capture = false;
 
     if(self->should_stop)
-        return -1;
+        return;
 
     if(gsr_pipewire_video_should_restart(&self->pipewire)) {
-        fprintf(stderr, "gsr info: gsr_capture_portal_capture: pipewire capture was paused, trying to start capture again\n");
+        fprintf(stderr, "gsr info: gsr_capture_portal_pre_capture: pipewire capture was paused, trying to start capture again\n");
         gsr_capture_portal_stop(self);
         const int result = gsr_capture_portal_setup(self, capture_metadata->fps);
         if(result != 0) {
             self->stop_is_error = result != PORTAL_CAPTURE_CANCELED_BY_USER_EXIT_CODE;
             self->should_stop = true;
         }
-        return -1;
+        return;
     }
 
     /* TODO: Handle formats other than RGB(A) */
@@ -346,32 +345,41 @@ static int gsr_capture_portal_capture(gsr_capture *cap, gsr_capture_metadata *ca
             if(self->pipewire_data.region.width != self->capture_size.x || self->pipewire_data.region.height != self->capture_size.y) {
                 self->capture_size.x = self->pipewire_data.region.width;
                 self->capture_size.y = self->pipewire_data.region.height;
-                gsr_color_conversion_clear(color_conversion);
+                color_conversion->schedule_clear = true;
             }
         } else {
-            return -1;
+            return;
         }
     }
 
-    const bool is_scaled = self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0;
-    vec2i output_size = is_scaled ? self->params.output_resolution : self->capture_size;
-    output_size = scale_keep_aspect_ratio(self->capture_size, output_size);
-    
-    const vec2i target_pos = { max_int(0, capture_metadata->width / 2 - output_size.x / 2), max_int(0, capture_metadata->height / 2 - output_size.y / 2) };
+    const bool fourcc_alpha = fourcc_has_alpha(self->pipewire_data.fourcc);
+    if(fourcc_alpha)
+        color_conversion->schedule_clear = true;
+
+    self->do_capture = true;
+}
+
+static int gsr_capture_portal_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
+    (void)color_conversion;
+    gsr_capture_portal *self = cap->priv;
+
+    if(self->should_stop || !self->do_capture)
+        return -1;
+
+    const vec2i output_size = scale_keep_aspect_ratio(self->capture_size, capture_metadata->recording_size);
+    const vec2i target_pos = gsr_capture_get_target_position(output_size, capture_metadata);
+
+    const vec2i actual_texture_size = {self->pipewire_data.texture_width, self->pipewire_data.texture_height};
 
     //self->params.egl->glFlush();
     //self->params.egl->glFinish();
 
     // TODO: Handle region crop
 
-    const bool fourcc_alpha = fourcc_has_alpha(self->pipewire_data.fourcc);
-    if(fourcc_alpha)
-        gsr_color_conversion_clear(color_conversion);
-
     gsr_color_conversion_draw(color_conversion, self->pipewire_data.using_external_image ? self->texture_map.external_texture_id : self->texture_map.texture_id,
        target_pos, output_size,
-       (vec2i){self->pipewire_data.region.x, self->pipewire_data.region.y}, self->capture_size, self->capture_size,
-       gsr_monitor_rotation_to_rotation(self->pipewire_data.rotation), GSR_SOURCE_COLOR_RGB, self->pipewire_data.using_external_image, fourcc_alpha);
+       (vec2i){self->pipewire_data.region.x, self->pipewire_data.region.y}, (vec2i){self->pipewire_data.region.width, self->pipewire_data.region.height}, actual_texture_size,
+       gsr_monitor_rotation_to_rotation(self->pipewire_data.rotation), capture_metadata->flip, GSR_SOURCE_COLOR_RGB, self->pipewire_data.using_external_image);
 
     if(self->params.record_cursor && self->texture_map.cursor_texture_id > 0 && self->pipewire_data.cursor_region.width > 0) {
         const vec2d scale = {
@@ -386,13 +394,15 @@ static int gsr_capture_portal_capture(gsr_capture *cap, gsr_capture_metadata *ca
 
         self->params.egl->glEnable(GL_SCISSOR_TEST);
         self->params.egl->glScissor(target_pos.x, target_pos.y, output_size.x, output_size.y);
+
         gsr_color_conversion_draw(color_conversion, self->texture_map.cursor_texture_id,
             (vec2i){cursor_pos.x, cursor_pos.y},
             (vec2i){self->pipewire_data.cursor_region.width * scale.x, self->pipewire_data.cursor_region.height * scale.y},
             (vec2i){0, 0},
             (vec2i){self->pipewire_data.cursor_region.width, self->pipewire_data.cursor_region.height},
             (vec2i){self->pipewire_data.cursor_region.width, self->pipewire_data.cursor_region.height},
-            gsr_monitor_rotation_to_rotation(self->pipewire_data.rotation), GSR_SOURCE_COLOR_RGB, false, true);
+            gsr_monitor_rotation_to_rotation(self->pipewire_data.rotation), capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false);
+
         self->params.egl->glDisable(GL_SCISSOR_TEST);
     }
 
@@ -459,6 +469,7 @@ gsr_capture* gsr_capture_portal_create(const gsr_capture_portal_params *params)
         .tick = NULL,
         .should_stop = gsr_capture_portal_should_stop,
         .capture_has_synchronous_task = gsr_capture_portal_capture_has_synchronous_task,
+        .pre_capture = gsr_capture_portal_pre_capture,
         .capture = gsr_capture_portal_capture,
         .uses_external_image = gsr_capture_portal_uses_external_image,
         .is_damaged = gsr_capture_portal_is_damaged,

src/capture/v4l2.c

@@ -0,0 +1,919 @@
+#include "../../include/capture/v4l2.h"
+#include "../../include/color_conversion.h"
+#include "../../include/egl.h"
+#include "../../include/utils.h"
+
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <poll.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <linux/videodev2.h>
+#include <linux/dma-buf.h>
+#include <drm_fourcc.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <assert.h>
+
+#define TJPF_RGB 0
+#define TJPF_RGBA 7
+#define TJFLAG_FASTDCT  2048
+
+#define NUM_BUFFERS 2
+#define NUM_PBOS 2
+
+typedef void* tjhandle;
+typedef tjhandle (*FUNC_tjInitDecompress)(void);
+typedef int (*FUNC_tjDestroy)(tjhandle handle);
+typedef int (*FUNC_tjDecompressHeader2)(tjhandle handle,
+                                        unsigned char *jpegBuf, unsigned long jpegSize,
+                                        int *width, int *height, int *jpegSubsamp);
+typedef int (*FUNC_tjDecompress2)(tjhandle handle, const unsigned char *jpegBuf,
+                                  unsigned long jpegSize, unsigned char *dstBuf,
+                                  int width, int pitch, int height, int pixelFormat,
+                                  int flags);
+typedef char* (*FUNC_tjGetErrorStr2)(tjhandle handle);
+
+typedef enum {
+    V4L2_BUFFER_TYPE_DMABUF,
+    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;
+
+    bool should_stop;
+    bool stop_is_error;
+
+    int fd;
+    int dmabuf_fd[NUM_BUFFERS];
+    EGLImage dma_image[NUM_BUFFERS];
+    unsigned int texture_id[NUM_BUFFERS];
+    unsigned int prev_texture_index;
+    bool got_first_frame;
+
+    void *dmabuf_map[NUM_BUFFERS];
+    size_t dmabuf_size[NUM_BUFFERS];
+    unsigned int pbos[NUM_PBOS];
+    unsigned int pbo_index;
+    
+    v4l2_buffer_type buffer_type;
+
+    void *libturbojpeg_lib;
+    FUNC_tjInitDecompress tjInitDecompress;
+    FUNC_tjDestroy tjDestroy;
+    FUNC_tjDecompressHeader2 tjDecompressHeader2;
+    FUNC_tjDecompress2 tjDecompress2;
+    FUNC_tjGetErrorStr2 tjGetErrorStr2;
+    tjhandle jpeg_decompressor;
+
+    double capture_start_time;
+
+    bool yuyv_conversion_fallback;
+} gsr_capture_v4l2;
+
+static int xioctl(int fd, unsigned long request, void *arg) {
+    int r;
+
+    do {
+        r = ioctl(fd, request, arg);
+    } while (-1 == r && EINTR == errno);
+
+    return r;
+}
+
+static void gsr_capture_v4l2_stop(gsr_capture_v4l2 *self) {
+    self->params.egl->glDeleteBuffers(NUM_PBOS, self->pbos);
+    for(int i = 0; i < NUM_PBOS; ++i) {
+        self->pbos[i] = 0;
+    }
+
+    self->params.egl->glDeleteTextures(NUM_BUFFERS, self->texture_id);
+    for(int i = 0; i < NUM_BUFFERS; ++i) {
+        self->texture_id[i] = 0;
+    }
+
+    for(int i = 0; i < NUM_BUFFERS; ++i) {
+        if(self->dmabuf_map[i]) {
+            munmap(self->dmabuf_map[i], self->dmabuf_size[i]);
+            self->dmabuf_map[i] = NULL;
+        }
+
+        if(self->dma_image[i]) {
+            self->params.egl->eglDestroyImage(self->params.egl->egl_display, self->dma_image[i]);
+            self->dma_image[i] = NULL;
+        }
+
+        if(self->dmabuf_fd[i] > 0) {
+            close(self->dmabuf_fd[i]);
+            self->dmabuf_fd[i] = 0;
+        }
+    }
+
+    if(self->fd > 0) {
+        xioctl(self->fd, VIDIOC_STREAMOFF, &(enum v4l2_buf_type){V4L2_BUF_TYPE_VIDEO_CAPTURE});
+        close(self->fd);
+        self->fd = 0;
+    }
+
+    if(self->jpeg_decompressor) {
+        self->tjDestroy(self->jpeg_decompressor);
+        self->jpeg_decompressor = NULL;
+    }
+
+    if(self->libturbojpeg_lib) {
+        dlclose(self->libturbojpeg_lib);
+        self->libturbojpeg_lib = NULL;
+    }
+}
+
+static void gsr_capture_v4l2_reset_cropping(gsr_capture_v4l2 *self) {
+    struct v4l2_cropcap cropcap = {
+        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE
+    };
+    if(xioctl(self->fd, VIDIOC_CROPCAP, &cropcap) == 0) {
+        struct v4l2_crop crop = {
+            .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+            .c = cropcap.defrect /* reset to default */
+        };
+
+        if(xioctl(self->fd, VIDIOC_S_CROP, &crop) == -1) {
+            switch (errno) {
+            case EINVAL:
+                /* Cropping not supported. */
+                break;
+            default:
+                /* Errors ignored. */
+                break;
+            }
+        }
+    } else {
+        /* Errors ignored. */
+    }
+}
+
+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 = {
+        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE
+    };
+    while(xioctl(fd, VIDIOC_ENUM_FMT, &fmt) == 0) {
+        //fprintf(stderr, "fmt: %d, desc: %s, flags: %d\n", fmt.pixelformat, fmt.description, fmt.flags);
+        switch(fmt.pixelformat) {
+            case V4L2_PIX_FMT_YUYV:
+                result.yuyv = true;
+                break;
+            case V4L2_PIX_FMT_MJPEG:
+                result.mjpeg = true;
+                break;
+        }
+        ++fmt.index;
+    }
+
+    return result;
+}
+
+/* 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;
+    }
+
+    return resolution_index;
+}
+
+/* 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 && !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;
+            }
+            break;
+        }
+        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);
+                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);
+                return false;
+            }
+            break;
+        }
+    }
+    return true;
+}
+
+static bool gsr_capture_v4l2_create_pbos(gsr_capture_v4l2 *self, int width, int height) {
+    self->pbo_index = 0;
+
+    self->params.egl->glGenBuffers(NUM_PBOS, self->pbos);
+    for(int i = 0; i < NUM_PBOS; ++i) {
+        if(self->pbos[i] == 0) {
+            fprintf(stderr, "gsr error: gsr_capture_v4l2_create_pbos: failed to create pixel buffer objects\n");
+            return false;
+        }
+
+        self->params.egl->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, self->pbos[i]);
+        self->params.egl->glBufferData(GL_PIXEL_UNPACK_BUFFER, width * height * 4, 0, GL_DYNAMIC_DRAW);
+    }
+
+    self->params.egl->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+    return true;
+}
+
+static bool gsr_capture_v4l2_map_buffer(gsr_capture_v4l2 *self, const struct v4l2_format *fmt) {
+    switch(self->params.pixfmt) {
+        case GSR_CAPTURE_V4L2_PIXFMT_AUTO: {
+            assert(false);
+            return false;
+        }
+        case GSR_CAPTURE_V4L2_PIXFMT_YUYV: {
+            self->params.egl->glGenTextures(NUM_BUFFERS, self->texture_id);
+
+            for(int i = 0; i < NUM_BUFFERS; ++i) {
+                self->dma_image[i] = self->params.egl->eglCreateImage(self->params.egl->egl_display, 0, EGL_LINUX_DMA_BUF_EXT, NULL, (intptr_t[]) {
+                    EGL_WIDTH, fmt->fmt.pix.width,
+                    EGL_HEIGHT, fmt->fmt.pix.height,
+                    EGL_LINUX_DRM_FOURCC_EXT, DRM_FORMAT_YUYV,
+                    EGL_DMA_BUF_PLANE0_FD_EXT, self->dmabuf_fd[i],
+                    EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0,
+                    EGL_DMA_BUF_PLANE0_PITCH_EXT, fmt->fmt.pix.bytesperline,
+                    EGL_NONE
+                });
+
+                if(!self->dma_image[i]) {
+                    self->yuyv_conversion_fallback = true;
+                    // This doesn't work for everybody on nvidia. On pop os 24.04 when egl_display is NULL (when capturing monitor on x11) then this fails with EGL_BAD_DISPLAY
+                    self->dma_image[i] = self->params.egl->eglCreateImage(self->params.egl->egl_display, 0, EGL_LINUX_DMA_BUF_EXT, NULL, (intptr_t[]) {
+                        EGL_WIDTH, fmt->fmt.pix.width,
+                        EGL_HEIGHT, fmt->fmt.pix.height,
+                        EGL_LINUX_DRM_FOURCC_EXT, DRM_FORMAT_RG88,
+                        EGL_DMA_BUF_PLANE0_FD_EXT, self->dmabuf_fd[i],
+                        EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0,
+                        EGL_DMA_BUF_PLANE0_PITCH_EXT, fmt->fmt.pix.bytesperline,
+                        EGL_NONE
+                    });
+
+                    if(!self->dma_image[i]) {
+                        fprintf(stderr, "gsr error: gsr_capture_v4l2_map_buffer: eglCreateImage failed, error: %d\n", self->params.egl->eglGetError());
+                        return false;
+                    }
+                }
+
+                self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, self->texture_id[i]);
+                self->params.egl->glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, self->dma_image[i]);
+                self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+                self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+                self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
+                if(self->texture_id[i] == 0) {
+                    fprintf(stderr, "gsr error: gsr_capture_v4l2_map_buffer: failed to create texture\n");
+                    return false;
+                }
+            }
+
+            self->buffer_type = V4L2_BUFFER_TYPE_DMABUF;
+            break;
+        }
+        case GSR_CAPTURE_V4L2_PIXFMT_MJPEG: {
+            for(int i = 0; i < NUM_BUFFERS; ++i) {
+                self->dmabuf_size[i] = fmt->fmt.pix.sizeimage;
+                self->dmabuf_map[i] = mmap(NULL, fmt->fmt.pix.sizeimage, PROT_READ, MAP_SHARED, self->dmabuf_fd[i], 0);
+                if(self->dmabuf_map[i] == MAP_FAILED) {
+                    fprintf(stderr, "gsr error: gsr_capture_v4l2_map_buffer: mmap failed, error: %s\n", strerror(errno));
+                    return false;
+                }
+
+                // GL_RGBA is intentionally used here instead of GL_RGB, because the performance is much better when using glTexSubImage2D (22% cpu usage compared to 38% cpu usage)
+                self->texture_id[i] = gl_create_texture(self->params.egl, fmt->fmt.pix.width, fmt->fmt.pix.height, GL_RGBA8, GL_RGBA, GL_LINEAR);
+                if(self->texture_id[i] == 0) {
+                    fprintf(stderr, "gsr error: gsr_capture_v4l2_map_buffer: failed to create texture\n");
+                    return false;
+                }
+            }
+
+            if(!gsr_capture_v4l2_create_pbos(self, fmt->fmt.pix.width, fmt->fmt.pix.height))
+                return false;
+
+            self->buffer_type = V4L2_BUFFER_TYPE_MMAP;
+            break;
+        }
+    }
+    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) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_create: failed to open %s, error: %s\n", self->params.device_path, strerror(errno));
+        return -1;
+    }
+
+    struct v4l2_capability cap = {0};
+    if(xioctl(self->fd, VIDIOC_QUERYCAP, &cap) == -1) {
+        if(EINVAL == errno) {
+            fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s isn't a v4l2 device\n", self->params.device_path);
+            return -1;
+        } else {
+            fprintf(stderr, "gsr error: gsr_capture_v4l2_create: VIDIOC_QUERYCAP failed, error: %s\n", strerror(errno));
+            return -1;
+        }
+    }
+
+    if(!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s isn't a video capture device\n", self->params.device_path);
+        return -1;
+    }
+
+    if(!(cap.capabilities & V4L2_CAP_STREAMING)) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s doesn't support streaming i/o\n", self->params.device_path);
+        return -1;
+    }
+
+    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);
+        if(!self->libturbojpeg_lib) {
+            fprintf(stderr, "gsr error: gsr_capture_v4l2_create: failed to load libturbojpeg.so.0 which is required for camera mjpeg capture, error: %s\n", dlerror());
+            return -1;
+        }
+
+        self->tjInitDecompress = (FUNC_tjInitDecompress)dlsym(self->libturbojpeg_lib, "tjInitDecompress");
+        self->tjDestroy = (FUNC_tjDestroy)dlsym(self->libturbojpeg_lib, "tjDestroy");
+        self->tjDecompressHeader2 = (FUNC_tjDecompressHeader2)dlsym(self->libturbojpeg_lib, "tjDecompressHeader2");
+        self->tjDecompress2 = (FUNC_tjDecompress2)dlsym(self->libturbojpeg_lib, "tjDecompress2");
+        self->tjGetErrorStr2 = (FUNC_tjGetErrorStr2)dlsym(self->libturbojpeg_lib, "tjGetErrorStr2");
+
+        if(!self->tjInitDecompress || !self->tjDestroy || !self->tjDecompressHeader2 || !self->tjDecompress2 || !self->tjGetErrorStr2) {
+            fprintf(stderr, "gsr error: gsr_capture_v4l2_create: libturbojpeg.so.0 is missing functions. The libturbojpeg version installed on your system might be outdated\n");
+            return -1;
+        }
+
+        self->jpeg_decompressor = self->tjInitDecompress();
+        if(!self->jpeg_decompressor) {
+            fprintf(stderr, "gsr error: gsr_capture_v4l2_create: failed to create jpeg decompressor\n");
+            return -1;
+        }
+    }
+
+    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.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));
+        return -1;
+    }
+
+    if(fmt.fmt.pix.pixelformat != v4l2_pixfmt) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_create: pixel format isn't as requested (got pixel format: %u, requested: %u), error: %s\n", fmt.fmt.pix.pixelformat, v4l2_pixfmt, strerror(errno));
+        return -1;
+    }
+
+    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,
+        .count = NUM_BUFFERS
+    };
+    if(xioctl(self->fd, VIDIOC_REQBUFS, &reqbuf) == -1) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_create: VIDIOC_REQBUFS failed, error: %s\n", strerror(errno));
+        return -1;
+    }
+
+    for(int i = 0; i < NUM_BUFFERS; ++i) {
+        struct v4l2_exportbuffer expbuf = {
+            .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+            .index = i,
+            .flags = O_RDONLY
+        };
+        if(xioctl(self->fd, VIDIOC_EXPBUF, &expbuf) == -1) {
+            fprintf(stderr, "gsr error: gsr_capture_v4l2_create: VIDIOC_EXPBUF failed, error: %s\n", strerror(errno));
+            return -1;
+        }
+        self->dmabuf_fd[i] = expbuf.fd;
+    }
+
+    if(!gsr_capture_v4l2_map_buffer(self, &fmt))
+        return -1;
+
+    for(int i = 0; i < NUM_BUFFERS; ++i) {
+        struct v4l2_buffer buf = {
+            .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+            .index = i,
+            .memory = V4L2_MEMORY_MMAP
+        };
+        xioctl(self->fd, VIDIOC_QBUF, &buf);
+    }
+
+    if(xioctl(self->fd, VIDIOC_STREAMON, &(enum v4l2_buf_type){V4L2_BUF_TYPE_VIDEO_CAPTURE})) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_create: VIDIOC_STREAMON failed, error: %s\n", strerror(errno));
+        return -1;
+    }
+
+    fprintf(stderr, "gsr info: gsr_capture_v4l2_create: waiting for camera %s to be ready\n", self->params.device_path);
+    return 0;
+}
+
+static int gsr_capture_v4l2_start(gsr_capture *cap, gsr_capture_metadata *capture_metadata) {
+    gsr_capture_v4l2 *self = cap->priv;
+
+    const int result = gsr_capture_v4l2_setup(self);
+    if(result != 0) {
+        gsr_capture_v4l2_stop(self);
+        return result;
+    }
+
+    if(self->params.output_resolution.x == 0 && self->params.output_resolution.y == 0) {
+        capture_metadata->video_size = self->capture_size;
+    } else {
+        self->params.output_resolution = scale_keep_aspect_ratio(self->capture_size, self->params.output_resolution);
+        capture_metadata->video_size = self->params.output_resolution;
+    }
+
+    self->capture_start_time = clock_get_monotonic_seconds();
+    return 0;
+}
+
+static void gsr_capture_v4l2_tick(gsr_capture *cap) {
+    gsr_capture_v4l2 *self = cap->priv;
+    if(!self->got_first_frame && !self->should_stop) {
+        const double timeout_sec = 5.0;
+        if(clock_get_monotonic_seconds() - self->capture_start_time >= timeout_sec) {
+            fprintf(stderr, "gsr error: gsr_capture_v4l2_capture: didn't receive camera data in %f seconds\n", timeout_sec);
+            self->should_stop = true;
+            self->stop_is_error = true;
+        }
+    }
+}
+
+static void gsr_capture_v4l2_decode_jpeg_to_texture(gsr_capture_v4l2 *self, const struct v4l2_buffer *buf) {
+    int jpeg_subsamp = 0;
+    int jpeg_width = 0;
+    int jpeg_height = 0;
+    if(self->tjDecompressHeader2(self->jpeg_decompressor, self->dmabuf_map[buf->index], buf->bytesused, &jpeg_width, &jpeg_height, &jpeg_subsamp) != 0) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_capture: failed to decompress camera jpeg header data, error: %s\n", self->tjGetErrorStr2(self->jpeg_decompressor));
+        return;
+    }
+
+    if(jpeg_width != self->capture_size.x || jpeg_height != self->capture_size.y) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_capture: got jpeg data of incorrect dimensions. Expected %dx%d, got %dx%d\n", self->capture_size.x, self->capture_size.y, jpeg_width, jpeg_height);
+        return;
+    }
+
+    self->params.egl->glBindTexture(GL_TEXTURE_2D, self->texture_id[buf->index]);
+
+    self->pbo_index = (self->pbo_index + 1) % NUM_PBOS;
+    const unsigned int next_pbo_index = (self->pbo_index + 1) % NUM_PBOS;
+    
+    self->params.egl->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, self->pbos[self->pbo_index]);
+    self->params.egl->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, self->capture_size.x, self->capture_size.y, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+
+    self->params.egl->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, self->pbos[next_pbo_index]);
+    self->params.egl->glBufferData(GL_PIXEL_UNPACK_BUFFER, self->capture_size.x * self->capture_size.y * 4, 0, GL_DYNAMIC_DRAW);
+
+    void *mapped_buffer = self->params.egl->glMapBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, self->capture_size.x * self->capture_size.y * 4, GL_MAP_WRITE_BIT);
+    if(mapped_buffer) {
+        if(self->tjDecompress2(self->jpeg_decompressor, self->dmabuf_map[buf->index], buf->bytesused, mapped_buffer, jpeg_width, 0, jpeg_height, TJPF_RGBA, TJFLAG_FASTDCT) != 0)
+            fprintf(stderr, "gsr error: gsr_capture_v4l2_capture: failed to decompress camera jpeg data, error: %s\n", self->tjGetErrorStr2(self->jpeg_decompressor));
+        self->params.egl->glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
+    }
+
+    self->params.egl->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+    self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+static int gsr_capture_v4l2_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
+    (void)color_conversion;
+    gsr_capture_v4l2 *self = cap->priv;
+
+    struct v4l2_buffer buf = {
+        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+        .memory = V4L2_MEMORY_MMAP
+    };
+
+    xioctl(self->fd, VIDIOC_DQBUF, &buf);
+    unsigned int texture_index = buf.index;
+
+    if(buf.bytesused > 0 && !(buf.flags & V4L2_BUF_FLAG_ERROR)) {
+        if(!self->got_first_frame)
+            fprintf(stderr, "gsr info: gsr_capture_v4l2_capture: camera %s is now ready\n", self->params.device_path);
+        self->got_first_frame = true;
+
+        switch(self->buffer_type) {
+            case V4L2_BUFFER_TYPE_DMABUF: {
+                //self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, self->texture_id);
+                //self->params.egl->glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, self->dma_image[buf.index]);
+                //self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
+                break;
+            }
+            case V4L2_BUFFER_TYPE_MMAP: {
+                //xioctl(self->dmabuf_fd[buf.index], DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync){ .flags = DMA_BUF_SYNC_START });
+                gsr_capture_v4l2_decode_jpeg_to_texture(self, &buf);
+                //xioctl(self->dmabuf_fd[buf.index], DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync){ .flags = DMA_BUF_SYNC_END });
+                break;
+            }
+        }
+
+        self->prev_texture_index = buf.index;
+    } else {
+        texture_index = self->prev_texture_index;
+    }
+    xioctl(self->fd, VIDIOC_QBUF, &buf);
+
+    const vec2i output_size = scale_keep_aspect_ratio(self->capture_size, capture_metadata->recording_size);
+    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();
+
+    if(self->buffer_type == V4L2_BUFFER_TYPE_DMABUF) {
+        gsr_color_conversion_draw(color_conversion, self->texture_id[texture_index],
+            target_pos, output_size,
+            (vec2i){0, 0}, self->capture_size, self->capture_size,
+            GSR_ROT_0, capture_metadata->flip, self->yuyv_conversion_fallback ? GSR_SOURCE_COLOR_YUYV : GSR_SOURCE_COLOR_RGB, true);
+    } else {
+        gsr_color_conversion_draw(color_conversion, self->texture_id[texture_index],
+            target_pos, output_size,
+            (vec2i){0, 0}, self->capture_size, self->capture_size,
+            GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false);
+    }
+
+    return self->got_first_frame ? 0 : -1;
+}
+
+static bool gsr_capture_v4l2_uses_external_image(gsr_capture *cap) {
+    (void)cap;
+    return true;
+}
+
+static bool gsr_capture_v4l2_should_stop(gsr_capture *cap, bool *err) {
+    gsr_capture_v4l2 *self = cap->priv;
+    if(err)
+        *err = self->stop_is_error;
+    return self->should_stop;
+}
+
+static bool gsr_capture_v4l2_is_damaged(gsr_capture *cap) {
+    gsr_capture_v4l2 *self = cap->priv;
+    struct pollfd poll_data = {
+        .fd = self->fd,
+        .events = POLLIN,
+        .revents = 0
+    };
+    return poll(&poll_data, 1, 0) > 0 && (poll_data.revents & POLLIN);
+}
+
+static void gsr_capture_v4l2_clear_damage(gsr_capture *cap) {
+    gsr_capture_v4l2 *self = cap->priv;
+    (void)self;
+}
+
+static void gsr_capture_v4l2_destroy(gsr_capture *cap) {
+    gsr_capture_v4l2 *self = cap->priv;
+    if(cap->priv) {
+        gsr_capture_v4l2_stop(self);
+        free(cap->priv);
+        cap->priv = NULL;
+    }
+    free(cap);
+}
+
+gsr_capture* gsr_capture_v4l2_create(const gsr_capture_v4l2_params *params) {
+    if(!params) {
+        fprintf(stderr, "gsr error: gsr_capture_v4l2_create params is NULL\n");
+        return NULL;
+    }
+
+    gsr_capture *cap = calloc(1, sizeof(gsr_capture));
+    if(!cap)
+        return NULL;
+
+    gsr_capture_v4l2 *cap_camera = calloc(1, sizeof(gsr_capture_v4l2));
+    if(!cap_camera) {
+        free(cap);
+        return NULL;
+    }
+
+    cap_camera->params = *params;
+
+    *cap = (gsr_capture) {
+        .start = gsr_capture_v4l2_start,
+        .tick = gsr_capture_v4l2_tick,
+        .should_stop = gsr_capture_v4l2_should_stop,
+        .capture = gsr_capture_v4l2_capture,
+        .uses_external_image = gsr_capture_v4l2_uses_external_image,
+        .is_damaged = gsr_capture_v4l2_is_damaged,
+        .clear_damage = gsr_capture_v4l2_clear_damage,
+        .destroy = gsr_capture_v4l2_destroy,
+        .priv = cap_camera
+    };
+
+    return cap;
+}
+
+void gsr_capture_v4l2_list_devices(v4l2_devices_query_callback callback, void *userdata) {
+    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);
+
+        const int fd = open(v4l2_device_path, O_RDWR | O_NONBLOCK);
+        if(fd < 0)
+            continue;
+
+        struct v4l2_capability cap = {0};
+        if(xioctl(fd, VIDIOC_QUERYCAP, &cap) == -1)
+            goto next;
+
+        if(!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
+            goto next;
+
+        if(!(cap.capabilities & V4L2_CAP_STREAMING))
+            goto next;
+
+        struct v4l2_format fmt = {
+            .type = V4L2_BUF_TYPE_VIDEO_CAPTURE
+        };
+        if(xioctl(fd, VIDIOC_G_FMT, &fmt) == -1)
+            goto next;
+
+        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/capture/xcomposite.c

@@ -23,6 +23,7 @@ typedef struct {
     bool init_new_window;
 
     Window window;
+    vec2i window_pos;
     vec2i window_size;
     vec2i texture_size;
     double window_resize_timer;
@@ -31,14 +32,11 @@ typedef struct {
 
     Atom net_active_window_atom;
 
-    gsr_cursor cursor;
-
     bool clear_background;
 } gsr_capture_xcomposite;
 
 static void gsr_capture_xcomposite_stop(gsr_capture_xcomposite *self) {
     window_texture_deinit(&self->window_texture);
-    gsr_cursor_deinit(&self->cursor);
 }
 
 static int max_int(int a, int b) {
@@ -81,6 +79,9 @@ static int gsr_capture_xcomposite_start(gsr_capture *cap, gsr_capture_metadata *
         return -1;
     }
 
+    self->window_pos.x = attr.x;
+    self->window_pos.y = attr.y;
+
     self->window_size.x = max_int(attr.width, 0);
     self->window_size.y = max_int(attr.height, 0);
 
@@ -95,25 +96,13 @@ static int gsr_capture_xcomposite_start(gsr_capture *cap, gsr_capture_metadata *
         return -1;
     }
 
-    if(gsr_cursor_init(&self->cursor, self->params.egl, self->display) != 0) {
-        gsr_capture_xcomposite_stop(self);
-        return -1;
-    }
-
-    self->texture_size.x = 0;
-    self->texture_size.y = 0;
-
-    self->params.egl->glBindTexture(GL_TEXTURE_2D, window_texture_get_opengl_texture_id(&self->window_texture));
-    self->params.egl->glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &self->texture_size.x);
-    self->params.egl->glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &self->texture_size.y);
-    self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
+    self->texture_size.x = self->window_texture.window_width;
+    self->texture_size.y = self->window_texture.window_height;
 
     if(self->params.output_resolution.x == 0 && self->params.output_resolution.y == 0) {
-        capture_metadata->width = self->texture_size.x;
-        capture_metadata->height = self->texture_size.y;
+        capture_metadata->video_size = self->texture_size;
     } else {
-        capture_metadata->width = self->params.output_resolution.x;
-        capture_metadata->height = self->params.output_resolution.y;
+        capture_metadata->video_size = self->params.output_resolution;
     }
 
     self->window_resize_timer = clock_get_monotonic_seconds();
@@ -142,19 +131,17 @@ static void gsr_capture_xcomposite_tick(gsr_capture *cap) {
             if(!XGetWindowAttributes(self->display, self->window, &attr))
                 fprintf(stderr, "gsr error: gsr_capture_xcomposite_tick failed: invalid window id: %lu\n", self->window);
 
+            self->window_pos.x = attr.x;
+            self->window_pos.y = attr.y;
+
             self->window_size.x = max_int(attr.width, 0);
             self->window_size.y = max_int(attr.height, 0);
 
             window_texture_deinit(&self->window_texture);
             window_texture_init(&self->window_texture, self->display, self->window, self->params.egl); // TODO: Do not do the below window_texture_on_resize after this
 
-            self->texture_size.x = 0;
-            self->texture_size.y = 0;
-
-            self->params.egl->glBindTexture(GL_TEXTURE_2D, window_texture_get_opengl_texture_id(&self->window_texture));
-            self->params.egl->glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &self->texture_size.x);
-            self->params.egl->glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &self->texture_size.y);
-            self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
+            self->texture_size.x = self->window_texture.window_width;
+            self->texture_size.y = self->window_texture.window_height;
 
             self->window_resized = false;
             self->clear_background = true;
@@ -172,13 +159,8 @@ static void gsr_capture_xcomposite_tick(gsr_capture *cap) {
             return;
         }
 
-        self->texture_size.x = 0;
-        self->texture_size.y = 0;
-
-        self->params.egl->glBindTexture(GL_TEXTURE_2D, window_texture_get_opengl_texture_id(&self->window_texture));
-        self->params.egl->glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &self->texture_size.x);
-        self->params.egl->glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &self->texture_size.y);
-        self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
+        self->texture_size.x = self->window_texture.window_width;
+        self->texture_size.y = self->window_texture.window_height;
 
         self->clear_background = true;
     }
@@ -205,6 +187,10 @@ static void gsr_capture_xcomposite_on_event(gsr_capture *cap, gsr_egl *egl) {
             break;
         }
         case ConfigureNotify: {
+            // TODO: Use PresentConfigureNotify instead
+            self->window_pos.x = xev->xconfigure.x;
+            self->window_pos.y = xev->xconfigure.y;
+
             /* Window resized */
             if(xev->xconfigure.window == self->window && (xev->xconfigure.width != self->window_size.x || xev->xconfigure.height != self->window_size.y)) {
                 self->window_size.x = max_int(xev->xconfigure.width, 0);
@@ -222,8 +208,6 @@ static void gsr_capture_xcomposite_on_event(gsr_capture *cap, gsr_egl *egl) {
             break;
         }
     }
-
-    gsr_cursor_on_event(&self->cursor, xev);
 }
 
 static bool gsr_capture_xcomposite_should_stop(gsr_capture *cap, bool *err) {
@@ -239,19 +223,21 @@ static bool gsr_capture_xcomposite_should_stop(gsr_capture *cap, bool *err) {
     return false;
 }
 
-static int gsr_capture_xcomposite_capture(gsr_capture *cap, gsr_capture_metadata *capture_metdata, gsr_color_conversion *color_conversion) {
+static void gsr_capture_xcomposite_pre_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
+    (void)capture_metadata;
     gsr_capture_xcomposite *self = cap->priv;
 
     if(self->clear_background) {
         self->clear_background = false;
-        gsr_color_conversion_clear(color_conversion);
+        color_conversion->schedule_clear = true;
     }
+}
 
-    const bool is_scaled = self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0;
-    vec2i output_size = is_scaled ? self->params.output_resolution : self->texture_size;
-    output_size = scale_keep_aspect_ratio(self->texture_size, output_size);
+static int gsr_capture_xcomposite_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
+    gsr_capture_xcomposite *self = cap->priv;
 
-    const vec2i target_pos = { max_int(0, capture_metdata->width / 2 - output_size.x / 2), max_int(0, capture_metdata->height / 2 - output_size.y / 2) };
+    const vec2i output_size = scale_keep_aspect_ratio(self->texture_size, capture_metadata->recording_size);
+    const vec2i target_pos = gsr_capture_get_target_position(output_size, capture_metadata);
 
     //self->params.egl->glFlush();
     //self->params.egl->glFinish();
@@ -259,28 +245,28 @@ static int gsr_capture_xcomposite_capture(gsr_capture *cap, gsr_capture_metadata
     gsr_color_conversion_draw(color_conversion, window_texture_get_opengl_texture_id(&self->window_texture),
         target_pos, output_size,
         (vec2i){0, 0}, self->texture_size, self->texture_size,
-        GSR_ROT_0, GSR_SOURCE_COLOR_RGB, false, false);
+        GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false);
 
-    if(self->params.record_cursor && self->cursor.visible) {
+    if(self->params.record_cursor && self->params.cursor->visible) {
         const vec2d scale = {
             self->texture_size.x == 0 ? 0 : (double)output_size.x / (double)self->texture_size.x,
             self->texture_size.y == 0 ? 0 : (double)output_size.y / (double)self->texture_size.y
         };
 
-        gsr_cursor_tick(&self->cursor, self->window);
-
         const vec2i cursor_pos = {
-            target_pos.x + (self->cursor.position.x - self->cursor.hotspot.x) * scale.x,
-            target_pos.y + (self->cursor.position.y - self->cursor.hotspot.y) * scale.y
+            target_pos.x + (self->params.cursor->position.x - self->params.cursor->hotspot.x - self->window_pos.x) * scale.x,
+            target_pos.y + (self->params.cursor->position.y - self->params.cursor->hotspot.y - self->window_pos.y) * scale.y
         };
 
-        if(cursor_pos.x < target_pos.x || cursor_pos.x + self->cursor.size.x > target_pos.x + output_size.x || cursor_pos.y < target_pos.y || cursor_pos.y + self->cursor.size.y > target_pos.y + output_size.y)
-            self->clear_background = true;
+        self->params.egl->glEnable(GL_SCISSOR_TEST);
+        self->params.egl->glScissor(target_pos.x, target_pos.y, output_size.x, output_size.y);
 
-        gsr_color_conversion_draw(color_conversion, self->cursor.texture_id,
-            cursor_pos, (vec2i){self->cursor.size.x * scale.x, self->cursor.size.y * scale.y},
-            (vec2i){0, 0}, self->cursor.size, self->cursor.size,
-            GSR_ROT_0, GSR_SOURCE_COLOR_RGB, false, true);
+        gsr_color_conversion_draw(color_conversion, self->params.cursor->texture_id,
+            cursor_pos, (vec2i){self->params.cursor->size.x * scale.x, self->params.cursor->size.y * scale.y},
+            (vec2i){0, 0}, self->params.cursor->size, self->params.cursor->size,
+            GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false);
+
+        self->params.egl->glDisable(GL_SCISSOR_TEST);
     }
 
     //self->params.egl->glFlush();
@@ -327,6 +313,7 @@ gsr_capture* gsr_capture_xcomposite_create(const gsr_capture_xcomposite_params *
         .on_event = gsr_capture_xcomposite_on_event,
         .tick = gsr_capture_xcomposite_tick,
         .should_stop = gsr_capture_xcomposite_should_stop,
+        .pre_capture = gsr_capture_xcomposite_pre_capture,
         .capture = gsr_capture_xcomposite_capture,
         .uses_external_image = NULL,
         .get_window_id = gsr_capture_xcomposite_get_window_id,

src/capture/ximage.c

@@ -16,7 +16,6 @@
 typedef struct {
     gsr_capture_ximage_params params;
     Display *display;
-    gsr_cursor cursor;
     gsr_monitor monitor;
     vec2i capture_pos;
     vec2i capture_size;
@@ -25,7 +24,6 @@ typedef struct {
 } gsr_capture_ximage;
 
 static void gsr_capture_ximage_stop(gsr_capture_ximage *self) {
-    gsr_cursor_deinit(&self->cursor);
     if(self->texture_id) {
         self->params.egl->glDeleteTextures(1, &self->texture_id);
         self->texture_id = 0;
@@ -40,11 +38,6 @@ static int gsr_capture_ximage_start(gsr_capture *cap, gsr_capture_metadata *capt
     gsr_capture_ximage *self = cap->priv;
     self->root_window = DefaultRootWindow(self->display);
 
-    if(gsr_cursor_init(&self->cursor, self->params.egl, self->display) != 0) {
-        gsr_capture_ximage_stop(self);
-        return -1;
-    }
-
     if(!get_monitor_by_name(self->params.egl, GSR_CONNECTION_X11, self->params.display_to_capture, &self->monitor)) {
         fprintf(stderr, "gsr error: gsr_capture_ximage_start: failed to find monitor by name \"%s\"\n", self->params.display_to_capture);
         gsr_capture_ximage_stop(self);
@@ -59,14 +52,11 @@ static int gsr_capture_ximage_start(gsr_capture *cap, gsr_capture_metadata *capt
 
     if(self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0) {
         self->params.output_resolution = scale_keep_aspect_ratio(self->capture_size, self->params.output_resolution);
-        capture_metadata->width = self->params.output_resolution.x;
-        capture_metadata->height = self->params.output_resolution.y;
+        capture_metadata->video_size = self->params.output_resolution;
     } else if(self->params.region_size.x > 0 && self->params.region_size.y > 0) {
-        capture_metadata->width = self->params.region_size.x;
-        capture_metadata->height = self->params.region_size.y;
+        capture_metadata->video_size = self->params.region_size;
     } else {
-        capture_metadata->width = self->capture_size.x;
-        capture_metadata->height = self->capture_size.y;
+        capture_metadata->video_size = self->capture_size;
     }
 
     self->texture_id = gl_create_texture(self->params.egl, self->capture_size.x, self->capture_size.y, GL_RGB8, GL_RGB, GL_LINEAR);
@@ -79,12 +69,6 @@ static int gsr_capture_ximage_start(gsr_capture *cap, gsr_capture_metadata *capt
     return 0;
 }
 
-static void gsr_capture_ximage_on_event(gsr_capture *cap, gsr_egl *egl) {
-    gsr_capture_ximage *self = cap->priv;
-    XEvent *xev = gsr_window_get_event_data(egl->window);
-    gsr_cursor_on_event(&self->cursor, xev);
-}
-
 static bool gsr_capture_ximage_upload_to_texture(gsr_capture_ximage *self, int x, int y, int width, int height) {
     const int max_width = XWidthOfScreen(DefaultScreenOfDisplay(self->display));
     const int max_height = XHeightOfScreen(DefaultScreenOfDisplay(self->display));
@@ -137,6 +121,7 @@ static bool gsr_capture_ximage_upload_to_texture(gsr_capture_ximage *self, int x
     }
 
     self->params.egl->glBindTexture(GL_TEXTURE_2D, self->texture_id);
+    // TODO: Change to GL_RGBA for better performance? image_data needs alpha then as well
     self->params.egl->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, image->width, image->height, GL_RGB, GL_UNSIGNED_BYTE, image_data);
     self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
     success = true;
@@ -147,41 +132,36 @@ static bool gsr_capture_ximage_upload_to_texture(gsr_capture_ximage *self, int x
     return success;
 }
 
-static int gsr_capture_ximage_capture(gsr_capture *cap, gsr_capture_metadata *capture_metdata, gsr_color_conversion *color_conversion) {
+static int gsr_capture_ximage_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
     gsr_capture_ximage *self = cap->priv;
 
-    const bool is_scaled = self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0;
-    vec2i output_size = is_scaled ? self->params.output_resolution : self->capture_size;
-    output_size = scale_keep_aspect_ratio(self->capture_size, output_size);
-
-    const vec2i target_pos = { max_int(0, capture_metdata->width / 2 - output_size.x / 2), max_int(0, capture_metdata->height / 2 - output_size.y / 2) };
+    const vec2i output_size = scale_keep_aspect_ratio(self->capture_size, capture_metadata->recording_size);
+    const vec2i target_pos = gsr_capture_get_target_position(output_size, capture_metadata);
     gsr_capture_ximage_upload_to_texture(self, self->capture_pos.x + self->params.region_position.x, self->capture_pos.y + self->params.region_position.y, self->capture_size.x, self->capture_size.y);
 
     gsr_color_conversion_draw(color_conversion, self->texture_id,
         target_pos, output_size,
         (vec2i){0, 0}, self->capture_size, self->capture_size,
-        GSR_ROT_0, GSR_SOURCE_COLOR_RGB, false, false);
+        GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false);
 
-    if(self->params.record_cursor && self->cursor.visible) {
+    if(self->params.record_cursor && self->params.cursor->visible) {
         const vec2d scale = {
             self->capture_size.x == 0 ? 0 : (double)output_size.x / (double)self->capture_size.x,
             self->capture_size.y == 0 ? 0 : (double)output_size.y / (double)self->capture_size.y
         };
 
-        gsr_cursor_tick(&self->cursor, self->root_window);
-
         const vec2i cursor_pos = {
-            target_pos.x + (self->cursor.position.x - self->cursor.hotspot.x) * scale.x - self->capture_pos.x - self->params.region_position.x,
-            target_pos.y + (self->cursor.position.y - self->cursor.hotspot.y) * scale.y - self->capture_pos.y - self->params.region_position.y
+            target_pos.x + (self->params.cursor->position.x - self->params.cursor->hotspot.x) * scale.x - self->capture_pos.x - self->params.region_position.x,
+            target_pos.y + (self->params.cursor->position.y - self->params.cursor->hotspot.y) * scale.y - self->capture_pos.y - self->params.region_position.y
         };
 
         self->params.egl->glEnable(GL_SCISSOR_TEST);
         self->params.egl->glScissor(target_pos.x, target_pos.y, output_size.x, output_size.y);
 
-        gsr_color_conversion_draw(color_conversion, self->cursor.texture_id,
-            cursor_pos, (vec2i){self->cursor.size.x * scale.x, self->cursor.size.y * scale.y},
-            (vec2i){0, 0}, self->cursor.size, self->cursor.size,
-            GSR_ROT_0, GSR_SOURCE_COLOR_RGB, false, true);
+        gsr_color_conversion_draw(color_conversion, self->params.cursor->texture_id,
+            cursor_pos, (vec2i){self->params.cursor->size.x * scale.x, self->params.cursor->size.y * scale.y},
+            (vec2i){0, 0}, self->params.cursor->size, self->params.cursor->size,
+            GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false);
 
         self->params.egl->glDisable(GL_SCISSOR_TEST);
     }
@@ -233,7 +213,6 @@ gsr_capture* gsr_capture_ximage_create(const gsr_capture_ximage_params *params)
     
     *cap = (gsr_capture) {
         .start = gsr_capture_ximage_start,
-        .on_event = gsr_capture_ximage_on_event,
         .tick = NULL,
         .should_stop = NULL,
         .capture = gsr_capture_ximage_capture,

src/codec_query/vaapi.c

@@ -87,7 +87,7 @@ static vec2i profile_entrypoint_get_max_resolution(VADisplay va_dpy, VAProfile p
             .type = VAConfigAttribMaxPictureHeight,
         }
     };
-    if(vaGetConfigAttributes(va_dpy, profile, entrypoint, attribs, 2) != VA_STATUS_SUCCESS)
+    if(vaGetConfigAttributes(va_dpy, profile, entrypoint, attribs, 2) != VA_STATUS_SUCCESS || (attribs[0].value & VA_ATTRIB_NOT_SUPPORTED) || (attribs[1].value & VA_ATTRIB_NOT_SUPPORTED))
         return (vec2i){0, 0};
 
     return (vec2i){ attribs[0].value, attribs[1].value };

src/color_conversion.c

@@ -1,29 +1,21 @@
 #include "../include/color_conversion.h"
 #include "../include/egl.h"
 #include <stdio.h>
-#include <math.h>
 #include <string.h>
 #include <assert.h>
 
-#define COMPUTE_SHADER_INDEX_Y                  0
-#define COMPUTE_SHADER_INDEX_UV                 1
-#define COMPUTE_SHADER_INDEX_Y_EXTERNAL         2
-#define COMPUTE_SHADER_INDEX_UV_EXTERNAL        3
-#define COMPUTE_SHADER_INDEX_RGB                4
-#define COMPUTE_SHADER_INDEX_RGB_EXTERNAL       5
-#define COMPUTE_SHADER_INDEX_Y_BLEND            6
-#define COMPUTE_SHADER_INDEX_UV_BLEND           7
-#define COMPUTE_SHADER_INDEX_Y_EXTERNAL_BLEND   8
-#define COMPUTE_SHADER_INDEX_UV_EXTERNAL_BLEND  9
-#define COMPUTE_SHADER_INDEX_RGB_BLEND          10
-#define COMPUTE_SHADER_INDEX_RGB_EXTERNAL_BLEND 11
-
-#define GRAPHICS_SHADER_INDEX_Y                  0
-#define GRAPHICS_SHADER_INDEX_UV                 1
-#define GRAPHICS_SHADER_INDEX_Y_EXTERNAL         2
-#define GRAPHICS_SHADER_INDEX_UV_EXTERNAL        3
-#define GRAPHICS_SHADER_INDEX_RGB                4
-#define GRAPHICS_SHADER_INDEX_RGB_EXTERNAL       5
+#define GRAPHICS_SHADER_INDEX_Y                    0
+#define GRAPHICS_SHADER_INDEX_UV                   1
+#define GRAPHICS_SHADER_INDEX_Y_EXTERNAL           2
+#define GRAPHICS_SHADER_INDEX_UV_EXTERNAL          3
+#define GRAPHICS_SHADER_INDEX_RGB                  4
+#define GRAPHICS_SHADER_INDEX_RGB_EXTERNAL         5
+#define GRAPHICS_SHADER_INDEX_YUYV_TO_Y            6
+#define GRAPHICS_SHADER_INDEX_YUYV_TO_UV           7
+#define GRAPHICS_SHADER_INDEX_YUYV_TO_Y_EXTERNAL   8
+#define GRAPHICS_SHADER_INDEX_YUYV_TO_UV_EXTERNAL  9
+#define GRAPHICS_SHADER_INDEX_YUYV_TO_RGB          10
+#define GRAPHICS_SHADER_INDEX_YUYV_TO_RGB_EXTERNAL 11
 
 /* https://en.wikipedia.org/wiki/YCbCr, see study/color_space_transform_matrix.png */
 
@@ -53,10 +45,6 @@
                             "                           0.060118,  0.429412, -0.038049, 0.000000,\n" \
                             "                           0.062745,  0.500000,  0.500000, 1.000000);\n"
 
-static int max_int(int a, int b) {
-    return a > b ? a : b;
-}
-
 static const char* color_format_range_get_transform_matrix(gsr_destination_color color_format, gsr_color_range color_range) {
     switch(color_format) {
         case GSR_DESTINATION_COLOR_NV12: {
@@ -85,156 +73,6 @@ static const char* color_format_range_get_transform_matrix(gsr_destination_color
     return NULL;
 }
 
-static void get_compute_shader_header(char *header, size_t header_size, bool external_texture) {
-    if(external_texture) {
-        snprintf(header, header_size,
-            "#version 310 es\n"
-            "#extension GL_OES_EGL_image_external : enable\n"
-            "#extension GL_OES_EGL_image_external_essl3 : require\n"
-            "layout(binding = 0) uniform highp samplerExternalOES img_input;\n"
-            "layout(binding = 1) uniform highp sampler2D img_background;\n");
-    } else {
-        snprintf(header, header_size,
-            "#version 310 es\n"
-            "layout(binding = 0) uniform highp sampler2D img_input;\n"
-            "layout(binding = 1) uniform highp sampler2D img_background;\n");
-    }
-}
-
-static int load_compute_shader_y(gsr_shader *shader, gsr_egl *egl, gsr_color_compute_uniforms *uniforms, int max_local_size_dim, gsr_destination_color color_format, gsr_color_range color_range, bool external_texture, bool alpha_blending) {
-    const char *color_transform_matrix = color_format_range_get_transform_matrix(color_format, color_range);
-
-    char header[512];
-    get_compute_shader_header(header, sizeof(header), external_texture);
-
-    char compute_shader[4096];
-    snprintf(compute_shader, sizeof(compute_shader),
-        "%s"
-        "layout (local_size_x = %d, local_size_y = %d, local_size_z = 1) in;\n"
-        "precision highp float;\n"
-        "uniform ivec2 source_position;\n"
-        "uniform ivec2 target_position;\n"
-        "uniform vec2 scale;\n"
-        "uniform mat2 rotation_matrix;\n"
-        "layout(rgba8, binding = 0) writeonly uniform highp image2D img_output;\n"
-        "%s"
-        "void main() {\n"
-        "    ivec2 texel_coord = ivec2(gl_GlobalInvocationID.xy);\n"
-        "    ivec2 size = ivec2(vec2(textureSize(img_input, 0)) * scale + 0.5);\n"
-        "    ivec2 size_shift = size >> 1;\n" // size/2
-        "    ivec2 output_size = textureSize(img_background, 0);\n"
-        "    vec2 rotated_texel_coord = vec2(texel_coord - source_position - size_shift) * rotation_matrix + vec2(size_shift) + 0.5;\n"
-        "    vec2 output_texel_coord = vec2(texel_coord - source_position + target_position) + 0.5;\n"
-        "    vec2 source_color_coords = rotated_texel_coord/vec2(size);\n"
-        "    vec4 source_color = texture(img_input, source_color_coords);\n"
-        "    if(source_color_coords.x > 1.0 || source_color_coords.y > 1.0)\n"
-        "        source_color.rgba = vec4(0.0, 0.0, 0.0, %s);\n"
-        "    vec4 source_color_yuv = RGBtoYUV * vec4(source_color.rgb, 1.0);\n"
-        "    vec4 output_color_yuv = %s;\n"
-        "    float y_color = mix(output_color_yuv.r, source_color_yuv.r, source_color.a);\n"
-        "    imageStore(img_output, texel_coord + target_position, vec4(y_color, 1.0, 1.0, 1.0));\n"
-        "}\n", header, max_local_size_dim, max_local_size_dim, color_transform_matrix,
-            alpha_blending ? "0.0" : "1.0",
-            alpha_blending ? "texture(img_background, output_texel_coord/vec2(output_size))" : "source_color_yuv");
-
-    if(gsr_shader_init(shader, egl, NULL, NULL, compute_shader) != 0)
-        return -1;
-
-    uniforms->source_position = egl->glGetUniformLocation(shader->program_id, "source_position");
-    uniforms->target_position = egl->glGetUniformLocation(shader->program_id, "target_position");
-    uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix");
-    uniforms->scale = egl->glGetUniformLocation(shader->program_id, "scale");
-    return 0;
-}
-
-static int load_compute_shader_uv(gsr_shader *shader, gsr_egl *egl, gsr_color_compute_uniforms *uniforms, int max_local_size_dim, gsr_destination_color color_format, gsr_color_range color_range, bool external_texture, bool alpha_blending) {
-    const char *color_transform_matrix = color_format_range_get_transform_matrix(color_format, color_range);
-
-    char header[512];
-    get_compute_shader_header(header, sizeof(header), external_texture);
-
-    char compute_shader[4096];
-    snprintf(compute_shader, sizeof(compute_shader),
-        "%s"
-        "layout (local_size_x = %d, local_size_y = %d, local_size_z = 1) in;\n"
-        "precision highp float;\n"
-        "uniform ivec2 source_position;\n"
-        "uniform ivec2 target_position;\n"
-        "uniform vec2 scale;\n"
-        "uniform mat2 rotation_matrix;\n"
-        "layout(rgba8, binding = 0) writeonly uniform highp image2D img_output;\n"
-        "%s"
-        "void main() {\n"
-        "    ivec2 texel_coord = ivec2(gl_GlobalInvocationID.xy);\n"
-        "    ivec2 size = ivec2(vec2(textureSize(img_input, 0)) * scale + 0.5);\n"
-        "    ivec2 size_shift = size >> 2;\n" // size/4
-        "    ivec2 output_size = textureSize(img_background, 0);\n"
-        "    vec2 rotated_texel_coord = vec2(texel_coord - source_position - size_shift) * rotation_matrix + vec2(size_shift) + 0.5;\n"
-        "    vec2 output_texel_coord = vec2(texel_coord - source_position + target_position) + 0.5;\n"
-        "    vec2 source_color_coords = rotated_texel_coord/vec2(size>>1);\n"
-        "    vec4 source_color = texture(img_input, source_color_coords);\n" // size/2
-        "    if(source_color_coords.x > 1.0 || source_color_coords.y > 1.0)\n"
-        "        source_color.rgba = vec4(0.0, 0.0, 0.0, %s);\n"
-        "    vec4 source_color_yuv = RGBtoYUV * vec4(source_color.rgb, 1.0);\n"
-        "    vec4 output_color_yuv = %s;\n"
-        "    vec2 uv_color = mix(output_color_yuv.rg, source_color_yuv.gb, source_color.a);\n"
-        "    imageStore(img_output, texel_coord + target_position, vec4(uv_color, 1.0, 1.0));\n"
-        "}\n", header, max_local_size_dim, max_local_size_dim, color_transform_matrix,
-            alpha_blending ? "0.0" : "1.0",
-            alpha_blending ? "texture(img_background, output_texel_coord/vec2(output_size))" : "source_color_yuv");
-
-    if(gsr_shader_init(shader, egl, NULL, NULL, compute_shader) != 0)
-        return -1;
-
-    uniforms->source_position = egl->glGetUniformLocation(shader->program_id, "source_position");
-    uniforms->target_position = egl->glGetUniformLocation(shader->program_id, "target_position");
-    uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix");
-    uniforms->scale = egl->glGetUniformLocation(shader->program_id, "scale");
-    return 0;
-}
-
-static int load_compute_shader_rgb(gsr_shader *shader, gsr_egl *egl, gsr_color_compute_uniforms *uniforms, int max_local_size_dim, bool external_texture, bool alpha_blending) {
-    char header[512];
-    get_compute_shader_header(header, sizeof(header), external_texture);
-
-    char compute_shader[4096];
-    snprintf(compute_shader, sizeof(compute_shader),
-        "%s"
-        "layout (local_size_x = %d, local_size_y = %d, local_size_z = 1) in;\n"
-        "precision highp float;\n"
-        "uniform ivec2 source_position;\n"
-        "uniform ivec2 target_position;\n"
-        "uniform vec2 scale;\n"
-        "uniform mat2 rotation_matrix;\n"
-        "layout(rgba8, binding = 0) writeonly uniform highp image2D img_output;\n"
-        "void main() {\n"
-        "    ivec2 texel_coord = ivec2(gl_GlobalInvocationID.xy);\n"
-        "    ivec2 size = ivec2(vec2(textureSize(img_input, 0)) * scale + 0.5);\n"
-        "    ivec2 size_shift = size >> 1;\n" // size/2
-        "    ivec2 output_size = textureSize(img_background, 0);\n"
-        "    vec2 rotated_texel_coord = vec2(texel_coord - source_position - size_shift) * rotation_matrix + vec2(size_shift) + 0.5;\n"
-        "    vec2 output_texel_coord = vec2(texel_coord - source_position + target_position) + 0.5;\n"
-        "    vec2 source_color_coords = rotated_texel_coord/vec2(size);\n"
-        "    vec4 source_color = texture(img_input, source_color_coords);\n"
-        "    if(source_color_coords.x > 1.0 || source_color_coords.y > 1.0)\n"
-        "        source_color.rgba = vec4(0.0, 0.0, 0.0, %s);\n"
-        "    vec4 output_color = %s;\n"
-        "    vec3 color = mix(output_color.rgb, source_color.rgb, source_color.a);\n"
-        "    imageStore(img_output, texel_coord + target_position, vec4(color, 1.0));\n"
-        "}\n", header, max_local_size_dim, max_local_size_dim,
-            alpha_blending ? "0.0" : "1.0",
-            alpha_blending ? "texture(img_background, output_texel_coord/vec2(output_size))" : "source_color");
-
-    if(gsr_shader_init(shader, egl, NULL, NULL, compute_shader) != 0)
-        return -1;
-
-    uniforms->source_position = egl->glGetUniformLocation(shader->program_id, "source_position");
-    uniforms->target_position = egl->glGetUniformLocation(shader->program_id, "target_position");
-    uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix");
-    uniforms->scale = egl->glGetUniformLocation(shader->program_id, "scale");
-    return 0;
-}
-
 static int load_graphics_shader_y(gsr_shader *shader, gsr_egl *egl, gsr_color_graphics_uniforms *uniforms, gsr_destination_color color_format, gsr_color_range color_range, bool external_texture) {
     const char *color_transform_matrix = color_format_range_get_transform_matrix(color_format, color_range);
 
@@ -287,7 +125,7 @@ static int load_graphics_shader_y(gsr_shader *shader, gsr_egl *egl, gsr_color_gr
             "}                                                                               \n", color_transform_matrix, main_code);
     }
 
-    if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader, NULL) != 0)
+    if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0)
         return -1;
 
     gsr_shader_bind_attribute_location(shader, "pos", 0);
@@ -349,7 +187,7 @@ static unsigned int load_graphics_shader_uv(gsr_shader *shader, gsr_egl *egl, gs
             "}                                                                                     \n", color_transform_matrix, main_code);
     }
 
-    if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader, NULL) != 0)
+    if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0)
         return -1;
 
     gsr_shader_bind_attribute_location(shader, "pos", 0);
@@ -406,7 +244,213 @@ static unsigned int load_graphics_shader_rgb(gsr_shader *shader, gsr_egl *egl, g
             "}                                                                                     \n", main_code);
     }
 
-    if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader, NULL) != 0)
+    if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0)
+        return -1;
+
+    gsr_shader_bind_attribute_location(shader, "pos", 0);
+    gsr_shader_bind_attribute_location(shader, "texcoords", 1);
+    uniforms->offset = egl->glGetUniformLocation(shader->program_id, "offset");
+    uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix");
+    return 0;
+}
+
+static int load_graphics_shader_yuyv_to_y(gsr_shader *shader, gsr_egl *egl, gsr_color_graphics_uniforms *uniforms, bool external_texture) {
+    char vertex_shader[2048];
+    snprintf(vertex_shader, sizeof(vertex_shader),
+        "#version 300 es                                   \n"
+        "in vec2 pos;                                      \n"
+        "in vec2 texcoords;                                \n"
+        "out vec2 texcoords_out;                           \n"
+        "uniform vec2 offset;                              \n"
+        "uniform float rotation;                           \n"
+        "uniform mat2 rotation_matrix;                     \n"
+        "void main()                                       \n"
+        "{                                                 \n"
+        "  texcoords_out = vec2(texcoords.x - 0.5, texcoords.y - 0.5) * rotation_matrix + vec2(0.5, 0.5);  \n"
+        "  gl_Position = vec4(offset.x, offset.y, 0.0, 0.0) + vec4(pos.x, pos.y, 0.0, 1.0);    \n"
+        "}                                                 \n");
+
+    const char *main_code =
+            "  vec4 pixel = texture(tex1, texcoords_out);                                    \n"
+            "  FragColor.x = pixel.r;                                                        \n"
+            "  FragColor.w = 1.0;                                                            \n";
+
+    char fragment_shader[2048];
+    if(external_texture) {
+        snprintf(fragment_shader, sizeof(fragment_shader),
+            "#version 300 es                                                                 \n"
+            "#extension GL_OES_EGL_image_external : enable                                   \n"
+            "#extension GL_OES_EGL_image_external_essl3 : require                            \n"
+            "precision highp float;                                                          \n"
+            "in vec2 texcoords_out;                                                          \n"
+            "uniform samplerExternalOES tex1;                                                \n"
+            "out vec4 FragColor;                                                             \n"
+            "void main()                                                                     \n"
+            "{                                                                               \n"
+            "%s"
+            "}                                                                               \n", main_code);
+    } else {
+        snprintf(fragment_shader, sizeof(fragment_shader),
+            "#version 300 es                                                                 \n"
+            "precision highp float;                                                          \n"
+            "in vec2 texcoords_out;                                                          \n"
+            "uniform sampler2D tex1;                                                         \n"
+            "out vec4 FragColor;                                                             \n"
+            "void main()                                                                     \n"
+            "{                                                                               \n"
+            "%s"
+            "}                                                                               \n", main_code);
+    }
+
+    if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0)
+        return -1;
+
+    gsr_shader_bind_attribute_location(shader, "pos", 0);
+    gsr_shader_bind_attribute_location(shader, "texcoords", 1);
+    uniforms->offset = egl->glGetUniformLocation(shader->program_id, "offset");
+    uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix");
+    return 0;
+}
+
+static unsigned int load_graphics_shader_yuyv_to_uv(gsr_shader *shader, gsr_egl *egl, gsr_color_graphics_uniforms *uniforms, bool external_texture) {
+    char vertex_shader[2048];
+    snprintf(vertex_shader, sizeof(vertex_shader),
+        "#version 300 es                                 \n"
+        "in vec2 pos;                                    \n"
+        "in vec2 texcoords;                              \n"
+        "out vec2 texcoords_out;                         \n"
+        "uniform vec2 offset;                            \n"
+        "uniform float rotation;                         \n"
+        "uniform mat2 rotation_matrix;                   \n"
+        "void main()                                     \n"
+        "{                                               \n"
+        "  texcoords_out = vec2(texcoords.x - 0.5, texcoords.y - 0.5) * rotation_matrix + vec2(0.5, 0.5);                      \n"
+        "  gl_Position = (vec4(offset.x, offset.y, 0.0, 0.0) + vec4(pos.x, pos.y, 0.0, 1.0)) * vec4(0.5, 0.5, 1.0, 1.0) - vec4(0.5, 0.5, 0.0, 0.0);   \n"
+        "}                                               \n");
+
+    const char *main_code =
+            "    vec2 resolution = vec2(textureSize(tex1, 0));\n"
+            "    ivec2 uv = ivec2(texcoords_out * resolution);\n"
+            "    float u = 0.0;\n"
+            "    float v = 0.0;\n"
+            "    vec4 this_color = texelFetch(tex1, uv, 0);\n"
+            "    if((uv.x & 1) == 0) {\n"
+            "        vec2 next_color = texelFetch(tex1, uv + ivec2(1, 0), 0).rg;\n"
+            "        u = this_color.g;\n"
+            "        v = next_color.g;\n"
+            "    } else {\n"
+            "        vec2 prev_color = texelFetch(tex1, uv - ivec2(1, 0), 0).rg;\n"
+            "        u = prev_color.g;\n"
+            "        v = this_color.g;\n"
+            "    }\n"
+            "    FragColor.rg = vec2(u, v);\n"
+            "    FragColor.w = 1.0;\n";
+
+    char fragment_shader[2048];
+    if(external_texture) {
+        snprintf(fragment_shader, sizeof(fragment_shader),
+            "#version 300 es                                                                       \n"
+            "#extension GL_OES_EGL_image_external : enable                                         \n"
+            "#extension GL_OES_EGL_image_external_essl3 : require                                  \n"
+            "precision highp float;                                                                \n"
+            "in vec2 texcoords_out;                                                                \n"
+            "uniform samplerExternalOES tex1;                                                      \n"
+            "out vec4 FragColor;                                                                   \n"
+            "void main()                                                                           \n"
+            "{                                                                                     \n"
+            "%s"
+            "}                                                                                     \n", main_code);
+    } else {
+        snprintf(fragment_shader, sizeof(fragment_shader),
+            "#version 300 es                                                                       \n"
+            "precision highp float;                                                                \n"
+            "in vec2 texcoords_out;                                                                \n"
+            "uniform sampler2D tex1;                                                               \n"
+            "out vec4 FragColor;                                                                   \n"
+            "void main()                                                                           \n"
+            "{                                                                                     \n"
+            "%s"
+            "}                                                                                     \n", main_code);
+    }
+
+    if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0)
+        return -1;
+
+    gsr_shader_bind_attribute_location(shader, "pos", 0);
+    gsr_shader_bind_attribute_location(shader, "texcoords", 1);
+    uniforms->offset = egl->glGetUniformLocation(shader->program_id, "offset");
+    uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix");
+    return 0;
+}
+
+static unsigned int load_graphics_shader_yuyv_to_rgb(gsr_shader *shader, gsr_egl *egl, gsr_color_graphics_uniforms *uniforms, bool external_texture) {
+    char vertex_shader[2048];
+    snprintf(vertex_shader, sizeof(vertex_shader),
+        "#version 300 es                                   \n"
+        "in vec2 pos;                                      \n"
+        "in vec2 texcoords;                                \n"
+        "out vec2 texcoords_out;                           \n"
+        "uniform vec2 offset;                              \n"
+        "uniform float rotation;                           \n"
+        "uniform mat2 rotation_matrix;                     \n"
+        "void main()                                       \n"
+        "{                                                 \n"
+        "  texcoords_out = vec2(texcoords.x - 0.5, texcoords.y - 0.5) * rotation_matrix + vec2(0.5, 0.5);  \n"
+        "  gl_Position = vec4(offset.x, offset.y, 0.0, 0.0) + vec4(pos.x, pos.y, 0.0, 1.0);    \n"
+        "}                                                 \n");
+
+    const char *main_code =
+        "    vec2 resolution = vec2(textureSize(tex1, 0));\n"
+        "    ivec2 uv = ivec2(texcoords_out * resolution);\n"
+        "    float y = 0.0;\n"
+        "    float u = 0.0;\n"
+        "    float v = 0.0;\n"
+        "    vec4 this_color = texelFetch(tex1, uv, 0);\n"
+        "    if((uv.x & 1) == 0) {\n"
+        "        vec2 next_color = texelFetch(tex1, uv + ivec2(1, 0), 0).rg;\n"
+        "        y = this_color.r;\n"
+        "        u = this_color.g;\n"
+        "        v = next_color.g;\n"
+        "    } else {\n"
+        "        vec2 prev_color = texelFetch(tex1, uv - ivec2(1, 0), 0).rg;\n"
+        "        y = this_color.r;\n"
+        "        u = prev_color.g;\n"
+        "        v = this_color.g;\n"
+        "    }\n"
+        "    FragColor = vec4(\n"
+        "        y + 1.4065 * (v - 0.5),\n"
+        "        y - 0.3455 * (u - 0.5) - 0.7169 * (v - 0.5),\n"
+        "        y + 1.1790 * (u - 0.5),\n"
+        "        1.0);\n";
+
+    char fragment_shader[4096];
+    if(external_texture) {
+        snprintf(fragment_shader, sizeof(fragment_shader),
+            "#version 300 es                                                                       \n"
+            "#extension GL_OES_EGL_image_external : enable                                         \n"
+            "#extension GL_OES_EGL_image_external_essl3 : require                                  \n"
+            "precision highp float;                                                              \n"
+            "in vec2 texcoords_out;                                                                \n"
+            "uniform samplerExternalOES tex1;                                                      \n"
+            "out vec4 FragColor;                                                                   \n"
+            "void main()                                                                           \n"
+            "{                                                                                     \n"
+            "%s"
+            "}                                                                                     \n", main_code);
+    } else {
+        snprintf(fragment_shader, sizeof(fragment_shader),
+            "#version 300 es                                                                       \n"
+            "precision highp float;                                                              \n"
+            "in vec2 texcoords_out;                                                                \n"
+            "uniform sampler2D tex1;                                                               \n"
+            "out vec4 FragColor;                                                                   \n"
+            "void main()                                                                           \n"
+            "{                                                                                     \n"
+            "%s"
+            "}                                                                                     \n", main_code);
+    }
+
+    if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0)
         return -1;
 
     gsr_shader_bind_attribute_location(shader, "pos", 0);
@@ -465,88 +509,6 @@ static int create_vertices(gsr_color_conversion *self) {
     return 0;
 }
 
-static bool gsr_color_conversion_load_compute_shaders(gsr_color_conversion *self) {
-    switch(self->params.destination_color) {
-        case GSR_DESTINATION_COLOR_NV12:
-        case GSR_DESTINATION_COLOR_P010: {
-            if(load_compute_shader_y(&self->compute_shaders[COMPUTE_SHADER_INDEX_Y], self->params.egl, &self->compute_uniforms[COMPUTE_SHADER_INDEX_Y], self->max_local_size_dim, self->params.destination_color, self->params.color_range, false, false) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y compute shader\n");
-                return false;
-            }
-
-            if(load_compute_shader_uv(&self->compute_shaders[COMPUTE_SHADER_INDEX_UV], self->params.egl, &self->compute_uniforms[COMPUTE_SHADER_INDEX_UV], self->max_local_size_dim, self->params.destination_color, self->params.color_range, false, false) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV compute shader\n");
-                return false;
-            }
-
-            if(load_compute_shader_y(&self->compute_shaders[COMPUTE_SHADER_INDEX_Y_BLEND], self->params.egl, &self->compute_uniforms[COMPUTE_SHADER_INDEX_Y_BLEND], self->max_local_size_dim, self->params.destination_color, self->params.color_range, false, true) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y compute shader\n");
-                return false;
-            }
-
-            if(load_compute_shader_uv(&self->compute_shaders[COMPUTE_SHADER_INDEX_UV_BLEND], self->params.egl, &self->compute_uniforms[COMPUTE_SHADER_INDEX_UV_BLEND], self->max_local_size_dim, self->params.destination_color, self->params.color_range, false, true) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV compute shader\n");
-                return false;
-            }
-            break;
-        }
-        case GSR_DESTINATION_COLOR_RGB8: {
-            if(load_compute_shader_rgb(&self->compute_shaders[COMPUTE_SHADER_INDEX_RGB], self->params.egl, &self->compute_uniforms[COMPUTE_SHADER_INDEX_RGB], self->max_local_size_dim, false, false) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y compute shader\n");
-                return false;
-            }
-
-            if(load_compute_shader_rgb(&self->compute_shaders[COMPUTE_SHADER_INDEX_RGB_BLEND], self->params.egl, &self->compute_uniforms[COMPUTE_SHADER_INDEX_RGB_BLEND], self->max_local_size_dim, false, true) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y compute shader\n");
-                return false;
-            }
-            break;
-        }
-    }
-    return true;
-}
-
-static bool gsr_color_conversion_load_external_compute_shaders(gsr_color_conversion *self) {
-    switch(self->params.destination_color) {
-        case GSR_DESTINATION_COLOR_NV12:
-        case GSR_DESTINATION_COLOR_P010: {
-            if(load_compute_shader_y(&self->compute_shaders[COMPUTE_SHADER_INDEX_Y_EXTERNAL], self->params.egl, &self->compute_uniforms[COMPUTE_SHADER_INDEX_Y_EXTERNAL], self->max_local_size_dim, self->params.destination_color, self->params.color_range, true, false) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y compute shader\n");
-                return false;
-            }
-
-            if(load_compute_shader_uv(&self->compute_shaders[COMPUTE_SHADER_INDEX_UV_EXTERNAL], self->params.egl, &self->compute_uniforms[COMPUTE_SHADER_INDEX_UV_EXTERNAL], self->max_local_size_dim, self->params.destination_color, self->params.color_range, true, false) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV compute shader\n");
-                return false;
-            }
-
-            if(load_compute_shader_y(&self->compute_shaders[COMPUTE_SHADER_INDEX_Y_EXTERNAL_BLEND], self->params.egl, &self->compute_uniforms[COMPUTE_SHADER_INDEX_Y_EXTERNAL_BLEND], self->max_local_size_dim, self->params.destination_color, self->params.color_range, true, true) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y compute shader\n");
-                return false;
-            }
-
-            if(load_compute_shader_uv(&self->compute_shaders[COMPUTE_SHADER_INDEX_UV_EXTERNAL_BLEND], self->params.egl, &self->compute_uniforms[COMPUTE_SHADER_INDEX_UV_EXTERNAL_BLEND], self->max_local_size_dim, self->params.destination_color, self->params.color_range, true, true) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV compute shader\n");
-                return false;
-            }
-            break;
-        }
-        case GSR_DESTINATION_COLOR_RGB8: {
-            if(load_compute_shader_rgb(&self->compute_shaders[COMPUTE_SHADER_INDEX_RGB_EXTERNAL], self->params.egl, &self->compute_uniforms[COMPUTE_SHADER_INDEX_RGB_EXTERNAL], self->max_local_size_dim, true, false) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y compute shader\n");
-                return false;
-            }
-
-            if(load_compute_shader_rgb(&self->compute_shaders[COMPUTE_SHADER_INDEX_RGB_EXTERNAL_BLEND], self->params.egl, &self->compute_uniforms[COMPUTE_SHADER_INDEX_RGB_EXTERNAL_BLEND], self->max_local_size_dim, true, true) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y compute shader\n");
-                return false;
-            }
-            break;
-        }
-    }
-    return true;
-}
-
 static bool gsr_color_conversion_load_graphics_shaders(gsr_color_conversion *self) {
     switch(self->params.destination_color) {
         case GSR_DESTINATION_COLOR_NV12:
@@ -560,11 +522,26 @@ static bool gsr_color_conversion_load_graphics_shaders(gsr_color_conversion *sel
                 fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV graphics shader\n");
                 return false;
             }
+
+            if(load_graphics_shader_yuyv_to_y(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_YUYV_TO_Y], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_YUYV_TO_Y], false) != 0) {
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load YUYV to Y graphics shader\n");
+                return false;
+            }
+
+            if(load_graphics_shader_yuyv_to_uv(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_YUYV_TO_UV], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_YUYV_TO_UV], false) != 0) {
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load YUYV to UV graphics shader\n");
+                return false;
+            }
             break;
         }
         case GSR_DESTINATION_COLOR_RGB8: {
             if(load_graphics_shader_rgb(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_RGB], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_RGB], false) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y graphics shader\n");
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load RGB graphics shader\n");
+                return false;
+            }
+
+            if(load_graphics_shader_yuyv_to_rgb(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_YUYV_TO_RGB], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_YUYV_TO_RGB], false) != 0) {
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load YUYV to RGB graphics shader\n");
                 return false;
             }
             break;
@@ -578,19 +555,34 @@ static bool gsr_color_conversion_load_external_graphics_shaders(gsr_color_conver
         case GSR_DESTINATION_COLOR_NV12:
         case GSR_DESTINATION_COLOR_P010: {
             if(load_graphics_shader_y(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_Y_EXTERNAL], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_Y_EXTERNAL], self->params.destination_color, self->params.color_range, true) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y graphics shader\n");
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y graphics shader (external)\n");
                 return false;
             }
 
             if(load_graphics_shader_uv(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_UV_EXTERNAL], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_UV_EXTERNAL], self->params.destination_color, self->params.color_range, true) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV graphics shader\n");
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV graphics shader (external)\n");
+                return false;
+            }
+
+            if(load_graphics_shader_yuyv_to_y(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_YUYV_TO_Y_EXTERNAL], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_YUYV_TO_Y_EXTERNAL], true) != 0) {
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load YUYV to Y graphics shader (external)\n");
+                return false;
+            }
+
+            if(load_graphics_shader_yuyv_to_uv(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_YUYV_TO_UV_EXTERNAL], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_YUYV_TO_UV_EXTERNAL], true) != 0) {
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load YUYV to UV graphics shader (external)\n");
                 return false;
             }
             break;
         }
         case GSR_DESTINATION_COLOR_RGB8: {
             if(load_graphics_shader_rgb(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_RGB_EXTERNAL], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_RGB_EXTERNAL], true) != 0) {
-                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y graphics shader\n");
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load RGB graphics shader (external)\n");
+                return false;
+            }
+
+            if(load_graphics_shader_yuyv_to_rgb(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_YUYV_TO_RGB_EXTERNAL], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_YUYV_TO_RGB_EXTERNAL], true) != 0) {
+                fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load YUYV to RGB graphics shader (external)\n");
                 return false;
             }
             break;
@@ -605,10 +597,6 @@ int gsr_color_conversion_init(gsr_color_conversion *self, const gsr_color_conver
     memset(self, 0, sizeof(*self));
     self->params.egl = params->egl;
     self->params = *params;
-    
-    int max_compute_work_group_invocations = 256;
-    self->params.egl->glGetIntegerv(GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS, &max_compute_work_group_invocations);
-    self->max_local_size_dim = sqrt(max_compute_work_group_invocations);
 
     switch(self->params.destination_color) {
         case GSR_DESTINATION_COLOR_NV12:
@@ -628,33 +616,12 @@ int gsr_color_conversion_init(gsr_color_conversion *self, const gsr_color_conver
         }
     }
 
-    if(self->params.force_graphics_shader) {
-        self->compute_shaders_failed_to_load = true;
-        self->external_compute_shaders_failed_to_load = true;
-        
-        if(!gsr_color_conversion_load_graphics_shaders(self))
+    if(!gsr_color_conversion_load_graphics_shaders(self))
+        goto err;
+
+    if(self->params.load_external_image_shader) {
+        if(!gsr_color_conversion_load_external_graphics_shaders(self))
             goto err;
-
-        if(self->params.load_external_image_shader) {
-            if(!gsr_color_conversion_load_external_graphics_shaders(self))
-                goto err;
-        }
-    } else {
-        if(!gsr_color_conversion_load_compute_shaders(self)) {
-            self->compute_shaders_failed_to_load = true;
-            fprintf(stderr, "gsr info: failed to load one or more compute shaders, run gpu-screen-recorder with the '-gl-debug yes' option to see why. Falling back to slower graphics shader instead\n");
-            if(!gsr_color_conversion_load_graphics_shaders(self))
-                goto err;
-        }
-
-        if(self->params.load_external_image_shader) {
-            if(!gsr_color_conversion_load_external_compute_shaders(self)) {
-                self->external_compute_shaders_failed_to_load = true;
-                fprintf(stderr, "gsr info: failed to load one or more external compute shaders, run gpu-screen-recorder with the '-gl-debug yes' option to see why. Falling back to slower graphics shader instead\n");
-                if(!gsr_color_conversion_load_external_graphics_shaders(self))
-                    goto err;
-            }
-        }
     }
 
     if(load_framebuffers(self) != 0)
@@ -689,10 +656,6 @@ void gsr_color_conversion_deinit(gsr_color_conversion *self) {
         self->framebuffers[i] = 0;
     }
 
-    for(int i = 0; i < GSR_COLOR_CONVERSION_MAX_COMPUTE_SHADERS; ++i) {
-        gsr_shader_deinit(&self->compute_shaders[i]);
-    }
-
     for(int i = 0; i < GSR_COLOR_CONVERSION_MAX_GRAPHICS_SHADERS; ++i) {
         gsr_shader_deinit(&self->graphics_shaders[i]);
     }
@@ -737,104 +700,35 @@ static void gsr_color_conversion_apply_rotation(gsr_rotation rotation, float rot
     }
 }
 
-static void gsr_color_conversion_swizzle_texture_source(gsr_color_conversion *self, gsr_source_color source_color) {
+static void gsr_color_conversion_swizzle_texture_source(gsr_color_conversion *self, unsigned int texture_target, gsr_source_color source_color) {
     if(source_color == GSR_SOURCE_COLOR_BGR) {
         const int swizzle_mask[] = { GL_BLUE, GL_GREEN, GL_RED, 1 };
-        self->params.egl->glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle_mask);
+        self->params.egl->glTexParameteriv(texture_target, GL_TEXTURE_SWIZZLE_RGBA, swizzle_mask);
     }
 }
 
-static void gsr_color_conversion_swizzle_reset(gsr_color_conversion *self, gsr_source_color source_color) {
+static void gsr_color_conversion_swizzle_reset(gsr_color_conversion *self, unsigned int texture_target, gsr_source_color source_color) {
     if(source_color == GSR_SOURCE_COLOR_BGR) {
         const int swizzle_mask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };
-        self->params.egl->glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle_mask);
+        self->params.egl->glTexParameteriv(texture_target, GL_TEXTURE_SWIZZLE_RGBA, swizzle_mask);
     }
 }
 
-typedef enum {
-    GSR_COLOR_COMP_Y,
-    GSR_COLOR_COMP_UV,
-    GSR_COLOR_COMP_RGB
-} gsr_color_component;
+static void gsr_color_conversion_draw_graphics(gsr_color_conversion *self, unsigned int texture_id, bool external_texture, gsr_rotation rotation, gsr_flip flip, float rotation_matrix[2][2], vec2i source_position, vec2i source_size, vec2i destination_pos, vec2i texture_size, vec2f scale, gsr_source_color source_color) {
+    if(source_size.x == 0 || source_size.y == 0)
+        return;
 
-static int color_component_get_destination_texture_index(gsr_color_component color_component) {
-    switch(color_component) {
-        case GSR_COLOR_COMP_Y:   return 0;
-        case GSR_COLOR_COMP_UV:  return 1;
-        case GSR_COLOR_COMP_RGB: return 0;
+    const vec2i dest_texture_size = self->params.destination_textures_size[0];
+    const unsigned int texture_target = external_texture ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
+
+    if(rotation == GSR_ROT_90 || rotation == GSR_ROT_270) {
+        const float tmp = texture_size.x;
+        texture_size.x = texture_size.y;
+        texture_size.y = tmp;
     }
-    assert(false);
-    return 0;
-}
-
-static unsigned int color_component_get_color_format(gsr_color_component color_component, bool use_16bit_colors) {
-    switch(color_component) {
-        case GSR_COLOR_COMP_Y:   return use_16bit_colors ? GL_R16 : GL_R8;
-        case GSR_COLOR_COMP_UV:  return use_16bit_colors ? GL_RG16 : GL_RG8;
-        case GSR_COLOR_COMP_RGB: return GL_RGBA8; // TODO: 16-bit color support
-    }
-    assert(false);
-    return GL_RGBA8;
-}
-
-static int color_component_get_COMPUTE_SHADER_INDEX(gsr_color_component color_component, bool external_texture, bool alpha_blending) {
-    switch(color_component) {
-        case GSR_COLOR_COMP_Y: {
-            if(external_texture)
-                return alpha_blending ? COMPUTE_SHADER_INDEX_Y_EXTERNAL_BLEND : COMPUTE_SHADER_INDEX_Y_EXTERNAL;
-            else
-                return alpha_blending ? COMPUTE_SHADER_INDEX_Y_BLEND : COMPUTE_SHADER_INDEX_Y;
-        }
-        case GSR_COLOR_COMP_UV: {
-            if(external_texture)
-                return alpha_blending ? COMPUTE_SHADER_INDEX_UV_EXTERNAL_BLEND : COMPUTE_SHADER_INDEX_UV_EXTERNAL;
-            else
-                return alpha_blending ? COMPUTE_SHADER_INDEX_UV_BLEND : COMPUTE_SHADER_INDEX_UV;
-        }
-        case GSR_COLOR_COMP_RGB: {
-            if(external_texture)
-                return alpha_blending ? COMPUTE_SHADER_INDEX_RGB_EXTERNAL_BLEND : COMPUTE_SHADER_INDEX_RGB_EXTERNAL;
-            else
-                return alpha_blending ? COMPUTE_SHADER_INDEX_RGB_BLEND : COMPUTE_SHADER_INDEX_RGB;
-        }
-    }
-    assert(false);
-    return COMPUTE_SHADER_INDEX_RGB;
-}
-
-static void gsr_color_conversion_dispatch_compute_shader(gsr_color_conversion *self, bool external_texture, bool alpha_blending, float rotation_matrix[2][2], vec2i source_position, vec2i destination_pos, vec2i destination_size, vec2f scale, bool use_16bit_colors, gsr_color_component color_component) {
-    const int compute_shader_index = color_component_get_COMPUTE_SHADER_INDEX(color_component, external_texture, alpha_blending);
-    const int destination_texture_index = color_component_get_destination_texture_index(color_component);
-    const unsigned int color_format = color_component_get_color_format(color_component, use_16bit_colors);
-
-    self->params.egl->glActiveTexture(GL_TEXTURE1);
-    self->params.egl->glBindTexture(GL_TEXTURE_2D, self->params.destination_textures[destination_texture_index]);
-    self->params.egl->glActiveTexture(GL_TEXTURE0);
-
-    gsr_color_compute_uniforms *uniform = &self->compute_uniforms[compute_shader_index];
-    gsr_shader_use(&self->compute_shaders[compute_shader_index]);
-    self->params.egl->glUniformMatrix2fv(uniform->rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix);
-    self->params.egl->glUniform2i(uniform->source_position, source_position.x, source_position.y);
-    self->params.egl->glUniform2i(uniform->target_position, destination_pos.x, destination_pos.y);
-    self->params.egl->glUniform2f(uniform->scale, scale.x, scale.y);
-    self->params.egl->glBindImageTexture(0, self->params.destination_textures[destination_texture_index], 0, GL_FALSE, 0, GL_WRITE_ONLY, color_format);
-    const double num_groups_x = ceil((double)destination_size.x/(double)self->max_local_size_dim);
-    const double num_groups_y = ceil((double)destination_size.y/(double)self->max_local_size_dim);
-    self->params.egl->glDispatchCompute(max_int(1, num_groups_x), max_int(1, num_groups_y), 1);
-}
-
-static void gsr_color_conversion_draw_graphics(gsr_color_conversion *self, unsigned int texture_id, bool external_texture, float rotation_matrix[2][2], vec2i source_position, vec2i source_size, vec2i destination_pos, vec2i texture_size, vec2f scale, gsr_source_color source_color) {
-    /* TODO: Do not call this every frame? */
-    vec2i dest_texture_size = {0, 0};
-    self->params.egl->glBindTexture(GL_TEXTURE_2D, self->params.destination_textures[0]);
-    self->params.egl->glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &dest_texture_size.x);
-    self->params.egl->glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &dest_texture_size.y);
-    self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
-
-    const int texture_target = external_texture ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
 
     self->params.egl->glBindTexture(texture_target, texture_id);
-    gsr_color_conversion_swizzle_texture_source(self, source_color);
+    gsr_color_conversion_swizzle_texture_source(self, texture_target, source_color);
 
     const vec2f pos_norm = {
         ((float)destination_pos.x / (dest_texture_size.x == 0 ? 1.0f : (float)dest_texture_size.x)) * 2.0f,
@@ -856,7 +750,7 @@ static void gsr_color_conversion_draw_graphics(gsr_color_conversion *self, unsig
         (float)source_size.y / (texture_size.y == 0 ? 1.0f : (float)texture_size.y),
     };
 
-    const float vertices[] = {
+    float vertices[] = {
         -1.0f + 0.0f,               -1.0f + 0.0f + size_norm.y, texture_pos_norm.x,                       texture_pos_norm.y + texture_size_norm.y,
         -1.0f + 0.0f,               -1.0f + 0.0f,               texture_pos_norm.x,                       texture_pos_norm.y,
         -1.0f + 0.0f + size_norm.x, -1.0f + 0.0f,               texture_pos_norm.x + texture_size_norm.x, texture_pos_norm.y,
@@ -866,6 +760,20 @@ static void gsr_color_conversion_draw_graphics(gsr_color_conversion *self, unsig
         -1.0f + 0.0f + size_norm.x, -1.0f + 0.0f + size_norm.y, texture_pos_norm.x + texture_size_norm.x, texture_pos_norm.y + texture_size_norm.y
     };
 
+    if(flip & GSR_FLIP_HORIZONTAL) {
+        for(int i = 0; i < 6; ++i) {
+            const float prev_x = vertices[i*4 + 2];
+            vertices[i*4 + 2] = texture_pos_norm.x + texture_size_norm.x - prev_x;
+        }
+    }
+
+    if(flip & GSR_FLIP_VERTICAL) {
+        for(int i = 0; i < 6; ++i) {
+            const float prev_y = vertices[i*4 + 3];
+            vertices[i*4 + 3] = texture_pos_norm.y + texture_size_norm.y - prev_y;
+        }
+    }
+
     self->params.egl->glBindVertexArray(self->vertex_array_object_id);
     self->params.egl->glViewport(0, 0, dest_texture_size.x, dest_texture_size.y);
 
@@ -873,51 +781,96 @@ 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);
 
-    switch(self->params.destination_color) {
-        case GSR_DESTINATION_COLOR_NV12:
-        case GSR_DESTINATION_COLOR_P010: {
-            self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]);
-            //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); // TODO: Do this in a separate clear_ function. We want to do that when using multiple drm to create the final image (multiple monitors for example)
+    switch(source_color) {
+        case GSR_SOURCE_COLOR_RGB:
+        case GSR_SOURCE_COLOR_BGR: {
+            switch(self->params.destination_color) {
+                case GSR_DESTINATION_COLOR_NV12:
+                case GSR_DESTINATION_COLOR_P010: {
+                    self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]);
+                    //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); // TODO: Do this in a separate clear_ function. We want to do that when using multiple drm to create the final image (multiple monitors for example)
 
-            int shader_index = external_texture ? GRAPHICS_SHADER_INDEX_Y_EXTERNAL : GRAPHICS_SHADER_INDEX_Y;
-            gsr_shader_use(&self->graphics_shaders[shader_index]);
-            self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix);
-            self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y);
-            self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6);
+                    int shader_index = external_texture ? GRAPHICS_SHADER_INDEX_Y_EXTERNAL : GRAPHICS_SHADER_INDEX_Y;
+                    gsr_shader_use(&self->graphics_shaders[shader_index]);
+                    self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix);
+                    self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y);
+                    self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6);
 
-            if(self->params.num_destination_textures > 1) {
-                self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[1]);
-                //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT);
+                    if(self->params.num_destination_textures > 1) {
+                        self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[1]);
+                        //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT);
 
-                shader_index = external_texture ? GRAPHICS_SHADER_INDEX_UV_EXTERNAL : GRAPHICS_SHADER_INDEX_UV;
-                gsr_shader_use(&self->graphics_shaders[shader_index]);
-                self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix);
-                self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y);
-                self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6);
+                        shader_index = external_texture ? GRAPHICS_SHADER_INDEX_UV_EXTERNAL : GRAPHICS_SHADER_INDEX_UV;
+                        gsr_shader_use(&self->graphics_shaders[shader_index]);
+                        self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix);
+                        self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y);
+                        self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6);
+                    }
+                    break;
+                }
+                case GSR_DESTINATION_COLOR_RGB8: {
+                    self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]);
+                    //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); // TODO: Do this in a separate clear_ function. We want to do that when using multiple drm to create the final image (multiple monitors for example)
+
+                    const int shader_index = external_texture ? GRAPHICS_SHADER_INDEX_RGB_EXTERNAL : GRAPHICS_SHADER_INDEX_RGB;
+                    gsr_shader_use(&self->graphics_shaders[shader_index]);
+                    self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix);
+                    self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y);
+                    self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6);
+                    break;
+                }
             }
             break;
         }
-        case GSR_DESTINATION_COLOR_RGB8: {
-            self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]);
-            //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); // TODO: Do this in a separate clear_ function. We want to do that when using multiple drm to create the final image (multiple monitors for example)
+        case GSR_SOURCE_COLOR_YUYV: {
+            switch(self->params.destination_color) {
+                case GSR_DESTINATION_COLOR_NV12:
+                case GSR_DESTINATION_COLOR_P010: {
+                    self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]);
+                    //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); // TODO: Do this in a separate clear_ function. We want to do that when using multiple drm to create the final image (multiple monitors for example)
 
-            const int shader_index = external_texture ? GRAPHICS_SHADER_INDEX_RGB_EXTERNAL : GRAPHICS_SHADER_INDEX_RGB;
-            gsr_shader_use(&self->graphics_shaders[shader_index]);
-            self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix);
-            self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y);
-            self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6);
+                    int shader_index = external_texture ? GRAPHICS_SHADER_INDEX_YUYV_TO_Y_EXTERNAL : GRAPHICS_SHADER_INDEX_YUYV_TO_Y;
+                    gsr_shader_use(&self->graphics_shaders[shader_index]);
+                    self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix);
+                    self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y);
+                    self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6);
+
+                    if(self->params.num_destination_textures > 1) {
+                        self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[1]);
+                        //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT);
+
+                        shader_index = external_texture ? GRAPHICS_SHADER_INDEX_YUYV_TO_UV_EXTERNAL : GRAPHICS_SHADER_INDEX_YUYV_TO_UV;
+                        gsr_shader_use(&self->graphics_shaders[shader_index]);
+                        self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix);
+                        self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y);
+                        self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6);
+                    }
+                    break;
+                }
+                case GSR_DESTINATION_COLOR_RGB8: {
+                    self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]);
+                    //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); // TODO: Do this in a separate clear_ function. We want to do that when using multiple drm to create the final image (multiple monitors for example)
+
+                    const int shader_index = external_texture ? GRAPHICS_SHADER_INDEX_YUYV_TO_RGB_EXTERNAL : GRAPHICS_SHADER_INDEX_YUYV_TO_RGB;
+                    gsr_shader_use(&self->graphics_shaders[shader_index]);
+                    self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix);
+                    self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y);
+                    self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6);
+                    break;
+                }
+            }
             break;
         }
     }
 
     self->params.egl->glBindVertexArray(0);
     self->params.egl->glUseProgram(0);
-    gsr_color_conversion_swizzle_reset(self, source_color);
+    gsr_color_conversion_swizzle_reset(self, texture_target, source_color);
     self->params.egl->glBindTexture(texture_target, 0);
     self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
-void gsr_color_conversion_draw(gsr_color_conversion *self, unsigned int texture_id, vec2i destination_pos, vec2i destination_size, vec2i source_pos, vec2i source_size, vec2i texture_size, gsr_rotation rotation, gsr_source_color source_color, bool external_texture, bool alpha_blending) {
+void gsr_color_conversion_draw(gsr_color_conversion *self, unsigned int texture_id, vec2i destination_pos, vec2i destination_size, vec2i source_pos, vec2i source_size, vec2i texture_size, gsr_rotation rotation, gsr_flip flip, gsr_source_color source_color, bool external_texture) {
     assert(!external_texture || self->params.load_external_image_shader);
     if(external_texture && !self->params.load_external_image_shader) {
         fprintf(stderr, "gsr error: gsr_color_conversion_draw: external texture not loaded\n");
@@ -934,53 +887,16 @@ void gsr_color_conversion_draw(gsr_color_conversion *self, unsigned int texture_
 
     const int texture_target = external_texture ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
     self->params.egl->glBindTexture(texture_target, texture_id);
-    gsr_color_conversion_swizzle_texture_source(self, source_color);
 
-    const bool use_graphics_shader = external_texture ? self->external_compute_shaders_failed_to_load : self->compute_shaders_failed_to_load;
-    if(use_graphics_shader) {
-        source_position.x += source_pos.x;
-        source_position.y += source_pos.y;
-        gsr_color_conversion_draw_graphics(self, texture_id, external_texture, rotation_matrix, source_position, source_size, destination_pos, texture_size, scale, source_color);
-    } else {
-        switch(rotation) {
-            case GSR_ROT_0:
-                break;
-            case GSR_ROT_90:
-                source_position.x += (((double)texture_size.x*0.5 - (double)texture_size.y*0.5) * scale.x);
-                source_position.y += (((double)texture_size.y*0.5 - (double)texture_size.x*0.5) * scale.y);
-                break;
-            case GSR_ROT_180:
-                break;
-            case GSR_ROT_270:
-                source_position.x += (((double)texture_size.x*0.5 - (double)texture_size.y*0.5) * scale.x);
-                source_position.y += (((double)texture_size.y*0.5 - (double)texture_size.x*0.5) * scale.y);
-                break;
-        }
-        source_position.x -= (source_pos.x * scale.x + 0.5);
-        source_position.y -= (source_pos.y * scale.y + 0.5);
-
-        switch(self->params.destination_color) {
-            case GSR_DESTINATION_COLOR_NV12:
-            case GSR_DESTINATION_COLOR_P010: {
-                const bool use_16bit_colors = self->params.destination_color == GSR_DESTINATION_COLOR_P010;
-                gsr_color_conversion_dispatch_compute_shader(self, external_texture, alpha_blending, rotation_matrix, source_position, destination_pos, destination_size, scale, use_16bit_colors, GSR_COLOR_COMP_Y);
-                gsr_color_conversion_dispatch_compute_shader(self, external_texture, alpha_blending, rotation_matrix, (vec2i){source_position.x/2, source_position.y/2},
-                    (vec2i){destination_pos.x/2, destination_pos.y/2}, (vec2i){destination_size.x/2, destination_size.y/2}, scale, use_16bit_colors, GSR_COLOR_COMP_UV);
-                break;
-            }
-            case GSR_DESTINATION_COLOR_RGB8: {
-                gsr_color_conversion_dispatch_compute_shader(self, external_texture, alpha_blending, rotation_matrix, source_position, destination_pos, destination_size, scale, false, GSR_COLOR_COMP_RGB);
-                break;
-            }
-        }
-    }
+    source_position.x += source_pos.x;
+    source_position.y += source_pos.y;
+    gsr_color_conversion_draw_graphics(self, texture_id, external_texture, rotation, flip, rotation_matrix, source_position, source_size, destination_pos, texture_size, scale, source_color);
 
     self->params.egl->glFlush();
     // TODO: Use the minimal barrier required
     self->params.egl->glMemoryBarrier(GL_ALL_BARRIER_BITS); // GL_SHADER_IMAGE_ACCESS_BARRIER_BIT
     self->params.egl->glUseProgram(0);
 
-    gsr_color_conversion_swizzle_reset(self, source_color);
     self->params.egl->glBindTexture(texture_target, 0);
 }
 

src/cursor.c

@@ -96,7 +96,7 @@ int gsr_cursor_init(gsr_cursor *self, gsr_egl *egl, Display *display) {
 }
 
 void gsr_cursor_deinit(gsr_cursor *self) {
-    if(!self->egl)
+    if(!self->display)
         return;
 
     if(self->texture_id) {
@@ -112,6 +112,9 @@ void gsr_cursor_deinit(gsr_cursor *self) {
 }
 
 bool gsr_cursor_on_event(gsr_cursor *self, XEvent *xev) {
+    if(!self->display)
+        return false;
+
     bool updated = false;
 
     if(xev->type == self->x_fixes_event_base + XFixesCursorNotify) {
@@ -131,6 +134,9 @@ bool gsr_cursor_on_event(gsr_cursor *self, XEvent *xev) {
 }
 
 void gsr_cursor_tick(gsr_cursor *self, Window relative_to) {
+    if(!self->display)
+        return;
+
     Window dummy_window;
     int dummy_i;
     unsigned int dummy_u;

src/damage.c

@@ -4,6 +4,7 @@
 
 #include <stdio.h>
 #include <string.h>
+#include <stdlib.h>
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/Xrandr.h>
 
@@ -26,51 +27,115 @@ static bool xrandr_is_supported(Display *display) {
     return major_version > 1 || (major_version == 1 && minor_version >= 2);
 }
 
-bool gsr_damage_init(gsr_damage *self, gsr_egl *egl, bool track_cursor) {
+static int gsr_damage_get_tracked_monitor_index(const gsr_damage *self, const char *monitor_name) {
+    for(int i = 0; i < self->num_monitors_tracked; ++i) {
+        if(strcmp(self->monitors_tracked[i].monitor_name, monitor_name) == 0)
+            return i;
+    }
+    return -1;
+}
+
+static void add_monitor_callback(const gsr_monitor *monitor, void *userdata) {
+    gsr_damage *self = userdata;
+
+    const int damage_monitor_index = gsr_damage_get_tracked_monitor_index(self, monitor->name);
+    gsr_damage_monitor *damage_monitor = NULL;
+    if(damage_monitor_index != -1) {
+        damage_monitor = &self->monitors_tracked[damage_monitor_index];
+        damage_monitor->monitor = NULL;
+    }
+
+    if(self->num_monitors + 1 > GSR_DAMAGE_MAX_MONITORS) {
+        fprintf(stderr, "gsr error: gsr_damage_on_output_change: max monitors reached\n");
+        return;
+    }
+
+    char *monitor_name_copy = strdup(monitor->name);
+    if(!monitor_name_copy) {
+        fprintf(stderr, "gsr error: gsr_damage_on_output_change: strdup failed for monitor: %s\n", monitor->name);
+        return;
+    }
+
+    self->monitors[self->num_monitors] = *monitor;
+    self->monitors[self->num_monitors].name = monitor_name_copy;
+    ++self->num_monitors;
+
+    if(damage_monitor)
+        damage_monitor->monitor = &self->monitors[self->num_monitors - 1];
+}
+
+bool gsr_damage_init(gsr_damage *self, gsr_egl *egl, gsr_cursor *cursor, bool track_cursor) {
     memset(self, 0, sizeof(*self));
     self->egl = egl;
     self->track_cursor = track_cursor;
+    self->cursor = cursor;
 
     if(gsr_window_get_display_server(egl->window) != GSR_DISPLAY_SERVER_X11) {
-        fprintf(stderr, "gsr warning: gsr_damage_init: damage tracking is not supported on wayland\n");
+        fprintf(stderr, "gsr error: gsr_damage_init: damage tracking is not supported on wayland\n");
         return false;
     }
     self->display = gsr_window_get_display(egl->window);
 
     if(!XDamageQueryExtension(self->display, &self->damage_event, &self->damage_error)) {
-        fprintf(stderr, "gsr warning: gsr_damage_init: XDamage is not supported by your X11 server\n");
+        fprintf(stderr, "gsr error: gsr_damage_init: XDamage is not supported by your X11 server\n");
         gsr_damage_deinit(self);
         return false;
     }
 
     if(!XRRQueryExtension(self->display, &self->randr_event, &self->randr_error)) {
-        fprintf(stderr, "gsr warning: gsr_damage_init: XRandr is not supported by your X11 server\n");
+        fprintf(stderr, "gsr error: gsr_damage_init: XRandr is not supported by your X11 server\n");
         gsr_damage_deinit(self);
         return false;
     }
 
     if(!xrandr_is_supported(self->display)) {
-        fprintf(stderr, "gsr warning: gsr_damage_init: your X11 randr version is too old\n");
+        fprintf(stderr, "gsr error: gsr_damage_init: your X11 randr version is too old\n");
         gsr_damage_deinit(self);
         return false;
     }
 
-    if(self->track_cursor)
-        self->track_cursor = gsr_cursor_init(&self->cursor, self->egl, self->display) == 0;
-
     XRRSelectInput(self->display, DefaultRootWindow(self->display), RRScreenChangeNotifyMask | RRCrtcChangeNotifyMask | RROutputChangeNotifyMask);
 
+    self->monitor_damage = XDamageCreate(self->display, DefaultRootWindow(self->display), XDamageReportNonEmpty);
+    if(!self->monitor_damage) {
+        fprintf(stderr, "gsr error: gsr_damage_init: XDamageCreate failed\n");
+        gsr_damage_deinit(self);
+        return false;
+    }
+    XDamageSubtract(self->display, self->monitor_damage, None, None);
+
+    for_each_active_monitor_output_x11_not_cached(self->display, add_monitor_callback, self);
+
     self->damaged = true;
     return true;
 }
 
+static void gsr_damage_deinit_monitors(gsr_damage *self) {
+    for(int i = 0; i < self->num_monitors; ++i) {
+        free((char*)self->monitors[i].name);
+    }
+    self->num_monitors = 0;
+}
+
 void gsr_damage_deinit(gsr_damage *self) {
-    if(self->damage) {
-        XDamageDestroy(self->display, self->damage);
-        self->damage = None;
+    if(self->monitor_damage) {
+        XDamageDestroy(self->display, self->monitor_damage);
+        self->monitor_damage = None;
     }
 
-    gsr_cursor_deinit(&self->cursor);
+    for(int i = 0; i < self->num_monitors_tracked; ++i) {
+        free(self->monitors_tracked[i].monitor_name);
+    }
+    self->num_monitors_tracked = 0;
+
+    for(int i = 0; i < self->num_windows_tracked; ++i) {
+        XSelectInput(self->display, self->windows_tracked[i].window_id, 0);
+        XDamageDestroy(self->display, self->windows_tracked[i].damage);
+    }
+    self->num_windows_tracked = 0;
+
+    self->all_monitors_tracked_refcount = 0;
+    gsr_damage_deinit_monitors(self);
 
     self->damage_event = 0;
     self->damage_error = 0;
@@ -79,139 +144,191 @@ void gsr_damage_deinit(gsr_damage *self) {
     self->randr_error = 0;
 }
 
-bool gsr_damage_set_target_window(gsr_damage *self, uint64_t window) {
-    if(self->damage_event == 0)
+static int gsr_damage_get_tracked_window_index(const gsr_damage *self, int64_t window) {
+    for(int i = 0; i < self->num_windows_tracked; ++i) {
+        if(self->windows_tracked[i].window_id == window)
+            return i;
+    }
+    return -1;
+}
+
+bool gsr_damage_start_tracking_window(gsr_damage *self, int64_t window) {
+    if(self->damage_event == 0 || window == None)
         return false;
 
-    if(window == self->window)
+    const int damage_window_index = gsr_damage_get_tracked_window_index(self, window);
+    if(damage_window_index != -1) {
+        ++self->windows_tracked[damage_window_index].refcount;
         return true;
-
-    if(self->damage) {
-        XDamageDestroy(self->display, self->damage);
-        self->damage = None;
     }
 
-    if(self->window)
-        XSelectInput(self->display, self->window, 0);
-
-    self->window = window;
-    XSelectInput(self->display, self->window, StructureNotifyMask | ExposureMask);
+    if(self->num_windows_tracked + 1 > GSR_DAMAGE_MAX_TRACKED_TARGETS) {
+        fprintf(stderr, "gsr error: gsr_damage_start_tracking_window: max window targets reached\n");
+        return false;
+    }
 
     XWindowAttributes win_attr;
     win_attr.x = 0;
     win_attr.y = 0;
     win_attr.width = 0;
     win_attr.height = 0;
-    if(!XGetWindowAttributes(self->display, self->window, &win_attr))
-        fprintf(stderr, "gsr warning: gsr_damage_set_target_window failed: failed to get window attributes: %ld\n", (long)self->window);
+    if(!XGetWindowAttributes(self->display, window, &win_attr))
+        fprintf(stderr, "gsr warning: gsr_damage_start_tracking_window failed: failed to get window attributes: %ld\n", (long)window);
 
-    //self->window_pos.x = win_attr.x;
-    //self->window_pos.y = win_attr.y;
-
-    self->window_size.x = win_attr.width;
-    self->window_size.y = win_attr.height;
-
-    self->damage = XDamageCreate(self->display, window, XDamageReportNonEmpty);
-    if(self->damage) {
-        XDamageSubtract(self->display, self->damage, None, None);
-        self->damaged = true;
-        self->track_type = GSR_DAMAGE_TRACK_WINDOW;
-        return true;
-    } else {
-        fprintf(stderr, "gsr warning: gsr_damage_set_target_window: XDamageCreate failed\n");
-        self->track_type = GSR_DAMAGE_TRACK_NONE;
+    const Damage damage = XDamageCreate(self->display, window, XDamageReportNonEmpty);
+    if(!damage) {
+        fprintf(stderr, "gsr error: gsr_damage_start_tracking_window: XDamageCreate failed\n");
         return false;
     }
+    XDamageSubtract(self->display, damage, None, None);
+
+    XSelectInput(self->display, window, StructureNotifyMask | ExposureMask);
+
+    gsr_damage_window *damage_window = &self->windows_tracked[self->num_windows_tracked];
+    ++self->num_windows_tracked;
+
+    damage_window->window_id = window;
+    damage_window->window_pos.x = win_attr.x;
+    damage_window->window_pos.y = win_attr.y;
+    damage_window->window_size.x = win_attr.width;
+    damage_window->window_size.y = win_attr.height;
+    damage_window->damage = damage;
+    damage_window->refcount = 1;
+    return true;
+}
+
+void gsr_damage_stop_tracking_window(gsr_damage *self, int64_t window) {
+    if(window == None)
+        return;
+
+    const int damage_window_index = gsr_damage_get_tracked_window_index(self, window);
+    if(damage_window_index == -1)
+        return;
+
+    gsr_damage_window *damage_window = &self->windows_tracked[damage_window_index];
+    --damage_window->refcount;
+    if(damage_window->refcount <= 0) {
+        XSelectInput(self->display, damage_window->window_id, 0);
+        XDamageDestroy(self->display, damage_window->damage);
+        self->windows_tracked[damage_window_index] = self->windows_tracked[self->num_windows_tracked - 1];
+        --self->num_windows_tracked;
+    }
 }
 
-bool gsr_damage_set_target_monitor(gsr_damage *self, const char *monitor_name) {
+static gsr_monitor* gsr_damage_get_monitor_by_id(gsr_damage *self, RRCrtc id) {
+    for(int i = 0; i < self->num_monitors; ++i) {
+        if(self->monitors[i].monitor_identifier == id)
+            return &self->monitors[i];
+    }
+    return NULL;
+}
+
+static gsr_monitor* gsr_damage_get_monitor_by_name(gsr_damage *self, const char *name) {
+    for(int i = 0; i < self->num_monitors; ++i) {
+        if(strcmp(self->monitors[i].name, name) == 0)
+            return &self->monitors[i];
+    }
+    return NULL;
+}
+
+bool gsr_damage_start_tracking_monitor(gsr_damage *self, const char *monitor_name) {
     if(self->damage_event == 0)
         return false;
 
-    if(strcmp(self->monitor_name, monitor_name) == 0)
-        return true;
+    if(strcmp(monitor_name, "screen-direct") == 0 || strcmp(monitor_name, "screen-direct-force") == 0)
+        monitor_name = NULL;
 
-    if(self->damage) {
-        XDamageDestroy(self->display, self->damage);
-        self->damage = None;
+    if(!monitor_name) {
+        ++self->all_monitors_tracked_refcount;
+        return true;
     }
 
-    memset(&self->monitor, 0, sizeof(self->monitor));
-    if(strcmp(monitor_name, "screen-direct") != 0 && strcmp(monitor_name, "screen-direct-force") != 0) {
-        if(!get_monitor_by_name(self->egl, GSR_CONNECTION_X11, monitor_name, &self->monitor))
-            fprintf(stderr, "gsr warning: gsr_damage_set_target_monitor: failed to find monitor: %s\n", monitor_name);
+    const int damage_monitor_index = gsr_damage_get_tracked_monitor_index(self, monitor_name);
+    if(damage_monitor_index != -1) {
+        ++self->monitors_tracked[damage_monitor_index].refcount;
+        return true;
     }
 
-    if(self->window)
-        XSelectInput(self->display, self->window, 0);
-
-    self->window = DefaultRootWindow(self->display);
-    self->damage = XDamageCreate(self->display, self->window, XDamageReportNonEmpty);
-    if(self->damage) {
-        XDamageSubtract(self->display, self->damage, None, None);
-        self->damaged = true;
-        snprintf(self->monitor_name, sizeof(self->monitor_name), "%s", monitor_name);
-        self->track_type = GSR_DAMAGE_TRACK_MONITOR;
-        return true;
-    } else {
-        fprintf(stderr, "gsr warning: gsr_damage_set_target_monitor: XDamageCreate failed\n");
-        self->track_type = GSR_DAMAGE_TRACK_NONE;
+    if(self->num_monitors_tracked + 1 > GSR_DAMAGE_MAX_TRACKED_TARGETS) {
+        fprintf(stderr, "gsr error: gsr_damage_start_tracking_monitor: max monitor targets reached\n");
         return false;
     }
+
+    char *monitor_name_copy = strdup(monitor_name);
+    if(!monitor_name_copy) {
+        fprintf(stderr, "gsr error: gsr_damage_start_tracking_monitor: strdup failed for monitor: %s\n", monitor_name);
+        return false;
+    }
+
+    gsr_monitor *monitor = gsr_damage_get_monitor_by_name(self, monitor_name);
+    if(!monitor) {
+        fprintf(stderr, "gsr error: gsr_damage_start_tracking_monitor: failed to find monitor: %s\n", monitor_name);
+        free(monitor_name_copy);
+        return false;
+    }
+
+    gsr_damage_monitor *damage_monitor = &self->monitors_tracked[self->num_monitors_tracked];
+    ++self->num_monitors_tracked;
+
+    damage_monitor->monitor_name = monitor_name_copy;
+    damage_monitor->monitor = monitor;
+    damage_monitor->refcount = 1;
+    return true;
+}
+
+void gsr_damage_stop_tracking_monitor(gsr_damage *self, const char *monitor_name) {
+    if(strcmp(monitor_name, "screen-direct") == 0 || strcmp(monitor_name, "screen-direct-force") == 0)
+        monitor_name = NULL;
+
+    if(!monitor_name) {
+        --self->all_monitors_tracked_refcount;
+        if(self->all_monitors_tracked_refcount < 0)
+            self->all_monitors_tracked_refcount = 0;
+        return;
+    }
+
+    const int damage_monitor_index = gsr_damage_get_tracked_monitor_index(self, monitor_name);
+    if(damage_monitor_index == -1)
+        return;
+
+    gsr_damage_monitor *damage_monitor = &self->monitors_tracked[damage_monitor_index];
+    --damage_monitor->refcount;
+    if(damage_monitor->refcount <= 0) {
+        free(damage_monitor->monitor_name);
+        self->monitors_tracked[damage_monitor_index] = self->monitors_tracked[self->num_monitors_tracked - 1];
+        --self->num_monitors_tracked;
+    }
 }
 
 static void gsr_damage_on_crtc_change(gsr_damage *self, XEvent *xev) {
     const XRRCrtcChangeNotifyEvent *rr_crtc_change_event = (XRRCrtcChangeNotifyEvent*)xev;
-    if(rr_crtc_change_event->crtc == 0 || self->monitor.monitor_identifier == 0)
-        return;
-
-    if(rr_crtc_change_event->crtc != self->monitor.monitor_identifier)
+    if(rr_crtc_change_event->crtc == 0)
         return;
 
     if(rr_crtc_change_event->width == 0 || rr_crtc_change_event->height == 0)
         return;
 
-    if(rr_crtc_change_event->x != self->monitor.pos.x || rr_crtc_change_event->y != self->monitor.pos.y ||
-        (int)rr_crtc_change_event->width != self->monitor.size.x || (int)rr_crtc_change_event->height != self->monitor.size.y) {
-        self->monitor.pos.x = rr_crtc_change_event->x;
-        self->monitor.pos.y = rr_crtc_change_event->y;
+    gsr_monitor *monitor = gsr_damage_get_monitor_by_id(self, rr_crtc_change_event->crtc);
+    if(!monitor)
+        return;
 
-        self->monitor.size.x = rr_crtc_change_event->width;
-        self->monitor.size.y = rr_crtc_change_event->height;
+    if(rr_crtc_change_event->x != monitor->pos.x || rr_crtc_change_event->y != monitor->pos.y ||
+        (int)rr_crtc_change_event->width != monitor->size.x || (int)rr_crtc_change_event->height != monitor->size.y) {
+        monitor->pos.x = rr_crtc_change_event->x;
+        monitor->pos.y = rr_crtc_change_event->y;
+
+        monitor->size.x = rr_crtc_change_event->width;
+        monitor->size.y = rr_crtc_change_event->height;
     }
 }
 
 static void gsr_damage_on_output_change(gsr_damage *self, XEvent *xev) {
     const XRROutputChangeNotifyEvent *rr_output_change_event = (XRROutputChangeNotifyEvent*)xev;
-    if(!rr_output_change_event->output || self->monitor.monitor_identifier == 0)
+    if(!rr_output_change_event->output)
         return;
 
-    XRRScreenResources *screen_res = XRRGetScreenResources(self->display, DefaultRootWindow(self->display));
-    if(!screen_res)
-        return;
-
-    // TODO: What about scaled output? look at for_each_active_monitor_output_x11_not_cached
-    XRROutputInfo *out_info = XRRGetOutputInfo(self->display, screen_res, rr_output_change_event->output);
-    if(out_info && out_info->crtc && out_info->crtc == self->monitor.monitor_identifier) {
-        XRRCrtcInfo *crtc_info = XRRGetCrtcInfo(self->display, screen_res, out_info->crtc);
-        if(crtc_info && (crtc_info->x != self->monitor.pos.x || crtc_info->y != self->monitor.pos.y ||
-            (int)crtc_info->width != self->monitor.size.x || (int)crtc_info->height != self->monitor.size.y))
-        {
-            self->monitor.pos.x = crtc_info->x;
-            self->monitor.pos.y = crtc_info->y;
-
-            self->monitor.size.x = crtc_info->width;
-            self->monitor.size.y = crtc_info->height;
-        }
-
-        if(crtc_info)
-            XRRFreeCrtcInfo(crtc_info);
-    }
-
-    if(out_info)
-        XRRFreeOutputInfo(out_info);
-    
-    XRRFreeScreenResources(screen_res);
+    gsr_damage_deinit_monitors(self);
+    for_each_active_monitor_output_x11_not_cached(self->display, add_monitor_callback, self);
 }
 
 static void gsr_damage_on_randr_event(gsr_damage *self, XEvent *xev) {
@@ -232,19 +349,38 @@ static void gsr_damage_on_damage_event(gsr_damage *self, XEvent *xev) {
     /* Subtract all the damage, repairing the window */
     XDamageSubtract(self->display, de->damage, None, region);
 
-    if(self->track_type == GSR_DAMAGE_TRACK_WINDOW || (self->track_type == GSR_DAMAGE_TRACK_MONITOR && self->monitor.connector_id == 0)) {
+    if(self->all_monitors_tracked_refcount > 0)
         self->damaged = true;
-    } else {
+
+    if(!self->damaged) {
+        for(int i = 0; i < self->num_windows_tracked; ++i) {
+            const gsr_damage_window *damage_window = &self->windows_tracked[i];
+            if(damage_window->window_id == (int64_t)de->drawable) {
+                self->damaged = true;
+                break;
+            }
+        }
+    }
+
+    if(!self->damaged) {
         int num_rectangles = 0;
         XRectangle *rectangles = XFixesFetchRegion(self->display, region, &num_rectangles);
         if(rectangles) {
-            const gsr_rectangle monitor_region = { self->monitor.pos, self->monitor.size };
             for(int i = 0; i < num_rectangles; ++i) {
                 const gsr_rectangle damage_region = { (vec2i){rectangles[i].x, rectangles[i].y}, (vec2i){rectangles[i].width, rectangles[i].height} };
-                self->damaged = rectangles_intersect(monitor_region, damage_region);
-                if(self->damaged)
-                    break;
+                for(int j = 0; j < self->num_monitors_tracked; ++j) {
+                    const gsr_monitor *monitor = self->monitors_tracked[j].monitor;
+                    if(!monitor)
+                        continue;
+
+                    const gsr_rectangle monitor_region = { monitor->pos, monitor->size };
+                    self->damaged = rectangles_intersect(monitor_region, damage_region);
+                    if(self->damaged)
+                        goto intersection_found;
+                }
             }
+
+            intersection_found:
             XFree(rectangles);
         }
     }
@@ -254,23 +390,35 @@ static void gsr_damage_on_damage_event(gsr_damage *self, XEvent *xev) {
 }
 
 static void gsr_damage_on_tick_cursor(gsr_damage *self) {
-    vec2i prev_cursor_pos = self->cursor.position;
-    gsr_cursor_tick(&self->cursor, self->window);
-    if(self->cursor.position.x != prev_cursor_pos.x || self->cursor.position.y != prev_cursor_pos.y) {
-        const gsr_rectangle cursor_region = { self->cursor.position, self->cursor.size };
-        switch(self->track_type) {
-            case GSR_DAMAGE_TRACK_NONE: {
+    if(self->cursor->position.x == self->cursor_pos.x && self->cursor->position.y == self->cursor_pos.y)
+        return;
+
+    self->cursor_pos = self->cursor->position;
+    const gsr_rectangle cursor_region = { self->cursor->position, self->cursor->size };
+
+    if(self->all_monitors_tracked_refcount > 0)
+        self->damaged = true;
+
+    if(!self->damaged) {
+        for(int i = 0; i < self->num_windows_tracked; ++i) {
+            const gsr_damage_window *damage_window = &self->windows_tracked[i];
+            const gsr_rectangle window_region = { damage_window->window_pos, damage_window->window_size };
+            if(rectangles_intersect(window_region, cursor_region)) {
                 self->damaged = true;
                 break;
             }
-            case GSR_DAMAGE_TRACK_WINDOW: {
-                const gsr_rectangle window_region = { (vec2i){0, 0}, self->window_size };
-                self->damaged = self->window_size.x == 0 || rectangles_intersect(window_region, cursor_region);
-                break;
-            }
-            case GSR_DAMAGE_TRACK_MONITOR: {
-                const gsr_rectangle monitor_region = { self->monitor.pos, self->monitor.size };
-                self->damaged = self->monitor.monitor_identifier == 0 || rectangles_intersect(monitor_region, cursor_region);
+        }
+    }
+
+    if(!self->damaged) {
+        for(int i = 0; i < self->num_monitors_tracked; ++i) {
+            const gsr_monitor *monitor = self->monitors_tracked[i].monitor;
+            if(!monitor)
+                continue;
+
+            const gsr_rectangle monitor_region = { monitor->pos, monitor->size };
+            if(rectangles_intersect(monitor_region, cursor_region)) {
+                self->damaged = true;
                 break;
             }
         }
@@ -278,21 +426,24 @@ static void gsr_damage_on_tick_cursor(gsr_damage *self) {
 }
 
 static void gsr_damage_on_window_configure_notify(gsr_damage *self, XEvent *xev) {
-    if(xev->xconfigure.window != self->window)
-        return;
+    for(int i = 0; i < self->num_windows_tracked; ++i) {
+        gsr_damage_window *damage_window = &self->windows_tracked[i];
+        if(damage_window->window_id == (int64_t)xev->xconfigure.window) {
+            damage_window->window_pos.x = xev->xconfigure.x;
+            damage_window->window_pos.y = xev->xconfigure.y;
 
-    //self->window_pos.x = xev->xconfigure.x;
-    //self->window_pos.y = xev->xconfigure.y;
-    
-    self->window_size.x = xev->xconfigure.width;
-    self->window_size.y = xev->xconfigure.height;
+            damage_window->window_size.x = xev->xconfigure.width;
+            damage_window->window_size.y = xev->xconfigure.height;
+            break;
+        }
+    }
 }
 
 void gsr_damage_on_event(gsr_damage *self, XEvent *xev) {
-    if(self->damage_event == 0 || self->track_type == GSR_DAMAGE_TRACK_NONE)
+    if(self->damage_event == 0)
         return;
 
-    if(self->track_type == GSR_DAMAGE_TRACK_WINDOW && xev->type == ConfigureNotify)
+    if(xev->type == ConfigureNotify)
         gsr_damage_on_window_configure_notify(self, xev);
 
     if(self->randr_event) {
@@ -305,21 +456,18 @@ void gsr_damage_on_event(gsr_damage *self, XEvent *xev) {
 
     if(self->damage_event && xev->type == self->damage_event + XDamageNotify)
         gsr_damage_on_damage_event(self, xev);
-
-    if(self->track_cursor)
-        gsr_cursor_on_event(&self->cursor, xev);
 }
 
 void gsr_damage_tick(gsr_damage *self) {
-    if(self->damage_event == 0 || self->track_type == GSR_DAMAGE_TRACK_NONE)
+    if(self->damage_event == 0)
         return;
 
-    if(self->track_cursor && self->cursor.visible && !self->damaged)
+    if(self->track_cursor && self->cursor->visible && !self->damaged)
         gsr_damage_on_tick_cursor(self);
 }
 
 bool gsr_damage_is_damaged(gsr_damage *self) {
-    return self->damage_event == 0 || !self->damage || self->damaged || self->track_type == GSR_DAMAGE_TRACK_NONE;
+    return self->damage_event == 0 || self->damaged;
 }
 
 void gsr_damage_clear(gsr_damage *self) {

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

@@ -280,7 +280,6 @@ static bool gsr_egl_load_gl(gsr_egl *self, void *library) {
         { (void**)&self->glTexParameteri, "glTexParameteri" },
         { (void**)&self->glTexParameteriv, "glTexParameteriv" },
         { (void**)&self->glTexParameterfv, "glTexParameterfv" },
-        { (void**)&self->glGetTexLevelParameteriv, "glGetTexLevelParameteriv" },
         { (void**)&self->glTexImage2D, "glTexImage2D" },
         { (void**)&self->glTexSubImage2D, "glTexSubImage2D" },
         { (void**)&self->glTexStorage2D, "glTexStorage2D" },
@@ -288,7 +287,6 @@ static bool gsr_egl_load_gl(gsr_egl *self, void *library) {
         { (void**)&self->glGenFramebuffers, "glGenFramebuffers" },
         { (void**)&self->glBindFramebuffer, "glBindFramebuffer" },
         { (void**)&self->glDeleteFramebuffers, "glDeleteFramebuffers" },
-        { (void**)&self->glDispatchCompute, "glDispatchCompute" },
         { (void**)&self->glMemoryBarrier, "glMemoryBarrier" },
         { (void**)&self->glViewport, "glViewport" },
         { (void**)&self->glFramebufferTexture2D, "glFramebufferTexture2D" },
@@ -332,7 +330,7 @@ static bool gsr_egl_load_gl(gsr_egl *self, void *library) {
         { (void**)&self->glDebugMessageCallback, "glDebugMessageCallback" },
         { (void**)&self->glScissor, "glScissor" },
         { (void**)&self->glReadPixels, "glReadPixels" },
-        { (void**)&self->glMapBuffer, "glMapBuffer" },
+        { (void**)&self->glMapBufferRange, "glMapBufferRange" },
         { (void**)&self->glUnmapBuffer, "glUnmapBuffer" },
         { (void**)&self->glGetIntegerv, "glGetIntegerv" },
 
@@ -525,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/nvenc.c

@@ -12,6 +12,7 @@ typedef struct {
     gsr_video_encoder_nvenc_params params;
 
     unsigned int target_textures[2];
+    vec2i target_texture_size[2];
 
     AVBufferRef *device_ctx;
 
@@ -95,7 +96,8 @@ static bool gsr_video_encoder_nvenc_setup_textures(gsr_video_encoder_nvenc *self
     const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size
 
     for(int i = 0; i < 2; ++i) {
-        self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i], GL_NEAREST);
+        self->target_texture_size[i] = (vec2i){ video_codec_context->width / div[i], video_codec_context->height / div[i] };
+        self->target_textures[i] = gl_create_texture(self->params.egl, self->target_texture_size[i].x, self->target_texture_size[i].y, self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i], GL_NEAREST);
         if(self->target_textures[i] == 0) {
             fprintf(stderr, "gsr error: gsr_video_encoder_nvenc_setup_textures: failed to create opengl texture\n");
             return false;
@@ -198,10 +200,12 @@ static void gsr_video_encoder_nvenc_copy_textures_to_frame(gsr_video_encoder *en
     self->cuda.cuStreamSynchronize(self->cuda_stream);
 }
 
-static void gsr_video_encoder_nvenc_get_textures(gsr_video_encoder *encoder, unsigned int *textures, int *num_textures, gsr_destination_color *destination_color) {
+static void gsr_video_encoder_nvenc_get_textures(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color) {
     gsr_video_encoder_nvenc *self = encoder->priv;
     textures[0] = self->target_textures[0];
     textures[1] = self->target_textures[1];
+    texture_sizes[0] = self->target_texture_size[0];
+    texture_sizes[1] = self->target_texture_size[1];
     *num_textures = 2;
     *destination_color = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS ? GSR_DESTINATION_COLOR_P010 : GSR_DESTINATION_COLOR_NV12;
 }

src/encoder/video/software.c

@@ -13,6 +13,7 @@ typedef struct {
     gsr_video_encoder_software_params params;
 
     unsigned int target_textures[2];
+    vec2i texture_sizes[2];
 } gsr_video_encoder_software;
 
 static bool gsr_video_encoder_software_setup_textures(gsr_video_encoder_software *self, AVCodecContext *video_codec_context, AVFrame *frame) {
@@ -34,7 +35,8 @@ static bool gsr_video_encoder_software_setup_textures(gsr_video_encoder_software
     const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size
 
     for(int i = 0; i < 2; ++i) {
-        self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i], GL_NEAREST);
+        self->texture_sizes[i] = (vec2i){ video_codec_context->width / div[i], video_codec_context->height / div[i] };
+        self->target_textures[i] = gl_create_texture(self->params.egl, self->texture_sizes[i].x, self->texture_sizes[i].y, self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i], GL_NEAREST);
         if(self->target_textures[i] == 0) {
             fprintf(stderr, "gsr error: gsr_capture_kms_setup_cuda_textures: failed to create opengl texture\n");
             return false;
@@ -86,10 +88,12 @@ static void gsr_video_encoder_software_copy_textures_to_frame(gsr_video_encoder
     //self->params.egl->glFinish();
 }
 
-static void gsr_video_encoder_software_get_textures(gsr_video_encoder *encoder, unsigned int *textures, int *num_textures, gsr_destination_color *destination_color) {
+static void gsr_video_encoder_software_get_textures(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color) {
     gsr_video_encoder_software *self = encoder->priv;
     textures[0] = self->target_textures[0];
     textures[1] = self->target_textures[1];
+    texture_sizes[0] = self->texture_sizes[0];
+    texture_sizes[1] = self->texture_sizes[1];
     *num_textures = 2;
     *destination_color = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS ? GSR_DESTINATION_COLOR_P010 : GSR_DESTINATION_COLOR_NV12;
 }

src/encoder/video/vaapi.c

@@ -6,6 +6,8 @@
 #include <libavutil/hwcontext_vaapi.h>
 #include <libavutil/intreadwrite.h>
 
+#include <va/va.h>
+#include <va/va_drm.h>
 #include <va/va_drmcommon.h>
 
 #include <stdlib.h>
@@ -16,6 +18,7 @@ typedef struct {
     gsr_video_encoder_vaapi_params params;
 
     unsigned int target_textures[2];
+    vec2i texture_sizes[2];
 
     AVBufferRef *device_ctx;
     VADisplay va_dpy;
@@ -112,6 +115,7 @@ static bool gsr_video_encoder_vaapi_setup_textures(gsr_video_encoder_vaapi *self
             intptr_t img_attr[44];
             setup_dma_buf_attrs(img_attr, formats[i], self->prime.width / div[i], self->prime.height / div[i],
                 fds, offsets, pitches, modifiers, self->prime.layers[layer].num_planes, true);
+            self->texture_sizes[i] = (vec2i){ self->prime.width / div[i], self->prime.height / div[i] };
 
             while(self->params.egl->eglGetError() != EGL_SUCCESS){}
             EGLImage image = self->params.egl->eglCreateImage(self->params.egl->egl_display, 0, EGL_LINUX_DMA_BUF_EXT, NULL, img_attr);
@@ -148,13 +152,102 @@ static bool gsr_video_encoder_vaapi_setup_textures(gsr_video_encoder_vaapi *self
 
 static void gsr_video_encoder_vaapi_stop(gsr_video_encoder_vaapi *self, AVCodecContext *video_codec_context);
 
+static bool supports_hevc_without_padding(const char *card_path) {
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(61, 28, 100) && VA_CHECK_VERSION(1, 21, 0)
+    VAStatus va_status;
+    VAConfigID va_config = 0;
+    unsigned int num_surface_attr = 0;
+    VASurfaceAttrib *surface_attr_list = NULL;
+    bool supports_surface_attrib_alignment_size = false;
+    int va_major = 0;
+    int va_minor = 0;
+    bool initialized = false;
+
+    char render_path[128];
+    if(!gsr_card_path_get_render_path(card_path, render_path)) {
+        fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to get /dev/dri/renderDXXX file from %s\n", card_path);
+        return false;
+    }
+
+    const int drm_fd = open(render_path, O_RDWR);
+    if(drm_fd == -1) {
+        fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to open device %s\n", render_path);
+        return false;
+    }
+
+    const VADisplay va_dpy = vaGetDisplayDRM(drm_fd);
+    if(!va_dpy) {
+        fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to get vaapi display for device %s\n", render_path);
+        goto done;
+    }
+
+    vaSetInfoCallback(va_dpy, NULL, NULL);
+
+    if(vaInitialize(va_dpy, &va_major, &va_minor) != VA_STATUS_SUCCESS) {
+        fprintf(stderr, "gsr error: supports_hevc_without_padding: vaInitialize failed\n");
+        goto done;
+    }
+    initialized = true;
+
+    va_status = vaCreateConfig(va_dpy, VAProfileHEVCMain, VAEntrypointEncSlice, NULL, 0, &va_config);
+    if(va_status != VA_STATUS_SUCCESS) {
+        va_status = vaCreateConfig(va_dpy, VAProfileHEVCMain, VAEntrypointEncSliceLP, NULL, 0, &va_config);
+        if(va_status != VA_STATUS_SUCCESS) {
+            fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to create hevc vaapi config, error: %s (%d)\n", vaErrorStr(va_status), va_status);
+            return false;
+        }
+    }
+
+    va_status = vaQuerySurfaceAttributes(va_dpy, va_config, 0, &num_surface_attr);
+    if(va_status != VA_STATUS_SUCCESS) {
+        fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to query vaapi surface attributes size, error: %s (%d)\n", vaErrorStr(va_status), va_status);
+        goto done;
+    }
+
+    surface_attr_list = malloc(num_surface_attr * sizeof(VASurfaceAttrib));
+    if(!surface_attr_list) {
+        fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to allocate memory for %u vaapi surface attributes, error: %s (%d)\n", num_surface_attr, vaErrorStr(va_status), va_status);
+        goto done;
+    }
+
+    va_status = vaQuerySurfaceAttributes(va_dpy, va_config, surface_attr_list, &num_surface_attr);
+    if(va_status != VA_STATUS_SUCCESS) {
+        fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to query vaapi surface attributes data, error: %s (%d)\n", vaErrorStr(va_status), va_status);
+        goto done;
+    }
+
+    for(unsigned int i = 0; i < num_surface_attr; ++i) {
+        if(surface_attr_list[i].type == VASurfaceAttribAlignmentSize) {
+            supports_surface_attrib_alignment_size = true;
+            break;
+        }
+    }
+
+    done:
+    free(surface_attr_list);
+    if(va_config > 0)
+        vaDestroyConfig(va_dpy, va_config);
+    if(initialized)
+        vaTerminate(va_dpy);
+    if(drm_fd > 0)
+        close(drm_fd);
+    return supports_surface_attrib_alignment_size;
+#else
+    return false;
+#endif
+}
+
 static bool gsr_video_encoder_vaapi_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) {
     gsr_video_encoder_vaapi *self = encoder->priv;
 
     if(self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_AMD && video_codec_context->codec_id == AV_CODEC_ID_HEVC) {
-        // TODO: dont do this if using ffmpeg reports that this is not needed (AMD driver bug that was fixed recently)
-        video_codec_context->width = FFALIGN(video_codec_context->width, 64);
-        video_codec_context->height = FFALIGN(video_codec_context->height, 16);
+        if(supports_hevc_without_padding(self->params.egl->card_path)) {
+            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, 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
         video_codec_context->width = FFALIGN(video_codec_context->width, 64);
@@ -214,10 +307,12 @@ void gsr_video_encoder_vaapi_stop(gsr_video_encoder_vaapi *self, AVCodecContext
     }
 }
 
-static void gsr_video_encoder_vaapi_get_textures(gsr_video_encoder *encoder, unsigned int *textures, int *num_textures, gsr_destination_color *destination_color) {
+static void gsr_video_encoder_vaapi_get_textures(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color) {
     gsr_video_encoder_vaapi *self = encoder->priv;
     textures[0] = self->target_textures[0];
     textures[1] = self->target_textures[1];
+    texture_sizes[0] = self->texture_sizes[0];
+    texture_sizes[1] = self->texture_sizes[1];
     *num_textures = 2;
     *destination_color = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS ? GSR_DESTINATION_COLOR_P010 : GSR_DESTINATION_COLOR_NV12;
 }

src/encoder/video/video.c

@@ -22,7 +22,7 @@ void gsr_video_encoder_copy_textures_to_frame(gsr_video_encoder *encoder, AVFram
         encoder->copy_textures_to_frame(encoder, frame, color_conversion);
 }
 
-void gsr_video_encoder_get_textures(gsr_video_encoder *encoder, unsigned int *textures, int *num_textures, gsr_destination_color *destination_color) {
+void gsr_video_encoder_get_textures(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color) {
     assert(encoder->started);
-    encoder->get_textures(encoder, textures, num_textures, destination_color);
+    encoder->get_textures(encoder, textures, texture_sizes, num_textures, destination_color);
 }

src/encoder/video/vulkan.c

@@ -4,7 +4,7 @@
 
 #include <libavcodec/avcodec.h>
 #define VK_NO_PROTOTYPES
-#include <libavutil/hwcontext_vulkan.h>
+//#include <libavutil/hwcontext_vulkan.h>
 
 //#include <vulkan/vulkan_core.h>
 
@@ -16,6 +16,7 @@
 typedef struct {
     gsr_video_encoder_vulkan_params params;
     unsigned int target_textures[2];
+    vec2i texture_sizes[2];
     AVBufferRef *device_ctx;
 } gsr_video_encoder_vulkan;
 
@@ -60,7 +61,7 @@ static bool gsr_video_encoder_vulkan_setup_context(gsr_video_encoder_vulkan *sel
 #endif
     return true;
 }
-
+#if 0
 static AVVulkanDeviceContext* video_codec_context_get_vulkan_data(AVCodecContext *video_codec_context) {
     AVBufferRef *hw_frames_ctx = video_codec_context->hw_frames_ctx;
     if(!hw_frames_ctx)
@@ -91,7 +92,7 @@ static uint32_t get_memory_type_idx(VkPhysicalDevice pdev, const VkMemoryRequire
     }
     return UINT32_MAX;
 }
-
+#endif
 static bool gsr_video_encoder_vulkan_setup_textures(gsr_video_encoder_vulkan *self, AVCodecContext *video_codec_context, AVFrame *frame) {
     const int res = av_hwframe_get_buffer(video_codec_context->hw_frames_ctx, frame, 0);
     if(res < 0) {
@@ -224,6 +225,9 @@ static bool gsr_video_encoder_vulkan_setup_textures(gsr_video_encoder_vulkan *se
 
         fprintf(stderr, "3 gl error: %d\n", self->params.egl->glGetError());
         self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
+
+        self->texture_sizes[0] = (vec2i){ frame->width, frame->height };
+        self->texture_sizes[1] = (vec2i){ frame->width/2, frame->height/2 };
      }
 #endif
     return true;
@@ -270,10 +274,12 @@ void gsr_video_encoder_vulkan_stop(gsr_video_encoder_vulkan *self, AVCodecContex
         av_buffer_unref(&self->device_ctx);
 }
 
-static void gsr_video_encoder_vulkan_get_textures(gsr_video_encoder *encoder, unsigned int *textures, int *num_textures, gsr_destination_color *destination_color) {
+static void gsr_video_encoder_vulkan_get_textures(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color) {
     gsr_video_encoder_vulkan *self = encoder->priv;
     textures[0] = self->target_textures[0];
     textures[1] = self->target_textures[1];
+    texture_sizes[0] = self->texture_sizes[0];
+    texture_sizes[1] = self->texture_sizes[1];
     *num_textures = 2;
     *destination_color = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS ? GSR_DESTINATION_COLOR_P010 : GSR_DESTINATION_COLOR_NV12;
 }

src/image_writer.c

@@ -13,7 +13,6 @@
 /* TODO: Support hdr/10-bit */
 bool gsr_image_writer_init_opengl(gsr_image_writer *self, gsr_egl *egl, int width, int height) {
     memset(self, 0, sizeof(*self));
-    self->source = GSR_IMAGE_WRITER_SOURCE_OPENGL;
     self->egl = egl;
     self->width = width;
     self->height = height;
@@ -25,15 +24,6 @@ bool gsr_image_writer_init_opengl(gsr_image_writer *self, gsr_egl *egl, int widt
     return true;
 }
 
-bool gsr_image_writer_init_memory(gsr_image_writer *self, const void *memory, int width, int height) {
-    memset(self, 0, sizeof(*self));
-    self->source = GSR_IMAGE_WRITER_SOURCE_OPENGL;
-    self->width = width;
-    self->height = height;
-    self->memory = memory;
-    return true;
-}
-
 void gsr_image_writer_deinit(gsr_image_writer *self) {
     if(self->texture) {
         self->egl->glDeleteTextures(1, &self->texture);
@@ -64,7 +54,6 @@ static bool gsr_image_writer_write_memory_to_file(gsr_image_writer *self, const
 }
 
 static bool gsr_image_writer_write_opengl_texture_to_file(gsr_image_writer *self, const char *filepath, gsr_image_format image_format, int quality) {
-    assert(self->source == GSR_IMAGE_WRITER_SOURCE_OPENGL);
     uint8_t *frame_data = malloc(self->width * self->height * 4);
     if(!frame_data) {
         fprintf(stderr, "gsr error: gsr_image_writer_write_to_file: failed to allocate memory for image frame\n");
@@ -90,11 +79,5 @@ static bool gsr_image_writer_write_opengl_texture_to_file(gsr_image_writer *self
 }
 
 bool gsr_image_writer_write_to_file(gsr_image_writer *self, const char *filepath, gsr_image_format image_format, int quality) {
-    switch(self->source) {
-        case GSR_IMAGE_WRITER_SOURCE_OPENGL:
-            return gsr_image_writer_write_opengl_texture_to_file(self, filepath, image_format, quality);
-        case GSR_IMAGE_WRITER_SOURCE_MEMORY:
-            return gsr_image_writer_write_memory_to_file(self, filepath, image_format, quality, self->memory);
-    }
-    return false;
+    return gsr_image_writer_write_opengl_texture_to_file(self, filepath, image_format, quality);
 }

src/overclock.c

@@ -246,7 +246,7 @@ bool gsr_overclock_start(gsr_overclock *self) {
         const int transfer_rate_max_diff = query.performance_level[query.num_performance_levels - 1].mem_transfer_rate_max - query.performance_level[query.num_performance_levels - 2].mem_transfer_rate_max;
         target_transfer_rate_offset = min_int(target_transfer_rate_offset, transfer_rate_max_diff);
         if(target_transfer_rate_offset >= 0 && xnvctrl_set_attribute_offset(&self->xnvctrl, self->num_performance_levels, target_transfer_rate_offset, NVCTRL_ATTRIB_GPU_MEM_TRANSFER_RATE)) {
-            fprintf(stderr, "gsr info: gsr_overclock_start: sucessfully set memory transfer rate offset to %d\n", target_transfer_rate_offset);
+            fprintf(stderr, "gsr info: gsr_overclock_start: successfully set memory transfer rate offset to %d\n", target_transfer_rate_offset);
         } else {
             fprintf(stderr, "gsr info: gsr_overclock_start: failed to overclock memory transfer rate offset to %d\n", target_transfer_rate_offset);
         }
@@ -261,7 +261,7 @@ bool gsr_overclock_start(gsr_overclock *self) {
         const int nv_clock_max_diff = query.performance_level[query.num_performance_levels - 1].nv_clock_max - query.performance_level[query.num_performance_levels - 2].nv_clock_max;
         target_nv_clock_offset = min_int(target_nv_clock_offset, nv_clock_max_diff);
         if(target_nv_clock_offset >= 0 && xnvctrl_set_attribute_offset(&self->xnvctrl, self->num_performance_levels, target_nv_clock_offset, NVCTRL_GPU_NVCLOCK)) {
-            fprintf(stderr, "gsr info: gsr_overclock_start: sucessfully set nv clock offset to %d\n", target_nv_clock_offset);
+            fprintf(stderr, "gsr info: gsr_overclock_start: successfully set nv clock offset to %d\n", target_nv_clock_offset);
         } else {
             fprintf(stderr, "gsr info: gsr_overclock_start: failed to overclock nv clock offset to %d\n", target_nv_clock_offset);
         }

src/pipewire_audio.c

@@ -58,6 +58,29 @@ static bool requested_link_matches_name_case_insensitive(const gsr_pipewire_audi
     return false;
 }
 
+static bool requested_link_matches_name_case_insensitive_any_type(const gsr_pipewire_audio *self, const gsr_pipewire_audio_requested_link *requested_link, const char *name) {
+    for(int i = 0; i < requested_link->num_outputs; ++i) {
+        switch(requested_link->outputs[i].type) {
+            case GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_STANDARD: {
+                if(strcasecmp(requested_link->outputs[i].name, name) == 0)
+                    return true;
+                break;
+            }
+            case GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT: {
+                if(strcasecmp(self->default_output_device_name, name) == 0)
+                    return true;
+                break;
+            }
+            case GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_INPUT: {
+                if(strcasecmp(self->default_input_device_name, name) == 0)
+                    return true;
+                break;
+            }
+        }
+    }
+    return false;
+}
+
 static bool requested_link_has_type(const gsr_pipewire_audio_requested_link *requested_link, gsr_pipewire_audio_requested_type type) {
     for(int i = 0; i < requested_link->num_outputs; ++i) {
         if(requested_link->outputs[i].type == type)
@@ -168,7 +191,7 @@ static void gsr_pipewire_audio_create_link(gsr_pipewire_audio *self, const gsr_p
         if(output_node->type != requested_link->output_type)
             continue;
 
-        const bool requested_link_matches_app = requested_link_matches_name_case_insensitive(requested_link, output_node->name);
+        const bool requested_link_matches_app = requested_link_matches_name_case_insensitive_any_type(self, requested_link, output_node->name);
         if(requested_link->inverted) {
             if(requested_link_matches_app)
                 continue;
@@ -392,20 +415,20 @@ static void registry_event_global(void *data, uint32_t id, uint32_t permissions,
                   const struct spa_dict *props)
 {
     //fprintf(stderr, "add: id: %d, type: %s\n", (int)id, type);
-    if(!props || !type)
+    gsr_pipewire_audio *self = (gsr_pipewire_audio*)data;
+    if(!props || !type || !self->running)
         return;
 
     //pw_properties_new_dict(props);
 
-    gsr_pipewire_audio *self = (gsr_pipewire_audio*)data;
     if(strcmp(type, PW_TYPE_INTERFACE_Node) == 0) {
         const char *node_name = spa_dict_lookup(props, PW_KEY_NODE_NAME);
         const char *media_class = spa_dict_lookup(props, PW_KEY_MEDIA_CLASS);
         //fprintf(stderr, "  node id: %u, node name: %s, media class: %s\n", id, node_name, media_class);
         const bool is_stream_output = media_class && strcmp(media_class, "Stream/Output/Audio") == 0;
         const bool is_stream_input = media_class && strcmp(media_class, "Stream/Input/Audio") == 0;
-        const bool is_sink = media_class && strcmp(media_class, "Audio/Sink") == 0;
-        const bool is_source = media_class && strcmp(media_class, "Audio/Source") == 0;
+        const bool is_sink = media_class && string_starts_with(media_class, "Audio/Sink"); // Matches Audio/Sink/Virtual as well
+        const bool is_source = media_class && string_starts_with(media_class, "Audio/Source"); // Matches Audio/Source/Virtual as well
         if(node_name && (is_stream_output || is_stream_input || is_sink || is_source)) {
             //const char *application_binary = spa_dict_lookup(props, PW_KEY_APP_PROCESS_BINARY);
             //const char *application_name = spa_dict_lookup(props, PW_KEY_APP_NAME);
@@ -547,6 +570,7 @@ static const struct pw_registry_events registry_events = {
 
 bool gsr_pipewire_audio_init(gsr_pipewire_audio *self) {
     memset(self, 0, sizeof(*self));
+    self->running = true;
 
     pw_init(NULL, NULL);
     
@@ -594,24 +618,51 @@ bool gsr_pipewire_audio_init(gsr_pipewire_audio *self) {
     return true;
 }
 
-void gsr_pipewire_audio_deinit(gsr_pipewire_audio *self) {
-    if(self->thread_loop) {
-        //pw_thread_loop_wait(self->thread_loop);
-        pw_thread_loop_stop(self->thread_loop);
+static gsr_pipewire_audio_link* gsr_pipewire_audio_get_first_link_to_node(gsr_pipewire_audio *self, uint32_t node_id) {
+    for(size_t i = 0; i < self->num_links; ++i) {
+        if(self->links[i].input_node_id == node_id)
+            return &self->links[i];
     }
+    return NULL;
+}
 
-    for(size_t i = 0; i < self->num_virtual_sink_proxies; ++i) {
-        if(self->virtual_sink_proxies[i]) {
-            pw_proxy_destroy(self->virtual_sink_proxies[i]);
-            self->virtual_sink_proxies[i] = NULL;
+static void gsr_pipewire_audio_destroy_requested_links(gsr_pipewire_audio *self) {
+    pw_thread_loop_lock(self->thread_loop);
+
+    self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, self->server_version_sync);
+    pw_thread_loop_wait(self->thread_loop);
+
+    for(size_t requested_link_index = 0; requested_link_index < self->num_requested_links; ++requested_link_index) {
+        const gsr_pipewire_audio_node_type requested_link_node_type = self->requested_links[requested_link_index].input_type == GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_STREAM ? GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_INPUT : GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE;
+        const gsr_pipewire_audio_node *stream_input_node = gsr_pipewire_audio_get_node_by_name_case_insensitive(self, self->requested_links[requested_link_index].input_name, requested_link_node_type);
+        if(!stream_input_node)
+            continue;
+
+        for(;;) {
+            gsr_pipewire_audio_link *link = gsr_pipewire_audio_get_first_link_to_node(self, stream_input_node->id);
+            if(!link)
+                break;
+
+            pw_registry_destroy(self->registry, link->id);
+
+            self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, self->server_version_sync);
+            pw_thread_loop_wait(self->thread_loop);
+
+            usleep(10 * 1000);
         }
     }
-    self->num_virtual_sink_proxies = 0;
-    self->virtual_sink_proxies_capacity_items = 0;
 
-    if(self->virtual_sink_proxies) {
-        free(self->virtual_sink_proxies);
-        self->virtual_sink_proxies = NULL;
+    pw_thread_loop_unlock(self->thread_loop);
+}
+
+void gsr_pipewire_audio_deinit(gsr_pipewire_audio *self) {
+    self->running = false;
+
+    if(self->thread_loop) {
+        /* We need to manually destroy links first, otherwise the linked audio sources will be paused when closing the program */
+        gsr_pipewire_audio_destroy_requested_links(self);
+        //pw_thread_loop_wait(self->thread_loop);
+        pw_thread_loop_stop(self->thread_loop);
     }
 
     if(self->metadata_proxy) {
@@ -691,52 +742,6 @@ void gsr_pipewire_audio_deinit(gsr_pipewire_audio *self) {
 #endif
 }
 
-static struct pw_properties* gsr_pipewire_create_null_audio_sink(const char *name) {
-    char props_str[512];
-    snprintf(props_str, sizeof(props_str), "{ factory.name=support.null-audio-sink node.name=\"%s\" media.class=Audio/Sink object.linger=false audio.position=[FL FR] monitor.channel-volumes=true monitor.passthrough=true adjust_time=0 node.description=gsr-app-sink slaves=\"\" }", name);
-    struct pw_properties *props = pw_properties_new_string(props_str);
-    if(!props) {
-        fprintf(stderr, "gsr error: gsr_pipewire_create_null_audio_sink: failed to create virtual sink properties\n");
-        return NULL;
-    }
-    return props;
-}
-
-bool gsr_pipewire_audio_create_virtual_sink(gsr_pipewire_audio *self, const char *name) {
-    if(!array_ensure_capacity((void**)&self->virtual_sink_proxies, self->num_virtual_sink_proxies, &self->virtual_sink_proxies_capacity_items, sizeof(struct pw_proxy*)))
-        return false;
-
-    pw_thread_loop_lock(self->thread_loop);
-
-    struct pw_properties *virtual_sink_props = gsr_pipewire_create_null_audio_sink(name);
-    if(!virtual_sink_props) {
-        pw_thread_loop_unlock(self->thread_loop);
-        return false;
-    }
-
-    struct pw_proxy *virtual_sink_proxy = pw_core_create_object(self->core, "adapter", PW_TYPE_INTERFACE_Node, PW_VERSION_NODE, &virtual_sink_props->dict, 0);
-    // TODO:
-    // If these are done then the above needs sizeof(*self) as the last argument
-    //pw_proxy_add_object_listener(virtual_sink_proxy, &pd->object_listener, &node_events, self);
-	//pw_proxy_add_listener(virtual_sink_proxy, &pd->proxy_listener, &proxy_events, self);
-    // TODO: proxy
-    pw_properties_free(virtual_sink_props);
-    if(!virtual_sink_proxy) {
-        fprintf(stderr, "gsr error: gsr_pipewire_audio_create_virtual_sink: failed to create virtual sink\n");
-        pw_thread_loop_unlock(self->thread_loop);
-        return false;
-    }
-
-    self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, self->server_version_sync);
-    pw_thread_loop_wait(self->thread_loop);
-    pw_thread_loop_unlock(self->thread_loop);
-
-    self->virtual_sink_proxies[self->num_virtual_sink_proxies] = virtual_sink_proxy;
-    ++self->num_virtual_sink_proxies;
-
-    return true;
-}
-
 static bool string_remove_suffix(char *str, const char *suffix) {
     int str_len = strlen(str);
     int suffix_len = strlen(suffix);
@@ -790,6 +795,7 @@ static bool gsr_pipewire_audio_add_links_to_output(gsr_pipewire_audio *self, con
     self->requested_links[self->num_requested_links].inverted = inverted;
     ++self->num_requested_links;
     gsr_pipewire_audio_create_link(self, &self->requested_links[self->num_requested_links - 1]);
+    // TODO: Remove these?
     gsr_pipewire_audio_create_link_for_default_devices(self, &self->requested_links[self->num_requested_links - 1], GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT);
     gsr_pipewire_audio_create_link_for_default_devices(self, &self->requested_links[self->num_requested_links - 1], GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_INPUT);
     pw_thread_loop_unlock(self->thread_loop);
@@ -821,6 +827,10 @@ bool gsr_pipewire_audio_add_link_from_apps_to_sink_inverted(gsr_pipewire_audio *
     return gsr_pipewire_audio_add_links_to_output(self, app_names, num_app_names, sink_name_input, GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_OUTPUT, GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_SINK, true);
 }
 
+bool gsr_pipewire_audio_add_link_from_sources_to_stream(gsr_pipewire_audio *self, const char **source_names, int num_source_names, const char *stream_name_input) {
+    return gsr_pipewire_audio_add_links_to_output(self, source_names, num_source_names, stream_name_input, GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE, GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_STREAM, false);
+}
+
 bool gsr_pipewire_audio_add_link_from_sources_to_sink(gsr_pipewire_audio *self, const char **source_names, int num_source_names, const char *sink_name_input) {
     return gsr_pipewire_audio_add_links_to_output(self, source_names, num_source_names, sink_name_input, GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE, GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_SINK, false);
 }

src/pipewire_video.c

@@ -134,7 +134,7 @@ static void on_process_cb(void *user_data) {
     }
 
     struct spa_buffer *buffer = pw_buf->buffer;
-    const bool has_buffer = buffer->datas[0].chunk->size != 0;
+    const bool has_buffer = buffer->n_datas > 0 && buffer->datas[0].chunk->size != 0;
 
     pthread_mutex_lock(&self->mutex);
 
@@ -280,7 +280,8 @@ static void on_param_changed_cb(void *user_data, uint32_t id, const struct spa_p
          self->format.info.raw.format,
          spa_debug_type_find_name(spa_type_video_format, self->format.info.raw.format));
 
-    if(has_modifier) {
+    self->has_modifier = has_modifier;
+    if(self->has_modifier) {
         fprintf(stderr, "gsr info: pipewire:    Modifier: 0x%" PRIx64 "\n", self->format.info.raw.modifier);
     }
 
@@ -347,6 +348,7 @@ static void on_state_changed_cb(void *user_data, enum pw_stream_state prev_state
     } else {
         self->paused = false;
     }
+    self->streaming = (new_state == PW_STREAM_STATE_STREAMING);
     pthread_mutex_unlock(&self->mutex);
 }
 
@@ -531,31 +533,36 @@ static bool spa_video_format_get_modifiers(gsr_pipewire_video *self, const enum
 static void gsr_pipewire_video_init_modifiers(gsr_pipewire_video *self) {
     for(size_t i = 0; i < GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS; i++) {
         self->supported_video_formats[i].format = video_formats[i];
-        int32_t num_modifiers = 0;
-        spa_video_format_get_modifiers(self, self->supported_video_formats[i].format, self->modifiers + self->num_modifiers, GSR_PIPEWIRE_VIDEO_MAX_MODIFIERS - self->num_modifiers, &num_modifiers);
+        int32_t num_modifiers_video_format = 0;
+        spa_video_format_get_modifiers(self, self->supported_video_formats[i].format, self->modifiers + self->num_modifiers, GSR_PIPEWIRE_VIDEO_MAX_MODIFIERS - self->num_modifiers, &num_modifiers_video_format);
         self->supported_video_formats[i].modifiers_index = self->num_modifiers;
-        self->supported_video_formats[i].modifiers_size = num_modifiers;
-        self->num_modifiers += num_modifiers;
+        self->supported_video_formats[i].modifiers_size = num_modifiers_video_format;
+        self->num_modifiers += num_modifiers_video_format;
     }
 }
 
-static void gsr_pipewire_video_format_remove_modifier(gsr_pipewire_video *self, gsr_video_format *video_format, uint64_t modifier) {
+/* Returns the number of modifiers  */
+static size_t gsr_pipewire_video_format_remove_modifier(gsr_pipewire_video *self, gsr_video_format *video_format, uint64_t modifier) {
     for(size_t i = 0; i < video_format->modifiers_size; ++i) {
-        if(self->modifiers[video_format->modifiers_index + i] != modifier)
-            continue;
+        if(self->modifiers[video_format->modifiers_index + i] == modifier) {
+            for(size_t j = i + 1; j < video_format->modifiers_size; ++j) {
+                self->modifiers[video_format->modifiers_index + j - 1] = self->modifiers[video_format->modifiers_index + j];
+            }
 
-        for(size_t j = i + 1; j < video_format->modifiers_size; ++j) {
-            self->modifiers[j - 1] = self->modifiers[j];
+            --video_format->modifiers_size;
+            break;
         }
-        --video_format->modifiers_size;
-        return;
     }
+    return video_format->modifiers_size;
 }
 
 static void gsr_pipewire_video_remove_modifier(gsr_pipewire_video *self, uint64_t modifier) {
+    self->num_modifiers = 0;
     for(size_t i = 0; i < GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS; i++) {
         gsr_video_format *video_format = &self->supported_video_formats[i];
-        gsr_pipewire_video_format_remove_modifier(self, video_format, modifier);
+        const size_t num_modifiers_video_format = gsr_pipewire_video_format_remove_modifier(self, video_format, modifier);
+        video_format->modifiers_index = self->num_modifiers;
+        self->num_modifiers += num_modifiers_video_format;
     }
 }
 
@@ -736,7 +743,6 @@ void gsr_pipewire_video_deinit(gsr_pipewire_video *self) {
     self->dmabuf_num_planes = 0;
 
     self->negotiated = false;
-    self->renegotiated = false;
 
     if(self->mutex_initialized) {
         pthread_mutex_destroy(&self->mutex);
@@ -783,21 +789,20 @@ static EGLImage gsr_pipewire_video_create_egl_image_with_fallback(gsr_pipewire_v
     }
 
     EGLImage image = NULL;
-    if(self->no_modifiers_fallback) {
+    if(self->no_modifiers_fallback || !self->has_modifier) {
         image = gsr_pipewire_video_create_egl_image(self, fds, offsets, pitches, modifiers, false);
     } else {
         image = gsr_pipewire_video_create_egl_image(self, fds, offsets, pitches, modifiers, true);
         if(!image) {
-            if(self->renegotiated || self->format.info.raw.modifier == DRM_FORMAT_MOD_INVALID) {
+            if(self->format.info.raw.modifier == DRM_FORMAT_MOD_INVALID) {
                 fprintf(stderr, "gsr error: gsr_pipewire_video_create_egl_image_with_fallback: failed to create egl image with modifiers, trying without modifiers\n");
                 self->no_modifiers_fallback = true;
                 image = gsr_pipewire_video_create_egl_image(self, fds, offsets, pitches, modifiers, false);
             } else {
-                fprintf(stderr, "gsr error: gsr_pipewire_video_create_egl_image_with_fallback: failed to create egl image with modifiers, renegotiating with a different modifier\n");
+                fprintf(stderr, "gsr error: gsr_pipewire_video_create_egl_image_with_fallback: failed to create egl image with modifier 0x%" PRIx64 ", renegotiating with a different modifier\n", self->format.info.raw.modifier);
                 self->negotiated = false;
-                self->renegotiated = true;
-                gsr_pipewire_video_remove_modifier(self, self->format.info.raw.modifier);
                 pw_thread_loop_lock(self->thread_loop);
+                gsr_pipewire_video_remove_modifier(self, self->format.info.raw.modifier);
                 pw_loop_signal_event(pw_thread_loop_get_loop(self->thread_loop), self->reneg);
                 pw_thread_loop_unlock(self->thread_loop);
             }
@@ -854,7 +859,7 @@ bool gsr_pipewire_video_map_texture(gsr_pipewire_video *self, gsr_texture_map te
     output->rotation = GSR_MONITOR_ROT_0;
     pthread_mutex_lock(&self->mutex);
 
-    if(!self->negotiated || self->dmabuf_data[0].fd <= 0) {
+    if(!self->negotiated || !self->streaming || self->dmabuf_data[0].fd <= 0) {
         pthread_mutex_unlock(&self->mutex);
         return false;
     }
@@ -871,6 +876,9 @@ bool gsr_pipewire_video_map_texture(gsr_pipewire_video *self, gsr_texture_map te
 
     gsr_pipewire_video_update_cursor_texture(self, texture_map);
 
+    output->texture_width = self->format.info.raw.size.width;
+    output->texture_height = self->format.info.raw.size.height;
+
     output->region.x = 0;
     output->region.y = 0;
 

src/plugins.c

@@ -33,6 +33,7 @@ bool gsr_plugins_init(gsr_plugins *self, gsr_plugin_init_params init_params, gsr
         .egl = egl,
         .destination_color = GSR_DESTINATION_COLOR_RGB8, /* TODO: Support 10-bits, use init_params.color_depth */
         .destination_textures[0] = self->texture,
+        .destination_textures_size[0] = (vec2i){ init_params.width, init_params.height },
         .num_destination_textures = 1,
         .color_range = GSR_COLOR_RANGE_FULL,
         .load_external_image_shader = false,

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/shader.c

@@ -38,10 +38,9 @@ static unsigned int load_shader(gsr_egl *egl, unsigned int type, const char *sou
     return shader_id;
 }
 
-static unsigned int load_program(gsr_egl *egl, const char *vertex_shader, const char *fragment_shader, const char *compute_shader) {
+static unsigned int load_program(gsr_egl *egl, const char *vertex_shader, const char *fragment_shader) {
     unsigned int vertex_shader_id = 0;
     unsigned int fragment_shader_id = 0;
-    unsigned int compute_shader_id = 0;
     unsigned int program_id = 0;
     int linked = 0;
     bool success = false;
@@ -58,12 +57,6 @@ static unsigned int load_program(gsr_egl *egl, const char *vertex_shader, const
             goto done;
     }
 
-    if(compute_shader) {
-        compute_shader_id = load_shader(egl, GL_COMPUTE_SHADER, compute_shader);
-        if(compute_shader_id == 0)
-            goto done;
-    }
-
     program_id = egl->glCreateProgram();
     if(program_id == 0) {
         fprintf(stderr, "gsr error: load_program: failed to create shader program, error: %d\n", egl->glGetError());
@@ -76,9 +69,6 @@ static unsigned int load_program(gsr_egl *egl, const char *vertex_shader, const
     if(fragment_shader_id)
         egl->glAttachShader(program_id, fragment_shader_id);
 
-    if(compute_shader_id)
-        egl->glAttachShader(program_id, compute_shader_id);
-
     egl->glLinkProgram(program_id);
 
     egl->glGetProgramiv(program_id, GL_LINK_STATUS, &linked);
@@ -102,8 +92,6 @@ static unsigned int load_program(gsr_egl *egl, const char *vertex_shader, const
         if(program_id)
             egl->glDeleteProgram(program_id);
     }
-    if(compute_shader_id)
-        egl->glDeleteShader(compute_shader_id);
     if(fragment_shader_id)
         egl->glDeleteShader(fragment_shader_id);
     if(vertex_shader_id)
@@ -111,17 +99,17 @@ static unsigned int load_program(gsr_egl *egl, const char *vertex_shader, const
     return program_id;
 }
 
-int gsr_shader_init(gsr_shader *self, gsr_egl *egl, const char *vertex_shader, const char *fragment_shader, const char *compute_shader) {
+int gsr_shader_init(gsr_shader *self, gsr_egl *egl, const char *vertex_shader, const char *fragment_shader) {
     assert(egl);
     self->egl = egl;
     self->program_id = 0;
 
-    if(!vertex_shader && !fragment_shader && !compute_shader) {
-        fprintf(stderr, "gsr error: gsr_shader_init: vertex, fragment shader and compute shaders can't be NULL at the same time\n");
+    if(!vertex_shader && !fragment_shader) {
+        fprintf(stderr, "gsr error: gsr_shader_init: vertex and fragment shader can't be NULL at the same time\n");
         return -1;
     }
 
-    self->program_id = load_program(self->egl, vertex_shader, fragment_shader, compute_shader);
+    self->program_id = load_program(self->egl, vertex_shader, fragment_shader);
     if(self->program_id == 0)
         return -1;
 

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,10 +195,11 @@ 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;
-    p->reconnect_last_tried_seconds = clock_get_monotonic_seconds() - 1000.0;
+    p->reconnect_last_tried_seconds = clock_get_monotonic_seconds() - (RECONNECT_TRY_TIMEOUT_SECONDS * 1000.0 * 2.0);
     p->default_output_device_name[0] = '\0';
     p->default_input_device_name[0] = '\0';
     p->device_type = DeviceType::STANDARD;
@@ -206,10 +216,17 @@ static pa_handle* pa_sound_device_new(const char *server,
     p->output_length = buffer_size;
     p->output_index = 0;
 
+    p->proplist = pa_proplist_new();
+    pa_proplist_sets(p->proplist, PA_PROP_MEDIA_ROLE, "production");
+    if(strcmp(device_name, "") == 0) {
+        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(pa_mainloop_get_api(p->mainloop), name)))
+    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) {
@@ -239,6 +256,7 @@ static pa_handle* pa_sound_device_new(const char *server,
     if(pa)
         pa_operation_unref(pa);
 
+    p->connected = true;
     return p;
 
 fail:
@@ -248,19 +266,67 @@ fail:
     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);
+
+    if(!p->reconnect && (!p->stream || !PA_STREAM_IS_GOOD(pa_stream_get_state(p->stream)))) {
+        p->reconnect = true;
+        p->reconnect_last_tried_seconds = now;
+    }
+
     if(p->reconnect && now - p->reconnect_last_tried_seconds >= RECONNECT_TRY_TIMEOUT_SECONDS) {
         p->reconnect_last_tried_seconds = now;
         // TODO: Size check
         snprintf(device_name, device_name_size, "%s", p->device_name);
         return true;
     }
+
     return false;
 }
 
 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;
 
@@ -268,34 +334,33 @@ 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))) {
+    pa_proplist *proplist = pa_proplist_new();
+    // This prevents microphone recording indicator from being shown on KDE
+    pa_proplist_sets(proplist, "node.virtual", "true");
+
+    if(!(p->stream = pa_stream_new_with_proplist(p->context, p->stream_name, &p->ss, NULL, proplist))) {
         //pa_context_errno(p->context);
+        pa_proplist_free(proplist);
         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));
+    pa_proplist_free(proplist);
+
+    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);
         return false;
     }
 
-    for(;;) {
-        pa_stream_state_t state = pa_stream_get_state(p->stream);
-
-        if(state == PA_STREAM_READY)
-            break;
-
-        if(!PA_STREAM_IS_GOOD(state)) {
-            //pa_context_errno(p->context);
-            return false;
-        }
-
-        pa_mainloop_iterate(p->mainloop, 1, NULL);
-    }
+    pa_mainloop_iterate(p->mainloop, 0, NULL);
 
     std::lock_guard<std::mutex> lock(p->reconnect_mutex);
     p->reconnect = false;
@@ -314,7 +379,21 @@ static int pa_sound_device_read(pa_handle *p, double timeout_seconds) {
     pa_usec_t latency = 0;
     int negative = 0;
 
-    if(!pa_sound_device_handle_reconnect(p, device_name, sizeof(device_name), start_time))
+    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;
+
+    if(pa_stream_get_state(p->stream) != PA_STREAM_READY)
         goto fail;
 
     CHECK_DEAD_GOTO(p, rerror, fail);
@@ -410,7 +489,7 @@ static int audio_format_to_get_bytes_per_sample(AudioFormat audio_format) {
     return 2;
 }
 
-int sound_device_get_by_name(SoundDevice *device, const char *device_name, const char *description, unsigned int num_channels, unsigned int period_frame_size, AudioFormat audio_format) {
+int sound_device_get_by_name(SoundDevice *device, const char *node_name, const char *device_name, const char *description, unsigned int num_channels, unsigned int period_frame_size, AudioFormat audio_format) {
     pa_sample_spec ss;
     ss.format = audio_format_to_pulse_audio_format(audio_format);
     ss.rate = 48000;
@@ -424,7 +503,7 @@ int sound_device_get_by_name(SoundDevice *device, const char *device_name, const
     buffer_attr.maxlength = buffer_attr.fragsize;
 
     int error = 0;
-    pa_handle *handle = pa_sound_device_new(nullptr, description, device_name, description, &ss, &buffer_attr, &error);
+    pa_handle *handle = pa_sound_device_new(nullptr, node_name, device_name, description, &ss, &buffer_attr, &error);
     if(!handle) {
         fprintf(stderr, "gsr error: pa_sound_device_new() failed: %s. Audio input device %s might not be valid\n", pa_strerror(error), device_name);
         return -1;

src/utils.c

@@ -1,5 +1,6 @@
 #include "../include/utils.h"
 #include "../include/window/window.h"
+#include "../include/capture/capture.h"
 
 #include <time.h>
 #include <string.h>
@@ -120,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
@@ -148,6 +151,8 @@ int get_connector_type_by_name(const char *name) {
         return 3;
     else if(len >= 4 && strncmp(name, "eDP-", 4) == 0)
         return 4;
+    else if(len >= 4 && strncmp(name, "DVI-", 4) == 0)
+        return 5;
     else
         return -1;
 }
@@ -226,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
@@ -261,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;
@@ -593,11 +602,43 @@ vec2i scale_keep_aspect_ratio(vec2i from, vec2i to) {
     return from;
 }
 
+vec2i gsr_capture_get_target_position(vec2i output_size, gsr_capture_metadata *capture_metadata) {
+    vec2i target_pos = {0, 0};
+
+    switch(capture_metadata->halign) {
+        case GSR_CAPTURE_ALIGN_START:
+            break;
+        case GSR_CAPTURE_ALIGN_CENTER:
+            target_pos.x = capture_metadata->video_size.x/2 - output_size.x/2;
+            break;
+        case GSR_CAPTURE_ALIGN_END:
+            target_pos.x = capture_metadata->video_size.x - output_size.x;
+            break;
+    }
+
+    switch(capture_metadata->valign) {
+        case GSR_CAPTURE_ALIGN_START:
+            break;
+        case GSR_CAPTURE_ALIGN_CENTER:
+            target_pos.y = capture_metadata->video_size.y/2 - output_size.y/2;
+            break;
+        case GSR_CAPTURE_ALIGN_END:
+            target_pos.y = capture_metadata->video_size.y - output_size.y;
+            break;
+    }
+
+    target_pos.x += capture_metadata->position.x;
+    target_pos.y += capture_metadata->position.y;
+    return target_pos;
+}
+
+
 unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format, int filter) {
     unsigned int texture_id = 0;
     egl->glGenTextures(1, &texture_id);
     egl->glBindTexture(GL_TEXTURE_2D, texture_id);
     //egl->glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
+    // 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);
@@ -606,3 +647,37 @@ unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal
     egl->glBindTexture(GL_TEXTURE_2D, 0);
     return texture_id;
 }
+
+/* TODO: Test with optimus and open kernel modules */
+bool get_nvidia_driver_version(int *major, int *minor) {
+    *major = 0;
+    *minor = 0;
+
+    FILE *f = fopen("/proc/driver/nvidia/version", "rb");
+    if(!f) {
+        fprintf(stderr, "gsr warning: failed to get nvidia driver version (failed to read /proc/driver/nvidia/version)\n");
+        return false;
+    }
+
+    char buffer[2048];
+    size_t bytes_read = fread(buffer, 1, sizeof(buffer) - 1, f);
+    buffer[bytes_read] = '\0';
+
+    bool success = false;
+    const char *p = strstr(buffer, "Kernel Module");
+    if(p) {
+        p += 13;
+        int driver_major_version = 0, driver_minor_version = 0;
+        if(sscanf(p, "%d.%d", &driver_major_version, &driver_minor_version) == 2) {
+            *major = driver_major_version;
+            *minor = driver_minor_version;
+            success = true;
+        }
+    }
+
+    if(!success)
+        fprintf(stderr, "gsr warning: failed to get nvidia driver version\n");
+
+    fclose(f);
+    return success;
+}

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

src/window_texture.c

@@ -20,6 +20,8 @@ int window_texture_init(WindowTexture *window_texture, Display *display, Window
     window_texture->texture_id = 0;
     window_texture->redirected = 0;
     window_texture->egl = egl;
+    window_texture->window_width = 0;
+    window_texture->window_height = 0;
     
     if(!x11_supports_composite_named_window_pixmap(display))
         return 1;
@@ -67,6 +69,11 @@ int window_texture_on_resize(WindowTexture *self) {
         EGL_NONE,
     };
 
+    Window root_window;
+    int window_x, window_y;
+    unsigned int window_border, window_depth;
+    XGetGeometry(self->display, self->window, &root_window, &window_x, &window_y, &self->window_width, &self->window_height, &window_border, &window_depth);
+
     pixmap = XCompositeNameWindowPixmap(self->display, self->window);
     if(!pixmap) {
         result = 2;