5.10.2

Connect application/device audio directly to gsr recording node.
This fixes an issue for some users where gsr-app-sink got selected by
default as an output device.

Dont wait until audio node first receives audio before recording audio
from the device. This might fix audio/video desync issue when recording
from microphone for example.

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
 
@@ -26,38 +26,14 @@ Supported image formats:
 * JPEG
 * PNG
 
-This software works on X11 and Wayland on AMD, Intel and NVIDIA. Replay data is stored in RAM by default but there is an option to store it on disk instead.
-### 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.
+This software works on X11 and Wayland on AMD, Intel and NVIDIA.
 
 # 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 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.\
@@ -67,7 +43,7 @@ Here are some known unofficial packages:
 * Debian/Ubuntu: [Pacstall](https://pacstall.dev/packages/gpu-screen-recorder)
 * Nix: [NixOS wiki](https://wiki.nixos.org/wiki/Gpu-screen-recorder)
 * openSUSE: [openSUSE software repository](https://software.opensuse.org/package/gpu-screen-recorder)
-* Fedora: [Copr](https://copr.fedorainfracloud.org/coprs/brycensranch/gpu-screen-recorder-git/)
+* Fedora, CentOS: [Copr](https://copr.fedorainfracloud.org/coprs/brycensranch/gpu-screen-recorder-git/)
 * OpenMandriva: [gpu-screen-recorder](https://github.com/OpenMandrivaAssociation/gpu-screen-recorder)
 * Solus: [gpu-screen-recorder](https://github.com/getsolus/packages/tree/main/packages/g/gpu-screen-recorder)
 * Nobara: [Nobara wiki](https://wiki.nobaraproject.org/en/general-usage/additional-software/GPU-Screen-Recorder)
@@ -79,14 +55,19 @@ 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
+
+## 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)
@@ -99,7 +80,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,11 +88,6 @@ 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 compiling GPU Screen Recorder with portal support (`-Dportal=true`, 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/).\
@@ -126,21 +102,25 @@ 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.
 The file path to the saved replay is output to stdout. All other output from GPU Screen Recorder are output to stderr.
 You can also use the `-sc` option to specify a script that should be run (asynchronously) when the video has been saved and the script will have access to the location of the saved file as its first argument.
-This can be used for example to show a notification when a replay has been saved, to rename the video with a title that matches the game played (see `scripts/record-save-application-name.sh` as an example on how to do this on X11) or to re-encode the video.\
-The replay buffer is stored in ram (as encoded video), so don't use a too large replay time and/or video quality unless you have enough ram to store it.
+This can be used for example to show a notification when a replay has been saved, to rename the video with a title that matches the game played (see `scripts/record-save-application-name.sh` as an example on how to do this on X11) or to re-encode the video.
+
+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`.\
@@ -156,13 +136,59 @@ If you installed GPU Screen Recorder from AUR or from source and you are running
 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.
 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
+Run `gpu-screen-recorder` with the `-sc` option to specify a script that should be run when a recording/replay a saved, for example `gpu-screen-recorder -w screen -sc ./script.sh -o video.mp4`.\
+The first argument to the script is the file path to the saved video. The second argument is either "regular" for regular recordings, "replay" for replays or "screenshot" for screenshots.\
+This can be used to for example showing a notification with the name of video or moving a video to a folder based on the name of the game that was recorded.
+## Plugins
+GPU Screen Recorder supports plugins for rendering additional graphics on top of the monitor/window capture. The plugin interface is defined in `plugin/plugin.h` and it gets installed to `gsr/plugin.h` in the systems include directory (usually `/usr/include`).
+An example plugin can be found at `plugin/examples/hello_triangle`.\
+Run `gpu-screen-recorder` with the `-p` option to specify a plugin to load, for example `gpu-screen-recorder -w screen -p ./triangle.so -o video.mp4`.
+`-p` can be specified multiple times to load multiple plugins.\
+Build GPU Screen Recorder with the `-Dplugin_examples=true` meson option to build plugin examples.
+## Smoother recording
+If you record at your monitors refresh rate and enabled vsync in a game then there might be a desync between the game updating a frame and GPU Screen Recorder capturing a frame.
+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 dont 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.
+
 # Reporting bugs, contributing patches, questions or donation
 See [https://git.dec05eba.com/?p=about](https://git.dec05eba.com/?p=about).
 
@@ -182,7 +208,9 @@ Browsers and discord don't support hevc video codec at the moment. Choose h264 v
 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
@@ -204,6 +232,20 @@ 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.
+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 dont 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).

TODO

@@ -30,9 +30,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,38 +61,24 @@ 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.-
 
 Drop frames if live streaming cant keep up with target fps, or dynamically change resolution/quality.
 
-Support low power option.
-
 Instead of sending a big list of drm data back to kms client, send the monitor we want to record to kms server and the server should respond with only the matching monitor, and cursor.
 
 Tonemap hdr to sdr when hdr is enabled and when hevc_hdr/av1_hdr is not used.
 
-Add 10 bit record option, h264_10bit, hevc_10bit and av1_10bit.
-
 Rotate cursor texture properly (around top left origin).
 
-Setup hardware video context so we can query constraints and capabilities for better default and better error messages.
-
-Use CAP_SYS_NICE in flatpak too on the main gpu screen recorder binary. It makes recording smoother, especially with constant framerate.
-
 Modify ffmpeg to accept opengl texture for nvenc encoding. Removes extra buffers and copies.
 
 When vulkan encode is added, mention minimum nvidia driver required. (550.54.14?).
 
-Support drm plane rotation. Neither X11 nor any Wayland compositor currently rotates drm planes so this might not be needed.
-
 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.
@@ -104,6 +87,9 @@ Enable b-frames.
 
 Support vfr matching games exact fps all the time. On x11 use damage tracking, on wayland? maybe there is drm plane damage tracking. But that may not be accurate as the compositor may update it every monitor hz anyways. On wayland maybe only support it for desktop portal + pipewire capture.
     Another method to track damage that works regardless of the display server would be to do a diff between frames with a shader.
+    A 1x1 texture could be created and then write to the texture with imageStore in glsl.
+    Multiple textures aren't needed for diff, the diff between the color conversion output can be done by using it as an input
+    as well, which would diff it against the previous frame.
 
 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.
@@ -196,13 +182,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.
@@ -216,8 +195,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.
 
@@ -251,8 +228,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.
@@ -282,7 +257,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.
 
@@ -315,3 +291,66 @@ Colors are correct, but they look incorrect for thin elements, such as colored t
 Record first video/audio frame immediately.
 
 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.
+
+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). 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.
+
+Check if pipewire audio link-factory is available before attempting to use app audio or merging audio with pipewire.
+    Also do the same in supports_app_audio check in gpu-screen-recorder --info output.
+
+Move region capture to an option in the color conversion instead of having the region code in kms capture code. This would make it cleaner and make it work with all capture methods.
+    -w region would just be an option for selecting the monitor and -region would work with all capture methods (-w).
+
+Set top level window argument for portal capture. Same for gpu-screen-recorder-gtk global shortcuts.
+
+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).
+
+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.
+
+Create a manpage and move --help text there and mention the manpage command to view it (and make it work in flatpak, maybe with man <link-to-manpage-file>).
+
+Implement webcam support by using mjpeg with v4l2 and use ffmpeg mjpeg decoder.
+
+After adding rpc, making recording while in replay/streaming work differently. Start recording should take audio as an argument, to optionally specify different audio for recording than replay/stream.
+
+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).

include/args_parser.h

@@ -8,7 +8,7 @@
 
 typedef struct gsr_egl gsr_egl;
 
-#define NUM_ARGS 30
+#define NUM_ARGS 32
 
 typedef enum {
     ARG_TYPE_STRING,
@@ -76,6 +76,7 @@ typedef struct {
     const char *recording_saved_script;
     bool verbose;
     bool gl_debug;
+    bool fallback_cpu_encoding;
     bool record_cursor;
     bool date_folders;
     bool restore_portal_session;

include/capture/capture.h

@@ -14,15 +14,17 @@ typedef struct AVContentLightMetadata AVContentLightMetadata;
 typedef struct gsr_capture gsr_capture;
 
 typedef struct {
-    int width;
-    int height;
+    // Width and height of the video
+    int video_width;
+    int video_height;
+    // Width and height of the frame at the start of capture, the target size
+    int recording_width;
+    int recording_height;
     int fps;
-    AVCodecContext *video_codec_context; /* can be NULL */
-    AVFrame *frame; /* can be NULL, but will never be NULL if |video_codec_context| is set */
 } gsr_capture_metadata;
 
 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_width| and |capture_metadata->video_height| 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 */

include/codec_query/codec_query.h

@@ -2,10 +2,12 @@
 #define GSR_CODEC_QUERY_H
 
 #include <stdbool.h>
+#include "../vec2.h"
 
 typedef struct {
     bool supported;
     bool low_power;
+    vec2i max_resolution;
 } gsr_supported_video_codec;
 
 typedef struct {

include/color_conversion.h

@@ -6,7 +6,6 @@
 #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_FRAMEBUFFERS 2
 
@@ -33,50 +32,35 @@ typedef struct {
     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;
 } 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_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/egl.h

@@ -105,6 +105,7 @@ typedef void(*__GLXextFuncPtr)(void);
 #define GL_RGBA                                 0x1908
 #define GL_RGB8                                 0x8051
 #define GL_RGBA8                                0x8058
+#define GL_RGBA16                               0x805B
 #define GL_R8                                   0x8229
 #define GL_RG8                                  0x822B
 #define GL_R16                                  0x822A
@@ -117,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
@@ -137,7 +136,6 @@ typedef void(*__GLXextFuncPtr)(void);
 #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
@@ -151,7 +149,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
 
@@ -259,7 +256,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);
@@ -267,7 +263,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);

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

@@ -1,6 +1,7 @@
 #ifndef GSR_PIPEWIRE_VIDEO_H
 #define GSR_PIPEWIRE_VIDEO_H
 
+#include "defs.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <pthread.h>
@@ -9,7 +10,7 @@
 #include <spa/param/video/format.h>
 
 #define GSR_PIPEWIRE_VIDEO_MAX_MODIFIERS 1024
-#define GSR_PIPEWIRE_VIDEO_MAX_VIDEO_FORMATS 12
+#define GSR_PIPEWIRE_VIDEO_MAX_VIDEO_FORMATS 10
 #define GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES 4
 
 typedef struct gsr_egl gsr_egl;
@@ -48,6 +49,19 @@ typedef struct {
     unsigned int cursor_texture_id;
 } gsr_texture_map;
 
+typedef struct {
+    gsr_pipewire_video_region region;
+    gsr_pipewire_video_region cursor_region;
+    gsr_pipewire_video_dmabuf_data dmabuf_data[GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES];
+    int num_dmabuf_data;
+    uint32_t fourcc;
+    uint64_t modifiers;
+    bool using_external_image;
+    gsr_monitor_rotation rotation;
+    int texture_width;
+    int texture_height;
+} gsr_map_texture_output;
+
 typedef struct {
     gsr_egl *egl;
     int fd;
@@ -65,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;
@@ -98,6 +112,8 @@ typedef struct {
 
     bool paused;
     double paused_start_secs;
+
+    gsr_monitor_rotation rotation;
 } gsr_pipewire_video;
 
 /*
@@ -108,8 +124,7 @@ typedef struct {
 bool gsr_pipewire_video_init(gsr_pipewire_video *self, int pipewire_fd, uint32_t pipewire_node, int fps, bool capture_cursor, gsr_egl *egl);
 void gsr_pipewire_video_deinit(gsr_pipewire_video *self);
 
-/* |dmabuf_data| should be at least GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES in size */
-bool gsr_pipewire_video_map_texture(gsr_pipewire_video *self, gsr_texture_map texture_map, gsr_pipewire_video_region *region, gsr_pipewire_video_region *cursor_region, gsr_pipewire_video_dmabuf_data *dmabuf_data, int *num_dmabuf_data, uint32_t *fourcc, uint64_t *modifiers, bool *using_external_image);
+bool gsr_pipewire_video_map_texture(gsr_pipewire_video *self, gsr_texture_map texture_map, gsr_map_texture_output *output);
 bool gsr_pipewire_video_is_damaged(gsr_pipewire_video *self);
 void gsr_pipewire_video_clear_damage(gsr_pipewire_video *self);
 bool gsr_pipewire_video_should_restart(gsr_pipewire_video *self);

include/plugins.h

@@ -0,0 +1,38 @@
+#ifndef GSR_PLUGINS_H
+#define GSR_PLUGINS_H
+
+#include "../plugin/plugin.h"
+#include <stdbool.h>
+#include "color_conversion.h"
+
+#define GSR_MAX_PLUGINS 128
+
+typedef bool (*gsr_plugin_init_func)(const gsr_plugin_init_params *params, gsr_plugin_init_return *ret);
+typedef void (*gsr_plugin_deinit_func)(void *userdata);
+
+typedef struct {
+    gsr_plugin_init_return data;
+    void *lib;
+    gsr_plugin_init_func gsr_plugin_init;
+    gsr_plugin_deinit_func gsr_plugin_deinit;
+} gsr_plugin;
+
+typedef struct {
+    gsr_plugin plugins[GSR_MAX_PLUGINS];
+    int num_plugins;
+
+    gsr_plugin_init_params init_params;
+    gsr_egl *egl;
+
+    unsigned int texture;
+    gsr_color_conversion color_conversion;
+} gsr_plugins;
+
+bool gsr_plugins_init(gsr_plugins *self, gsr_plugin_init_params init_params, gsr_egl *egl);
+/* Plugins are unloaded in reverse order */
+void gsr_plugins_deinit(gsr_plugins *self);
+
+bool gsr_plugins_load_plugin(gsr_plugins *self, const char *plugin_filepath);
+void gsr_plugins_draw(gsr_plugins *self);
+
+#endif /* GSR_PLUGINS_H */

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

@@ -58,4 +58,6 @@ vec2i scale_keep_aspect_ratio(vec2i from, vec2i to);
 
 unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format, int filter);
 
+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/kms_shared.h

@@ -5,7 +5,7 @@
 #include <stdbool.h>
 #include <drm_mode.h>
 
-#define GSR_KMS_PROTOCOL_VERSION 4
+#define GSR_KMS_PROTOCOL_VERSION 5
 
 #define GSR_KMS_MAX_ITEMS 8
 #define GSR_KMS_MAX_DMA_BUFS 4
@@ -39,6 +39,13 @@ struct gsr_kms_response_dma_buf {
     uint32_t offset;
 };
 
+typedef enum {
+    KMS_ROT_0,
+    KMS_ROT_90,
+    KMS_ROT_180,
+    KMS_ROT_270
+} gsr_kms_rotation;
+
 struct gsr_kms_response_item {
     gsr_kms_response_dma_buf dma_buf[GSR_KMS_MAX_DMA_BUFS];
     int num_dma_bufs;
@@ -49,6 +56,7 @@ struct gsr_kms_response_item {
     uint32_t connector_id; /* 0 if unknown */
     bool is_cursor;
     bool has_hdr_metadata;
+    gsr_kms_rotation rotation;
     int x;
     int y;
     int src_w;

kms/server/kms_server.c

@@ -145,16 +145,18 @@ typedef enum {
     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 *src_w, int *src_h) {
+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;
     *src_w = 0;
     *src_h = 0;
+    *rotation = KMS_ROT_0;
 
     plane_property_mask property_mask = 0;
 
@@ -199,6 +201,15 @@ static uint32_t plane_get_properties(int drmfd, uint32_t plane_id, int *x, int *
                     break;
                 }
             }
+        } else if((type & DRM_MODE_PROP_BITMASK) && strcmp(prop->name, "rotation") == 0) {
+            const uint64_t rotation_bitmask = props->prop_values[i];
+            *rotation = KMS_ROT_0;
+            if(rotation_bitmask & 2)
+                *rotation = (*rotation + KMS_ROT_90) % 4;
+            if(rotation_bitmask & 4)
+                *rotation = (*rotation + KMS_ROT_180) % 4;
+            if(rotation_bitmask & 8)
+                *rotation = (*rotation + KMS_ROT_270) % 4;
         }
 
         drmModeFreeProperty(prop);
@@ -341,7 +352,8 @@ static int kms_get_fb(gsr_drm *drm, gsr_kms_response *response) {
         // 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, src_w = 0, src_h = 0;
-        plane_property_mask property_mask = plane_get_properties(drm->drmfd, plane->plane_id, &x, &y, &src_x, &src_y, &src_w, &src_h);
+        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, &src_w, &src_h, &rotation);
         if(!(property_mask & PLANE_PROPERTY_IS_PRIMARY) && !(property_mask & PLANE_PROPERTY_IS_CURSOR))
             continue;
 
@@ -375,6 +387,7 @@ static int kms_get_fb(gsr_drm *drm, gsr_kms_response *response) {
         response->items[item_index].pixel_format = drmfb->pixel_format;
         response->items[item_index].modifier = drmfb->flags & DRM_MODE_FB_MODIFIERS ? drmfb->modifier : DRM_FORMAT_MOD_INVALID;
         response->items[item_index].connector_id = crtc_pair ? crtc_pair->connector_id : 0;
+        response->items[item_index].rotation = rotation;
         response->items[item_index].is_cursor = property_mask & PLANE_PROPERTY_IS_CURSOR;
         if(property_mask & PLANE_PROPERTY_IS_CURSOR) {
             response->items[item_index].x = x;

meson.build

@@ -1,4 +1,4 @@
-project('gpu-screen-recorder', ['c', 'cpp'], version : '5.6.2', default_options : ['warning_level=2'])
+project('gpu-screen-recorder', ['c', 'cpp'], version : '5.10.2', default_options : ['warning_level=2'])
 
 add_project_arguments('-Wshadow', language : ['c', 'cpp'])
 if get_option('buildtype') == 'debug'
@@ -43,6 +43,7 @@ src = [
     'src/image_writer.c',
     'src/args_parser.c',
     'src/defs.c',
+    'src/plugins.c',
     'src/sound.cpp',
     'src/main.cpp',
 ]
@@ -50,8 +51,12 @@ src = [
 subdir('protocol')
 src += protocol_src
 
+cc = meson.get_compiler('c')
+m_dep = cc.find_library('m', required : true)
+
 dep = [
     dependency('threads'),
+    m_dep,
     dependency('libavcodec'),
     dependency('libavformat'),
     dependency('libavutil'),
@@ -109,6 +114,8 @@ add_project_arguments('-DGSR_VERSION="' + meson.project_version() + '"', languag
 executable('gsr-kms-server', 'kms/server/kms_server.c', dependencies : dependency('libdrm'), c_args : '-fstack-protector-all', install : true)
 executable('gpu-screen-recorder', src, dependencies : dep, install : true)
 
+install_headers('plugin/plugin.h', install_dir : 'include/gsr')
+
 if get_option('systemd') == true
     install_data(files('extra/gpu-screen-recorder.service'), install_dir : 'lib/systemd/user')
 endif
@@ -120,3 +127,10 @@ endif
 if get_option('nvidia_suspend_fix') == true
     install_data(files('extra/gsr-nvidia.conf'), install_dir : 'lib/modprobe.d')
 endif
+
+if get_option('plugin_examples') == true
+    shared_library('triangle', 'plugin/examples/hello_triangle/triangle.c',
+        dependencies: [dependency('gl'), m_dep],
+        name_prefix : '',
+        name_suffix: 'so')
+endif

meson_options.txt

@@ -3,3 +3,4 @@ option('capabilities', type : 'boolean', value : true, description : 'Set binary
 option('nvidia_suspend_fix', type : 'boolean', value : true, description : 'Install nvidia modprobe config file to tell nvidia driver to preserve video memory on suspend. This is a workaround for an nvidia driver bug that breaks cuda (and gpu screen recorder) on suspend')
 option('portal', type : 'boolean', value : true, description : 'Build with support for xdg desktop portal ScreenCast capture (wayland only) (-w portal option). Requires pipewire')
 option('app_audio', type : 'boolean', value : true, description : 'Build with support for recording a single audio source (-a app: option). Requires pipewire')
+option('plugin_examples', type : 'boolean', value : false, description : 'Build plugin examples')

plugin/examples/hello_triangle/triangle.c

@@ -0,0 +1,108 @@
+#include <gsr/plugin.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <math.h>
+#define GL_GLEXT_PROTOTYPES
+#include <GL/gl.h>
+
+const char vertex_shader_source[] =
+    "attribute vec4 vertex_pos;   \n"
+    "void main() {                \n"
+    "   gl_Position = vertex_pos; \n"
+    "}";
+
+const char fragment_shader_source[] =
+    "precision mediump float;                    \n"
+    "uniform vec3 color;                         \n"
+    "void main() {                               \n"
+    "   gl_FragColor = vec4(color, 1.0); \n"
+    "}";
+
+typedef struct {
+    GLuint shader_program;
+    GLuint vao;
+    GLuint vbo;
+    GLint color_uniform;
+    unsigned int counter;
+} Triangle;
+
+static GLuint load_shader(const char *shaderSrc, GLenum type) {
+    GLuint shader = glCreateShader(type);
+    glShaderSource(shader, 1, &shaderSrc, NULL);
+    glCompileShader(shader);
+    return shader;
+}
+
+static void draw(const gsr_plugin_draw_params *params, void *userdata) {
+    Triangle *triangle = userdata;
+
+    GLfloat glverts[6];
+
+    glverts[0] = -0.5f;
+    glverts[1] = -0.5f;
+
+    glverts[2] = 0.5f;
+    glverts[3] = -0.5f;
+
+    glverts[4] = 0.0f;
+    glverts[5] = 0.5f;
+
+    glBindVertexArray(triangle->vao);
+    glBindBuffer(GL_ARRAY_BUFFER, triangle->vbo);
+    glBufferSubData(GL_ARRAY_BUFFER, 0, 6 * sizeof(float), glverts);
+
+    glUseProgram(triangle->shader_program);
+    const double pp = triangle->counter * 0.05;
+    glUniform3f(triangle->color_uniform, 0.5 + sin(pp)*0.5, 0.5 + cos(pp)*0.5, 0.5 + sin(0.2 + pp)*0.5);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+
+    glBindVertexArray(0);
+    glUseProgram(0);
+
+    ++triangle->counter;
+}
+
+bool gsr_plugin_init(const gsr_plugin_init_params *params, gsr_plugin_init_return *ret) {
+    Triangle *triangle = calloc(1, sizeof(Triangle));
+    if(!triangle)
+        return false;
+
+    triangle->shader_program = glCreateProgram();
+
+    const GLuint vertex_shader = load_shader(vertex_shader_source, GL_VERTEX_SHADER);
+    const GLuint fragment_shader = load_shader(fragment_shader_source, GL_FRAGMENT_SHADER);
+
+    glAttachShader(triangle->shader_program, vertex_shader);
+    glAttachShader(triangle->shader_program, fragment_shader);
+    glBindAttribLocation(triangle->shader_program, 0, "vertex_pos");
+    glLinkProgram(triangle->shader_program);
+
+    glGenVertexArrays(1, &triangle->vao);
+    glBindVertexArray(triangle->vao);
+
+    glGenBuffers(1, &triangle->vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, triangle->vbo);
+    glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), NULL, GL_DYNAMIC_DRAW);
+
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void *)0);
+
+    glBindVertexArray(0);
+
+    glDeleteShader(vertex_shader);
+    glDeleteShader(fragment_shader);
+
+    triangle->color_uniform = glGetUniformLocation(triangle->shader_program, "color");
+
+    ret->name = "hello_triangle";
+    ret->version = 1;
+    ret->userdata = triangle;
+    ret->draw = draw;
+    return true;
+}
+
+void gsr_plugin_deinit(void *userdata) {
+    Triangle *triangle = userdata;
+    glDeleteProgram(triangle->shader_program);
+    free(triangle);
+}

plugin/plugin.h

@@ -0,0 +1,56 @@
+#ifndef GSR_PLUGIN_H
+#define GSR_PLUGIN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GSR_PLUGIN_INTERFACE_MAJOR_VERSION 0
+#define GSR_PLUGIN_INTERFACE_MINOR_VERSION 1
+
+#define GSR_PLUGIN_INTERFACE_MAKE_VERSION(major, minor) (((major) << 16) | (minor))
+#define GSR_PLUGIN_INTERFACE_VERSION GSR_PLUGIN_INTERFACE_MAKE_VERSION(GSR_PLUGIN_INTERFACE_MAJOR_VERSION, GSR_PLUGIN_INTERFACE_MINOR_VERSION)
+
+#include <stdbool.h>
+
+typedef enum {
+    GSR_PLUGIN_GRAPHICS_API_EGL_ES,
+    GSR_PLUGIN_GRAPHICS_API_GLX,
+} gsr_plugin_graphics_api;
+
+typedef enum {
+    GSR_PLUGIN_COLOR_DEPTH_8_BITS,
+    GSR_PLUGIN_COLOR_DEPTH_10_BITS,
+} gsr_plugin_color_depth;
+
+typedef struct {
+    unsigned int width;
+    unsigned int height;
+} gsr_plugin_draw_params;
+
+typedef struct {
+    unsigned int width;
+    unsigned int height;
+    unsigned int fps;
+    gsr_plugin_color_depth color_depth;
+    gsr_plugin_graphics_api graphics_api;
+} gsr_plugin_init_params;
+
+typedef struct {
+    const char *name; /* Mandatory */
+    unsigned int version; /* Mandatory, can't be 0 */
+    void *userdata; /* Optional */
+
+    /* Optional, called when the plugin is expected to draw something to the current framebuffer */
+    void (*draw)(const gsr_plugin_draw_params *params, void *userdata);
+} gsr_plugin_init_return;
+
+/* The plugin is expected to implement these functions and export them: */
+bool gsr_plugin_init(const gsr_plugin_init_params *params, gsr_plugin_init_return *ret);
+void gsr_plugin_deinit(void *userdata);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GSR_PLUGIN_H */

project.conf

@@ -1,11 +1,11 @@
 [package]
 name = "gpu-screen-recorder"
 type = "executable"
-version = "5.6.2"
+version = "5.10.2"
 platforms = ["posix"]
 
 [config]
-ignore_dirs = ["kms/server", "build", "debug-build"]
+ignore_dirs = ["kms/server", "build", "debug-build", "plugin/examples"]
 #error_on_warning = "true"
 
 [define]

src/args_parser.c

@@ -190,7 +190,13 @@ static double args_get_double_by_key(Arg *args, int num_args, const char *key, d
 static void usage_header() {
     const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
     const char *program_name = inside_flatpak ? "flatpak run --command=gpu-screen-recorder com.dec05eba.gpu_screen_recorder" : "gpu-screen-recorder";
-    printf("usage: %s -w <window_id|monitor|focused|portal|region> [-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>] [-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] [-v yes|no] [-gl-debug yes|no] [--version] [-h|--help]\n", program_name);
+    printf("usage: %s -w <window_id|monitor|focused|portal|region> [-c <container_format>] [-s WxH] [-region WxH+X+Y] [-f <fps>] [-a <audio_input>] "
+           "[-q <quality>] [-r <replay_buffer_size_sec>] [-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] "
+           "[-fallback-cpu-encoding yes|no] [-o <output_file>] [-ro <output_directory>] [--list-capture-options [card_path]] [--list-audio-devices] [--list-application-audio] "
+           "[-v yes|no] [-gl-debug yes|no] [--version] [-h|--help]\n", program_name);
     fflush(stdout);
 }
 
@@ -245,14 +251,14 @@ static void usage_full() {
     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("  -q    Video/image 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 5 and 1200.\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");
@@ -287,8 +293,9 @@ static void usage_full() {
     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("        'vfr' is recommended for general 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("        'content' is the best option to use when possible as it avoids capturing duplicate frames, which results in a smoother video.\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");
@@ -305,8 +312,11 @@ static void usage_full() {
     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 file and the second argument is the recording type (either \"regular\" or \"replay\").\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");
@@ -332,6 +342,12 @@ static void usage_full() {
     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("  -fallback-cpu-encoding\n");
+    printf("        If this is set to 'yes' and GPU encoding is not available on the system then CPU encoding will be used instead. Optional, set to 'no' by default.\n");
+    printf("        If the fallback to CPU encoding happens then h264 codec will forcefully be used.\n");
+    printf("        This should ideally not be used. Instead properly install vaapi on your system to encode the video with your GPU.\n");
+    printf("        Some very old GPUs dont support video encoding in which case this option may be used.\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");
@@ -394,13 +410,14 @@ static void usage_full() {
     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 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);
@@ -411,6 +428,7 @@ static void usage_full() {
     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");
     fflush(stdout);
 }
@@ -458,6 +476,7 @@ 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->audio_bitrate = args_get_i64_by_key(self->args, NUM_ARGS, "-ab", 0);
     self->audio_bitrate *= 1000LL;
@@ -575,8 +594,8 @@ static bool args_parser_set_values(args_parser *self) {
             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);
+        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;
         }
@@ -744,7 +763,9 @@ 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 };
     assert(arg_index == NUM_ARGS);
 
     for(int i = 1; i < argc; i += 2) {

src/capture/kms.c

@@ -209,14 +209,14 @@ static int gsr_capture_kms_start(gsr_capture *cap, gsr_capture_metadata *capture
 
     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_width = self->params.output_resolution.x;
+        capture_metadata->video_height = self->params.output_resolution.y;
     } else if(self->params.region_size.x > 0 && self->params.region_size.y > 0) {
-        capture_metadata->width = self->params.region_size.x;
-        capture_metadata->height = self->params.region_size.y;
+        capture_metadata->video_width = self->params.region_size.x;
+        capture_metadata->video_height = self->params.region_size.y;
     } else {
-        capture_metadata->width = self->capture_size.x;
-        capture_metadata->height = self->capture_size.y;
+        capture_metadata->video_width = self->capture_size.x;
+        capture_metadata->video_height = self->capture_size.y;
     }
 
     self->last_time_monitor_check = clock_get_monotonic_seconds();
@@ -418,6 +418,19 @@ static gsr_kms_response_item* find_cursor_drm_if_on_monitor(gsr_capture_kms *sel
     return cursor_drm_fd;
 }
 
+static gsr_monitor_rotation kms_rotation_to_gsr_monitor_rotation(gsr_kms_rotation rotation) {
+    // Right now both enums have the same values
+    return (gsr_monitor_rotation)rotation;
+}
+
+static int remainder_int(int a, int b) {
+    return a - (a / b) * b;
+}
+
+static gsr_monitor_rotation sub_rotations(gsr_monitor_rotation rot1, gsr_monitor_rotation rot2) {
+    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) {
     const vec2d scale = {
         self->capture_size.x == 0 ? 0 : (double)output_size.x / (double)self->capture_size.x,
@@ -427,8 +440,11 @@ static void render_drm_cursor(gsr_capture_kms *self, gsr_color_conversion *color
     const bool cursor_texture_id_is_external = self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA;
     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);
+
     vec2i cursor_pos = {cursor_drm_fd->x, cursor_drm_fd->y};
-    switch(self->monitor_rotation) {
+    switch(rotation) {
         case GSR_MONITOR_ROT_0:
             break;
         case GSR_MONITOR_ROT_90:
@@ -492,7 +508,7 @@ 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(self->monitor_rotation), GSR_SOURCE_COLOR_RGB, cursor_texture_id_is_external, true);
+        gsr_monitor_rotation_to_rotation(rotation), GSR_SOURCE_COLOR_RGB, cursor_texture_id_is_external);
 
     self->params.egl->glDisable(GL_SCISSOR_TEST);
 }
@@ -520,7 +536,7 @@ static void render_x11_cursor(gsr_capture_kms *self, gsr_color_conversion *color
     gsr_color_conversion_draw(color_conversion, self->x11_cursor.texture_id,
         cursor_pos, (vec2i){self->x11_cursor.size.x * scale.x, self->x11_cursor.size.y * scale.y},
         (vec2i){0, 0}, self->x11_cursor.size, self->x11_cursor.size,
-        GSR_ROT_0, GSR_SOURCE_COLOR_RGB, false, true);
+        GSR_ROT_0, GSR_SOURCE_COLOR_RGB, false);
 
     self->params.egl->glDisable(GL_SCISSOR_TEST);
 }
@@ -606,15 +622,11 @@ static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *captu
         gsr_kms_set_hdr_metadata(self, drm_fd);
 
     self->capture_size = rotate_capture_size_if_rotated(self, (vec2i){ drm_fd->src_w, drm_fd->src_h });
-    const vec2i original_frame_size = self->capture_size;
     if(self->params.region_size.x > 0 && self->params.region_size.y > 0)
         self->capture_size = self->params.region_size;
 
-    const bool is_scaled = self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0;
-    vec2i output_size = is_scaled ? self->params.output_resolution : self->capture_size;
-    output_size = scale_keep_aspect_ratio(self->capture_size, output_size);
-
-    const 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(self->capture_size, (vec2i){capture_metadata->recording_width, capture_metadata->recording_height});
+    const vec2i target_pos = { max_int(0, capture_metadata->video_width / 2 - output_size.x / 2), max_int(0, capture_metadata->video_height / 2 - output_size.y / 2) };
     gsr_capture_kms_update_capture_size_change(self, color_conversion, target_pos, drm_fd);
 
     vec2i capture_pos = self->capture_pos;
@@ -633,10 +645,13 @@ static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *captu
         self->params.egl->eglDestroyImage(self->params.egl->egl_display, image);
     }
 
+    const gsr_monitor_rotation plane_rotation = kms_rotation_to_gsr_monitor_rotation(drm_fd->rotation);
+    const gsr_monitor_rotation rotation = capture_is_combined_plane ? GSR_MONITOR_ROT_0 : sub_rotations(self->monitor_rotation, plane_rotation);
+
     gsr_color_conversion_draw(color_conversion, self->external_texture_fallback ? self->external_input_texture_id : self->input_texture_id,
         target_pos, output_size,
-        capture_pos, self->capture_size, original_frame_size,
-        gsr_monitor_rotation_to_rotation(self->monitor_rotation), GSR_SOURCE_COLOR_RGB, self->external_texture_fallback, false);
+        capture_pos, self->capture_size, (vec2i){ drm_fd->width, drm_fd->height },
+        gsr_monitor_rotation_to_rotation(rotation), 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);

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,16 @@ 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_width = self->tracking_width;
+    capture_metadata->video_height = 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((vec2i){capture_metadata->video_width, capture_metadata->video_height}, self->params.output_resolution);
+        capture_metadata->video_width = self->params.output_resolution.x;
+        capture_metadata->video_height = self->params.output_resolution.y;
     } else if(self->params.region_size.x > 0 && self->params.region_size.y > 0) {
-        capture_metadata->width = self->params.region_size.x;
-        capture_metadata->height = self->params.region_size.y;
+        capture_metadata->video_width = self->params.region_size.x;
+        capture_metadata->video_height = self->params.region_size.y;
     }
 
     return 0;
@@ -336,6 +303,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 +340,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 +359,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 +371,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, (vec2i){capture_metadata->recording_width, capture_metadata->recording_height});
+    const vec2i target_pos = { max_int(0, capture_metadata->video_width / 2 - output_size.x / 2), max_int(0, capture_metadata->video_height / 2 - output_size.y / 2) };
 
     NVFBC_FRAME_GRAB_INFO frame_info;
     memset(&frame_info, 0, sizeof(frame_info));
@@ -397,7 +398,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, GSR_SOURCE_COLOR_BGR, false);
 
     //self->params.egl->glFlush();
     //self->params.egl->glFinish();

src/capture/portal.c

@@ -30,27 +30,21 @@ typedef struct {
 
     gsr_pipewire_video pipewire;
     vec2i capture_size;
-    gsr_pipewire_video_dmabuf_data dmabuf_data[GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES];
-    int num_dmabuf_data;
 
-    gsr_pipewire_video_region region;
-    gsr_pipewire_video_region cursor_region;
-    uint32_t pipewire_fourcc;
-    uint64_t pipewire_modifiers;
-    bool using_external_image;
+    gsr_map_texture_output pipewire_data;
 
     bool should_stop;
     bool stop_is_error;
 } gsr_capture_portal;
 
 static void gsr_capture_portal_cleanup_plane_fds(gsr_capture_portal *self) {
-    for(int i = 0; i < self->num_dmabuf_data; ++i) {
-        if(self->dmabuf_data[i].fd > 0) {
-            close(self->dmabuf_data[i].fd);
-            self->dmabuf_data[i].fd = 0;
+    for(int i = 0; i < self->pipewire_data.num_dmabuf_data; ++i) {
+        if(self->pipewire_data.dmabuf_data[i].fd > 0) {
+            close(self->pipewire_data.dmabuf_data[i].fd);
+            self->pipewire_data.dmabuf_data[i].fd = 0;
         }
     }
-    self->num_dmabuf_data = 0;
+    self->pipewire_data.num_dmabuf_data = 0;
 }
 
 static void gsr_capture_portal_stop(gsr_capture_portal *self) {
@@ -238,9 +232,9 @@ static bool gsr_capture_portal_get_frame_dimensions(gsr_capture_portal *self) {
 
     const double start_time = clock_get_monotonic_seconds();
     while(clock_get_monotonic_seconds() - start_time < 5.0) {
-        if(gsr_pipewire_video_map_texture(&self->pipewire, self->texture_map, &self->region, &self->cursor_region, self->dmabuf_data, &self->num_dmabuf_data, &self->pipewire_fourcc, &self->pipewire_modifiers, &self->using_external_image)) {
-            self->capture_size.x = self->region.width;
-            self->capture_size.y = self->region.height;
+        if(gsr_pipewire_video_map_texture(&self->pipewire, self->texture_map, &self->pipewire_data)) {
+            self->capture_size.x = self->pipewire_data.region.width;
+            self->capture_size.y = self->pipewire_data.region.height;
             fprintf(stderr, "gsr info: gsr_capture_portal_start: pipewire negotiation finished\n");
             return true;
         }
@@ -299,12 +293,12 @@ static int gsr_capture_portal_start(gsr_capture *cap, gsr_capture_metadata *capt
     }
 
     if(self->params.output_resolution.x == 0 && self->params.output_resolution.y == 0) {
-        capture_metadata->width = self->capture_size.x;
-        capture_metadata->height = self->capture_size.y;
+        capture_metadata->video_width = self->capture_size.x;
+        capture_metadata->video_height = self->capture_size.y;
     } 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_width = self->params.output_resolution.x;
+        capture_metadata->video_height = self->params.output_resolution.y;
     }
 
     return 0;
@@ -347,11 +341,11 @@ static int gsr_capture_portal_capture(gsr_capture *cap, gsr_capture_metadata *ca
     }
 
     /* TODO: Handle formats other than RGB(A) */
-    if(self->num_dmabuf_data == 0) {
-        if(gsr_pipewire_video_map_texture(&self->pipewire, self->texture_map, &self->region, &self->cursor_region, self->dmabuf_data, &self->num_dmabuf_data, &self->pipewire_fourcc, &self->pipewire_modifiers, &self->using_external_image)) {
-            if(self->region.width != self->capture_size.x || self->region.height != self->capture_size.y) {
-                self->capture_size.x = self->region.width;
-                self->capture_size.y = self->region.height;
+    if(self->pipewire_data.num_dmabuf_data == 0) {
+        if(gsr_pipewire_video_map_texture(&self->pipewire, self->texture_map, &self->pipewire_data)) {
+            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);
             }
         } else {
@@ -359,43 +353,45 @@ static int gsr_capture_portal_capture(gsr_capture *cap, gsr_capture_metadata *ca
         }
     }
 
-    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 vec2i output_size = scale_keep_aspect_ratio(self->capture_size, (vec2i){capture_metadata->recording_width, capture_metadata->recording_height});
+    const vec2i target_pos = { max_int(0, capture_metadata->video_width / 2 - output_size.x / 2), max_int(0, capture_metadata->video_height / 2 - output_size.y / 2) };
+
+    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_fourcc);
+    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->using_external_image ? self->texture_map.external_texture_id : self->texture_map.texture_id,
+    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->region.x, self->region.y}, self->capture_size, self->capture_size,
-       GSR_ROT_0, GSR_SOURCE_COLOR_RGB, self->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), GSR_SOURCE_COLOR_RGB, self->pipewire_data.using_external_image);
 
-    if(self->params.record_cursor && self->texture_map.cursor_texture_id > 0 && self->cursor_region.width > 0) {
+    if(self->params.record_cursor && self->texture_map.cursor_texture_id > 0 && self->pipewire_data.cursor_region.width > 0) {
         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
         };
 
         const vec2i cursor_pos = {
-            target_pos.x + (self->cursor_region.x * scale.x),
-            target_pos.y + (self->cursor_region.y * scale.y)
+            target_pos.x + (self->pipewire_data.cursor_region.x * scale.x),
+            target_pos.y + (self->pipewire_data.cursor_region.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->texture_map.cursor_texture_id,
-            (vec2i){cursor_pos.x, cursor_pos.y}, (vec2i){self->cursor_region.width * scale.x, self->cursor_region.height * scale.y},
-            (vec2i){0, 0}, (vec2i){self->cursor_region.width, self->cursor_region.height}, (vec2i){self->cursor_region.width, self->cursor_region.height},
-            GSR_ROT_0, GSR_SOURCE_COLOR_RGB, false, true);
+            (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);
         self->params.egl->glDisable(GL_SCISSOR_TEST);
     }
 

src/capture/xcomposite.c

@@ -100,20 +100,15 @@ static int gsr_capture_xcomposite_start(gsr_capture *cap, gsr_capture_metadata *
         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_width = self->texture_size.x;
+        capture_metadata->video_height = self->texture_size.y;
     } else {
-        capture_metadata->width = self->params.output_resolution.x;
-        capture_metadata->height = self->params.output_resolution.y;
+        capture_metadata->video_width = self->params.output_resolution.x;
+        capture_metadata->video_height = self->params.output_resolution.y;
     }
 
     self->window_resize_timer = clock_get_monotonic_seconds();
@@ -148,13 +143,8 @@ static void gsr_capture_xcomposite_tick(gsr_capture *cap) {
             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 +162,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;
     }
@@ -239,7 +224,7 @@ 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 int gsr_capture_xcomposite_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) {
     gsr_capture_xcomposite *self = cap->priv;
 
     if(self->clear_background) {
@@ -247,11 +232,8 @@ static int gsr_capture_xcomposite_capture(gsr_capture *cap, gsr_capture_metadata
         gsr_color_conversion_clear(color_conversion);
     }
 
-    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);
-
-    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, (vec2i){capture_metadata->recording_width, capture_metadata->recording_height});
+    const vec2i target_pos = { max_int(0, capture_metadata->video_width / 2 - output_size.x / 2), max_int(0, capture_metadata->video_height / 2 - output_size.y / 2) };
 
     //self->params.egl->glFlush();
     //self->params.egl->glFinish();
@@ -259,7 +241,7 @@ 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, GSR_SOURCE_COLOR_RGB, false);
 
     if(self->params.record_cursor && self->cursor.visible) {
         const vec2d scale = {
@@ -280,7 +262,7 @@ static int gsr_capture_xcomposite_capture(gsr_capture *cap, gsr_capture_metadata
         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_ROT_0, GSR_SOURCE_COLOR_RGB, false);
     }
 
     //self->params.egl->glFlush();

src/capture/ximage.c

@@ -59,14 +59,14 @@ 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_width = self->params.output_resolution.x;
+        capture_metadata->video_height = self->params.output_resolution.y;
     } else if(self->params.region_size.x > 0 && self->params.region_size.y > 0) {
-        capture_metadata->width = self->params.region_size.x;
-        capture_metadata->height = self->params.region_size.y;
+        capture_metadata->video_width = self->params.region_size.x;
+        capture_metadata->video_height = self->params.region_size.y;
     } else {
-        capture_metadata->width = self->capture_size.x;
-        capture_metadata->height = self->capture_size.y;
+        capture_metadata->video_width = self->capture_size.x;
+        capture_metadata->video_height = self->capture_size.y;
     }
 
     self->texture_id = gl_create_texture(self->params.egl, self->capture_size.x, self->capture_size.y, GL_RGB8, GL_RGB, GL_LINEAR);
@@ -147,20 +147,17 @@ 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, (vec2i){capture_metadata->recording_width, capture_metadata->recording_height});
+    const vec2i target_pos = { max_int(0, capture_metadata->video_width / 2 - output_size.x / 2), max_int(0, capture_metadata->video_height / 2 - output_size.y / 2) };
     gsr_capture_ximage_upload_to_texture(self, self->capture_pos.x + self->params.region_position.x, self->capture_pos.y + self->params.region_position.y, self->capture_size.x, self->capture_size.y);
 
     gsr_color_conversion_draw(color_conversion, self->texture_id,
         target_pos, output_size,
         (vec2i){0, 0}, self->capture_size, self->capture_size,
-        GSR_ROT_0, GSR_SOURCE_COLOR_RGB, false, false);
+        GSR_ROT_0, GSR_SOURCE_COLOR_RGB, false);
 
     if(self->params.record_cursor && self->cursor.visible) {
         const vec2d scale = {
@@ -181,7 +178,7 @@ static int gsr_capture_ximage_capture(gsr_capture *cap, gsr_capture_metadata *ca
         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_ROT_0, GSR_SOURCE_COLOR_RGB, false);
 
         self->params.egl->glDisable(GL_SCISSOR_TEST);
     }

src/codec_query/nvenc.c

@@ -6,6 +6,11 @@
 #include <stdio.h>
 #include <string.h>
 
+#define NVENCAPI_MAJOR_VERSION_470 11
+#define NVENCAPI_MINOR_VERSION_470 1
+#define NVENCAPI_VERSION_470 (NVENCAPI_MAJOR_VERSION_470 | (NVENCAPI_MINOR_VERSION_470 << 24))
+#define NVENCAPI_STRUCT_VERSION_CUSTOM(nvenc_api_version, struct_version)  ((uint32_t)(nvenc_api_version) | ((struct_version)<<16) | (0x7 << 28))
+
 static void* open_nvenc_library(void) {
     dlerror(); /* clear */
     void *lib = dlopen("libnvidia-encode.so.1", RTLD_LAZY);
@@ -75,7 +80,28 @@ static bool profile_is_av1(const GUID *profile_guid) {
     return false;
 }
 
-static bool encoder_get_supported_profiles(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, const GUID *encoder_guid, gsr_supported_video_codecs *supported_video_codecs) {
+/* Returns 0 on error */
+static int nvenc_get_encoding_capability(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, const GUID *encode_guid, uint32_t nvenc_api_version, NV_ENC_CAPS cap) {
+    NV_ENC_CAPS_PARAM param = {
+        .version = NVENCAPI_STRUCT_VERSION_CUSTOM(nvenc_api_version, 1),
+        .capsToQuery = cap
+    };
+
+    int value = 0;
+    if(function_list->nvEncGetEncodeCaps(nvenc_encoder, *encode_guid, &param, &value) != NV_ENC_SUCCESS)
+        return 0;
+
+    return value;
+}
+
+static vec2i encoder_get_max_resolution(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, const GUID *encode_guid, uint32_t nvenc_api_version) {
+    return (vec2i){
+        .x = nvenc_get_encoding_capability(function_list, nvenc_encoder, encode_guid, nvenc_api_version, NV_ENC_CAPS_WIDTH_MAX),
+        .y = nvenc_get_encoding_capability(function_list, nvenc_encoder, encode_guid, nvenc_api_version, NV_ENC_CAPS_HEIGHT_MAX),
+    };
+}
+
+static bool encoder_get_supported_profiles(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, const GUID *encoder_guid, gsr_supported_video_codecs *supported_video_codecs, uint32_t nvenc_api_version) {
     bool success = false;
     GUID *profile_guids = NULL;
 
@@ -99,18 +125,19 @@ static bool encoder_get_supported_profiles(const NV_ENCODE_API_FUNCTION_LIST *fu
         goto fail;
     }
 
+    const vec2i max_resolution = encoder_get_max_resolution(function_list, nvenc_encoder, encoder_guid, nvenc_api_version);
     for(uint32_t i = 0; i < profile_guid_count; ++i) {
         if(profile_is_h264(&profile_guids[i])) {
-            supported_video_codecs->h264 = (gsr_supported_video_codec){ true, false };
+            supported_video_codecs->h264 = (gsr_supported_video_codec){ true, false, max_resolution };
         } else if(profile_is_hevc(&profile_guids[i])) {
-            supported_video_codecs->hevc = (gsr_supported_video_codec){ true, false };
+            supported_video_codecs->hevc = (gsr_supported_video_codec){ true, false, max_resolution };
         } else if(profile_is_hevc_10bit(&profile_guids[i])) {
-            supported_video_codecs->hevc_hdr = (gsr_supported_video_codec){ true, false };
-            supported_video_codecs->hevc_10bit = (gsr_supported_video_codec){ true, false };
+            supported_video_codecs->hevc_hdr = (gsr_supported_video_codec){ true, false, max_resolution };
+            supported_video_codecs->hevc_10bit = (gsr_supported_video_codec){ true, false, max_resolution };
         } else if(profile_is_av1(&profile_guids[i])) {
-            supported_video_codecs->av1 = (gsr_supported_video_codec){ true, false };
-            supported_video_codecs->av1_hdr = (gsr_supported_video_codec){ true, false };
-            supported_video_codecs->av1_10bit = (gsr_supported_video_codec){ true, false };
+            supported_video_codecs->av1 = (gsr_supported_video_codec){ true, false, max_resolution };
+            supported_video_codecs->av1_hdr = (gsr_supported_video_codec){ true, false, max_resolution };
+            supported_video_codecs->av1_10bit = (gsr_supported_video_codec){ true, false, max_resolution };
         }
     }
 
@@ -123,7 +150,7 @@ static bool encoder_get_supported_profiles(const NV_ENCODE_API_FUNCTION_LIST *fu
     return success;
 }
 
-static bool get_supported_video_codecs(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, gsr_supported_video_codecs *supported_video_codecs) {
+static bool get_supported_video_codecs(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, gsr_supported_video_codecs *supported_video_codecs, uint32_t nvenc_api_version) {
     bool success = false;
     GUID *encoder_guids = NULL;
     *supported_video_codecs = (gsr_supported_video_codecs){0};
@@ -149,7 +176,7 @@ static bool get_supported_video_codecs(const NV_ENCODE_API_FUNCTION_LIST *functi
     }
 
     for(uint32_t i = 0; i < encode_guid_count; ++i) {
-        encoder_get_supported_profiles(function_list, nvenc_encoder, &encoder_guids[i], supported_video_codecs);
+        encoder_get_supported_profiles(function_list, nvenc_encoder, &encoder_guids[i], supported_video_codecs, nvenc_api_version);
     }
 
     success = true;
@@ -161,9 +188,6 @@ static bool get_supported_video_codecs(const NV_ENCODE_API_FUNCTION_LIST *functi
     return success;
 }
 
-#define NVENCAPI_VERSION_470 (11 | (1 << 24))
-#define NVENCAPI_STRUCT_VERSION_470(ver) ((uint32_t)NVENCAPI_VERSION_470 | ((ver)<<16) | (0x7 << 28))
-
 bool gsr_get_supported_video_codecs_nvenc(gsr_supported_video_codecs *video_codecs, bool cleanup) {
     memset(video_codecs, 0, sizeof(*video_codecs));
 
@@ -206,13 +230,13 @@ bool gsr_get_supported_video_codecs_nvenc(gsr_supported_video_codecs *video_code
     if(function_list.nvEncOpenEncodeSessionEx(&params, &nvenc_encoder) != NV_ENC_SUCCESS) {
         // Old nvidia gpus dont support the new nvenc api (which is required for av1).
         // In such cases fallback to old api version if possible and try again.
-        function_list.version = NVENCAPI_STRUCT_VERSION_470(2);
+        function_list.version = NVENCAPI_STRUCT_VERSION_CUSTOM(NVENCAPI_VERSION_470, 2);
         if(nvEncodeAPICreateInstance(&function_list) != NV_ENC_SUCCESS) {
             fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncodeAPICreateInstance (retry) failed\n");
             goto done;
         }
 
-        params.version = NVENCAPI_STRUCT_VERSION_470(1);
+        params.version = NVENCAPI_STRUCT_VERSION_CUSTOM(NVENCAPI_VERSION_470, 1);
         params.apiVersion = NVENCAPI_VERSION_470;
         if(function_list.nvEncOpenEncodeSessionEx(&params, &nvenc_encoder) != NV_ENC_SUCCESS) {
             fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncOpenEncodeSessionEx (retry) failed\n");
@@ -220,7 +244,7 @@ bool gsr_get_supported_video_codecs_nvenc(gsr_supported_video_codecs *video_code
         }
     }
 
-    success = get_supported_video_codecs(&function_list, nvenc_encoder, video_codecs);
+    success = get_supported_video_codecs(&function_list, nvenc_encoder, video_codecs, params.apiVersion);
 
     done:
     if(cleanup) {

src/codec_query/vaapi.c

@@ -77,32 +77,51 @@ static bool profile_is_vp9(VAProfile profile) {
     }
 }
 
-static bool profile_supports_video_encoding(VADisplay va_dpy, VAProfile profile, bool *low_power) {
-    *low_power = false;
+/* Returns 0, 0 on error */
+static vec2i profile_entrypoint_get_max_resolution(VADisplay va_dpy, VAProfile profile, VAEntrypoint entrypoint) {
+    VAConfigAttrib attribs[2] = {
+        {
+            .type = VAConfigAttribMaxPictureWidth,
+        },
+        {
+            .type = VAConfigAttribMaxPictureHeight,
+        }
+    };
+    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 };
+}
+
+/* Returns 0 on error or if none is supported */
+static VAEntrypoint profile_get_video_encoding_entrypoint(VADisplay va_dpy, VAProfile profile) {
     int num_entrypoints = vaMaxNumEntrypoints(va_dpy);
     if(num_entrypoints <= 0)
-        return false;
+        return 0;
 
     VAEntrypoint *entrypoint_list = calloc(num_entrypoints, sizeof(VAEntrypoint));
     if(!entrypoint_list)
-        return false;
+        return 0;
 
-    bool supports_encoding = false;
-    bool supports_low_power_encoding = false;
+    int encoding_entrypoint_index = -1;
+    int lower_power_entrypoint_index = -1;
     if(vaQueryConfigEntrypoints(va_dpy, profile, entrypoint_list, &num_entrypoints) == VA_STATUS_SUCCESS) {
         for(int i = 0; i < num_entrypoints; ++i) {
             if(entrypoint_list[i] == VAEntrypointEncSlice)
-                supports_encoding = true;
+                encoding_entrypoint_index = i;
             else if(entrypoint_list[i] == VAEntrypointEncSliceLP)
-                supports_low_power_encoding = true;
+                lower_power_entrypoint_index = i;
         }
     }
 
-    if(!supports_encoding && supports_low_power_encoding)
-        *low_power = true;
+    VAEntrypoint encoding_entrypoint = 0;
+    if(encoding_entrypoint_index != -1)
+        encoding_entrypoint = entrypoint_list[encoding_entrypoint_index];
+    else if(lower_power_entrypoint_index != -1)
+        encoding_entrypoint = entrypoint_list[lower_power_entrypoint_index];
 
     free(entrypoint_list);
-    return supports_encoding || supports_low_power_encoding;
+    return encoding_entrypoint;
 }
 
 static bool get_supported_video_codecs(VADisplay va_dpy, gsr_supported_video_codecs *video_codecs, bool cleanup) {
@@ -128,31 +147,45 @@ static bool get_supported_video_codecs(VADisplay va_dpy, gsr_supported_video_cod
         goto fail;
 
     for(int i = 0; i < num_profiles; ++i) {
-        bool low_power = false;
         if(profile_is_h264(profile_list[i])) {
-            if(profile_supports_video_encoding(va_dpy, profile_list[i], &low_power)) {
-                video_codecs->h264 = (gsr_supported_video_codec){ true, low_power };
+            const VAEntrypoint encoding_entrypoint = profile_get_video_encoding_entrypoint(va_dpy, profile_list[i]);
+            if(encoding_entrypoint != 0) {
+                const vec2i max_resolution = profile_entrypoint_get_max_resolution(va_dpy, profile_list[i], encoding_entrypoint);
+                video_codecs->h264 = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution };
             }
         } else if(profile_is_hevc_8bit(profile_list[i])) {
-            if(profile_supports_video_encoding(va_dpy, profile_list[i], &low_power))
-                video_codecs->hevc = (gsr_supported_video_codec){ true, low_power };
+            const VAEntrypoint encoding_entrypoint = profile_get_video_encoding_entrypoint(va_dpy, profile_list[i]);
+            if(encoding_entrypoint != 0) {
+                const vec2i max_resolution = profile_entrypoint_get_max_resolution(va_dpy, profile_list[i], encoding_entrypoint);
+                video_codecs->hevc = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution };
+            }
         } else if(profile_is_hevc_10bit(profile_list[i])) {
-            if(profile_supports_video_encoding(va_dpy, profile_list[i], &low_power)) {
-                video_codecs->hevc_hdr = (gsr_supported_video_codec){ true, low_power };
-                video_codecs->hevc_10bit = (gsr_supported_video_codec){ true, low_power };
+            const VAEntrypoint encoding_entrypoint = profile_get_video_encoding_entrypoint(va_dpy, profile_list[i]);
+            if(encoding_entrypoint != 0) {
+                const vec2i max_resolution = profile_entrypoint_get_max_resolution(va_dpy, profile_list[i], encoding_entrypoint);
+                video_codecs->hevc_hdr = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution };
+                video_codecs->hevc_10bit = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution };
             }
         } else if(profile_is_av1(profile_list[i])) {
-            if(profile_supports_video_encoding(va_dpy, profile_list[i], &low_power)) {
-                video_codecs->av1 = (gsr_supported_video_codec){ true, low_power };
-                video_codecs->av1_hdr = (gsr_supported_video_codec){ true, low_power };
-                video_codecs->av1_10bit = (gsr_supported_video_codec){ true, low_power };
+            const VAEntrypoint encoding_entrypoint = profile_get_video_encoding_entrypoint(va_dpy, profile_list[i]);
+            if(encoding_entrypoint != 0) {
+                const vec2i max_resolution = profile_entrypoint_get_max_resolution(va_dpy, profile_list[i], encoding_entrypoint);
+                video_codecs->av1 = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution };
+                video_codecs->av1_hdr = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution };
+                video_codecs->av1_10bit = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution };
             }
         } else if(profile_is_vp8(profile_list[i])) {
-            if(profile_supports_video_encoding(va_dpy, profile_list[i], &low_power))
-                video_codecs->vp8 = (gsr_supported_video_codec){ true, low_power };
+            const VAEntrypoint encoding_entrypoint = profile_get_video_encoding_entrypoint(va_dpy, profile_list[i]);
+            if(encoding_entrypoint != 0) {
+                const vec2i max_resolution = profile_entrypoint_get_max_resolution(va_dpy, profile_list[i], encoding_entrypoint);
+                video_codecs->vp8 = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution };
+            }
         } else if(profile_is_vp9(profile_list[i])) {
-            if(profile_supports_video_encoding(va_dpy, profile_list[i], &low_power))
-                video_codecs->vp9 = (gsr_supported_video_codec){ true, low_power };
+            const VAEntrypoint encoding_entrypoint = profile_get_video_encoding_entrypoint(va_dpy, profile_list[i]);
+            if(encoding_entrypoint != 0) {
+                const vec2i max_resolution = profile_entrypoint_get_max_resolution(va_dpy, profile_list[i], encoding_entrypoint);
+                video_codecs->vp9 = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution };
+            }
         }
     }
 

src/color_conversion.c

@@ -1,23 +1,9 @@
 #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
@@ -53,10 +39,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 +67,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 +119,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 +181,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 +238,7 @@ 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);
@@ -465,88 +297,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:
@@ -605,10 +355,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 +374,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 +414,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]);
     }
@@ -751,88 +472,19 @@ static void gsr_color_conversion_swizzle_reset(gsr_color_conversion *self, gsr_s
     }
 }
 
-typedef enum {
-    GSR_COLOR_COMP_Y,
-    GSR_COLOR_COMP_UV,
-    GSR_COLOR_COMP_RGB
-} gsr_color_component;
-
-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;
-    }
-    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);
+static void gsr_color_conversion_draw_graphics(gsr_color_conversion *self, unsigned int texture_id, bool external_texture, gsr_rotation rotation, 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;
 
+    const vec2i dest_texture_size = self->params.destination_textures_size[0];
     const 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;
+    }
+
     self->params.egl->glBindTexture(texture_target, texture_id);
     gsr_color_conversion_swizzle_texture_source(self, source_color);
 
@@ -870,7 +522,7 @@ static void gsr_color_conversion_draw_graphics(gsr_color_conversion *self, unsig
     self->params.egl->glViewport(0, 0, dest_texture_size.x, dest_texture_size.y);
 
     /* TODO: this, also cleanup */
-    //self->params.egl->glBindBuffer(GL_ARRAY_BUFFER, self->vertex_buffer_object_id);
+    self->params.egl->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) {
@@ -917,7 +569,7 @@ static void gsr_color_conversion_draw_graphics(gsr_color_conversion *self, unsig
     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_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");
@@ -936,44 +588,9 @@ void gsr_color_conversion_draw(gsr_color_conversion *self, unsigned int texture_
     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, rotation_matrix, source_position, source_size, destination_pos, texture_size, scale, source_color);
 
     self->params.egl->glFlush();
     // TODO: Use the minimal barrier required

src/cuda.c

@@ -65,6 +65,7 @@ bool gsr_cuda_load(gsr_cuda *self, Display *display, bool do_overclock) {
         goto fail;
     }
 
+    // TODO: Use the device associated with the opengl graphics context
     CUdevice cu_dev;
     res = self->cuDeviceGet(&cu_dev, 0);
     if(res != CUDA_SUCCESS) {

src/egl.c

@@ -40,7 +40,7 @@ static bool gsr_egl_create_window(gsr_egl *self, bool enable_debug) {
     };
 
     int32_t ctxattr[] = {
-        EGL_CONTEXT_CLIENT_VERSION, 2,
+        EGL_CONTEXT_CLIENT_VERSION, 3,
         EGL_NONE, EGL_NONE, EGL_NONE
     };
 
@@ -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" },

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, 256);
+            video_codec_context->height = FFALIGN(video_codec_context->height, 256);
+        }
     } 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

@@ -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;
 
@@ -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/main.cpp

@@ -26,6 +26,7 @@ extern "C" {
 #include "../include/color_conversion.h"
 #include "../include/image_writer.h"
 #include "../include/args_parser.h"
+#include "../include/plugins.h"
 }
 
 #include <assert.h>
@@ -47,7 +48,6 @@ extern "C" {
 extern "C" {
 #include <libavutil/pixfmt.h>
 #include <libavcodec/avcodec.h>
-#include <libavcodec/defs.h>
 #include <libavformat/avformat.h>
 #include <libavutil/opt.h>
 #include <libswresample/swresample.h>
@@ -122,12 +122,12 @@ static void get_monitor_by_position_callback(const gsr_monitor *monitor, void *u
             std::swap(monitor_size.x, monitor_size.y);
     }
 
-    if(!data->output_name && data->position.x >= monitor_position.x && data->position.x <= monitor_position.x + monitor->size.x
-        && data->position.y >= monitor_position.y && data->position.y <= monitor_position.y + monitor->size.y)
+    if(!data->output_name && data->position.x >= monitor_position.x && data->position.x <= monitor_position.x + monitor_size.x
+        && data->position.y >= monitor_position.y && data->position.y <= monitor_position.y + monitor_size.y)
     {
         data->output_name = strdup(monitor->name);
         data->monitor_pos = monitor_position;
-        data->monitor_size = monitor->size;
+        data->monitor_size = monitor_size;
     }
 }
 
@@ -336,7 +336,7 @@ static int vbr_get_quality_parameter(AVCodecContext *codec_context, gsr_video_qu
     return 22 * qp_multiply;
 }
 
-static AVCodecContext *create_video_codec_context(AVPixelFormat pix_fmt, const AVCodec *codec, const gsr_egl &egl, const args_parser &arg_parser) {
+static AVCodecContext *create_video_codec_context(AVPixelFormat pix_fmt, const AVCodec *codec, const gsr_egl &egl, const args_parser &arg_parser, int width, int height) {
     const bool use_software_video_encoder = arg_parser.video_encoder == GSR_VIDEO_ENCODER_HW_CPU;
     const bool hdr = video_codec_is_hdr(arg_parser.video_codec);
     AVCodecContext *codec_context = avcodec_alloc_context3(codec);
@@ -345,6 +345,8 @@ static AVCodecContext *create_video_codec_context(AVPixelFormat pix_fmt, const A
 
     assert(codec->type == AVMEDIA_TYPE_VIDEO);
     codec_context->codec_id = codec->id;
+    codec_context->width = width;
+    codec_context->height = height;
     // Timebase: This is the fundamental unit of time (in seconds) in terms
     // of which frame timestamps are represented. For fixed-fps content,
     // timebase should be 1/framerate and timestamp increments should be
@@ -378,8 +380,9 @@ static AVCodecContext *create_video_codec_context(AVPixelFormat pix_fmt, const A
         codec_context->colorspace = AVCOL_SPC_BT709;
     }
     //codec_context->chroma_sample_location = AVCHROMA_LOC_CENTER;
-    if(codec->id == AV_CODEC_ID_HEVC)
-        codec_context->codec_tag = MKTAG('h', 'v', 'c', '1'); // QuickTime on MacOS requires this or the video wont be playable
+    // Can't use this because it's fucking broken in ffmpeg 8 or new mesa. It produces garbage output
+    //if(codec->id == AV_CODEC_ID_HEVC)
+    //    codec_context->codec_tag = MKTAG('h', 'v', 'c', '1'); // QuickTime on MacOS requires this or the video wont be playable
 
     if(arg_parser.bitrate_mode == GSR_BITRATE_MODE_CBR) {
         codec_context->bit_rate = arg_parser.video_bitrate;
@@ -515,6 +518,9 @@ static AVCodecContext *create_video_codec_context(AVPixelFormat pix_fmt, const A
 
     //av_opt_set(codec_context->priv_data, "bsf", "hevc_metadata=colour_primaries=9:transfer_characteristics=16:matrix_coefficients=9", 0);
 
+    if(arg_parser.tune == GSR_TUNE_QUALITY)
+        codec_context->max_b_frames = 2;
+
     codec_context->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
 
     return codec_context;
@@ -1262,6 +1268,11 @@ static RecordingStartAudio* get_recording_start_item_by_stream_index(RecordingSt
     return nullptr;
 }
 
+struct AudioPtsOffset {
+    int64_t pts_offset = 0;
+    int stream_index = 0;
+};
+
 static void save_replay_async(AVCodecContext *video_codec_context, int video_stream_index, const std::vector<AudioTrack> &audio_tracks, gsr_replay_buffer *replay_buffer, std::string output_dir, const char *container_format, const std::string &file_extension, bool date_folders, bool hdr, gsr_capture *capture, int current_save_replay_seconds) {
     if(save_replay_thread.valid())
         return;
@@ -1273,14 +1284,15 @@ static void save_replay_async(AVCodecContext *video_codec_context, int video_str
         return;
     }
 
-    const gsr_replay_buffer_iterator audio_start_iterator = gsr_replay_buffer_find_keyframe(replay_buffer, video_start_iterator, video_stream_index, true);
-    // if(audio_start_index == (size_t)-1) {
-    //     fprintf(stderr, "gsr error: failed to save replay: failed to find an audio keyframe. perhaps replay was saved too fast, before anything has been recorded\n");
-    //     return;
-    // }
-
     const int64_t video_pts_offset = gsr_replay_buffer_iterator_get_packet(replay_buffer, video_start_iterator)->pts;
-    const int64_t audio_pts_offset = audio_start_iterator.packet_index == (size_t)-1 ? 0 : gsr_replay_buffer_iterator_get_packet(replay_buffer, audio_start_iterator)->pts;
+
+    std::vector<AudioPtsOffset> audio_pts_offsets;
+    audio_pts_offsets.reserve(audio_tracks.size());
+    for(const AudioTrack &audio_track : audio_tracks) {
+        const gsr_replay_buffer_iterator audio_start_iterator = gsr_replay_buffer_find_keyframe(replay_buffer, video_start_iterator, audio_track.stream_index, false);
+        const int64_t audio_pts_offset = audio_start_iterator.packet_index == (size_t)-1 ? 0 : gsr_replay_buffer_iterator_get_packet(replay_buffer, audio_start_iterator)->pts;
+        audio_pts_offsets.push_back(AudioPtsOffset{audio_pts_offset, audio_track.stream_index});
+    }
 
     gsr_replay_buffer *cloned_replay_buffer = gsr_replay_buffer_clone(replay_buffer);
     if(!cloned_replay_buffer) {
@@ -1296,7 +1308,7 @@ static void save_replay_async(AVCodecContext *video_codec_context, int video_str
 
     save_replay_output_filepath = std::move(output_filepath);
 
-    save_replay_thread = std::async(std::launch::async, [video_stream_index, recording_start_result, video_start_iterator, video_pts_offset, audio_pts_offset, video_codec_context, cloned_replay_buffer]() mutable {
+    save_replay_thread = std::async(std::launch::async, [video_stream_index, recording_start_result, video_start_iterator, video_pts_offset, audio_pts_offsets{std::move(audio_pts_offsets)}, video_codec_context, cloned_replay_buffer]() mutable {
         gsr_replay_buffer_iterator replay_iterator = video_start_iterator;
         for(;;) {
             AVPacket *replay_packet = gsr_replay_buffer_iterator_get_packet(cloned_replay_buffer, replay_iterator);
@@ -1344,8 +1356,10 @@ static void save_replay_async(AVCodecContext *video_codec_context, int video_str
                 stream = recording_start_audio->stream;
                 codec_context = audio_track->codec_context;
 
-                av_packet.pts -= audio_pts_offset;
-                av_packet.dts -= audio_pts_offset;
+                const AudioPtsOffset &audio_pts_offset = audio_pts_offsets[av_packet.stream_index - 1];
+                assert(audio_pts_offset.stream_index == av_packet.stream_index);
+                av_packet.pts -= audio_pts_offset.pts_offset;
+                av_packet.dts -= audio_pts_offset.pts_offset;
             }
 
             //av_packet.stream_index = stream->index;
@@ -1402,8 +1416,12 @@ static const AudioDevice* get_audio_device_by_name(const std::vector<AudioDevice
 
 static MergedAudioInputs parse_audio_input_arg(const char *str) {
     MergedAudioInputs result;
+    result.track_name = str;
 
     split_string(str, '|', [&](const char *sub, size_t size) {
+        if(size == 0)
+            return true;
+
         AudioInput audio_input;
         audio_input.name.assign(sub, size);
 
@@ -1611,7 +1629,8 @@ static bool get_supported_video_codecs(gsr_egl *egl, gsr_video_codec video_codec
     memset(video_codecs, 0, sizeof(*video_codecs));
 
     if(use_software_video_encoder) {
-        video_codecs->h264.supported = true;
+        video_codecs->h264.supported = avcodec_find_encoder_by_name("libx264");
+        video_codecs->h264.max_resolution = {4096, 2304};
         return true;
     }
 
@@ -1751,14 +1770,16 @@ static void set_supported_video_codecs_ffmpeg(gsr_supported_video_codecs *suppor
         supported_video_codecs->vp9.supported = false;
     }
 
-    if(!get_ffmpeg_video_codec(GSR_VIDEO_CODEC_H264_VULKAN, vendor)) {
-        supported_video_codecs_vulkan->h264.supported = false;
-    }
+    if(supported_video_codecs_vulkan) {
+        if(!get_ffmpeg_video_codec(GSR_VIDEO_CODEC_H264_VULKAN, vendor)) {
+            supported_video_codecs_vulkan->h264.supported = false;
+        }
 
-    if(!get_ffmpeg_video_codec(GSR_VIDEO_CODEC_HEVC_VULKAN, vendor)) {
-        supported_video_codecs_vulkan->hevc.supported = false;
-        supported_video_codecs_vulkan->hevc_hdr.supported = false;
-        supported_video_codecs_vulkan->hevc_10bit.supported = false;
+        if(!get_ffmpeg_video_codec(GSR_VIDEO_CODEC_HEVC_VULKAN, vendor)) {
+            supported_video_codecs_vulkan->hevc.supported = false;
+            supported_video_codecs_vulkan->hevc_hdr.supported = false;
+            supported_video_codecs_vulkan->hevc_10bit.supported = false;
+        }
     }
 }
 
@@ -2267,7 +2288,7 @@ static int video_quality_to_image_quality_value(gsr_video_quality video_quality)
         case GSR_VIDEO_QUALITY_HIGH:
             return 85;
         case GSR_VIDEO_QUALITY_VERY_HIGH:
-            return 90;
+            return 91; // Quality above 90 makes the jpeg image encoder (stb_image_writer) use yuv444 instead of yuv420, which greatly improves small colored text quality on dark background
         case GSR_VIDEO_QUALITY_ULTRA:
             return 97;
     }
@@ -2283,11 +2304,11 @@ static void capture_image_to_file(args_parser &arg_parser, gsr_egl *egl, gsr_ima
     gsr_capture *capture = create_capture_impl(arg_parser, egl, prefer_ximage);
 
     gsr_capture_metadata capture_metadata;
-    capture_metadata.width = 0;
-    capture_metadata.height = 0;
+    capture_metadata.video_width = 0;
+    capture_metadata.video_height = 0;
+    capture_metadata.recording_width = 0;
+    capture_metadata.recording_height = 0;
     capture_metadata.fps = fps;
-    capture_metadata.video_codec_context = nullptr;
-    capture_metadata.frame = nullptr;
 
     int capture_result = gsr_capture_start(capture, &capture_metadata);
     if(capture_result != 0) {
@@ -2295,8 +2316,11 @@ static void capture_image_to_file(args_parser &arg_parser, gsr_egl *egl, gsr_ima
         _exit(capture_result);
     }
 
+    capture_metadata.recording_width = capture_metadata.video_width;
+    capture_metadata.recording_height = capture_metadata.video_height;
+
     gsr_image_writer image_writer;
-    if(!gsr_image_writer_init_opengl(&image_writer, egl, capture_metadata.width, capture_metadata.height)) {
+    if(!gsr_image_writer_init_opengl(&image_writer, egl, capture_metadata.video_width, capture_metadata.video_height)) {
         fprintf(stderr, "gsr error: capture_image_to_file_wayland: gsr_image_write_gl_init failed\n");
         _exit(1);
     }
@@ -2308,6 +2332,7 @@ static void capture_image_to_file(args_parser &arg_parser, gsr_egl *egl, gsr_ima
     color_conversion_params.load_external_image_shader = gsr_capture_uses_external_image(capture);
 
     color_conversion_params.destination_textures[0] = image_writer.texture;
+    color_conversion_params.destination_textures_size[0] = { capture_metadata.video_width, capture_metadata.video_height };
     color_conversion_params.num_destination_textures = 1;
     color_conversion_params.destination_color = GSR_DESTINATION_COLOR_RGB8;
 
@@ -2340,11 +2365,16 @@ static void capture_image_to_file(args_parser &arg_parser, gsr_egl *egl, gsr_ima
     }
 
     gsr_egl_swap_buffers(egl);
-    
-    const int image_quality = video_quality_to_image_quality_value(arg_parser.video_quality);
-    if(!gsr_image_writer_write_to_file(&image_writer, arg_parser.filename, image_format, image_quality)) {
-        fprintf(stderr, "gsr error: capture_image_to_file_wayland: failed to write opengl texture to image output file %s\n", arg_parser.filename);
-        _exit(1);
+
+    if(!should_stop_error) {
+        const int image_quality = video_quality_to_image_quality_value(arg_parser.video_quality);
+        if(!gsr_image_writer_write_to_file(&image_writer, arg_parser.filename, image_format, image_quality)) {
+            fprintf(stderr, "gsr error: capture_image_to_file_wayland: failed to write opengl texture to image output file %s\n", arg_parser.filename);
+            _exit(1);
+        }
+
+        if(arg_parser.recording_saved_script)
+            run_recording_saved_script_async(arg_parser.recording_saved_script, arg_parser.filename, "screenshot");
     }
 
     gsr_image_writer_deinit(&image_writer);
@@ -2559,105 +2589,192 @@ static bool video_codec_only_supports_low_power_mode(const gsr_supported_video_c
     return false;
 }
 
-static const AVCodec* pick_video_codec(gsr_video_codec *video_codec, gsr_egl *egl, bool use_software_video_encoder, bool video_codec_auto, bool is_flv, bool *low_power) {
-    // TODO: software encoder for hevc, av1, vp8 and vp9
-    *low_power = false;
-
-    gsr_supported_video_codecs supported_video_codecs;
-    if(!get_supported_video_codecs(egl, *video_codec, use_software_video_encoder, true, &supported_video_codecs)) {
-        fprintf(stderr, "gsr error: failed to query for supported video codecs\n");
-        _exit(11);
-    }
-
-    const AVCodec *video_codec_f = nullptr;
-
-    switch(*video_codec) {
+static const AVCodec* get_av_codec_if_supported(gsr_video_codec video_codec, gsr_egl *egl, bool use_software_video_encoder, const gsr_supported_video_codecs *supported_video_codecs) {
+    switch(video_codec) {
         case GSR_VIDEO_CODEC_H264: {
             if(use_software_video_encoder)
-                video_codec_f = avcodec_find_encoder_by_name("libx264");
-            else if(supported_video_codecs.h264.supported)
-                video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
+                return avcodec_find_encoder_by_name("libx264");
+            else if(supported_video_codecs->h264.supported)
+                return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor);
             break;
         }
         case GSR_VIDEO_CODEC_HEVC: {
-            if(supported_video_codecs.hevc.supported)
-                video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
+            if(supported_video_codecs->hevc.supported)
+                return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor);
             break;
         }
         case GSR_VIDEO_CODEC_HEVC_HDR: {
-            if(supported_video_codecs.hevc_hdr.supported)
-                video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
+            if(supported_video_codecs->hevc_hdr.supported)
+                return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor);
             break;
         }
         case GSR_VIDEO_CODEC_HEVC_10BIT: {
-            if(supported_video_codecs.hevc_10bit.supported)
-                video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
+            if(supported_video_codecs->hevc_10bit.supported)
+                return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor);
             break;
         }
         case GSR_VIDEO_CODEC_AV1: {
-            if(supported_video_codecs.av1.supported)
-                video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
+            if(supported_video_codecs->av1.supported)
+                return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor);
             break;
         }
         case GSR_VIDEO_CODEC_AV1_HDR: {
-            if(supported_video_codecs.av1_hdr.supported)
-                video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
+            if(supported_video_codecs->av1_hdr.supported)
+                return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor);
             break;
         }
         case GSR_VIDEO_CODEC_AV1_10BIT: {
-            if(supported_video_codecs.av1_10bit.supported)
-                video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
+            if(supported_video_codecs->av1_10bit.supported)
+                return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor);
             break;
         }
         case GSR_VIDEO_CODEC_VP8: {
-            if(supported_video_codecs.vp8.supported)
-                video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
+            if(supported_video_codecs->vp8.supported)
+                return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor);
             break;
         }
         case GSR_VIDEO_CODEC_VP9: {
-            if(supported_video_codecs.vp9.supported)
-                video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
+            if(supported_video_codecs->vp9.supported)
+                return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor);
             break;
         }
         case GSR_VIDEO_CODEC_H264_VULKAN: {
-            if(supported_video_codecs.h264.supported)
-                video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
+            if(supported_video_codecs->h264.supported)
+                return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor);
             break;
         }
         case GSR_VIDEO_CODEC_HEVC_VULKAN: {
             // TODO: hdr, 10 bit
-            if(supported_video_codecs.hevc.supported)
-                video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
+            if(supported_video_codecs->hevc.supported)
+                return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor);
             break;
         }
     }
+    return nullptr;
+}
 
-    if(!video_codec_auto && !video_codec_f && !is_flv) {
-        switch(*video_codec) {
+static vec2i codec_get_max_resolution(gsr_video_codec video_codec, bool use_software_video_encoder, const gsr_supported_video_codecs *supported_video_codecs) {
+    switch(video_codec) {
+        case GSR_VIDEO_CODEC_H264: {
+            if(use_software_video_encoder)
+                return {4096, 2304};
+            else if(supported_video_codecs->h264.supported)
+                return supported_video_codecs->h264.max_resolution;
+            break;
+        }
+        case GSR_VIDEO_CODEC_HEVC: {
+            if(supported_video_codecs->hevc.supported)
+                return supported_video_codecs->hevc.max_resolution;
+            break;
+        }
+        case GSR_VIDEO_CODEC_HEVC_HDR: {
+            if(supported_video_codecs->hevc_hdr.supported)
+                return supported_video_codecs->hevc_hdr.max_resolution;
+            break;
+        }
+        case GSR_VIDEO_CODEC_HEVC_10BIT: {
+            if(supported_video_codecs->hevc_10bit.supported)
+                return supported_video_codecs->hevc_10bit.max_resolution;
+            break;
+        }
+        case GSR_VIDEO_CODEC_AV1: {
+            if(supported_video_codecs->av1.supported)
+                return supported_video_codecs->av1.max_resolution;
+            break;
+        }
+        case GSR_VIDEO_CODEC_AV1_HDR: {
+            if(supported_video_codecs->av1_hdr.supported)
+                return supported_video_codecs->av1_hdr.max_resolution;
+            break;
+        }
+        case GSR_VIDEO_CODEC_AV1_10BIT: {
+            if(supported_video_codecs->av1_10bit.supported)
+                return supported_video_codecs->av1_10bit.max_resolution;
+            break;
+        }
+        case GSR_VIDEO_CODEC_VP8: {
+            if(supported_video_codecs->vp8.supported)
+                return supported_video_codecs->vp8.max_resolution;
+            break;
+        }
+        case GSR_VIDEO_CODEC_VP9: {
+            if(supported_video_codecs->vp9.supported)
+                return supported_video_codecs->vp9.max_resolution;
+            break;
+        }
+        case GSR_VIDEO_CODEC_H264_VULKAN: {
+            if(supported_video_codecs->h264.supported)
+                return supported_video_codecs->h264.max_resolution;
+            break;
+        }
+        case GSR_VIDEO_CODEC_HEVC_VULKAN: {
+            // TODO: hdr, 10 bit
+            if(supported_video_codecs->hevc.supported)
+                return supported_video_codecs->hevc.max_resolution;
+            break;
+        }
+    }
+    return {0, 0};
+}
+
+static bool codec_supports_resolution(vec2i codec_max_resolution, vec2i capture_resolution) {
+    if(codec_max_resolution.x == 0 || codec_max_resolution.y == 0)
+        return true;
+    return codec_max_resolution.x >= capture_resolution.x && codec_max_resolution.y >= capture_resolution.y;
+}
+
+static void print_codec_error(gsr_video_codec video_codec) {
+    if(video_codec == (gsr_video_codec)GSR_VIDEO_CODEC_AUTO)
+        video_codec = GSR_VIDEO_CODEC_H264;
+
+    const char *video_codec_name = video_codec_to_string(video_codec);
+    fprintf(stderr, "gsr error: your gpu does not support '%s' video codec. If you are sure that your gpu does support '%s' video encoding and you are using an AMD/Intel GPU,\n"
+        "  then make sure you have installed the GPU specific vaapi packages (intel-media-driver, libva-intel-driver, libva-mesa-driver and linux-firmware).\n"
+        "  It's also possible that your distro has disabled hardware accelerated video encoding for '%s' video codec.\n"
+        "  This may be the case on corporate distros such as Manjaro, Fedora or OpenSUSE.\n"
+        "  You can test this by running 'vainfo | grep VAEntrypointEncSlice' to see if it matches any H264/HEVC/AV1/VP8/VP9 profile.\n"
+        "  On such distros, you need to manually install mesa from source to enable H264/HEVC hardware acceleration, or use a more user friendly distro. Alternatively record with AV1 if supported by your GPU.\n"
+        "  You can alternatively use the flatpak version of GPU Screen Recorder (https://flathub.org/apps/com.dec05eba.gpu_screen_recorder) which bypasses system issues with patented H264/HEVC codecs.\n"
+        "  If your GPU doesn't support hardware accelerated video encoding then you can use '-fallback-cpu-encoding yes' option to encode with your cpu instead.\n", video_codec_name, video_codec_name, video_codec_name);
+}
+
+static void force_cpu_encoding(args_parser *args_parser) {
+    args_parser->video_codec = GSR_VIDEO_CODEC_H264;
+    args_parser->video_encoder = GSR_VIDEO_ENCODER_HW_CPU;
+    if(args_parser->bitrate_mode == GSR_BITRATE_MODE_VBR) {
+        fprintf(stderr, "gsr warning: bitrate mode has been forcefully set to qp because software encoding option doesn't support vbr option\n");
+        args_parser->bitrate_mode = GSR_BITRATE_MODE_QP;
+    }
+}
+
+static const AVCodec* pick_video_codec(gsr_egl *egl, args_parser *args_parser, bool use_fallback_codec, bool *low_power, gsr_supported_video_codecs *supported_video_codecs) {
+    // TODO: software encoder for hevc, av1, vp8 and vp9
+    *low_power = false;
+    const AVCodec *video_codec_f = get_av_codec_if_supported(args_parser->video_codec, egl, args_parser->video_encoder == GSR_VIDEO_ENCODER_HW_CPU, supported_video_codecs);
+
+    if(!video_codec_f && use_fallback_codec && args_parser->video_encoder != GSR_VIDEO_ENCODER_HW_CPU) {
+        switch(args_parser->video_codec) {
             case GSR_VIDEO_CODEC_H264: {
-                fprintf(stderr, "gsr warning: selected video codec h264 is not supported, trying hevc instead\n");
-                *video_codec = GSR_VIDEO_CODEC_HEVC;
-                if(supported_video_codecs.hevc.supported)
-                    video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
+                fprintf(stderr, "gsr error: selected video codec h264 is not supported\n");
+                if(args_parser->fallback_cpu_encoding) {
+                    fprintf(stderr, "gsr warning: gpu encoding is not available on your system, trying cpu encoding instead because -fallback-cpu-encoding is enabled. Install the proper vaapi drivers on your system (if supported) if you experience performance issues\n");
+                    force_cpu_encoding(args_parser);
+                }
                 break;
             }
             case GSR_VIDEO_CODEC_HEVC:
             case GSR_VIDEO_CODEC_HEVC_HDR:
             case GSR_VIDEO_CODEC_HEVC_10BIT: {
                 fprintf(stderr, "gsr warning: selected video codec hevc is not supported, trying h264 instead\n");
-                *video_codec = GSR_VIDEO_CODEC_H264;
-                if(supported_video_codecs.h264.supported)
-                    video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
-                break;
+                args_parser->video_codec = GSR_VIDEO_CODEC_H264;
+                return pick_video_codec(egl, args_parser, true, low_power, supported_video_codecs);
             }
             case GSR_VIDEO_CODEC_AV1:
             case GSR_VIDEO_CODEC_AV1_HDR:
             case GSR_VIDEO_CODEC_AV1_10BIT: {
                 fprintf(stderr, "gsr warning: selected video codec av1 is not supported, trying h264 instead\n");
-                *video_codec = GSR_VIDEO_CODEC_H264;
-                if(supported_video_codecs.h264.supported)
-                    video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
-                break;
+                args_parser->video_codec = GSR_VIDEO_CODEC_H264;
+                return pick_video_codec(egl, args_parser, true, low_power, supported_video_codecs);
             }
             case GSR_VIDEO_CODEC_VP8:
             case GSR_VIDEO_CODEC_VP9:
@@ -2665,99 +2782,116 @@ static const AVCodec* pick_video_codec(gsr_video_codec *video_codec, gsr_egl *eg
                 break;
             case GSR_VIDEO_CODEC_H264_VULKAN: {
                 fprintf(stderr, "gsr warning: selected video codec h264_vulkan is not supported, trying h264 instead\n");
-                *video_codec = GSR_VIDEO_CODEC_H264;
+                args_parser->video_codec = GSR_VIDEO_CODEC_H264;
                 // Need to do a query again because this time it's without vulkan
-                if(!get_supported_video_codecs(egl, *video_codec, use_software_video_encoder, true, &supported_video_codecs)) {
+                if(!get_supported_video_codecs(egl, args_parser->video_codec, false, true, supported_video_codecs)) {
                     fprintf(stderr, "gsr error: failed to query for supported video codecs\n");
+                    print_codec_error(args_parser->video_codec);
                     _exit(11);
                 }
-                if(supported_video_codecs.h264.supported)
-                    video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
-                break;
+                return pick_video_codec(egl, args_parser, true, low_power, supported_video_codecs);
             }
             case GSR_VIDEO_CODEC_HEVC_VULKAN: {
                 fprintf(stderr, "gsr warning: selected video codec hevc_vulkan is not supported, trying hevc instead\n");
-                *video_codec = GSR_VIDEO_CODEC_HEVC;
+                args_parser->video_codec = GSR_VIDEO_CODEC_HEVC;
                 // Need to do a query again because this time it's without vulkan
-                if(!get_supported_video_codecs(egl, *video_codec, use_software_video_encoder, true, &supported_video_codecs)) {
+                if(!get_supported_video_codecs(egl, args_parser->video_codec, false, true, supported_video_codecs)) {
                     fprintf(stderr, "gsr error: failed to query for supported video codecs\n");
+                    print_codec_error(args_parser->video_codec);
                     _exit(11);
                 }
-                if(supported_video_codecs.hevc.supported)
-                    video_codec_f = get_ffmpeg_video_codec(*video_codec, egl->gpu_info.vendor);
-                break;
+                return pick_video_codec(egl, args_parser, true, low_power, supported_video_codecs);
             }
         }
+
+        video_codec_f = get_av_codec_if_supported(args_parser->video_codec, egl, args_parser->video_encoder == GSR_VIDEO_ENCODER_HW_CPU, supported_video_codecs);
     }
 
     if(!video_codec_f) {
-        const char *video_codec_name = video_codec_to_string(*video_codec);
-        fprintf(stderr, "gsr error: your gpu does not support '%s' video codec. If you are sure that your gpu does support '%s' video encoding and you are using an AMD/Intel GPU,\n"
-            "  then make sure you have installed the GPU specific vaapi packages (intel-media-driver, libva-intel-driver, libva-mesa-driver and linux-firmware).\n"
-            "  It's also possible that your distro has disabled hardware accelerated video encoding for '%s' video codec.\n"
-            "  This may be the case on corporate distros such as Manjaro, Fedora or OpenSUSE.\n"
-            "  You can test this by running 'vainfo | grep VAEntrypointEncSlice' to see if it matches any H264/HEVC/AV1/VP8/VP9 profile.\n"
-            "  On such distros, you need to manually install mesa from source to enable H264/HEVC hardware acceleration, or use a more user friendly distro. Alternatively record with AV1 if supported by your GPU.\n"
-            "  You can alternatively use the flatpak version of GPU Screen Recorder (https://flathub.org/apps/com.dec05eba.gpu_screen_recorder) which bypasses system issues with patented H264/HEVC codecs.\n"
-            "  Make sure you have mesa-extra freedesktop runtime installed when using the flatpak (this should be the default), which can be installed with this command:\n"
-            "  flatpak install --system org.freedesktop.Platform.GL.default//23.08-extra\n"
-            "  If your GPU doesn't support hardware accelerated video encoding then you can use '-encoder cpu' option to encode with your cpu instead.\n", video_codec_name, video_codec_name, video_codec_name);
-        _exit(2);
+        print_codec_error(args_parser->video_codec);
+        _exit(54);
     }
 
-    *low_power = video_codec_only_supports_low_power_mode(supported_video_codecs, *video_codec);
+    *low_power = video_codec_only_supports_low_power_mode(*supported_video_codecs, args_parser->video_codec);
 
     return video_codec_f;
 }
 
-static const AVCodec* select_video_codec_with_fallback(gsr_video_codec *video_codec, const char *file_extension, bool use_software_video_encoder, gsr_egl *egl, bool *low_power) {
-    const bool video_codec_auto = *video_codec == (gsr_video_codec)GSR_VIDEO_CODEC_AUTO;
+/* Returns -1 if none is available */
+static gsr_video_codec select_appropriate_video_codec_automatically(gsr_capture_metadata capture_metadata, const gsr_supported_video_codecs *supported_video_codecs) {
+    const vec2i capture_size = {capture_metadata.video_width, capture_metadata.video_height};
+    if(supported_video_codecs->h264.supported && codec_supports_resolution(supported_video_codecs->h264.max_resolution, capture_size)) {
+        fprintf(stderr, "gsr info: using h264 encoder because a codec was not specified\n");
+        return GSR_VIDEO_CODEC_H264;
+    } else if(supported_video_codecs->hevc.supported && codec_supports_resolution(supported_video_codecs->hevc.max_resolution, capture_size)) {
+        fprintf(stderr, "gsr info: using hevc encoder because a codec was not specified and h264 supported max resolution (%dx%d) is less than capture resolution (%dx%d)\n",
+            supported_video_codecs->h264.max_resolution.x, supported_video_codecs->h264.max_resolution.y,
+            capture_size.x, capture_size.y);
+        return GSR_VIDEO_CODEC_HEVC;
+    } else if(supported_video_codecs->av1.supported && codec_supports_resolution(supported_video_codecs->av1.max_resolution, capture_size)) {
+        fprintf(stderr, "gsr info: using av1 encoder because a codec was not specified and hevc supported max resolution (%dx%d) is less than capture resolution (%dx%d)\n",
+            supported_video_codecs->hevc.max_resolution.x, supported_video_codecs->hevc.max_resolution.y,
+            capture_size.x, capture_size.y);
+        return GSR_VIDEO_CODEC_AV1;
+    } else {
+        return (gsr_video_codec)-1;
+    }
+}
+
+static const AVCodec* select_video_codec_with_fallback(gsr_capture_metadata capture_metadata, args_parser *args_parser, const char *file_extension, gsr_egl *egl, bool *low_power) {
+    gsr_supported_video_codecs supported_video_codecs;
+    get_supported_video_codecs(egl, args_parser->video_codec, args_parser->video_encoder == GSR_VIDEO_ENCODER_HW_CPU, true, &supported_video_codecs);
+    // TODO: Use gsr_supported_video_codecs *supported_video_codecs_vulkan here to properly query vulkan video support
+    set_supported_video_codecs_ffmpeg(&supported_video_codecs, nullptr, egl->gpu_info.vendor);
+
+    const bool video_codec_auto = args_parser->video_codec == (gsr_video_codec)GSR_VIDEO_CODEC_AUTO;
     if(video_codec_auto) {
         if(strcmp(file_extension, "webm") == 0) {
             fprintf(stderr, "gsr info: using vp8 encoder because a codec was not specified and the file extension is .webm\n");
-            *video_codec = GSR_VIDEO_CODEC_VP8;
-        } else {
+            args_parser->video_codec = GSR_VIDEO_CODEC_VP8;
+        } else if(args_parser->video_encoder == GSR_VIDEO_ENCODER_HW_CPU) {
             fprintf(stderr, "gsr info: using h264 encoder because a codec was not specified\n");
-            *video_codec = GSR_VIDEO_CODEC_H264;
+            args_parser->video_codec = GSR_VIDEO_CODEC_H264;
+        } else if(args_parser->video_encoder != GSR_VIDEO_ENCODER_HW_CPU) {
+            args_parser->video_codec = select_appropriate_video_codec_automatically(capture_metadata, &supported_video_codecs);
+            if(args_parser->video_codec == (gsr_video_codec)-1) {
+                if(args_parser->fallback_cpu_encoding) {
+                    fprintf(stderr, "gsr warning: gpu encoding is not available on your system or your gpu doesn't support recording at the resolution you are trying to record, trying cpu encoding instead because -fallback-cpu-encoding is enabled. Install the proper vaapi drivers on your system (if supported) if you experience performance issues\n");
+                    force_cpu_encoding(args_parser);
+                } else {
+                    fprintf(stderr, "gsr error: no video encoder was specified and neither h264, hevc nor av1 are supported on your system or you are trying to capture at a resolution higher than your system supports for each codec.\n");
+                    fprintf(stderr, "  Ensure that you have installed the proper vaapi driver. If your gpu doesn't support video encoding then you can run gpu-screen-recorder with \"-fallback-cpu-encoding yes\" option to use cpu encoding.\n");
+                    _exit(52);
+                }
+            }
         }
     }
 
     // TODO: Allow hevc, vp9 and av1 in (enhanced) flv (supported since ffmpeg 6.1)
-    const bool is_flv = strcmp(file_extension, "flv") == 0;
-    if(is_flv) {
-        if(*video_codec != GSR_VIDEO_CODEC_H264) {
-            *video_codec = GSR_VIDEO_CODEC_H264;
-            fprintf(stderr, "gsr warning: hevc/av1 is not compatible with flv, falling back to h264 instead.\n");
+    if(LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(60, 10, 100) && strcmp(file_extension, "flv") == 0) {
+        if(args_parser->video_codec != GSR_VIDEO_CODEC_H264) {
+            args_parser->video_codec = GSR_VIDEO_CODEC_H264;
+            fprintf(stderr, "gsr warning: hevc/av1 is not compatible with flv in your outdated version of ffmpeg, falling back to h264 instead.\n");
         }
-
-        // if(audio_codec != GSR_AUDIO_CODEC_AAC) {
-        //     audio_codec_to_use = "aac";
-        //     audio_codec = GSR_AUDIO_CODEC_AAC;
-        //     fprintf(stderr, "gsr warning: flv only supports aac, falling back to aac instead.\n");
-        // }
-    }
-
-    const bool is_hls = strcmp(file_extension, "m3u8") == 0;
-    if(is_hls) {
-        if(video_codec_is_av1(*video_codec)) {
-            *video_codec = GSR_VIDEO_CODEC_HEVC;
+    } else if(strcmp(file_extension, "m3u8") == 0) {
+        if(video_codec_is_av1(args_parser->video_codec)) {
+            args_parser->video_codec = GSR_VIDEO_CODEC_HEVC;
             fprintf(stderr, "gsr warning: av1 is not compatible with hls (m3u8), falling back to hevc instead.\n");
         }
-
-        // if(audio_codec != GSR_AUDIO_CODEC_AAC) {
-        //     audio_codec_to_use = "aac";
-        //     audio_codec = GSR_AUDIO_CODEC_AAC;
-        //     fprintf(stderr, "gsr warning: hls (m3u8) only supports aac, falling back to aac instead.\n");
-        // }
     }
 
-    if(use_software_video_encoder && *video_codec != GSR_VIDEO_CODEC_H264) {
-        fprintf(stderr, "gsr error: \"-encoder cpu\" option is currently only available when using h264 codec option (-k)\n");
-        args_parser_print_usage();
-        _exit(1);
+    const AVCodec *codec = pick_video_codec(egl, args_parser, true, low_power, &supported_video_codecs);
+
+    const vec2i codec_max_resolution = codec_get_max_resolution(args_parser->video_codec, args_parser->video_encoder == GSR_VIDEO_ENCODER_HW_CPU, &supported_video_codecs);
+    const vec2i capture_size = {capture_metadata.video_width, capture_metadata.video_height};
+    if(!codec_supports_resolution(codec_max_resolution, capture_size)) {
+        const char *video_codec_name = video_codec_to_string(args_parser->video_codec);
+        fprintf(stderr, "gsr error: The max resolution for video codec %s is %dx%d while you are trying to capture at resolution %dx%d. Change capture resolution or video codec and try again\n",
+            video_codec_name, codec_max_resolution.x, codec_max_resolution.y, capture_size.x, capture_size.y);
+        _exit(53);
     }
 
-    return pick_video_codec(video_codec, egl, use_software_video_encoder, video_codec_auto, is_flv, low_power);
+    return codec;
 }
 
 static std::vector<AudioDeviceData> create_device_audio_inputs(const std::vector<AudioInput> &audio_inputs, AVCodecContext *audio_codec_context, int num_channels, double num_audio_frames_shift, std::vector<AVFilterContext*> &src_filter_ctx, bool use_amix) {
@@ -2777,7 +2911,7 @@ static std::vector<AudioDeviceData> create_device_audio_inputs(const std::vector
             audio_device.sound_device.frames = 0;
         } else {
             const std::string description = "gsr-" + audio_input.name;
-            if(sound_device_get_by_name(&audio_device.sound_device, audio_input.name.c_str(), description.c_str(), num_channels, audio_codec_context->frame_size, audio_codec_context_get_audio_format(audio_codec_context)) != 0) {
+            if(sound_device_get_by_name(&audio_device.sound_device, description.c_str(), audio_input.name.c_str(), description.c_str(), num_channels, audio_codec_context->frame_size, audio_codec_context_get_audio_format(audio_codec_context)) != 0) {
                 fprintf(stderr, "gsr error: failed to get \"%s\" audio device\n", audio_input.name.c_str());
                 _exit(1);
             }
@@ -2802,17 +2936,12 @@ static AudioDeviceData create_application_audio_audio_input(const MergedAudioInp
         fprintf(stderr, "gsr error: failed to generate random string\n");
         _exit(1);
     }
+
     std::string combined_sink_name = "gsr-combined-";
     combined_sink_name.append(random_str, sizeof(random_str));
-
-    if(!gsr_pipewire_audio_create_virtual_sink(pipewire_audio, combined_sink_name.c_str())) {
-        fprintf(stderr, "gsr error: failed to create virtual sink for application audio\n");
-        _exit(1);
-    }
-
     combined_sink_name += ".monitor";
 
-    if(sound_device_get_by_name(&audio_device.sound_device, combined_sink_name.c_str(), "gpu-screen-recorder", num_channels, audio_codec_context->frame_size, audio_codec_context_get_audio_format(audio_codec_context)) != 0) {
+    if(sound_device_get_by_name(&audio_device.sound_device, combined_sink_name.c_str(), "", "gpu-screen-recorder", num_channels, audio_codec_context->frame_size, audio_codec_context_get_audio_format(audio_codec_context)) != 0) {
         fprintf(stderr, "gsr error: failed to setup audio recording to combined sink\n");
         _exit(1);
     }
@@ -2833,19 +2962,19 @@ static AudioDeviceData create_application_audio_audio_input(const MergedAudioInp
     }
 
     if(!audio_devices_sources.empty()) {
-        if(!gsr_pipewire_audio_add_link_from_sources_to_sink(pipewire_audio, audio_devices_sources.data(), audio_devices_sources.size(), combined_sink_name.c_str())) {
+        if(!gsr_pipewire_audio_add_link_from_sources_to_stream(pipewire_audio, audio_devices_sources.data(), audio_devices_sources.size(), combined_sink_name.c_str())) {
             fprintf(stderr, "gsr error: failed to add application audio link\n");
             _exit(1);
         }
     }
 
     if(app_audio_inverted) {
-        if(!gsr_pipewire_audio_add_link_from_apps_to_sink_inverted(pipewire_audio, app_names.data(), app_names.size(), combined_sink_name.c_str())) {
+        if(!gsr_pipewire_audio_add_link_from_apps_to_stream_inverted(pipewire_audio, app_names.data(), app_names.size(), combined_sink_name.c_str())) {
             fprintf(stderr, "gsr error: failed to add application audio link\n");
             _exit(1);
         }
     } else {
-        if(!gsr_pipewire_audio_add_link_from_apps_to_sink(pipewire_audio, app_names.data(), app_names.size(), combined_sink_name.c_str())) {
+        if(!gsr_pipewire_audio_add_link_from_apps_to_stream(pipewire_audio, app_names.data(), app_names.size(), combined_sink_name.c_str())) {
             fprintf(stderr, "gsr error: failed to add application audio link\n");
             _exit(1);
         }
@@ -2931,7 +3060,7 @@ static void set_display_server_environment_variables() {
 
 int main(int argc, char **argv) {
     setlocale(LC_ALL, "C"); // Sigh... stupid C
-#ifdef __linux__
+#ifdef __GLIBC__
     mallopt(M_MMAP_THRESHOLD, 65536);
 #endif
 
@@ -2949,6 +3078,11 @@ int main(int argc, char **argv) {
 
     set_display_server_environment_variables();
 
+    // Linux nvidia driver 580.105.08 added the environment variable CUDA_DISABLE_PERF_BOOST to disable the p2 power level issue,
+    // where running cuda (which includes nvenc) causes the gpu to be forcefully set to p2 power level which on many nvidia gpus
+    // decreases gpu performance in games. On my GTX 1080 it decreased game performance by 10% for absolutely no reason.
+    // TODO: This only seems to allow the gpu to go to lower power level states, but not higher than p2.
+    setenv("CUDA_DISABLE_PERF_BOOST", "1", true);
     // Stop nvidia driver from buffering frames
     setenv("__GL_MaxFramesAllowed", "1", true);
     // If this is set to 1 then cuGraphicsGLRegisterImage will fail for egl context with error: invalid OpenGL or DirectX context,
@@ -2986,6 +3120,15 @@ int main(int argc, char **argv) {
     if(!args_parser_parse(&arg_parser, argc, argv, &arg_handlers, NULL))
         _exit(1);
 
+    if(arg_parser.overclock) {
+        int driver_major_version = 0;
+        int driver_minor_version = 0;
+        if(get_nvidia_driver_version(&driver_major_version, &driver_minor_version) && (driver_major_version > 580 || (driver_major_version == 580 && driver_minor_version >= 105))) {
+            fprintf(stderr, "gsr info: overclocking was set by has been forcefully disabled since your gpu supports CUDA_DISABLE_PERF_BOOST to workaround driver issue (overclocking is not needed)\n");
+            arg_parser.overclock = false;
+        }
+    }
+
     //av_log_set_level(AV_LOG_TRACE);
 
     const Arg *audio_input_arg = args_parser_get_arg(&arg_parser, "-a");
@@ -3019,6 +3162,11 @@ int main(int argc, char **argv) {
             return true;
         }, &app_audio_names);
     }
+#else
+    if(uses_app_audio) {
+        fprintf(stderr, "gsr error: application audio can't be recorded because GPU Screen Recorder is built without application audio support (-Dapp_audio option)\n");
+        _exit(2);
+    }
 #endif
 
     validate_merged_audio_inputs_app_audio(requested_audio_inputs, app_audio_names);
@@ -3126,10 +3274,21 @@ int main(int argc, char **argv) {
 
     const bool uses_amix = merged_audio_inputs_should_use_amix(requested_audio_inputs);
     arg_parser.audio_codec = select_audio_codec_with_fallback(arg_parser.audio_codec, file_extension, uses_amix);
-    bool low_power = false;
-    const AVCodec *video_codec_f = select_video_codec_with_fallback(&arg_parser.video_codec, file_extension.c_str(), arg_parser.video_encoder == GSR_VIDEO_ENCODER_HW_CPU, &egl, &low_power);
 
     gsr_capture *capture = create_capture_impl(arg_parser, &egl, false);
+    
+    gsr_capture_metadata capture_metadata;
+    capture_metadata.video_width = 0;
+    capture_metadata.video_height = 0;
+    capture_metadata.recording_width = 0;
+    capture_metadata.recording_height = 0;
+    capture_metadata.fps = arg_parser.fps;
+
+    int capture_result = gsr_capture_start(capture, &capture_metadata);
+    if(capture_result != 0) {
+        fprintf(stderr, "gsr error: gsr_capture_start failed\n");
+        _exit(capture_result);
+    }
 
     // (Some?) livestreaming services require at least one audio track to work.
     // If not audio is provided then create one silent audio track.
@@ -3143,46 +3302,33 @@ int main(int argc, char **argv) {
     AVStream *video_stream = nullptr;
     std::vector<AudioTrack> audio_tracks;
 
+    if(arg_parser.video_encoder == GSR_VIDEO_ENCODER_HW_CPU && arg_parser.video_codec != (gsr_video_codec)GSR_VIDEO_CODEC_AUTO && arg_parser.video_codec != GSR_VIDEO_CODEC_H264) {
+        fprintf(stderr, "gsr error: -encoder cpu was specified but a codec other than h264 was specified. -encoder cpu supports only h264 at the moment\n");
+        _exit(1);
+    }
+
+    bool low_power = false;
+    const AVCodec *video_codec_f = select_video_codec_with_fallback(capture_metadata, &arg_parser, file_extension.c_str(), &egl, &low_power);
+
     const enum AVPixelFormat video_pix_fmt = get_pixel_format(arg_parser.video_codec, egl.gpu_info.vendor, arg_parser.video_encoder == GSR_VIDEO_ENCODER_HW_CPU);
-    AVCodecContext *video_codec_context = create_video_codec_context(video_pix_fmt, video_codec_f, egl, arg_parser);
+    AVCodecContext *video_codec_context = create_video_codec_context(video_pix_fmt, video_codec_f, egl, arg_parser, capture_metadata.video_width, capture_metadata.video_height);
     if(!is_replaying)
         video_stream = create_stream(av_format_context, video_codec_context);
 
-    if(arg_parser.tune == GSR_TUNE_QUALITY)
-        video_codec_context->max_b_frames = 2;
-
     AVFrame *video_frame = av_frame_alloc();
     if(!video_frame) {
         fprintf(stderr, "gsr error: Failed to allocate video frame\n");
         _exit(1);
     }
     video_frame->format = video_codec_context->pix_fmt;
-    video_frame->width = 0;
-    video_frame->height = 0;
+    video_frame->width = capture_metadata.video_width;
+    video_frame->height = capture_metadata.video_height;
     video_frame->color_range = video_codec_context->color_range;
     video_frame->color_primaries = video_codec_context->color_primaries;
     video_frame->color_trc = video_codec_context->color_trc;
     video_frame->colorspace = video_codec_context->colorspace;
     video_frame->chroma_location = video_codec_context->chroma_sample_location;
 
-    gsr_capture_metadata capture_metadata;
-    capture_metadata.width = 0;
-    capture_metadata.height = 0;
-    capture_metadata.fps = arg_parser.fps;
-    capture_metadata.video_codec_context = video_codec_context;
-    capture_metadata.frame = video_frame;
-
-    int capture_result = gsr_capture_start(capture, &capture_metadata);
-    if(capture_result != 0) {
-        fprintf(stderr, "gsr error: gsr_capture_start failed\n");
-        _exit(capture_result);
-    }
-
-    video_codec_context->width = capture_metadata.width;
-    video_codec_context->height = capture_metadata.height;
-    video_frame->width = capture_metadata.width;
-    video_frame->height = capture_metadata.height;
-
     const size_t estimated_replay_buffer_packets = calculate_estimated_replay_buffer_packets(arg_parser.replay_buffer_size_secs, arg_parser.fps, arg_parser.audio_codec, requested_audio_inputs);
     gsr_encoder encoder;
     if(!gsr_encoder_init(&encoder, arg_parser.replay_storage, estimated_replay_buffer_packets, arg_parser.replay_buffer_size_secs, arg_parser.filename)) {
@@ -3201,15 +3347,46 @@ int main(int argc, char **argv) {
         _exit(1);
     }
 
-    capture_metadata.width = video_codec_context->width;
-    capture_metadata.height = video_codec_context->height;
+    capture_metadata.recording_width = capture_metadata.video_width;
+    capture_metadata.recording_height = capture_metadata.video_height;
+
+    // TODO: What if this updated resolution is above max resolution?
+    capture_metadata.video_width = video_codec_context->width;
+    capture_metadata.video_height = video_codec_context->height;
+
+    const Arg *plugin_arg = args_parser_get_arg(&arg_parser, "-p");
+    assert(plugin_arg);
+
+    gsr_plugins plugins;
+    memset(&plugins, 0, sizeof(plugins));
+
+    if(plugin_arg->num_values > 0) {
+        const gsr_color_depth color_depth = video_codec_to_bit_depth(arg_parser.video_codec);
+        assert(color_depth == GSR_COLOR_DEPTH_8_BITS || color_depth == GSR_COLOR_DEPTH_10_BITS);
+
+        const gsr_plugin_init_params plugin_init_params = {
+            (unsigned int)capture_metadata.video_width,
+            (unsigned int)capture_metadata.video_height,
+            (unsigned int)arg_parser.fps,
+            color_depth == GSR_COLOR_DEPTH_8_BITS ? GSR_PLUGIN_COLOR_DEPTH_8_BITS : GSR_PLUGIN_COLOR_DEPTH_10_BITS,
+            egl.context_type == GSR_GL_CONTEXT_TYPE_GLX ? GSR_PLUGIN_GRAPHICS_API_GLX : GSR_PLUGIN_GRAPHICS_API_EGL_ES,
+        };
+
+        if(!gsr_plugins_init(&plugins, plugin_init_params, &egl))
+            _exit(1);
+
+        for(int i = 0; i < plugin_arg->num_values; ++i) {
+            if(!gsr_plugins_load_plugin(&plugins, plugin_arg->values[i]))
+                _exit(1);
+        }
+    }
 
     gsr_color_conversion_params color_conversion_params;
     memset(&color_conversion_params, 0, sizeof(color_conversion_params));
     color_conversion_params.color_range = arg_parser.color_range;
     color_conversion_params.egl = &egl;
     color_conversion_params.load_external_image_shader = gsr_capture_uses_external_image(capture);
-    gsr_video_encoder_get_textures(video_encoder, color_conversion_params.destination_textures, &color_conversion_params.num_destination_textures, &color_conversion_params.destination_color);
+    gsr_video_encoder_get_textures(video_encoder, color_conversion_params.destination_textures, color_conversion_params.destination_textures_size, &color_conversion_params.num_destination_textures, &color_conversion_params.destination_color);
 
     gsr_color_conversion color_conversion;
     if(gsr_color_conversion_init(&color_conversion, &color_conversion_params) != 0) {
@@ -3219,6 +3396,8 @@ int main(int argc, char **argv) {
 
     gsr_color_conversion_clear(&color_conversion);
 
+    gsr_color_conversion *output_color_conversion = plugins.num_plugins > 0 ? &plugins.color_conversion : &color_conversion;
+
     if(arg_parser.video_encoder == GSR_VIDEO_ENCODER_HW_CPU) {
         open_video_software(video_codec_context, arg_parser);
     } else {
@@ -3373,7 +3552,7 @@ int main(int argc, char **argv) {
                 while(running) {
                     void *sound_buffer;
                     int sound_buffer_size = -1;
-                    //const double time_before_read_seconds = clock_get_monotonic_seconds();
+                    const double time_before_read_seconds = clock_get_monotonic_seconds();
                     if(audio_device.sound_device.handle) {
                         // TODO: use this instead of calculating time to read. But this can fluctuate and we dont want to go back in time,
                         // also it's 0.0 for some users???
@@ -3383,8 +3562,6 @@ int main(int argc, char **argv) {
 
                     const bool got_audio_data = sound_buffer_size >= 0;
                     //fprintf(stderr, "got audio data: %s\n", got_audio_data ? "yes" : "no");
-                    //const double time_after_read_seconds = clock_get_monotonic_seconds();
-                    //const double time_to_read_seconds = time_after_read_seconds - time_before_read_seconds;
                     //fprintf(stderr, "time to read: %f, %s, %f\n", time_to_read_seconds, got_audio_data ? "yes" : "no", timeout_sec);
                     const double this_audio_frame_time = clock_get_monotonic_seconds() - paused_time_offset;
 
@@ -3453,10 +3630,9 @@ int main(int argc, char **argv) {
                         }
                     }
 
-                    if(!audio_device.sound_device.handle)
+                    if(!audio_device.sound_device.handle) {
                         av_usleep(timeout_ms * 1000);
-
-                    if(got_audio_data) {
+                    } else if(got_audio_data) {
                         // TODO: Instead of converting audio, get float audio from alsa. Or does alsa do conversion internally to get this format?
                         if(needs_audio_conversion)
                             swr_convert(swr, &audio_device.frame->data[0], audio_track.codec_context->frame_size, (const uint8_t**)&sound_buffer, audio_track.codec_context->frame_size);
@@ -3484,6 +3660,13 @@ int main(int argc, char **argv) {
 
                         audio_device.frame->pts += audio_track.codec_context->frame_size;
                         num_received_frames++;
+                    } else {
+                        // TODO: Maybe sleep for time_to_sleep_until_next_frame/4? for better latency
+                        const double time_after_read_seconds = clock_get_monotonic_seconds();
+                        const double time_to_read_seconds = time_after_read_seconds - time_before_read_seconds;
+                        const double time_to_sleep_until_next_frame = timeout_sec - time_to_read_seconds;
+                        if(time_to_sleep_until_next_frame > 0.0)
+                            av_usleep(time_to_sleep_until_next_frame * 1000ULL * 1000ULL);
                     }
                 }
 
@@ -3535,19 +3718,20 @@ int main(int argc, char **argv) {
     bool hdr_metadata_set = false;
     const bool hdr = video_codec_is_hdr(arg_parser.video_codec);
 
-    double damage_timeout_seconds = arg_parser.framerate_mode == GSR_FRAMERATE_MODE_CONTENT ? 0.5 : 0.1;
-    damage_timeout_seconds = std::max(damage_timeout_seconds, target_fps);
-
     bool use_damage_tracking = false;
     gsr_damage damage;
     memset(&damage, 0, sizeof(damage));
-    if(gsr_window_get_display_server(window) == GSR_DISPLAY_SERVER_X11) {
-        gsr_damage_init(&damage, &egl, arg_parser.record_cursor);
-        use_damage_tracking = true;
-    }
+    if(arg_parser.framerate_mode == GSR_FRAMERATE_MODE_CONTENT) {
+        if(gsr_window_get_display_server(window) == GSR_DISPLAY_SERVER_X11) {
+            gsr_damage_init(&damage, &egl, arg_parser.record_cursor);
+            use_damage_tracking = true;
+        } else if(!capture->is_damaged) {
+            fprintf(stderr, "gsr warning: \"-fm content\" has no effect on Wayland when recording a monitor. Either record a monitor on X11 or capture with desktop portal instead (-w portal)\n");
+        }
 
-    if(is_monitor_capture)
-        gsr_damage_set_target_monitor(&damage, arg_parser.window);
+        if(is_monitor_capture)
+            gsr_damage_set_target_monitor(&damage, arg_parser.window);
+    }
 
     while(running) {
         while(gsr_window_process_event(window)) {
@@ -3621,7 +3805,15 @@ int main(int argc, char **argv) {
                 }
             }
 
-            gsr_capture_capture(capture, &capture_metadata, &color_conversion);
+            gsr_capture_capture(capture, &capture_metadata, output_color_conversion);
+
+            if(plugins.num_plugins > 0) {
+                gsr_plugins_draw(&plugins);
+                gsr_color_conversion_draw(&color_conversion, plugins.texture,
+                    {0, 0}, {capture_metadata.video_width, capture_metadata.video_height},
+                    {0, 0}, {capture_metadata.video_width, capture_metadata.video_height},
+                    {capture_metadata.video_width, capture_metadata.video_height}, GSR_ROT_0, GSR_SOURCE_COLOR_RGB, false);
+            }
 
             if(capture_has_synchronous_task) {
                 paused_time_offset = paused_time_offset + (clock_get_monotonic_seconds() - paused_time_start);
@@ -3629,7 +3821,7 @@ int main(int argc, char **argv) {
             }
 
             gsr_egl_swap_buffers(&egl);
-            gsr_video_encoder_copy_textures_to_frame(video_encoder, video_frame, &color_conversion);
+            gsr_video_encoder_copy_textures_to_frame(video_encoder, video_frame, output_color_conversion);
 
             if(hdr && !hdr_metadata_set && !is_replaying && add_hdr_metadata_to_video_stream(capture, video_stream))
                 hdr_metadata_set = true;
@@ -3796,6 +3988,8 @@ int main(int argc, char **argv) {
         }
     }
 
+    gsr_plugins_deinit(&plugins);
+
     if(replay_recording_start_result.av_format_context) {
         for(size_t id : replay_recording_items) {
             gsr_encoder_remove_recording_destination(&encoder, id);

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

@@ -21,6 +21,29 @@
 #define SPA_POD_PROP_FLAG_DONT_FIXATE (1 << 4)
 #endif
 
+#if !PW_CHECK_VERSION(0, 3, 62)
+enum spa_meta_videotransform_value {
+    SPA_META_TRANSFORMATION_None = 0,    /**< no transform */
+    SPA_META_TRANSFORMATION_90,          /**< 90 degree counter-clockwise */
+    SPA_META_TRANSFORMATION_180,         /**< 180 degree counter-clockwise */
+    SPA_META_TRANSFORMATION_270,         /**< 270 degree counter-clockwise */
+    SPA_META_TRANSFORMATION_Flipped,     /**< 180 degree flipped around the vertical axis. Equivalent
+                                           * to a reflexion through the vertical line splitting the
+                                           * buffer in two equal sized parts */
+    SPA_META_TRANSFORMATION_Flipped90,   /**< flip then rotate around 90 degree counter-clockwise */
+    SPA_META_TRANSFORMATION_Flipped180,  /**< flip then rotate around 180 degree counter-clockwise */
+    SPA_META_TRANSFORMATION_Flipped270,  /**< flip then rotate around 270 degree counter-clockwise */
+};
+
+/** a transformation of the buffer */
+struct spa_meta_videotransform {
+    uint32_t transform;                  /**< orientation transformation that was applied to the buffer,
+                                           *  one of enum spa_meta_videotransform_value */
+};
+
+#define SPA_META_VideoTransform 8
+#endif
+
 #define CURSOR_META_SIZE(width, height)                                    \
     (sizeof(struct spa_meta_cursor) + sizeof(struct spa_meta_bitmap) + \
      width * height * 4)
@@ -93,8 +116,6 @@ static const struct pw_core_events core_events = {
 
 static void on_process_cb(void *user_data) {
     gsr_pipewire_video *self = user_data;
-    struct spa_meta_cursor *cursor = NULL;
-    //struct spa_meta *video_damage = NULL;
 
     /* Find the most recent buffer */
     struct pw_buffer *pw_buf = NULL;
@@ -114,12 +135,11 @@ 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;
-    if(!has_buffer)
-        goto read_metadata;
 
     pthread_mutex_lock(&self->mutex);
 
-    if(buffer->datas[0].type == SPA_DATA_DmaBuf) {
+    bool buffer_updated = false;
+    if(has_buffer && buffer->datas[0].type == SPA_DATA_DmaBuf) {
         for(size_t i = 0; i < self->dmabuf_num_planes; ++i) {
             if(self->dmabuf_data[i].fd > 0) {
                 close(self->dmabuf_data[i].fd);
@@ -137,9 +157,7 @@ static void on_process_cb(void *user_data) {
             self->dmabuf_data[i].stride = buffer->datas[i].chunk->stride;
         }
 
-        self->damaged = true;
-    } else {
-        // TODO:
+        buffer_updated = true;
     }
 
     // TODO: Move down to read_metadata
@@ -157,32 +175,51 @@ static void on_process_cb(void *user_data) {
         self->crop.valid = false;
     }
 
-    pthread_mutex_unlock(&self->mutex);
+    struct spa_meta_videotransform *video_transform = spa_buffer_find_meta_data(buffer, SPA_META_VideoTransform, sizeof(*video_transform));
+    enum spa_meta_videotransform_value transform = SPA_META_TRANSFORMATION_None;
+    if(video_transform)
+        transform = video_transform->transform;
 
-read_metadata:
+    self->rotation = GSR_MONITOR_ROT_0;
+    switch(transform) {
+        case SPA_META_TRANSFORMATION_90:
+            self->rotation = GSR_MONITOR_ROT_90;
+            break;
+        case SPA_META_TRANSFORMATION_180:
+            self->rotation = GSR_MONITOR_ROT_180;
+            break;
+        case SPA_META_TRANSFORMATION_270:
+            self->rotation = GSR_MONITOR_ROT_270;
+            break;
+        default:
+            // TODO: Support other rotations. Wayland compositors dont use them yet so it's ok to not support it now
+            break;
+    }
 
-    // video_damage = spa_buffer_find_meta(buffer, SPA_META_VideoDamage);
-    // if(video_damage) {
-    //     struct spa_meta_region *r = spa_meta_first(video_damage);
-    //     if(spa_meta_check(r, video_damage)) {
-    //         //fprintf(stderr, "damage: %d,%d %ux%u\n", r->region.position.x, r->region.position.y, r->region.size.width, r->region.size.height);
-    //         pthread_mutex_lock(&self->mutex);
-    //         self->damaged = true;
-    //         pthread_mutex_unlock(&self->mutex);
-    //     }
-    // }
+    const struct spa_meta *video_damage = spa_buffer_find_meta(buffer, SPA_META_VideoDamage);
+    if(video_damage) {
+        struct spa_meta_region *meta_region = NULL;
+        spa_meta_for_each(meta_region, video_damage) {
+            if(meta_region->region.size.width == 0 || meta_region->region.size.height == 0)
+                continue;
 
-    cursor = spa_buffer_find_meta_data(buffer, SPA_META_Cursor, sizeof(*cursor));
+            self->damaged = true;
+            break;
+        }
+    } else if(buffer_updated) {
+        self->damaged = true;
+    }
+
+    const struct spa_meta_cursor *cursor = spa_buffer_find_meta_data(buffer, SPA_META_Cursor, sizeof(*cursor));
     self->cursor.valid = cursor && spa_meta_cursor_is_valid(cursor);
     
     if (self->cursor.visible && self->cursor.valid) {
-        pthread_mutex_lock(&self->mutex);
-
         struct spa_meta_bitmap *bitmap = NULL;
         if (cursor->bitmap_offset)
             bitmap = SPA_MEMBER(cursor, cursor->bitmap_offset, struct spa_meta_bitmap);
 
-        if (bitmap && bitmap->size.width > 0 && bitmap->size.height && is_cursor_format_supported(bitmap->format)) {
+        // TODO: Maybe check if the cursor is actually visible by checking if there are visible pixels
+        if (bitmap && bitmap->size.width > 0 && bitmap->size.height > 0 && is_cursor_format_supported(bitmap->format)) {
             const uint8_t *bitmap_data = SPA_MEMBER(bitmap, bitmap->offset, uint8_t);
             fprintf(stderr, "gsr info: pipewire: cursor bitmap update, size: %dx%d, format: %s\n",
                 (int)bitmap->size.width, (int)bitmap->size.height, spa_debug_type_find_name(spa_type_video_format, bitmap->format));
@@ -199,15 +236,19 @@ read_metadata:
             self->cursor.hotspot_y = cursor->hotspot.y;
             self->cursor.width = bitmap->size.width;
             self->cursor.height = bitmap->size.height;
+            self->damaged = true;
         }
 
+        if(cursor->position.x != self->cursor.x || cursor->position.y != self->cursor.y)
+            self->damaged = true;
+
         self->cursor.x = cursor->position.x;
         self->cursor.y = cursor->position.y;
-        pthread_mutex_unlock(&self->mutex);
 
         //fprintf(stderr, "gsr info: pipewire: cursor: %d %d %d %d\n", cursor->hotspot.x, cursor->hotspot.y, cursor->position.x, cursor->position.y);
     }
 
+    pthread_mutex_unlock(&self->mutex);
     pw_stream_queue_buffer(self->stream, pw_buf);
 }
 
@@ -239,24 +280,26 @@ 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);
     }
 
     fprintf(stderr, "gsr info: pipewire:    Size: %dx%d\n", self->format.info.raw.size.width, self->format.info.raw.size.height);
     fprintf(stderr, "gsr info: pipewire:    Framerate: %d/%d\n", self->format.info.raw.framerate.num, self->format.info.raw.framerate.denom);
 
-    uint8_t params_buffer[1024];
+    uint8_t params_buffer[2048];
     struct spa_pod_builder pod_builder = SPA_POD_BUILDER_INIT(params_buffer, sizeof(params_buffer));
-    const struct spa_pod *params[4];
+    const struct spa_pod *params[5];
+    int param_index = 0;
 
-    params[0] = spa_pod_builder_add_object(
+    params[param_index++] = spa_pod_builder_add_object(
         &pod_builder, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
         SPA_PARAM_META_type, SPA_POD_Id(SPA_META_VideoCrop),
         SPA_PARAM_META_size,
         SPA_POD_Int(sizeof(struct spa_meta_region)));
 
-    params[1] = spa_pod_builder_add_object(
+    params[param_index++] = spa_pod_builder_add_object(
         &pod_builder, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
         SPA_PARAM_META_type, SPA_POD_Id(SPA_META_VideoDamage),
         SPA_PARAM_META_size, SPA_POD_CHOICE_RANGE_Int(
@@ -264,7 +307,7 @@ static void on_param_changed_cb(void *user_data, uint32_t id, const struct spa_p
                                 sizeof(struct spa_meta_region) * 1,
                                 sizeof(struct spa_meta_region) * 16));
 
-    params[2] = spa_pod_builder_add_object(
+    params[param_index++] = spa_pod_builder_add_object(
         &pod_builder, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
         SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Cursor),
         SPA_PARAM_META_size,
@@ -272,11 +315,22 @@ static void on_param_changed_cb(void *user_data, uint32_t id, const struct spa_p
                      CURSOR_META_SIZE(1, 1),
                      CURSOR_META_SIZE(1024, 1024)));
 
-    params[3] = spa_pod_builder_add_object(
+    params[param_index++] = spa_pod_builder_add_object(
         &pod_builder, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
         SPA_PARAM_BUFFERS_dataType, SPA_POD_Int(buffer_types));
 
-    pw_stream_update_params(self->stream, params, 4);
+#if PW_CHECK_VERSION(0, 3, 62)
+	if (check_pw_version(&self->server_version, 0, 3, 62)) {
+		/* Video transformation */
+		params[param_index++] = spa_pod_builder_add_object(&pod_builder, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
+								SPA_PARAM_META_type,
+								SPA_POD_Id(SPA_META_VideoTransform),
+								SPA_PARAM_META_size,
+								SPA_POD_Int(sizeof(struct spa_meta_videotransform)));
+	}
+#endif
+
+    pw_stream_update_params(self->stream, params, param_index);
     self->negotiated = true;
 }
 
@@ -358,8 +412,8 @@ static int64_t spa_video_format_to_drm_format(const enum spa_video_format format
         case SPA_VIDEO_FORMAT_BGRA:       return DRM_FORMAT_ARGB8888;
         case SPA_VIDEO_FORMAT_RGB:        return DRM_FORMAT_XBGR8888;
         case SPA_VIDEO_FORMAT_BGR:        return DRM_FORMAT_XRGB8888;
-        case SPA_VIDEO_FORMAT_ARGB:       return DRM_FORMAT_BGRA8888;
-        case SPA_VIDEO_FORMAT_ABGR:       return DRM_FORMAT_RGBA8888;
+        //case SPA_VIDEO_FORMAT_ARGB:       return DRM_FORMAT_BGRA8888;
+        //case SPA_VIDEO_FORMAT_ABGR:       return DRM_FORMAT_RGBA8888;
 #if PW_CHECK_VERSION(0, 3, 41)
         case SPA_VIDEO_FORMAT_xRGB_210LE: return DRM_FORMAT_XRGB2101010;
         case SPA_VIDEO_FORMAT_xBGR_210LE: return DRM_FORMAT_XBGR2101010;
@@ -374,7 +428,7 @@ static int64_t spa_video_format_to_drm_format(const enum spa_video_format format
 #if PW_CHECK_VERSION(0, 3, 41)
 #define GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS GSR_PIPEWIRE_VIDEO_MAX_VIDEO_FORMATS
 #else
-#define GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS 8
+#define GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS 6
 #endif
 
 static const enum spa_video_format video_formats[GSR_PIPEWIRE_VIDEO_MAX_VIDEO_FORMATS] = {
@@ -382,16 +436,16 @@ static const enum spa_video_format video_formats[GSR_PIPEWIRE_VIDEO_MAX_VIDEO_FO
     SPA_VIDEO_FORMAT_BGR,
     SPA_VIDEO_FORMAT_RGBx,
     SPA_VIDEO_FORMAT_RGB,
+    SPA_VIDEO_FORMAT_RGBA,
+    SPA_VIDEO_FORMAT_BGRA,
+    //SPA_VIDEO_FORMAT_ARGB,
+    //SPA_VIDEO_FORMAT_ABGR,
 #if PW_CHECK_VERSION(0, 3, 41)
     SPA_VIDEO_FORMAT_xRGB_210LE,
     SPA_VIDEO_FORMAT_xBGR_210LE,
     SPA_VIDEO_FORMAT_ARGB_210LE,
     SPA_VIDEO_FORMAT_ABGR_210LE,
 #endif
-    SPA_VIDEO_FORMAT_RGBA,
-    SPA_VIDEO_FORMAT_BGRA,
-    SPA_VIDEO_FORMAT_ARGB,
-    SPA_VIDEO_FORMAT_ABGR,
 };
 
 static bool gsr_pipewire_video_build_format_params(gsr_pipewire_video *self, struct spa_pod_builder *pod_builder, struct spa_pod **params, uint32_t *num_params) {
@@ -683,7 +737,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);
@@ -730,21 +783,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");
                 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);
             }
@@ -790,14 +842,15 @@ static void gsr_pipewire_video_update_cursor_texture(gsr_pipewire_video *self, g
     self->cursor.data = NULL;
 }
 
-bool gsr_pipewire_video_map_texture(gsr_pipewire_video *self, gsr_texture_map texture_map, gsr_pipewire_video_region *region, gsr_pipewire_video_region *cursor_region, gsr_pipewire_video_dmabuf_data *dmabuf_data, int *num_dmabuf_data, uint32_t *fourcc, uint64_t *modifiers, bool *using_external_image) {
+bool gsr_pipewire_video_map_texture(gsr_pipewire_video *self, gsr_texture_map texture_map, gsr_map_texture_output *output) {
     for(int i = 0; i < GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES; ++i) {
-        memset(&dmabuf_data[i], 0, sizeof(gsr_pipewire_video_dmabuf_data));
+        memset(&output->dmabuf_data[i], 0, sizeof(gsr_pipewire_video_dmabuf_data));
     }
-    *num_dmabuf_data = 0;
-    *using_external_image = self->external_texture_fallback;
-    *fourcc = 0;
-    *modifiers = 0;
+    output->num_dmabuf_data = 0;
+    output->using_external_image = self->external_texture_fallback;
+    output->fourcc = 0;
+    output->modifiers = 0;
+    output->rotation = GSR_MONITOR_ROT_0;
     pthread_mutex_lock(&self->mutex);
 
     if(!self->negotiated || self->dmabuf_data[0].fd <= 0) {
@@ -812,39 +865,50 @@ bool gsr_pipewire_video_map_texture(gsr_pipewire_video *self, gsr_texture_map te
     }
 
     gsr_pipewire_video_bind_image_to_texture_with_fallback(self, texture_map, image);
-    *using_external_image = self->external_texture_fallback;
+    output->using_external_image = self->external_texture_fallback;
     self->egl->eglDestroyImage(self->egl->egl_display, image);
 
     gsr_pipewire_video_update_cursor_texture(self, texture_map);
 
-    region->x = 0;
-    region->y = 0;
+    output->texture_width = self->format.info.raw.size.width;
+    output->texture_height = self->format.info.raw.size.height;
 
-    region->width = self->format.info.raw.size.width;
-    region->height = self->format.info.raw.size.height;
+    output->region.x = 0;
+    output->region.y = 0;
+
+    output->region.width = self->format.info.raw.size.width;
+    output->region.height = self->format.info.raw.size.height;
 
     if(self->crop.valid) {
-        region->x = self->crop.x;
-        region->y = self->crop.y;
+        output->region.x = self->crop.x;
+        output->region.y = self->crop.y;
 
-        region->width = self->crop.width;
-        region->height = self->crop.height;
+        output->region.width = self->crop.width;
+        output->region.height = self->crop.height;
+    }
+
+    // TODO: Test transform + cropping
+    if(self->rotation == GSR_MONITOR_ROT_90 || self->rotation == GSR_MONITOR_ROT_270) {
+        const int temp = output->region.width;
+        output->region.width = output->region.height;
+        output->region.height = temp;
     }
 
     /* TODO: Test if cursor hotspot is correct */
-    cursor_region->x = self->cursor.x - self->cursor.hotspot_x;
-    cursor_region->y = self->cursor.y - self->cursor.hotspot_y;
+    output->cursor_region.x = self->cursor.x - self->cursor.hotspot_x;
+    output->cursor_region.y = self->cursor.y - self->cursor.hotspot_y;
 
-    cursor_region->width = self->cursor.width;
-    cursor_region->height = self->cursor.height;
+    output->cursor_region.width = self->cursor.width;
+    output->cursor_region.height = self->cursor.height;
 
     for(size_t i = 0; i < self->dmabuf_num_planes; ++i) {
-        dmabuf_data[i] = self->dmabuf_data[i];
+        output->dmabuf_data[i] = self->dmabuf_data[i];
         self->dmabuf_data[i].fd = -1;
     }
-    *num_dmabuf_data = self->dmabuf_num_planes;
-    *fourcc = spa_video_format_to_drm_format(self->format.info.raw.format);
-    *modifiers = self->format.info.raw.modifier;
+    output->num_dmabuf_data = self->dmabuf_num_planes;
+    output->fourcc = spa_video_format_to_drm_format(self->format.info.raw.format);
+    output->modifiers = self->format.info.raw.modifier;
+    output->rotation = self->rotation;
     self->dmabuf_num_planes = 0;
 
     pthread_mutex_unlock(&self->mutex);

src/plugins.c

@@ -0,0 +1,138 @@
+#include "../include/plugins.h"
+#include "../include/utils.h"
+#include <stdio.h>
+#include <string.h>
+#include <dlfcn.h>
+#include <assert.h>
+
+static int color_depth_to_gl_internal_format(gsr_plugin_color_depth color_depth) {
+    switch(color_depth) {
+        case GSR_PLUGIN_COLOR_DEPTH_8_BITS:
+            return GL_RGBA8;
+        case GSR_PLUGIN_COLOR_DEPTH_10_BITS:
+            return GL_RGBA16;
+    }
+    assert(false);
+    return GL_RGBA8;
+}
+
+bool gsr_plugins_init(gsr_plugins *self, gsr_plugin_init_params init_params, gsr_egl *egl) {
+    memset(self, 0, sizeof(*self));
+    self->init_params = init_params;
+    self->egl = egl;
+
+    /* TODO: GL_RGB8? */
+    const unsigned int texture = gl_create_texture(egl, init_params.width, init_params.height, color_depth_to_gl_internal_format(init_params.color_depth), GL_RGBA, GL_LINEAR);
+    if(texture == 0) {
+        fprintf(stderr, "gsr error: gsr_plugins_init failed to create texture\n");
+        return false;
+    }
+    self->texture = texture;
+
+    gsr_color_conversion_params color_conversion_params = {
+        .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,
+        //.force_graphics_shader = false,
+    };
+    color_conversion_params.destination_textures[0] = self->texture;
+
+    if(gsr_color_conversion_init(&self->color_conversion, &color_conversion_params) != 0) {
+        fprintf(stderr, "gsr error: gsr_plugins_init failed to create color conversion\n");
+        gsr_plugins_deinit(self);
+        return false;
+    }
+    gsr_color_conversion_clear(&self->color_conversion);
+
+    return true;
+}
+
+void gsr_plugins_deinit(gsr_plugins *self) {
+    for(int i = self->num_plugins - 1; i >= 0; --i) {
+        gsr_plugin *plugin = &self->plugins[i];
+        plugin->gsr_plugin_deinit(plugin->data.userdata);
+        fprintf(stderr, "gsr info: unloaded plugin: %s\n", plugin->data.name);
+    }
+    self->num_plugins = 0;
+
+    if(self->texture > 0) {
+        self->egl->glDeleteTextures(1, &self->texture);
+        self->texture = 0;
+    }
+
+    gsr_color_conversion_deinit(&self->color_conversion);
+}
+
+bool gsr_plugins_load_plugin(gsr_plugins *self, const char *plugin_filepath) {
+    if(self->num_plugins >= GSR_MAX_PLUGINS) {
+        fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed, more plugins can't load more than %d plugins. Report this as an issue\n", GSR_MAX_PLUGINS);
+        return false;
+    }
+
+    gsr_plugin plugin;
+    memset(&plugin, 0, sizeof(plugin));
+
+    plugin.lib = dlopen(plugin_filepath, RTLD_LAZY);
+    if(!plugin.lib) {
+        fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed to load \"%s\", error: %s\n", plugin_filepath, dlerror());
+        return false;
+    }
+
+    plugin.gsr_plugin_init = dlsym(plugin.lib, "gsr_plugin_init");
+    if(!plugin.gsr_plugin_init) {
+        fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed to find \"gsr_plugin_init\" in plugin \"%s\"\n", plugin_filepath);
+        goto fail;
+    }
+
+    plugin.gsr_plugin_deinit = dlsym(plugin.lib, "gsr_plugin_deinit");
+    if(!plugin.gsr_plugin_deinit) {
+        fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed to find \"gsr_plugin_deinit\" in plugin \"%s\"\n", plugin_filepath);
+        goto fail;
+    }
+
+    if(!plugin.gsr_plugin_init(&self->init_params, &plugin.data)) {
+        fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed to load plugin \"%s\", gsr_plugin_init in the plugin failed\n", plugin_filepath);
+        goto fail;
+    }
+
+    if(!plugin.data.name) {
+        fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed to load plugin \"%s\", the plugin didn't set the name (gsr_plugin_init_return.name)\n", plugin_filepath);
+        goto fail;
+    }
+
+    if(plugin.data.version == 0) {
+        fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed to load plugin \"%s\", the plugin didn't set the version (gsr_plugin_init_return.version)\n", plugin_filepath);
+        goto fail;
+    }
+
+    fprintf(stderr, "gsr info: loaded plugin: %s, name: %s, version: %u\n", plugin_filepath, plugin.data.name, plugin.data.version);
+    self->plugins[self->num_plugins] = plugin;
+    ++self->num_plugins;
+    return true;
+
+    fail:
+    dlclose(plugin.lib);
+    return false;
+}
+
+void gsr_plugins_draw(gsr_plugins *self) {
+    const gsr_plugin_draw_params params = {
+        .width = self->init_params.width,
+        .height = self->init_params.height,
+    };
+
+    self->egl->glBindFramebuffer(GL_FRAMEBUFFER, self->color_conversion.framebuffers[0]);
+    self->egl->glViewport(0, 0, self->init_params.width, self->init_params.height);
+
+    for(int i = 0; i < self->num_plugins; ++i) {
+        const gsr_plugin *plugin = &self->plugins[i];
+        if(plugin->data.draw)
+            plugin->data.draw(&params, plugin->data.userdata);
+    }
+
+    self->egl->glBindFramebuffer(GL_FRAMEBUFFER, 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

@@ -189,7 +189,7 @@ static pa_handle* pa_sound_device_new(const char *server,
     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 +206,17 @@ static pa_handle* pa_sound_device_new(const char *server,
     p->output_length = buffer_size;
     p->output_index = 0;
 
+    pa_proplist *proplist = pa_proplist_new();
+    pa_proplist_sets(proplist, PA_PROP_MEDIA_ROLE, "production");
+    if(strcmp(device_name, "") == 0) {
+        pa_proplist_sets(proplist, "node.autoconnect", "false");
+        pa_proplist_sets(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), name, proplist)))
         goto fail;
 
     if (pa_context_connect(p->context, server, PA_CONTEXT_NOFLAGS, NULL) < 0) {
@@ -239,12 +246,14 @@ static pa_handle* pa_sound_device_new(const char *server,
     if(pa)
         pa_operation_unref(pa);
 
+    pa_proplist_free(proplist);
     return p;
 
 fail:
     if (rerror)
         *rerror = error;
     pa_sound_device_free(p);
+    pa_proplist_free(proplist);
     return NULL;
 }
 
@@ -283,20 +292,6 @@ static bool pa_sound_device_handle_reconnect(pa_handle *p, char *device_name, si
         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);
-    }
-
     std::lock_guard<std::mutex> lock(p->reconnect_mutex);
     p->reconnect = false;
     return true;
@@ -317,6 +312,10 @@ static int pa_sound_device_read(pa_handle *p, double timeout_seconds) {
     if(!pa_sound_device_handle_reconnect(p, device_name, sizeof(device_name), start_time))
         goto fail;
 
+    pa_mainloop_iterate(p->mainloop, 0, NULL);
+    if(pa_stream_get_state(p->stream) != PA_STREAM_READY)
+        goto fail;
+
     CHECK_DEAD_GOTO(p, rerror, fail);
 
     while (p->output_index < p->output_length) {
@@ -410,7 +409,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 +423,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

@@ -148,6 +148,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;
 }
@@ -285,13 +287,9 @@ typedef struct {
     bool match_found;
 } get_monitor_by_connector_id_userdata;
 
-static bool vec2i_eql(vec2i a, vec2i b) {
-    return a.x == b.x && a.y == b.y;
-}
-
-static void get_monitor_by_name_and_size_callback(const gsr_monitor *monitor, void *userdata) {
+static void get_monitor_by_name_wayland_callback(const gsr_monitor *monitor, void *userdata) {
     get_monitor_by_connector_id_userdata *data = (get_monitor_by_connector_id_userdata*)userdata;
-    if(monitor->name && data->monitor->name && strcmp(monitor->name, data->monitor->name) == 0 && vec2i_eql(monitor->size, data->monitor->size)) {
+    if(monitor->name && data->monitor->name && strcmp(monitor->name, data->monitor->name) == 0) {
         data->rotation = monitor->rotation;
         data->position = monitor->pos;
         data->match_found = true;
@@ -320,7 +318,7 @@ bool drm_monitor_get_display_server_data(const gsr_window *window, const gsr_mon
             userdata.rotation = GSR_MONITOR_ROT_0;
             userdata.position = (vec2i){0, 0};
             userdata.match_found = false;
-            gsr_window_for_each_active_monitor_output_cached(window, get_monitor_by_name_and_size_callback, &userdata);
+            gsr_window_for_each_active_monitor_output_cached(window, get_monitor_by_name_wayland_callback, &userdata);
             if(userdata.match_found) {
                 *monitor_rotation = userdata.rotation;
                 *monitor_position = userdata.position;
@@ -610,3 +608,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_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;