public/gpu-screen-recorder
1
0
Fork 0
mirror of https://repo.dec05eba.com/gpu-screen-recorder synced 2026-04-22 01:37:23 +09:00
Code Issues Actions Packages Projects Releases Wiki Activity

Compare commits

base: public:5.11.3
Branches Tags
public:master
public:5.13.1 public:5.13.0 public:5.12.5 public:5.12.4 public:5.12.3 public:5.12.2 public:5.12.1 public:5.12.0 public:5.11.5 public:5.11.4 public:5.11.3 public:5.11.2 public:5.11.1 public:5.11.0 public:5.10.2 public:5.10.1 public:5.10.0 public:5.9.4 public:5.9.3 public:5.9.2 public:5.9.1 public:5.9.0 public:5.8.2 public:5.8.1 public:5.8.0 public:5.7.4 public:5.7.3 public:5.7.2 public:5.7.1 public:5.7.0 public:5.6.8 public:5.6.7 public:5.6.6 public:5.6.5 public:5.6.4 public:5.6.3 public:5.6.2 public:5.6.1 public:5.6.0 public:5.5.10 public:5.5.9 public:5.5.8 public:5.5.7 public:5.5.6 public:5.5.5 public:5.5.4 public:5.5.3 public:5.5.2 public:5.5.1 public:5.5.0 public:5.4.1 public:5.4.0 public:5.3.8 public:5.3.7 public:5.3.6 public:5.3.5 public:5.3.4 public:5.3.3 public:5.3.2 public:5.3.1 public:5.3.0 public:5.2.3 public:5.2.2 public:5.2.1 public:5.2.0 public:5.1.3 public:5.1.2 public:5.1.1 public:5.1.0 public:5.0.3 public:5.0.2 public:5.0.1 public:5.0.0 public:4.3.5 public:4.3.4 public:4.3.3 public:4.3.2 public:4.3.1 public:4.3.0 public:4.2.6 public:4.2.5 public:4.2.4 public:4.2.3 public:4.2.2 public:4.2.1 public:4.2.0 public:4.1.11
..
compare: public:master
Branches Tags
public:master
public:5.13.1 public:5.13.0 public:5.12.5 public:5.12.4 public:5.12.3 public:5.12.2 public:5.12.1 public:5.12.0 public:5.11.5 public:5.11.4 public:5.11.3 public:5.11.2 public:5.11.1 public:5.11.0 public:5.10.2 public:5.10.1 public:5.10.0 public:5.9.4 public:5.9.3 public:5.9.2 public:5.9.1 public:5.9.0 public:5.8.2 public:5.8.1 public:5.8.0 public:5.7.4 public:5.7.3 public:5.7.2 public:5.7.1 public:5.7.0 public:5.6.8 public:5.6.7 public:5.6.6 public:5.6.5 public:5.6.4 public:5.6.3 public:5.6.2 public:5.6.1 public:5.6.0 public:5.5.10 public:5.5.9 public:5.5.8 public:5.5.7 public:5.5.6 public:5.5.5 public:5.5.4 public:5.5.3 public:5.5.2 public:5.5.1 public:5.5.0 public:5.4.1 public:5.4.0 public:5.3.8 public:5.3.7 public:5.3.6 public:5.3.5 public:5.3.4 public:5.3.3 public:5.3.2 public:5.3.1 public:5.3.0 public:5.2.3 public:5.2.2 public:5.2.1 public:5.2.0 public:5.1.3 public:5.1.2 public:5.1.1 public:5.1.0 public:5.0.3 public:5.0.2 public:5.0.1 public:5.0.0 public:4.3.5 public:4.3.4 public:4.3.3 public:4.3.2 public:4.3.1 public:4.3.0 public:4.2.6 public:4.2.5 public:4.2.4 public:4.2.3 public:4.2.2 public:4.2.1 public:4.2.0 public:4.1.11

58 Commits
5.11.3 ... master

Author SHA1 Message Date
dec05eba
1e1da80d74 Make sure the first frame is pts 0 2026-04-21 18:16:06 +02:00
dec05eba
9a6b345bac Fix kms capture crash when no monitor is available 2026-04-21 16:42:36 +02:00
dec05eba
eea9c307cd Add info about cuda and vulkan video 2026-04-20 01:26:15 +02:00
dec05eba
ac15027657 5.13.1 2026-04-19 00:49:02 +02:00
dec05eba
5d03193f29 Fix compile error with old vulkan header: ifdef check vulkan video encoding 2026-04-19 00:42:00 +02:00
dec05eba
2f4a906b78 5.13.0 2026-04-17 01:13:57 +02:00
dec05eba
3e6bc0224a v4l2: skip resolutions that we cant import with eglCreateImage for yuyv 2026-04-17 01:10:27 +02:00
dec05eba
286158a838 Implement vulkan video capture (h264, hevc and av1) 2026-04-17 00:56:22 +02:00
dec05eba
8b953e95d8 wip 2026-04-16 00:01:18 +02:00
dec05eba
4ed04830c1 Add void linux to README, update pkill command 2026-03-18 15:39:41 +01:00
dec05eba
755340454d Poll reset revents 2026-03-11 11:32:45 +01:00
dec05eba
2f8212b122 5.12.5 2026-03-02 00:00:38 +01:00
dec05eba
23782889be Minor check 2026-03-01 23:52:59 +01:00
dec05eba
fd08cdb9b4 pipewire video: fail video map texture if state is not streaming 
Fixes portal capture failing on some systems
 2026-03-01 19:30:17 +01:00
dec05eba
6079a0162d Portal capture: test disable modifier recheck same 2026-03-01 18:12:00 +01:00
dec05eba
eff5d619eb Fix incorrect manpage 2026-02-25 01:08:05 +01:00
dec05eba
309c4e5f2e Update info about reporting bugs in the manpage, move gpu-screen-recorder.env to ~/.config/gpu-screen-recorder but keep old path as well 2026-02-23 23:15:09 +01:00
dec05eba
0555cfde58 FAQ browser av1 2026-02-19 22:29:55 +01:00
p0358
ff030ba63f don't show microphone indicator on KDE 2026-02-19 20:04:55 +01:00
dec05eba
0de75e5b7e 5.12.4 2026-02-12 01:24:26 +01:00
dec05eba
c79fb1e5c9 pipewire-video: do correct removal of modifier 2026-02-12 01:07:48 +01:00
eonphi
4a4af85b6d attempt EGLImage without modifiers when last failed 2026-02-12 00:41:21 +01:00
dec05eba
8f7608e7ee Add --list-monitors option to list only monitors, refactor 2026-02-09 15:03:10 +01:00
dec05eba
f3235ed1bf Improve manpage 2026-02-09 13:59:18 +01:00
dec05eba
3666bba518 aur -> official repo 2026-02-06 19:02:23 +01:00
dec05eba
5d8d14eeaf FAQ vlc 2026-02-04 01:43:27 +01:00
dec05eba
57caf13d65 5.12.3 2026-01-28 01:39:09 +01:00
dec05eba
bdf1950ca2 Dont use dbus_bus_request_name 2026-01-28 01:37:50 +01:00
Victor Nova
144b481526 Add -write-first-frame-ts switch 
Add -write-first-frame-ts switch that creates a .ts file next to the output
file with values from CLOCK_MONOTONIC and CLOCK_REALTIME corresponding to the
first frame to be able to synchronize video with other timestamped data.
 2026-01-27 17:43:41 +01:00
dec05eba
f4ee71a094 Remove fixed TODO 2026-01-26 15:18:26 +01:00
dec05eba
2dce92d82f Use constant bitrate mode in example scripts 2026-01-25 03:16:56 +01:00
Mroik
933911bdde Install example scripts and add fix man example 2026-01-25 03:08:15 +01:00
dec05eba
01d0df500c Revert "Test dont set environment variables" 
This reverts commit 95415f7ac7.
 2026-01-24 15:41:31 +01:00
dec05eba
95415f7ac7 Test dont set environment variables 2026-01-24 15:19:31 +01:00
dec05eba
a39dad1c02 Remove capture source property clamp, cleanup manpage 2026-01-23 01:39:49 +01:00
dec05eba
c1af143406 5.12.2 2026-01-23 00:41:44 +01:00
dec05eba
4cebc3f0ee Fix negative relative position not working (incorrectly clamped to 0, 100) 2026-01-23 00:10:11 +01:00
dec05eba
f6013d094d Lock around get packet data 2026-01-21 18:29:41 +01:00
dec05eba
45daccff84 Clone replay buffer immediately, only one short mutex lock 2026-01-21 17:29:03 +01:00
dec05eba
ede1e46503 Fix possible replay race condition, move mutex out of replay 2026-01-21 02:24:30 +01:00
dec05eba
6b37b82f97 5.12.1 2026-01-20 18:46:22 +01:00
dec05eba
19add54c0c Make sure logical_size isn't 0 on gamescope 2026-01-20 14:39:11 +01:00
dec05eba
a44e119c43 Print correct regions when region is invalid 2026-01-20 13:56:52 +01:00
dec05eba
054282bafe Wayland region: fix incorrect region captured if monitor is scaled 2026-01-20 13:32:42 +01:00
dec05eba
1e7fe1fec1 5.12.0 2026-01-18 01:17:54 +01:00
dec05eba
d2f449bd73 v4l2: prefer yuyv over mjpeg if all other factors are equal 2026-01-15 23:02:36 +01:00
dec05eba
91f48ce332 Ignore scalar sizes that aren't 100% for video size calculation 2026-01-15 20:52:28 +01:00
dec05eba
f4d061eee7 Add -low-power option to allow prevent the gpu to go into a high power mode on amd, useful for replay running 24/7 2026-01-15 20:38:53 +01:00
dec05eba
8af761f9bd v4l2: select best camera option by default 
Display all camera options in --info and --list-v4l2-devices.
Add camera_width, camera_height and camera_fps v4l2 capture options.
 2026-01-15 20:03:23 +01:00
dec05eba
b2f0d13512 kms capture: fix incorrect framebuffer capture size on steam deck on kde plasma wayland 2026-01-13 01:24:44 +01:00
dec05eba
6cbf660afa 5.11.5 2026-01-08 01:23:55 +01:00
dec05eba
827751cc55 Correctly reconnect default audio device when changing it on the system 2026-01-08 01:23:55 +01:00
dec05eba
a4b3be3786 Fix application audio node getting recreated by pipewire after suspended (idle) for 30 seconds 2026-01-08 00:53:30 +01:00
dec05eba
240ccf569c debug output 2026-01-07 19:37:37 +01:00
dec05eba
88d356386b Test audio 2026-01-07 19:35:03 +01:00
dec05eba
c4104e18cc Test audio node leak fix 2026-01-07 01:35:30 +01:00
dec05eba
640e377c90 5.11.4 2026-01-06 19:53:09 +01:00
dec05eba
2545db7e50 Fix incorrect padding when amd gpu doesn't support padding fix for hevc 2026-01-06 19:52:56 +01:00
40 changed files with 2145 additions and 819 deletions
Expand all files Collapse all files

37
README.md
View File

@@ -29,14 +29,14 @@ Supported image formats:
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 an Arch Linux based distro then you can find gpu screen recorder in the official repositories under the name gpu-screen-recorder (`sudo pacman -S gpu-screen-recorder`).\
If you are running another distro then you can run `sudo ./install.sh`, but you need to manually install the dependencies, as described below.\
You can also install gpu screen recorder ([the 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 --system com.dec05eba.gpu_screen_recorder`).
## Unofficial install methods
The only official ways to install GPU Screen Recorder is either from source, AUR or flathub. Other sources may be out of date and missing features or may not work correctly.\
The only official ways to install GPU Screen Recorder is either from source, arch linux extra repository or flathub. Other sources may be out of date and missing features or may not work correctly.\
If you install GPU Screen Recorder from somewhere else and have an issue then try installing it from one of the official sources before reporting it as an issue.\
If you still prefer to install GPU Screen Recorder with a package manager instead of from source or as a flatpak then you may be able to find a package for your distro.\
Here are some known unofficial packages:
@@ -48,6 +48,7 @@ Here are some known unofficial packages:
* Solus: [gpu-screen-recorder](https://github.com/getsolus/packages/tree/main/packages/g/gpu-screen-recorder)
* Nobara: [Nobara wiki](https://wiki.nobaraproject.org/en/general-usage/additional-software/GPU-Screen-Recorder)
* AppImage [AppImage GitHub releases](https://github.com/pkgforge-dev/gpu-screen-recorder-AppImage/releases)
* Void Linux: [gpu-screen-recorder](https://voidlinux.org/packages/?arch=x86_64&q=gpu-screen-recorder) (Make sure to read the README in the package)
# Dependencies
GPU Screen Recorder uses meson build system so you need to install `meson` to build GPU Screen Recorder.
@@ -91,12 +92,12 @@ There are also additional dependencies needed at runtime depending on your GPU v
* xnvctrl (libxnvctrl0, when using the `-oc` option)
# How to use
Run `gpu-screen-recorder --help` to see all options and also examples.\
Run `gpu-screen-recorder --help` to see all options and run `man gpu-screen-recorder` to see more detailed explanations for the options and also examples.\
There is also a gui for the gpu screen recorder called [GPU Screen Recorder GTK](https://git.dec05eba.com/gpu-screen-recorder-gtk/).\
There is also a new alternative UI for GPU Screen Recorder in the style of ShadowPlay called [GPU Screen Recorder UI](https://git.dec05eba.com/gpu-screen-recorder-ui/).
## Recording
Here is an example of how to record your monitor and the default audio output: `gpu-screen-recorder -w screen -f 60 -a default_output -o ~/Videos/test_video.mp4`.
Yyou can stop and save the recording with `Ctrl+C` or by running `pkill -SIGINT -f gpu-screen-recorder`.
Yyou can stop and save the recording with `Ctrl+C` or by running `pkill -SIGINT -f "^gpu-screen-recorder"`.
You can see a list of capture options to record if you run `gpu-screen-recorder --list-capture-options`. This will list possible capture options and monitor names, for example:\
```
window
@@ -122,12 +123,12 @@ GPU Screen Recorder uses Ffmpeg so GPU Screen Recorder supports all protocols th
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 (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.\
To start/stop (and save) recording use the SIGRTMIN signal, for example `pkill -SIGRTMIN -f "^gpu-screen-recorder"`. The path to the video will be displayed in stdout when saving the video.\
This way of recording while using replay/streaming is more efficient than running GPU Screen Recorder multiple times since this way it only records the screen and encodes the video once.
## Controlling GPU Screen Recorder remotely
To save a video in replay mode, you need to send signal SIGUSR1 to gpu screen recorder. You can do this by running `pkill -SIGUSR1 -f gpu-screen-recorder`.\
To stop recording send SIGINT to gpu screen recorder. You can do this by running `pkill -SIGINT -f gpu-screen-recorder` or pressing `Ctrl-C` in the terminal that runs gpu screen recorder. When recording a regular non-replay video this will also save the video.\
To pause/unpause recording send SIGUSR2 to gpu screen recorder. You can do this by running `pkill -SIGUSR2 -f gpu-screen-recorder`. This is only applicable and useful when recording (not streaming nor replay).\
To save a video in replay mode, you need to send signal SIGUSR1 to gpu screen recorder. You can do this by running `pkill -SIGUSR1 -f "^gpu-screen-recorder"`.\
To stop recording send SIGINT to gpu screen recorder. You can do this by running `pkill -SIGINT -f "^gpu-screen-recorder"` or pressing `Ctrl-C` in the terminal that runs gpu screen recorder. When recording a regular non-replay video this will also save the video.\
To pause/unpause recording send SIGUSR2 to gpu screen recorder. You can do this by running `pkill -SIGUSR2 -f "^gpu-screen-recorder"`. This is only applicable and useful when recording (not streaming nor replay).\
There are more signals to control GPU Screen Recorder. Run `gpu-screen-recorder --help` to list them all (under `NOTES` section).
## Simple way to run replay without gui
Run the script `scripts/start-replay.sh` to start replay and then `scripts/save-replay.sh` to save a replay and `scripts/stop-replay.sh` to stop the replay. The videos are saved to `$HOME/Videos`.
@@ -135,7 +136,7 @@ You can use these scripts to start replay at system startup if you add `scripts/
hotkey settings on your system and choose a hotkey to run the script `scripts/save-replay.sh`. Modify `scripts/start-replay.sh` if you want to use other replay options.
## Run replay on system startup
If you installed GPU Screen Recorder from AUR or from source and you are running a distro that uses systemd then you will have a systemd service installed that can be started with `systemctl enable --now --user gpu-screen-recorder`. This systemd service runs GPU Screen Recorder on system startup.\
It's configured with `$HOME/.config/gpu-screen-recorder.env` (create it if it doesn't exist). You can look at [extra/gpu-screen-recorder.env](https://git.dec05eba.com/gpu-screen-recorder/plain/extra/gpu-screen-recorder.env) to see an example.
It's configured with `$HOME/.config/gpu-screen-recorder/gpu-screen-recorder.env` (create it if it doesn't exist). You can look at [extra/gpu-screen-recorder.env](https://git.dec05eba.com/gpu-screen-recorder/plain/extra/gpu-screen-recorder.env) to see an example.
You can see which variables that you can use in the `gpu-screen-recorder.env` file by looking at the `extra/gpu-screen-recorder.service` file. Note that all of the variables are optional, you only have to set the ones that are you interested in.
You can use the `scripts/save-replay.sh` script to save a replay and by default the systemd service saves videos in `$HOME/Videos`.
## Run a script when a video is saved
@@ -164,16 +165,20 @@ GPU Screen Recorder has much better performance than OBS Studio even with versio
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!
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.
This issue doesn't happen with vulkan video encoding so you may have better performance in games when recording with vulkan video.
You can use vulkan video encoding by adding `_vulkan` at the end of the video codec option, for example: `-k h264_vulkan` or a full command example: `gpu-screen-recorder -w screen -k h264_vulkan -o video.mp4`.
Vulkan video encoding in GPU Screen Recorder supports `h264`, `hevc` and `av1` (along with `hdr` and `10bit` options), assuming your gpu drivers, ffmpeg and vulkan is up to date.
Note: vulkan video encoding support is experimental and you may experience GPU Screen Recorder or gpu driver bugs with it.
# 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.
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.
Note: this issue doesn't happen when you using the vulkan video encoding option (for example when using `-k h264_vulkan`).
## 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.
@@ -209,7 +214,7 @@ Newer ffmpeg versions don't support older nvidia cards. Try installing GPU Scree
## I get a black screen/glitches while live streaming
It seems like ffmpeg earlier than version 6.1 has some type of bug. Install ffmpeg version 6.1 or later and then reinstall GPU Screen Recorder to fix this issue. The flatpak version of GPU Screen Recorder comes with a newer version of ffmpeg so no extra steps are needed.
## I can't play the video in my browser directly or in discord
Browsers and discord don't support hevc video codec at the moment. Choose h264 video codec instead with the -k h264 option.
Browsers and discord don't support hevc video codec at the moment. You can instead choose h264 video codec with the -k h264 option or av1 video codec with the -k av1 option.
Note that websites such as youtube support hevc so there is no need to choose h264 video codec if you intend to upload the video to youtube or if you want to play the video locally or if you intend to
edit the video with a video editor. Hevc allows for better video quality (especially at lower file sizes) so hevc (or av1) is recommended for source videos.
## I get a black bar/distorted colors on the sides in the video
@@ -261,3 +266,5 @@ If the root user is disabled on your system then you can instead record with `-w
## GPU usage is high on my laptop
GPU usage on battery powered devices is misleading. For example Intel iGPUs has multiple performance levels and the GPU usage reported on the system is the GPU usage at the current performance level.
The performance level changes depending on the GPU load, so it may say that GPU usage is 80%, but the actual GPU usage may be 5%.
## The video is too dark when capturing full-range video or 10-bit video
This is an issue in some broken video players such as vlc. Play the video with a video player such as mpv (or a mpv frontend such as celluloid) or a browser instead.

33
TODO
View File

@@ -312,10 +312,6 @@ Check if region capture works properly with fractional scaling on wayland.
Add option to specify medium/high/very high/ultra for -bm cbr as well, which should automatically pick bitrate based on resolution and framerate.
This should also be reflected in gsr ui.
Create a manpage and move --help text there and mention the manpage command to view it (and make it work in flatpak, maybe with man <link-to-manpage-file>).
Implement webcam support by using mjpeg with v4l2 and use ffmpeg mjpeg decoder.
After adding rpc, making recording while in replay/streaming work differently. Start recording should take audio as an argument, to optionally specify different audio for recording than replay/stream.
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.
@@ -392,4 +388,31 @@ Close pipewire links or maybe there are file descriptor leaks?
Make multiple capture sources work properly in regards to size. The size of the video should be the region size of each capture source.
--
Support hdr camera capture.
Return the max resolution of each codec in --info to display an error in the UI before capture starts. Right now its fine since the UI will report bad resolution after capture starts and fails but it doesn't say what the max resolution is.
Should -low-power option also use vaapi/vulkan low power, if available?
Should capture option x=bla;y=bla be scaled by -s (output resolution scale)? width and height is.
Add option to capture all monitors automatically.
Make -w optional, to only capture audio.
Use GL_RGBA16F or GL_RGBA32F for hdr, that allows color values to be outside the 0.0 to 1.0 range.
https://registry.khronos.org/EGL/extensions/EXT/EGL_EXT_surface_SMPTE2086_metadata.txt
Doesn't work: sibs run --args -w "/dev/video0;camera_width=800;camera_height=600;pixfmt=yuyv" -fm content -o video.mp4
Delay adding audio data until 1 frames time has passed.
Allow av1 in the flatpak. Do that by patching ffmpeg to support multiple nvenc codepaths by using header versions, the same way gsr does in the nvenc query.
Increase qp on av1 non-nvidia, decrease qp on h264 nvidia. For vulkan.
Check if the vulkan codec query works on nvidia x11.
Fix webcam capture on nvidia x11. It doesn't work when capturing a webcam at the same time as capturing the monitor (nvfbc) because nvfbc requires glx context active (in older nvfbc version, works with egl in newer version)
while v4l2 requires egl. All other capture methods require egl so they cant be used together with nvfbc.

1
extra/gpu-screen-recorder.service
View File

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

147
gpu-screen-recorder.1
View File

@@ -14,13 +14,17 @@ gpu-screen-recorder \- The fastest screen recording tool for Linux
|
.B \-\-version
|
.B \-\-info
|
.B \-\-list\-capture\-options
|
.B \-\-list\-monitors
|
.B \-\-list\-v4l2\-devices
|
.B \-\-list\-audio\-devices
|
.B \-\-list\-application\-audio
|
.B \-\-info
.SH DESCRIPTION
.B gpu-screen-recorder
is the fastest screen recording tool for Linux. It uses the GPU
@@ -92,31 +96,27 @@ Run
.B \-\-list\-capture\-options
to list available capture sources.
.PP
Run
.B \-\-list\-v4l2\-devices
to list available camera devices (V4L2).
.PP
Additional options can be passed to each capture source by splitting capture source with
.B ;
for example
.BR "screen;x=50;y=50".
.br
These are the available options for capture sources:
These are the available options for all capture sources (optional):
.RS
.IP \(bu 3
.B x
- The X position in pixels. If the number ends with % and is a number between 0 and 100 then it's a position relative to the video size
- The X position in pixels. If the number ends with % then this sets the X position relative to the video width (integer percentage where 100 = 100%)
.IP \(bu 3
.B y
- The Y position in pixels. If the number ends with % and is a number between 0 and 100 then it's a position relative to the video size
- The Y position in pixels. If the number ends with % then this sets the Y position relative to the video height (integer percentage where 100 = 100%)
.IP \(bu 3
.B width
- The width in pixels. If the number ends with % and is a number between 0 and 100 then it's a size relative to the video size.
- The width in pixels. If the number ends with % then this sets the width relative to the video width (integer percentage where 100 = 100%).
A value of 0 means to not scale the capture source and instead use the original width.
.IP \(bu 3
.B height
- The height in pixels. If the number ends with % and is a number between 0 and 100 then it's a size relative to the video size
- The height in pixels. If the number ends with % then this sets the height relative to the video height (integer percentage where 100 = 100%).
A value of 0 means to not scale the capture source and instead use the original height.
.IP \(bu 3
@@ -129,9 +129,9 @@ or
Set to
.B center
by default, except for camera (V4L2) when capturing the camera above something else in which case this is set to
by default when using one capture source, otherwise it's set to
.B start
by default
by default.
.IP \(bu 3
.B valign
- The vertical alignment, should be either
@@ -142,9 +142,9 @@ or
Set to
.B center
by default, except for camera (V4L2) when capturing the camera above something else in which case this is set to
.B end
by default
by default when using one capture source, otherwise it's set to
.B start
by default.
.IP \(bu 3
.B hflip
- If the source should be flipped horizontally, should be either
@@ -163,9 +163,13 @@ or
Set to
.B false
by default
.RE
.PP
These are the additional options available for camera (V4L2) sources (optional):
.RS
.IP \(bu 3
.B pixfmt
- The pixel format for cameras (V4L2), should be either
- The pixel format, should be either
.BR "auto",
.B yuyv
or
@@ -173,12 +177,39 @@ or
Set to
.B auto
by default
.IP \(bu 3
.B camera_fps
- The camera fps. Has to match a camera fps returned in
.B --info
or
.B --list-v4l2-devices
for the device.
A value of 0 means to use the best option available.
.IP \(bu 3
.B camera_width
- The camera width in pixels. Has to match a camera width returned in
.B --info
or
.B --list-v4l2-devices
for the device.
A value of 0 means to use the best option available.
.IP \(bu 3
.B camera_height
- The camera height in pixels. Has to match a camera height returned in
.B --info
or
.B --list-v4l2-devices
for the device.
A value of 0 means to use the best option available.
.RE
.TP
.BI \-region " WxH+X+Y"
Specify region to capture when using
.BR \-w " region."
Format is width x height + X offset + Y offset. Use 0x0 for full monitor.
Format is width x height + X offset + Y offset. Set width and height to 0 to capture the whole monitor that contains the position.
It is compatible with tools such as slop (X11) and slurp (Wayland).
.TP
@@ -243,19 +274,28 @@ Audio bitrate in kbps (default: 128 for opus/flac, 160 for aac). 0 = automatic.
.TP
.BI \-k " codec"
Video codec:
.BR auto ", " h264 ", " hevc ", " av1 ", " vp8 ", " vp9 ", " hevc_hdr ", " av1_hdr ", " hevc_10bit ", " av1_10bit
(default: auto → h264). HDR options not available on X11 or portal capture.
.BR auto ", " h264 ", " hevc ", " av1 ", " vp8 ", " vp9 ", " hevc_hdr ", " av1_hdr ", " hevc_10bit ", " av1_10bit ", " h264_vulkan ", " hevc_vulkan ", " hevc_10bit_vulkan ", " av1_vulkan ", " av1_hdr_vulkan ", " av1_10bit_vulkan
10-bit capture reduces banding but may not be supported properly by all video players.
HDR options not available on X11 or portal capture. 10-bit capture reduces banding but may not be supported properly by all video players.
.br
Vulkan codec options are experimental. They may not work properly on your system because of GPU driver issues.
.br
Using vulkan codecs may result in better gaming performance, especially on NVIDIA as it doesn't suffer from an issue known as "cuda p2 state"
.br
where the GPU gets downclocked when using nvenc (regular video codecs on NVIDIA).
(default: auto → h264).
.TP
.BI \-q " quality"
Quality preset (medium, high, very_high, ultra) for QP/VBR mode, or bitrate (kbps) for CBR mode (default: very_high).
.TP
.BI \-bm " auto|qp|vbr|cbr"
Bitrate mode (default: auto → qp). CBR recommended for replay buffer.
Bitrate mode (default: auto → qp). CBR recommended for replay buffer and live streaming.
QP means to capture with constant quality, even in motion, while VBR and CBR means to capture with constant size.
.TP
.BI \-fm " cfr|vfr|content"
Frame rate mode: constant, variable, or match content (default: vfr). Content mode only on X11 or portal.
Frame rate mode: cfr (constant), vfr (variable), or content (match content) (default: vfr). Content mode is only available on X11 or portal.
Content mode syncs video to the captured content and is recommended for smoothest video when the game is running
at the same frame rate or lower than what you are trying to record at.
@@ -327,6 +367,28 @@ OpenGL debug output (default: no).
.TP
.BI \-v " yes|no"
Print FPS and damage info (default: yes).
.TP
.BI \-low-power " yes|no"
Run in low power mode. This currently has only an affect on AMD (as it's only an issue on AMD) and allows the GPU to go into a lower power mode when recording (default: no).
.br
Setting this to
.B yes
might not always be ideal because of AMD driver issues where after playing a video with VAAPI on the system the video encoding performance
also reduces, which affects GPU Screen Recorder.
.br
It's recommended to also use the option
.B -fm content
when this is set to
.B yes
to only encode frames when the screen content updates to lower GPU and video encoding usage when the system is idle.
.TP
.BI \-write\-first\-frame\-ts " yes|no"
When enabled, writes a timestamp file with extra extension \fI.ts\fR next to the output video containing:
.nf
monotonic_microsec realtime_microsec
<monotonic_microsec> <realtime_microsec>
.fi
(default: no). Ignored for live streaming and when output is piped.
.SS Output Options
.TP
.BI \-o " output"
@@ -348,6 +410,9 @@ Show system info (codecs, capture options).
.B \-\-list\-capture\-options
List available capture sources (window, monitors, portal, v4l2 device path).
.TP
.B \-\-list\-monitors
List available monitors.
.TP
.B \-\-list\-v4l2\-devices
List available cameras devices (V4L2).
.TP
@@ -392,7 +457,7 @@ Save last 30 minutes (replay mode).
Use
.B pkill
to send signals (e.g.,
.BR "pkill -SIGUSR1 -f gpu-screen-recorder" ).
.BR "pkill -SIGUSR1 -f ""^gpu-screen-recorder""" ).
.SH EXAMPLES
Record monitor at 60 FPS with desktop audio:
.PP
@@ -422,7 +487,7 @@ Instant replay (last 60 seconds):
.PP
.nf
.RS
gpu-screen-recorder -w screen -f 60 -c mkv -r 60 -o ~/Videos
gpu-screen-recorder -w screen -c mkv -r 60 -o ~/Videos
.RE
.fi
.PP
@@ -446,15 +511,15 @@ Instant replay and launch a script when saving replay:
.PP
.nf
.RS
gpu-screen-recorder -w screen -f 60 -c mkv -r 60 -sc ./script.sh -o ~/Videos
gpu-screen-recorder -w screen -c mkv -r 60 -sc ./script.sh -o ~/Videos
.RE
.fi
.PP
Stream to Twitch:
Stream to Twitch with constant bitrate mode:
.PP
.nf
.RS
gpu-screen-recorder -w screen -f 60 -a default_output -o "rtmp://live.twitch.tv/app/stream_key"
gpu-screen-recorder -w screen -c flv -a default_output -bm cbr -q 8000 -o "rtmp://live.twitch.tv/app/stream_key"
.RE
.fi
.PP
@@ -474,16 +539,24 @@ gpu-screen-recorder -w "screen|/dev/video0" -o video.mp4
.PP
.RE
.fi
Record screen and camera. The camera is located at the bottom right flipped horizontally:
Record screen and camera. The camera is located at the bottom right and flipped horizontally:
.PP
.nf
.RS
gpu-screen-recorder -w "monitor:screen|v4l2:/dev/video0;halign=end;valign=end;hflip=true" -o video.mp4
gpu-screen-recorder -w "screen|/dev/video0;halign=end;valign=end;hflip=true;width=30%;height=30%" -o video.mp4
.PP
.RE
.fi
Record two monitors, side by side (assuming the first monitor has a resolution of 1920x1080)
.PP
.nf
.RS
gpu-screen-recorder -w "DP-1|DP-2;x=1920" -o video.mp4
.RE
.fi
.SH FILES
.TP
.I ~/.config/gpu-screen-recorder.env
.I ~/.config/gpu-screen-recorder/gpu-screen-recorder.env
Environment variables for systemd service (optional).
.TP
.I /usr/lib/modprobe.d/gsr-nvidia.conf
@@ -515,7 +588,7 @@ Close other screen recorders (including idle OBS)
.IP \(bu 3
NVIDIA: CUDA breaks after suspend (install gsr-nvidia.conf fix)
.IP \(bu 3
AMD: Possible black bars colors with HEVC/AV1 (use H264 or FFmpeg >=8)
AMD: Possible black bars in output video with HEVC/AV1 (use H264 or FFmpeg >=8)
.SH SEE ALSO
.UR https://git.dec05eba.com/gpu-screen-recorder
Project homepage
@@ -540,8 +613,16 @@ ShadowPlay-style UI
Developed by dec05eba and contributors.
.SH COPYRIGHT
Copyright © dec05eba. Licensed under GPL3-only.
.SH BUGS
.SH REPORTING BUGS
Report bugs at
.UR mailto:dec05eba@protonmail.com
dec05eba@protonmail.com
.UE .
.UR https://git.dec05eba.com/?p=about
See more information about reporting bugs at the gpu-screen-recorder website
.UE .
.br
.UR https://git.dec05eba.com/gpu-screen-recorder/about/
Before reporting a bug or an issue, please take a look at FAQ part of the README
.UE .
The bug or issue may have been previously reported or may not be related to gpu-screen-recorder.

5
include/args_parser.h
View File

@@ -8,7 +8,7 @@
typedef struct gsr_egl gsr_egl;
#define NUM_ARGS 35
#define NUM_ARGS 37
typedef enum {
GSR_CAPTURE_SOURCE_TYPE_WINDOW,
@@ -63,6 +63,7 @@ typedef struct {
void (*list_application_audio)(void *userdata);
void (*list_v4l2_devices)(void *userdata);
void (*list_capture_options)(const char *card_path, void *userdata);
void (*list_monitors)(void *userdata);
} args_handlers;
typedef struct {
@@ -91,11 +92,13 @@ typedef struct {
bool verbose;
bool gl_debug;
bool fallback_cpu_encoding;
bool low_power;
bool record_cursor;
bool date_folders;
bool restore_portal_session;
bool restart_replay_on_save;
bool overclock;
bool write_first_frame_ts;
bool is_livestream;
bool is_output_piped;
bool low_latency_recording;

24
include/capture/v4l2.h
View File

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

2
include/codec_query/vulkan.h
View File

@@ -3,6 +3,6 @@
#include "codec_query.h"
bool gsr_get_supported_video_codecs_vulkan(gsr_supported_video_codecs *video_codecs, const char *card_path, bool cleanup);
bool gsr_get_supported_video_codecs_vulkan(gsr_supported_video_codecs *video_codecs, const char *card_path, int *device_index_ret, bool cleanup);
#endif /* GSR_CODEC_QUERY_VULKAN_H */

5
include/defs.h
View File

@@ -51,6 +51,11 @@ typedef enum {
GSR_VIDEO_CODEC_VP9,
GSR_VIDEO_CODEC_H264_VULKAN,
GSR_VIDEO_CODEC_HEVC_VULKAN,
GSR_VIDEO_CODEC_HEVC_HDR_VULKAN,
GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN,
GSR_VIDEO_CODEC_AV1_VULKAN,
GSR_VIDEO_CODEC_AV1_HDR_VULKAN,
GSR_VIDEO_CODEC_AV1_10BIT_VULKAN,
} gsr_video_codec;
typedef enum {

7
include/egl.h
View File

@@ -169,6 +169,9 @@ typedef void (*FUNC_glTexStorageMem2DEXT)(unsigned int target, int levels, unsig
typedef void (*FUNC_glBufferStorageMemEXT)(unsigned int target, ssize_t size, unsigned int memory, uint64_t offset);
typedef void (*FUNC_glNamedBufferStorageMemEXT)(unsigned int buffer, ssize_t size, unsigned int memory, uint64_t offset);
typedef void (*FUNC_glMemoryObjectParameterivEXT)(unsigned int memoryObject, unsigned int pname, const int *params);
typedef void (*FUNC_glGenSemaphoresEXT)(int n, unsigned int *semaphores);
typedef void (*FUNC_glImportSemaphoreFdEXT)(unsigned int semaphore, unsigned int handleType, int fd);
typedef void (*FUNC_glSignalSemaphoreEXT)(unsigned int semaphore, unsigned int numBufferBarriers, const unsigned int *buffers, unsigned int numTextureBarriers, const unsigned int *textures, const unsigned int *dstLayouts);
typedef enum {
GSR_GL_CONTEXT_TYPE_EGL,
@@ -195,6 +198,7 @@ struct gsr_egl {
gsr_gpu_info gpu_info;
char card_path[128];
int vulkan_device_index;
int32_t (*eglGetError)(void);
EGLDisplay (*eglGetDisplay)(EGLNativeDisplayType display_id);
@@ -226,6 +230,9 @@ struct gsr_egl {
FUNC_glBufferStorageMemEXT glBufferStorageMemEXT;
FUNC_glNamedBufferStorageMemEXT glNamedBufferStorageMemEXT;
FUNC_glMemoryObjectParameterivEXT glMemoryObjectParameterivEXT;
FUNC_glGenSemaphoresEXT glGenSemaphoresEXT;
FUNC_glImportSemaphoreFdEXT glImportSemaphoreFdEXT;
FUNC_glSignalSemaphoreEXT glSignalSemaphoreEXT;
__GLXextFuncPtr (*glXGetProcAddress)(const unsigned char *procName);
GLXFBConfig* (*glXChooseFBConfig)(Display *dpy, int screen, const int *attribList, int *nitems);

11
include/encoder/encoder.h
View File

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

1
include/pipewire_video.h
View File

@@ -112,6 +112,7 @@ typedef struct {
bool paused;
double paused_start_secs;
bool streaming;
gsr_monitor_rotation rotation;
} gsr_pipewire_video;

7
include/replay_buffer/replay_buffer.h
View File

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

2
include/utils.h
View File

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

1
kms/client/kms_client.c
View File

@@ -378,6 +378,7 @@ int gsr_kms_client_init(gsr_kms_client *self, const char *card_path) {
goto err;
}
}
poll_fd.revents = 0;
}
fprintf(stderr, "gsr info: gsr_kms_client_init: server connected\n");

4
meson.build
View File

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

2
project.conf
View File

@@ -1,7 +1,7 @@
[package]
name = "gpu-screen-recorder"
type = "executable"
version = "5.11.3"
version = "5.13.1"
platforms = ["posix"]
[config]

2
scripts/twitch-stream-local-copy.sh
View File

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

2
scripts/twitch-stream.sh
View File

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

2
scripts/youtube-hls-stream.sh
View File

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

46
src/args_parser.c
View File

@@ -9,7 +9,6 @@
#include <inttypes.h>
#include <limits.h>
#include <assert.h>
#include <errno.h>
#include <libgen.h>
#include <sys/stat.h>
@@ -18,17 +17,24 @@
#endif
static const ArgEnum video_codec_enums[] = {
{ .name = "auto", .value = GSR_VIDEO_CODEC_AUTO },
{ .name = "h264", .value = GSR_VIDEO_CODEC_H264 },
{ .name = "h265", .value = GSR_VIDEO_CODEC_HEVC },
{ .name = "hevc", .value = GSR_VIDEO_CODEC_HEVC },
{ .name = "hevc_hdr", .value = GSR_VIDEO_CODEC_HEVC_HDR },
{ .name = "hevc_10bit", .value = GSR_VIDEO_CODEC_HEVC_10BIT },
{ .name = "av1", .value = GSR_VIDEO_CODEC_AV1 },
{ .name = "av1_hdr", .value = GSR_VIDEO_CODEC_AV1_HDR },
{ .name = "av1_10bit", .value = GSR_VIDEO_CODEC_AV1_10BIT },
{ .name = "vp8", .value = GSR_VIDEO_CODEC_VP8 },
{ .name = "vp9", .value = GSR_VIDEO_CODEC_VP9 },
{ .name = "auto", .value = GSR_VIDEO_CODEC_AUTO },
{ .name = "h264", .value = GSR_VIDEO_CODEC_H264 },
{ .name = "h265", .value = GSR_VIDEO_CODEC_HEVC },
{ .name = "hevc", .value = GSR_VIDEO_CODEC_HEVC },
{ .name = "hevc_hdr", .value = GSR_VIDEO_CODEC_HEVC_HDR },
{ .name = "hevc_10bit", .value = GSR_VIDEO_CODEC_HEVC_10BIT },
{ .name = "av1", .value = GSR_VIDEO_CODEC_AV1 },
{ .name = "av1_hdr", .value = GSR_VIDEO_CODEC_AV1_HDR },
{ .name = "av1_10bit", .value = GSR_VIDEO_CODEC_AV1_10BIT },
{ .name = "vp8", .value = GSR_VIDEO_CODEC_VP8 },
{ .name = "vp9", .value = GSR_VIDEO_CODEC_VP9 },
{ .name = "h264_vulkan", .value = GSR_VIDEO_CODEC_H264_VULKAN },
{ .name = "hevc_vulkan", .value = GSR_VIDEO_CODEC_HEVC_VULKAN },
{ .name = "hevc_hdr_vulkan", .value = GSR_VIDEO_CODEC_HEVC_HDR_VULKAN },
{ .name = "hevc_10bit_vulkan", .value = GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN },
{ .name = "av1_vulkan", .value = GSR_VIDEO_CODEC_AV1_VULKAN },
{ .name = "av1_hdr_vulkan", .value = GSR_VIDEO_CODEC_AV1_HDR_VULKAN },
{ .name = "av1_10bit_vulkan", .value = GSR_VIDEO_CODEC_AV1_10BIT_VULKAN },
};
static const ArgEnum audio_codec_enums[] = {
@@ -197,7 +203,8 @@ static void usage_header(void) {
"[-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>] [-ffmpeg-opts <options>] [--list-capture-options [card_path]] "
"[--list-audio-devices] [--list-application-audio] [--list-v4l2-devices] [-v yes|no] [-gl-debug yes|no] [--version] [-h|--help]\n", program_name);
"[--list-monitors] [--list-audio-devices] [--list-application-audio] [--list-v4l2-devices] [-write-first-frame-ts yes|no] [-low-power yes|no] "
"[-v yes|no] [-gl-debug yes|no] [--version] [-h|--help]\n", program_name);
fflush(stdout);
}
@@ -256,6 +263,8 @@ static bool args_parser_set_values(args_parser *self) {
self->restart_replay_on_save = args_get_boolean_by_key(self->args, NUM_ARGS, "-restart-replay-on-save", false);
self->overclock = args_get_boolean_by_key(self->args, NUM_ARGS, "-oc", false);
self->fallback_cpu_encoding = args_get_boolean_by_key(self->args, NUM_ARGS, "-fallback-cpu-encoding", false);
self->write_first_frame_ts = args_get_boolean_by_key(self->args, NUM_ARGS, "-write-first-frame-ts", false);
self->low_power = args_get_boolean_by_key(self->args, NUM_ARGS, "-low-power", false);
self->audio_bitrate = args_get_i64_by_key(self->args, NUM_ARGS, "-ab", 0);
self->audio_bitrate *= 1000LL;
@@ -432,6 +441,10 @@ static bool args_parser_set_values(args_parser *self) {
self->is_output_piped = strcmp(self->filename, "/dev/stdout") == 0;
self->low_latency_recording = self->is_livestream || self->is_output_piped;
if(self->write_first_frame_ts && (self->is_livestream || self->is_output_piped)) {
fprintf(stderr, "gsr warning: -write-first-frame-ts is ignored for livestreaming or when output is piped\n");
self->write_first_frame_ts = false;
}
self->replay_recording_directory = args_get_value_by_key(self->args, NUM_ARGS, "-ro");
@@ -495,6 +508,11 @@ bool args_parser_parse(args_parser *self, int argc, char **argv, const args_hand
}
}
if(strcmp(argv[1], "--list-monitors") == 0) {
arg_handlers->list_monitors(userdata);
return true;
}
if(argc == 2 && strcmp(argv[1], "--version") == 0) {
arg_handlers->version(userdata);
return true;
@@ -536,6 +554,8 @@ bool args_parser_parse(args_parser *self, int argc, char **argv, const args_hand
self->args[arg_index++] = (Arg){ .key = "-ffmpeg-opts", .optional = true, .list = false, .type = ARG_TYPE_STRING };
self->args[arg_index++] = (Arg){ .key = "-ffmpeg-video-opts", .optional = true, .list = false, .type = ARG_TYPE_STRING };
self->args[arg_index++] = (Arg){ .key = "-ffmpeg-audio-opts", .optional = true, .list = false, .type = ARG_TYPE_STRING };
self->args[arg_index++] = (Arg){ .key = "-write-first-frame-ts", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN };
self->args[arg_index++] = (Arg){ .key = "-low-power", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN };
assert(arg_index == NUM_ARGS);
for(int i = 1; i < argc; i += 2) {

31
src/capture/kms.c
View File

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

301
src/capture/v4l2.c
View File

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

1
src/capture/xcomposite.c
View File

@@ -187,6 +187,7 @@ static void gsr_capture_xcomposite_on_event(gsr_capture *cap, gsr_egl *egl) {
break;
}
case ConfigureNotify: {
// TODO: Use PresentConfigureNotify instead
self->window_pos.x = xev->xconfigure.x;
self->window_pos.y = xev->xconfigure.y;

216
src/codec_query/vulkan.c
View File

@@ -1,11 +1,13 @@
#include "../../include/codec_query/vulkan.h"
#include "../../include/utils.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <xf86drm.h>
#include <dlfcn.h>
#define VK_NO_PROTOTYPES
//#include <vulkan/vulkan.h>
#include <vulkan/vulkan.h>
#define MAX_PHYSICAL_DEVICES 32
@@ -21,15 +23,167 @@ static const char *required_device_extensions[] = {
};
static int num_required_device_extensions = 8;
bool gsr_get_supported_video_codecs_vulkan(gsr_supported_video_codecs *video_codecs, const char *card_path, bool cleanup) {
static void set_h264_max_resolution(PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR, VkPhysicalDevice physical_device, gsr_supported_video_codecs *video_codecs) {
#ifdef VK_KHR_video_encode_h264
const VkVideoEncodeH264ProfileInfoKHR h264_profile = {
.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR,
.pNext = NULL,
.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH
};
const VkVideoProfileInfoKHR video_profile = {
.sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
.pNext = &h264_profile, // Chain the codec-specific profile
.videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR,
.chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR,
.lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR,
.chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR
};
VkVideoEncodeH264CapabilitiesKHR encode_caps = {
.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR,
.pNext = NULL
};
VkVideoCapabilitiesKHR video_caps = {
.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR,
.pNext = &encode_caps
};
if (vkGetPhysicalDeviceVideoCapabilitiesKHR(physical_device, &video_profile, &video_caps) == VK_SUCCESS) {
video_codecs->h264.max_resolution.x = video_caps.maxCodedExtent.width;
video_codecs->h264.max_resolution.y = video_caps.maxCodedExtent.height;
}
#else
(void)vkGetPhysicalDeviceVideoCapabilitiesKHR;
(void)physical_device;
(void)video_codecs;
#endif
}
static void set_hevc_max_resolution(PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR, VkPhysicalDevice physical_device, gsr_supported_video_codecs *video_codecs) {
#ifdef VK_KHR_video_encode_h265
const VkVideoEncodeH265ProfileInfoKHR hevc_profile = {
.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR,
.pNext = NULL,
.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN
};
const VkVideoProfileInfoKHR video_profile = {
.sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
.pNext = &hevc_profile, // Chain the codec-specific profile
.videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR,
.chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR,
.lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR,
.chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR
};
VkVideoEncodeH265CapabilitiesKHR encode_caps = {
.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR,
.pNext = NULL
};
VkVideoCapabilitiesKHR video_caps = {
.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR,
.pNext = &encode_caps
};
if (vkGetPhysicalDeviceVideoCapabilitiesKHR(physical_device, &video_profile, &video_caps) == VK_SUCCESS) {
video_codecs->hevc.max_resolution.x = video_caps.maxCodedExtent.width;
video_codecs->hevc.max_resolution.y = video_caps.maxCodedExtent.height;
video_codecs->hevc_hdr.max_resolution.x = video_caps.maxCodedExtent.width;
video_codecs->hevc_hdr.max_resolution.y = video_caps.maxCodedExtent.height;
video_codecs->hevc_10bit.max_resolution.x = video_caps.maxCodedExtent.width;
video_codecs->hevc_10bit.max_resolution.y = video_caps.maxCodedExtent.height;
}
#else
(void)vkGetPhysicalDeviceVideoCapabilitiesKHR;
(void)physical_device;
(void)video_codecs;
#endif
}
static void set_av1_max_resolution(PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR, VkPhysicalDevice physical_device, gsr_supported_video_codecs *video_codecs) {
#ifdef VK_KHR_video_encode_av1
const VkVideoEncodeAV1ProfileInfoKHR av1_profile = {
.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR,
.pNext = NULL,
.stdProfile = STD_VIDEO_AV1_PROFILE_MAIN
};
const VkVideoProfileInfoKHR video_profile = {
.sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
.pNext = &av1_profile, // Chain the codec-specific profile
.videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR,
.chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR,
.lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR,
.chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR
};
VkVideoEncodeAV1CapabilitiesKHR encode_caps = {
.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR,
.pNext = NULL
};
VkVideoCapabilitiesKHR video_caps = {
.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR,
.pNext = &encode_caps
};
if (vkGetPhysicalDeviceVideoCapabilitiesKHR(physical_device, &video_profile, &video_caps) == VK_SUCCESS) {
video_codecs->av1.max_resolution.x = video_caps.maxCodedExtent.width;
video_codecs->av1.max_resolution.y = video_caps.maxCodedExtent.height;
video_codecs->av1_hdr.max_resolution.x = video_caps.maxCodedExtent.width;
video_codecs->av1_hdr.max_resolution.y = video_caps.maxCodedExtent.height;
video_codecs->av1_10bit.max_resolution.x = video_caps.maxCodedExtent.width;
video_codecs->av1_10bit.max_resolution.y = video_caps.maxCodedExtent.height;
}
#else
(void)vkGetPhysicalDeviceVideoCapabilitiesKHR;
(void)physical_device;
(void)video_codecs;
#endif
}
bool gsr_get_supported_video_codecs_vulkan(gsr_supported_video_codecs *video_codecs, const char *card_path, int *device_index_ret, bool cleanup) {
memset(video_codecs, 0, sizeof(*video_codecs));
#if 0
*device_index_ret = 0;
bool success = false;
void* libvulkan = NULL;
VkInstance instance = NULL;
VkPhysicalDevice physical_devices[MAX_PHYSICAL_DEVICES];
VkDevice device = NULL;
VkExtensionProperties *device_extensions = NULL;
char render_path[128];
if(!gsr_card_path_get_render_path(card_path, render_path)) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: failed to get /dev/dri/renderDXXX file from %s\n", card_path);
return false;
}
libvulkan = dlopen("libvulkan.so.1", RTLD_NOW);
if (!libvulkan) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: failed to load libvulkan.so.1, error: %s\n", dlerror());
return false;
}
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(libvulkan, "vkGetInstanceProcAddr");
if (!vkGetInstanceProcAddr) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: could not find vkGetInstanceProcAddr in libvulkan.so.1\n");
goto done;
}
PFN_vkCreateInstance vkCreateInstance = (PFN_vkCreateInstance)vkGetInstanceProcAddr(NULL, "vkCreateInstance");
if(!vkCreateInstance) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: could not find vkCreateInstance in libvulkan.so.1\n");
goto done;
}
const VkApplicationInfo app_info = {
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
.pApplicationName = "GPU Screen Recorder",
@@ -49,6 +203,26 @@ bool gsr_get_supported_video_codecs_vulkan(gsr_supported_video_codecs *video_cod
goto done;
}
PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = NULL;
PFN_vkDestroyInstance vkDestroyInstance = NULL;
PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = NULL;
PFN_vkCreateDevice vkCreateDevice = NULL;
PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = NULL;
PFN_vkDestroyDevice vkDestroyDevice = NULL;
PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = NULL;
#define LOAD_INST(name) name = (PFN_##name)vkGetInstanceProcAddr(instance, #name); if(!name) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: could not find " #name " in libvulkan.so.1\n"); goto done; }
LOAD_INST(vkEnumeratePhysicalDevices)
LOAD_INST(vkDestroyInstance)
LOAD_INST(vkGetPhysicalDeviceProperties2)
LOAD_INST(vkCreateDevice)
LOAD_INST(vkEnumerateDeviceExtensionProperties)
LOAD_INST(vkDestroyDevice)
LOAD_INST(vkGetPhysicalDeviceVideoCapabilitiesKHR)
#undef LOAD_INST
uint32_t num_devices = 0;
if(vkEnumeratePhysicalDevices(instance, &num_devices, NULL) != VK_SUCCESS) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: vkEnumeratePhysicalDevices (query num devices) failed\n");
@@ -81,12 +255,13 @@ bool gsr_get_supported_video_codecs_vulkan(gsr_supported_video_codecs *video_cod
};
vkGetPhysicalDeviceProperties2(physical_devices[i], &device_properties);
if(!device_drm_properties.hasPrimary)
if(!device_drm_properties.hasRender)
continue;
snprintf(device_card_path, sizeof(device_card_path), DRM_DEV_NAME, DRM_DIR_NAME, (int)device_drm_properties.primaryMinor);
if(strcmp(device_card_path, card_path) == 0) {
snprintf(device_card_path, sizeof(device_card_path), DRM_RENDER_DEV_NAME, DRM_DIR_NAME, (int)device_drm_properties.renderMinor);
if(strcmp(device_card_path, render_path) == 0) {
physical_device = physical_devices[i];
*device_index_ret = i;
break;
}
}
@@ -126,31 +301,36 @@ bool gsr_get_supported_video_codecs_vulkan(gsr_supported_video_codecs *video_cod
for(uint32_t i = 0; i < num_device_extensions; ++i) {
if(strcmp(device_extensions[i].extensionName, "VK_KHR_video_encode_h264") == 0) {
video_codecs->h264 = true;
video_codecs->h264.supported = true;
} else if(strcmp(device_extensions[i].extensionName, "VK_KHR_video_encode_h265") == 0) {
// TODO: Verify if 10bit and hdr are actually supported
video_codecs->hevc = true;
video_codecs->hevc_10bit = true;
video_codecs->hevc_hdr = true;
video_codecs->hevc.supported = true;
video_codecs->hevc_10bit.supported = true;
video_codecs->hevc_hdr.supported = true;
} else if(strcmp(device_extensions[i].extensionName, "VK_KHR_video_encode_av1") == 0) {
// TODO: Verify if 10bit and hdr are actually supported
video_codecs->av1.supported = true;
video_codecs->av1_10bit.supported = true;
video_codecs->av1_hdr.supported = true;
}
}
set_h264_max_resolution(vkGetPhysicalDeviceVideoCapabilitiesKHR, physical_device, video_codecs);
set_hevc_max_resolution(vkGetPhysicalDeviceVideoCapabilitiesKHR, physical_device, video_codecs);
set_av1_max_resolution(vkGetPhysicalDeviceVideoCapabilitiesKHR, physical_device, video_codecs);
success = true;
done:
if(device_extensions)
free(device_extensions);
if(cleanup) {
if(device)
vkDestroyDevice(device, NULL);
if(instance)
vkDestroyInstance(instance, NULL);
}
if(device_extensions)
free(device_extensions);
if(libvulkan)
dlclose(libvulkan);
return success;
#else
// TODO: Low power query
video_codecs->h264 = (gsr_supported_video_codec){ true, false };
video_codecs->hevc = (gsr_supported_video_codec){ true, false };
return true;
#endif
}

16
src/dbus.c
View File

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

52
src/defs.c
View File

@@ -2,10 +2,11 @@
#include <assert.h>
bool video_codec_is_hdr(gsr_video_codec video_codec) {
// TODO: Vulkan
switch(video_codec) {
case GSR_VIDEO_CODEC_HEVC_HDR:
case GSR_VIDEO_CODEC_AV1_HDR:
case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN:
case GSR_VIDEO_CODEC_AV1_HDR_VULKAN:
return true;
default:
return false;
@@ -13,24 +14,30 @@ bool video_codec_is_hdr(gsr_video_codec video_codec) {
}
gsr_video_codec hdr_video_codec_to_sdr_video_codec(gsr_video_codec video_codec) {
// TODO: Vulkan
switch(video_codec) {
case GSR_VIDEO_CODEC_HEVC_HDR:
return GSR_VIDEO_CODEC_HEVC;
case GSR_VIDEO_CODEC_AV1_HDR:
return GSR_VIDEO_CODEC_AV1;
case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN:
return GSR_VIDEO_CODEC_HEVC_VULKAN;
case GSR_VIDEO_CODEC_AV1_HDR_VULKAN:
return GSR_VIDEO_CODEC_AV1_VULKAN;
default:
return video_codec;
}
}
gsr_color_depth video_codec_to_bit_depth(gsr_video_codec video_codec) {
// TODO: 10-bit Vulkan
switch(video_codec) {
case GSR_VIDEO_CODEC_HEVC_HDR:
case GSR_VIDEO_CODEC_HEVC_10BIT:
case GSR_VIDEO_CODEC_AV1_HDR:
case GSR_VIDEO_CODEC_AV1_10BIT:
case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN:
case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN:
case GSR_VIDEO_CODEC_AV1_HDR_VULKAN:
case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN:
return GSR_COLOR_DEPTH_10_BITS;
default:
return GSR_COLOR_DEPTH_8_BITS;
@@ -39,28 +46,34 @@ gsr_color_depth video_codec_to_bit_depth(gsr_video_codec video_codec) {
const char* video_codec_to_string(gsr_video_codec video_codec) {
switch(video_codec) {
case GSR_VIDEO_CODEC_H264: return "h264";
case GSR_VIDEO_CODEC_HEVC: return "hevc";
case GSR_VIDEO_CODEC_HEVC_HDR: return "hevc_hdr";
case GSR_VIDEO_CODEC_HEVC_10BIT: return "hevc_10bit";
case GSR_VIDEO_CODEC_AV1: return "av1";
case GSR_VIDEO_CODEC_AV1_HDR: return "av1_hdr";
case GSR_VIDEO_CODEC_AV1_10BIT: return "av1_10bit";
case GSR_VIDEO_CODEC_VP8: return "vp8";
case GSR_VIDEO_CODEC_VP9: return "vp9";
case GSR_VIDEO_CODEC_H264_VULKAN: return "h264_vulkan";
case GSR_VIDEO_CODEC_HEVC_VULKAN: return "hevc_vulkan";
case GSR_VIDEO_CODEC_H264: return "h264";
case GSR_VIDEO_CODEC_HEVC: return "hevc";
case GSR_VIDEO_CODEC_HEVC_HDR: return "hevc_hdr";
case GSR_VIDEO_CODEC_HEVC_10BIT: return "hevc_10bit";
case GSR_VIDEO_CODEC_AV1: return "av1";
case GSR_VIDEO_CODEC_AV1_HDR: return "av1_hdr";
case GSR_VIDEO_CODEC_AV1_10BIT: return "av1_10bit";
case GSR_VIDEO_CODEC_VP8: return "vp8";
case GSR_VIDEO_CODEC_VP9: return "vp9";
case GSR_VIDEO_CODEC_H264_VULKAN: return "h264_vulkan";
case GSR_VIDEO_CODEC_HEVC_VULKAN: return "hevc_vulkan";
case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN: return "hevc_hdr_vulkan";
case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN: return "hevc_10bit_vulkan";
case GSR_VIDEO_CODEC_AV1_VULKAN: return "av1_vulkan";
case GSR_VIDEO_CODEC_AV1_HDR_VULKAN: return "av1_hdr_vulkan";
case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN: return "av1_10bit_vulkan";
}
return "";
}
// bool video_codec_is_hevc(gsr_video_codec video_codec) {
// // TODO: 10-bit vulkan
// switch(video_codec) {
// case GSR_VIDEO_CODEC_HEVC:
// case GSR_VIDEO_CODEC_HEVC_HDR:
// case GSR_VIDEO_CODEC_HEVC_10BIT:
// case GSR_VIDEO_CODEC_HEVC_VULKAN:
// case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN:
// case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN:
// return true;
// default:
// return false;
@@ -68,11 +81,13 @@ const char* video_codec_to_string(gsr_video_codec video_codec) {
// }
bool video_codec_is_av1(gsr_video_codec video_codec) {
// TODO: Vulkan
switch(video_codec) {
case GSR_VIDEO_CODEC_AV1:
case GSR_VIDEO_CODEC_AV1_HDR:
case GSR_VIDEO_CODEC_AV1_10BIT:
case GSR_VIDEO_CODEC_AV1_VULKAN:
case GSR_VIDEO_CODEC_AV1_HDR_VULKAN:
case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN:
return true;
default:
return false;
@@ -83,6 +98,11 @@ bool video_codec_is_vulkan(gsr_video_codec video_codec) {
switch(video_codec) {
case GSR_VIDEO_CODEC_H264_VULKAN:
case GSR_VIDEO_CODEC_HEVC_VULKAN:
case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN:
case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN:
case GSR_VIDEO_CODEC_AV1_VULKAN:
case GSR_VIDEO_CODEC_AV1_HDR_VULKAN:
case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN:
return true;
default:
return false;

4
src/egl.c
View File

@@ -216,6 +216,10 @@ static bool gsr_egl_proc_load_egl(gsr_egl *self) {
self->glNamedBufferStorageMemEXT = (FUNC_glNamedBufferStorageMemEXT)self->eglGetProcAddress("glNamedBufferStorageMemEXT");
self->glMemoryObjectParameterivEXT = (FUNC_glMemoryObjectParameterivEXT)self->eglGetProcAddress("glMemoryObjectParameterivEXT");
self->glGenSemaphoresEXT = (FUNC_glGenSemaphoresEXT)self->eglGetProcAddress("glGenSemaphoresEXT");
self->glImportSemaphoreFdEXT = (FUNC_glImportSemaphoreFdEXT)self->eglGetProcAddress("glImportSemaphoreFdEXT");
self->glSignalSemaphoreEXT = (FUNC_glSignalSemaphoreEXT)self->eglGetProcAddress("glSignalSemaphoreEXT");
if(!self->eglExportDMABUFImageQueryMESA) {
fprintf(stderr, "gsr error: gsr_egl_load failed: could not find eglExportDMABUFImageQueryMESA\n");
return false;

116
src/encoder/encoder.c
View File

@@ -3,20 +3,56 @@
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <time.h>
#include <errno.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
static uint64_t clock_gettime_microseconds(clockid_t clock_id) {
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 0;
clock_gettime(clock_id, &ts);
return (uint64_t)ts.tv_sec * 1000000ULL + (uint64_t)ts.tv_nsec / 1000ULL;
}
static void gsr_write_first_frame_timestamp_file(const char *filepath) {
const uint64_t evdev_compatible_ts = clock_gettime_microseconds(CLOCK_MONOTONIC);
const uint64_t unix_time_microsec = clock_gettime_microseconds(CLOCK_REALTIME);
FILE *file = fopen(filepath, "w");
if(!file) {
fprintf(stderr, "gsr warning: failed to open timestamp file '%s': %s\n", filepath, strerror(errno));
return;
}
fputs("monotonic_microsec\trealtime_microsec\n", file);
fprintf(file, "%" PRIu64 "\t%" PRIu64 "\n", evdev_compatible_ts, unix_time_microsec);
fclose(file);
}
bool gsr_encoder_init(gsr_encoder *self, gsr_replay_storage replay_storage, size_t replay_buffer_num_packets, double replay_buffer_time, const char *replay_directory) {
memset(self, 0, sizeof(*self));
self->num_recording_destinations = 0;
self->recording_destination_id_counter = 0;
self->first_pts = -1;
if(pthread_mutex_init(&self->file_write_mutex, NULL) != 0) {
fprintf(stderr, "gsr error: gsr_encoder_init: failed to create mutex\n");
gsr_encoder_deinit(self);
return false;
}
self->mutex_created = true;
self->file_write_mutex_created = true;
if(pthread_mutex_init(&self->replay_mutex, NULL) != 0) {
fprintf(stderr, "gsr error: gsr_encoder_init: failed to create mutex\n");
gsr_encoder_deinit(self);
return false;
}
self->replay_mutex_created = true;
if(replay_buffer_num_packets > 0) {
self->replay_buffer = gsr_replay_buffer_create(replay_storage, replay_directory, replay_buffer_time, replay_buffer_num_packets);
@@ -31,18 +67,36 @@ bool gsr_encoder_init(gsr_encoder *self, gsr_replay_storage replay_storage, size
}
void gsr_encoder_deinit(gsr_encoder *self) {
if(self->mutex_created) {
self->mutex_created = false;
if(self->file_write_mutex_created)
pthread_mutex_lock(&self->file_write_mutex);
for(size_t i = 0; i < self->num_recording_destinations; ++i) {
free(self->recording_destinations[i].first_frame_ts_filepath);
self->recording_destinations[i].first_frame_ts_filepath = NULL;
self->recording_destinations[i].first_frame_ts_written = false;
}
if(self->file_write_mutex_created)
pthread_mutex_unlock(&self->file_write_mutex);
if(self->replay_buffer) {
pthread_mutex_lock(&self->replay_mutex);
gsr_replay_buffer_destroy(self->replay_buffer);
self->replay_buffer = NULL;
pthread_mutex_unlock(&self->replay_mutex);
}
if(self->file_write_mutex_created) {
self->file_write_mutex_created = false;
pthread_mutex_destroy(&self->file_write_mutex);
}
if(self->replay_buffer) {
gsr_replay_buffer_destroy(self->replay_buffer);
self->replay_buffer = NULL;
if(self->replay_mutex_created) {
self->replay_mutex_created = false;
pthread_mutex_destroy(&self->replay_mutex);
}
self->num_recording_destinations = 0;
self->recording_destination_id_counter = 0;
self->first_pts = -1;
}
void gsr_encoder_receive_packets(gsr_encoder *self, AVCodecContext *codec_context, int64_t pts, int stream_index) {
@@ -55,14 +109,19 @@ void gsr_encoder_receive_packets(gsr_encoder *self, AVCodecContext *codec_contex
av_packet->size = 0;
int res = avcodec_receive_packet(codec_context, av_packet);
if(res == 0) { // we have a packet, send the packet to the muxer
if(self->first_pts == -1)
self->first_pts = pts;
av_packet->stream_index = stream_index;
av_packet->pts = pts;
av_packet->dts = pts;
av_packet->pts = pts - self->first_pts;
av_packet->dts = av_packet->pts;
if(self->replay_buffer) {
pthread_mutex_lock(&self->replay_mutex);
const double time_now = clock_get_monotonic_seconds();
if(!gsr_replay_buffer_append(self->replay_buffer, av_packet, time_now))
fprintf(stderr, "gsr error: gsr_encoder_receive_packets: failed to add replay buffer data\n");
pthread_mutex_unlock(&self->replay_mutex);
}
pthread_mutex_lock(&self->file_write_mutex);
@@ -77,8 +136,16 @@ void gsr_encoder_receive_packets(gsr_encoder *self, AVCodecContext *codec_contex
else if(!recording_destination->has_received_keyframe)
continue;
av_packet->pts = pts - recording_destination->start_pts;
av_packet->dts = pts - recording_destination->start_pts;
if(recording_destination->first_frame_ts_filepath && !recording_destination->first_frame_ts_written) {
gsr_write_first_frame_timestamp_file(recording_destination->first_frame_ts_filepath);
recording_destination->first_frame_ts_written = true;
}
if(recording_destination->first_pts == -1)
recording_destination->first_pts = pts;
av_packet->pts = (pts - recording_destination->first_pts) - recording_destination->start_pts;
av_packet->dts = av_packet->pts;
av_packet_rescale_ts(av_packet, codec_context->time_base, recording_destination->stream->time_base);
// TODO: Is av_interleaved_write_frame needed?. Answer: might be needed for mkv but dont use it! it causes frames to be inconsistent, skipping frames and duplicating frames.
@@ -130,7 +197,10 @@ size_t gsr_encoder_add_recording_destination(gsr_encoder *self, AVCodecContext *
recording_destination->format_context = format_context;
recording_destination->stream = stream;
recording_destination->start_pts = start_pts;
recording_destination->first_pts = -1;
recording_destination->has_received_keyframe = false;
recording_destination->first_frame_ts_filepath = NULL;
recording_destination->first_frame_ts_written = false;
++self->recording_destination_id_counter;
++self->num_recording_destinations;
@@ -144,6 +214,9 @@ bool gsr_encoder_remove_recording_destination(gsr_encoder *self, size_t id) {
pthread_mutex_lock(&self->file_write_mutex);
for(size_t i = 0; i < self->num_recording_destinations; ++i) {
if(self->recording_destinations[i].id == id) {
free(self->recording_destinations[i].first_frame_ts_filepath);
self->recording_destinations[i].first_frame_ts_filepath = NULL;
self->recording_destinations[i].first_frame_ts_written = false;
self->recording_destinations[i] = self->recording_destinations[self->num_recording_destinations - 1];
--self->num_recording_destinations;
found = true;
@@ -153,3 +226,26 @@ bool gsr_encoder_remove_recording_destination(gsr_encoder *self, size_t id) {
pthread_mutex_unlock(&self->file_write_mutex);
return found;
}
bool gsr_encoder_set_recording_destination_first_frame_ts_filepath(gsr_encoder *self, size_t id, const char *filepath) {
if(!filepath)
return false;
bool found = false;
pthread_mutex_lock(&self->file_write_mutex);
for(size_t i = 0; i < self->num_recording_destinations; ++i) {
if(self->recording_destinations[i].id == id) {
char *filepath_copy = strdup(filepath);
if(!filepath_copy)
break;
free(self->recording_destinations[i].first_frame_ts_filepath);
self->recording_destinations[i].first_frame_ts_filepath = filepath_copy;
self->recording_destinations[i].first_frame_ts_written = false;
found = true;
break;
}
}
pthread_mutex_unlock(&self->file_write_mutex);
return found;
}

4
src/encoder/video/vaapi.c
View File

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

840
src/encoder/video/vulkan.c
View File

@@ -4,29 +4,120 @@
#include <libavcodec/avcodec.h>
#define VK_NO_PROTOTYPES
//#include <libavutil/hwcontext_vulkan.h>
#include <libavutil/hwcontext_vulkan.h>
//#include <vulkan/vulkan_core.h>
#include <vulkan/vulkan_core.h>
#define GL_HANDLE_TYPE_OPAQUE_FD_EXT 0x9586
#define GL_TEXTURE_TILING_EXT 0x9580
#define GL_OPTIMAL_TILING_EXT 0x9584
#define GL_LINEAR_TILING_EXT 0x9585
#define GL_HANDLE_TYPE_OPAQUE_FD_EXT 0x9586
#define GL_TEXTURE_TILING_EXT 0x9580
#define GL_OPTIMAL_TILING_EXT 0x9584
#define GL_LINEAR_TILING_EXT 0x9585
#define GL_DEDICATED_MEMORY_OBJECT_EXT 0x9581
#define GL_LAYOUT_GENERAL_EXT 0x958D
typedef struct {
PFN_vkCreateImage vkCreateImage;
PFN_vkDestroyImage vkDestroyImage;
PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
PFN_vkAllocateMemory vkAllocateMemory;
PFN_vkFreeMemory vkFreeMemory;
PFN_vkBindImageMemory vkBindImageMemory;
PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR;
PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
PFN_vkCreateCommandPool vkCreateCommandPool;
PFN_vkDestroyCommandPool vkDestroyCommandPool;
PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers;
PFN_vkBeginCommandBuffer vkBeginCommandBuffer;
PFN_vkEndCommandBuffer vkEndCommandBuffer;
PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier;
PFN_vkCmdCopyImage vkCmdCopyImage;
PFN_vkCreateFence vkCreateFence;
PFN_vkDestroyFence vkDestroyFence;
PFN_vkResetFences vkResetFences;
PFN_vkWaitForFences vkWaitForFences;
PFN_vkGetDeviceQueue vkGetDeviceQueue;
PFN_vkQueueSubmit vkQueueSubmit;
PFN_vkResetCommandBuffer vkResetCommandBuffer;
PFN_vkCreateSemaphore vkCreateSemaphore;
PFN_vkDestroySemaphore vkDestroySemaphore;
PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR;
} gsr_vk_funcs;
typedef struct {
gsr_video_encoder_vulkan_params params;
unsigned int target_textures[2];
vec2i texture_sizes[2];
AVBufferRef *device_ctx;
gsr_vk_funcs vk;
VkDevice vk_device;
VkQueue vk_queue;
/* Exportable images that GL renders into */
VkImage export_images[2];
VkDeviceMemory export_memory[2];
VkDeviceSize export_memory_size[2];
unsigned int gl_memory_objects[2];
/* Vulkan command infrastructure for copying to encoder frame */
VkCommandPool command_pool;
VkCommandBuffer command_buffer;
VkFence fence;
bool fence_submitted; /* true if the fence was submitted and not yet waited on */
/* GL→Vulkan semaphore (binary, exported to GL via GL_EXT_semaphore_fd) */
VkSemaphore gl_ready_semaphore;
unsigned int gl_semaphore;
} gsr_video_encoder_vulkan;
static bool gsr_vk_funcs_load(gsr_vk_funcs *vk, PFN_vkGetInstanceProcAddr get_inst_proc, VkInstance inst, VkDevice dev) {
PFN_vkGetDeviceProcAddr get_dev_proc = (PFN_vkGetDeviceProcAddr)get_inst_proc(inst, "vkGetDeviceProcAddr");
if(!get_dev_proc) {
fprintf(stderr, "gsr error: gsr_vk_funcs_load: failed to load vkGetDeviceProcAddr\n");
return false;
}
#define LOAD_INST(name) vk->name = (PFN_##name)get_inst_proc(inst, #name); if(!vk->name) { fprintf(stderr, "gsr error: gsr_vk_funcs_load: failed to load " #name "\n"); return false; }
#define LOAD_DEV(name) vk->name = (PFN_##name)get_dev_proc(dev, #name); if(!vk->name) { fprintf(stderr, "gsr error: gsr_vk_funcs_load: failed to load " #name "\n"); return false; }
LOAD_INST(vkGetPhysicalDeviceMemoryProperties)
LOAD_DEV(vkCreateImage)
LOAD_DEV(vkDestroyImage)
LOAD_DEV(vkGetImageMemoryRequirements)
LOAD_DEV(vkAllocateMemory)
LOAD_DEV(vkFreeMemory)
LOAD_DEV(vkBindImageMemory)
LOAD_DEV(vkGetMemoryFdKHR)
LOAD_DEV(vkCreateCommandPool)
LOAD_DEV(vkDestroyCommandPool)
LOAD_DEV(vkAllocateCommandBuffers)
LOAD_DEV(vkBeginCommandBuffer)
LOAD_DEV(vkEndCommandBuffer)
LOAD_DEV(vkCmdPipelineBarrier)
LOAD_DEV(vkCmdCopyImage)
LOAD_DEV(vkCreateFence)
LOAD_DEV(vkDestroyFence)
LOAD_DEV(vkResetFences)
LOAD_DEV(vkWaitForFences)
LOAD_DEV(vkGetDeviceQueue)
LOAD_DEV(vkQueueSubmit)
LOAD_DEV(vkResetCommandBuffer)
LOAD_DEV(vkCreateSemaphore)
LOAD_DEV(vkDestroySemaphore)
LOAD_DEV(vkGetSemaphoreFdKHR)
#undef LOAD_INST
#undef LOAD_DEV
return true;
}
static bool gsr_video_encoder_vulkan_setup_context(gsr_video_encoder_vulkan *self, AVCodecContext *video_codec_context) {
AVDictionary *options = NULL;
//av_dict_set(&options, "linear_images", "1", 0);
//av_dict_set(&options, "disable_multiplane", "1", 0);
#if 0
// TODO: Use correct device
if(av_hwdevice_ctx_create(&self->device_ctx, AV_HWDEVICE_TYPE_VULKAN, NULL, options, 0) < 0) {
char device_index_str[32];
snprintf(device_index_str, sizeof(device_index_str), "%d", self->params.egl->vulkan_device_index);
if(av_hwdevice_ctx_create(&self->device_ctx, AV_HWDEVICE_TYPE_VULKAN, device_index_str, options, 0) < 0) {
fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_context: failed to create hardware device context\n");
return false;
}
@@ -45,23 +136,19 @@ static bool gsr_video_encoder_vulkan_setup_context(gsr_video_encoder_vulkan *sel
hw_frame_context->format = video_codec_context->pix_fmt;
hw_frame_context->device_ctx = (AVHWDeviceContext*)self->device_ctx->data;
//AVVulkanFramesContext *vk_frame_ctx = (AVVulkanFramesContext*)hw_frame_context->hwctx;
//hw_frame_context->initial_pool_size = 20;
if (av_hwframe_ctx_init(frame_context) < 0) {
fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_context: failed to initialize hardware frame context "
"(note: ffmpeg version needs to be > 4.0)\n");
av_buffer_unref(&self->device_ctx);
//av_buffer_unref(&frame_context);
return false;
}
video_codec_context->hw_frames_ctx = av_buffer_ref(frame_context);
av_buffer_unref(&frame_context);
#endif
return true;
}
#if 0
static AVVulkanDeviceContext* video_codec_context_get_vulkan_data(AVCodecContext *video_codec_context) {
AVBufferRef *hw_frames_ctx = video_codec_context->hw_frames_ctx;
if(!hw_frames_ctx)
@@ -75,24 +162,118 @@ static AVVulkanDeviceContext* video_codec_context_get_vulkan_data(AVCodecContext
return (AVVulkanDeviceContext*)device_context->hwctx;
}
static int get_graphics_queue_family(AVVulkanDeviceContext *vv) {
for(int i = 0; i < vv->nb_qf; i++) {
if(vv->qf[i].flags & VK_QUEUE_GRAPHICS_BIT)
return vv->qf[i].idx;
}
/* Fall back to any queue that supports transfer */
for(int i = 0; i < vv->nb_qf; i++) {
if(vv->qf[i].flags & VK_QUEUE_TRANSFER_BIT)
return vv->qf[i].idx;
}
return -1;
}
static uint32_t get_memory_type_idx(VkPhysicalDevice pdev, const VkMemoryRequirements *mem_reqs, VkMemoryPropertyFlagBits prop_flags, PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties) {
VkPhysicalDeviceMemoryProperties pdev_mem_props;
uint32_t i;
vkGetPhysicalDeviceMemoryProperties(pdev, &pdev_mem_props);
for (i = 0; i < pdev_mem_props.memoryTypeCount; i++) {
const VkMemoryType *type = &pdev_mem_props.memoryTypes[i];
if ((mem_reqs->memoryTypeBits & (1 << i)) &&
(type->propertyFlags & prop_flags) == prop_flags) {
for(uint32_t i = 0; i < pdev_mem_props.memoryTypeCount; i++) {
if((mem_reqs->memoryTypeBits & (1 << i)) &&
(pdev_mem_props.memoryTypes[i].propertyFlags & prop_flags) == prop_flags) {
return i;
break;
}
}
return UINT32_MAX;
}
#endif
static bool create_exportable_image(
const gsr_vk_funcs *vk,
VkDevice dev,
VkPhysicalDevice phys_dev,
int width, int height,
VkFormat format,
VkImage *out_image,
VkDeviceMemory *out_memory,
VkDeviceSize *out_size)
{
VkExternalMemoryImageCreateInfo ext_img_info = {
.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
};
VkImageCreateInfo img_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
.pNext = &ext_img_info,
.imageType = VK_IMAGE_TYPE_2D,
.format = format,
.extent = { (uint32_t)width, (uint32_t)height, 1 },
.mipLevels = 1,
.arrayLayers = 1,
.samples = VK_SAMPLE_COUNT_1_BIT,
.tiling = VK_IMAGE_TILING_OPTIMAL,
.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
VK_IMAGE_USAGE_STORAGE_BIT,
.flags = VK_IMAGE_CREATE_ALIAS_BIT | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
};
if(vk->vkCreateImage(dev, &img_info, NULL, out_image) != VK_SUCCESS) {
fprintf(stderr, "gsr error: create_exportable_image: vkCreateImage failed\n");
return false;
}
VkMemoryRequirements mem_reqs;
vk->vkGetImageMemoryRequirements(dev, *out_image, &mem_reqs);
uint32_t mem_type_idx = get_memory_type_idx(phys_dev, &mem_reqs,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, vk->vkGetPhysicalDeviceMemoryProperties);
if(mem_type_idx == UINT32_MAX) {
fprintf(stderr, "gsr error: create_exportable_image: no suitable memory type\n");
vk->vkDestroyImage(dev, *out_image, NULL);
*out_image = VK_NULL_HANDLE;
return false;
}
VkMemoryDedicatedAllocateInfo ded_info = {
.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
.image = *out_image,
};
VkExportMemoryAllocateInfo exp_mem_info = {
.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
.pNext = &ded_info,
.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
};
VkMemoryAllocateInfo mem_alloc_info = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.pNext = &exp_mem_info,
.allocationSize = mem_reqs.size,
.memoryTypeIndex = mem_type_idx,
};
if(vk->vkAllocateMemory(dev, &mem_alloc_info, NULL, out_memory) != VK_SUCCESS) {
fprintf(stderr, "gsr error: create_exportable_image: vkAllocateMemory failed\n");
vk->vkDestroyImage(dev, *out_image, NULL);
*out_image = VK_NULL_HANDLE;
return false;
}
if(vk->vkBindImageMemory(dev, *out_image, *out_memory, 0) != VK_SUCCESS) {
fprintf(stderr, "gsr error: create_exportable_image: vkBindImageMemory failed\n");
vk->vkFreeMemory(dev, *out_memory, NULL);
vk->vkDestroyImage(dev, *out_image, NULL);
*out_memory = VK_NULL_HANDLE;
*out_image = VK_NULL_HANDLE;
return false;
}
*out_size = mem_reqs.size;
return true;
}
static bool gsr_video_encoder_vulkan_setup_textures(gsr_video_encoder_vulkan *self, AVCodecContext *video_codec_context, AVFrame *frame) {
const int res = av_hwframe_get_buffer(video_codec_context->hw_frames_ctx, frame, 0);
if(res < 0) {
@@ -101,135 +282,179 @@ static bool gsr_video_encoder_vulkan_setup_textures(gsr_video_encoder_vulkan *se
}
while(self->params.egl->glGetError()) {}
#if 0
AVVkFrame *target_surface_id = (AVVkFrame*)frame->data[0];
AVVulkanDeviceContext* vv = video_codec_context_get_vulkan_data(video_codec_context);
const size_t luma_size = frame->width * frame->height;
if(vv) {
PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)vv->get_proc_addr(vv->inst, "vkGetImageMemoryRequirements");
PFN_vkAllocateMemory vkAllocateMemory = (PFN_vkAllocateMemory)vv->get_proc_addr(vv->inst, "vkAllocateMemory");
PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)vv->get_proc_addr(vv->inst, "vkGetPhysicalDeviceMemoryProperties");
PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = (PFN_vkGetMemoryFdKHR)vv->get_proc_addr(vv->inst, "vkGetMemoryFdKHR");
VkMemoryRequirements mem_reqs = {0};
vkGetImageMemoryRequirements(vv->act_dev, target_surface_id->img[0], &mem_reqs);
AVVulkanDeviceContext *vv = video_codec_context_get_vulkan_data(video_codec_context);
if(!vv) {
fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: failed to get vulkan device context\n");
return false;
}
fprintf(stderr, "size: %lu, alignment: %lu, memory bits: 0x%08x\n", mem_reqs.size, mem_reqs.alignment, mem_reqs.memoryTypeBits);
VkDeviceMemory mem;
{
VkExportMemoryAllocateInfo exp_mem_info;
VkMemoryAllocateInfo mem_alloc_info;
VkMemoryDedicatedAllocateInfoKHR ded_info;
if(!gsr_vk_funcs_load(&self->vk, vv->get_proc_addr, vv->inst, vv->act_dev))
return false;
memset(&exp_mem_info, 0, sizeof(exp_mem_info));
exp_mem_info.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
exp_mem_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
memset(&ded_info, 0, sizeof(ded_info));
ded_info.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
ded_info.image = target_surface_id->img[0];
self->vk_device = vv->act_dev;
exp_mem_info.pNext = &ded_info;
const bool is_p010 = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS;
const VkFormat fmt_y = is_p010 ? VK_FORMAT_R16_UNORM : VK_FORMAT_R8_UNORM;
const VkFormat fmt_uv = is_p010 ? VK_FORMAT_R16G16_UNORM : VK_FORMAT_R8G8_UNORM;
const unsigned int gl_fmt_y = is_p010 ? GL_R16 : GL_R8;
const unsigned int gl_fmt_uv = is_p010 ? GL_RG16 : GL_RG8;
memset(&mem_alloc_info, 0, sizeof(mem_alloc_info));
mem_alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
mem_alloc_info.pNext = &exp_mem_info;
mem_alloc_info.allocationSize = target_surface_id->size[0];
mem_alloc_info.memoryTypeIndex = get_memory_type_idx(vv->phys_dev, &mem_reqs, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, vkGetPhysicalDeviceMemoryProperties);
if(!create_exportable_image(&self->vk, vv->act_dev, vv->phys_dev,
frame->width, frame->height, fmt_y,
&self->export_images[0], &self->export_memory[0], &self->export_memory_size[0]))
return false;
if (mem_alloc_info.memoryTypeIndex == UINT32_MAX) {
fprintf(stderr, "No suitable memory type index found.\n");
return VK_NULL_HANDLE;
if(!create_exportable_image(&self->vk, vv->act_dev, vv->phys_dev,
frame->width / 2, frame->height / 2, fmt_uv,
&self->export_images[1], &self->export_memory[1], &self->export_memory_size[1]))
return false;
/* Export Vulkan memory as FDs and import into GL */
for(int i = 0; i < 2; i++) {
VkMemoryGetFdInfoKHR fd_info = {
.sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
.memory = self->export_memory[i],
.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
};
int fd = -1;
if(self->vk.vkGetMemoryFdKHR(vv->act_dev, &fd_info, &fd) != VK_SUCCESS) {
fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: vkGetMemoryFdKHR failed for plane %d\n", i);
return false;
}
self->params.egl->glCreateMemoryObjectsEXT(1, &self->gl_memory_objects[i]);
const int dedicated = 1;
self->params.egl->glMemoryObjectParameterivEXT(self->gl_memory_objects[i],
GL_DEDICATED_MEMORY_OBJECT_EXT, &dedicated);
self->params.egl->glImportMemoryFdEXT(self->gl_memory_objects[i], self->export_memory_size[i],
GL_HANDLE_TYPE_OPAQUE_FD_EXT, fd);
if(!self->params.egl->glIsMemoryObjectEXT(self->gl_memory_objects[i])) {
fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: failed to import memory FD for plane %d\n", i);
return false;
}
}
/* Create GL textures backed by the exportable images */
self->params.egl->glGenTextures(2, self->target_textures);
self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[0]);
self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_TILING_EXT, GL_OPTIMAL_TILING_EXT);
self->params.egl->glTexStorageMem2DEXT(GL_TEXTURE_2D, 1, gl_fmt_y,
frame->width, frame->height,
self->gl_memory_objects[0], 0);
self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[1]);
self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_TILING_EXT, GL_OPTIMAL_TILING_EXT);
self->params.egl->glTexStorageMem2DEXT(GL_TEXTURE_2D, 1, gl_fmt_uv,
frame->width / 2, frame->height / 2,
self->gl_memory_objects[1], 0);
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 };
/* Set up Vulkan command infrastructure */
VkCommandPoolCreateInfo pool_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
.queueFamilyIndex = (uint32_t)get_graphics_queue_family(vv),
};
if(self->vk.vkCreateCommandPool(vv->act_dev, &pool_info, NULL, &self->command_pool) != VK_SUCCESS) {
fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: vkCreateCommandPool failed\n");
return false;
}
VkCommandBufferAllocateInfo cb_alloc_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.commandPool = self->command_pool,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
.commandBufferCount = 1,
};
if(self->vk.vkAllocateCommandBuffers(vv->act_dev, &cb_alloc_info, &self->command_buffer) != VK_SUCCESS) {
fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: vkAllocateCommandBuffers failed\n");
return false;
}
VkFenceCreateInfo fence_info = {
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
};
if(self->vk.vkCreateFence(vv->act_dev, &fence_info, NULL, &self->fence) != VK_SUCCESS) {
fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: vkCreateFence failed\n");
return false;
}
self->vk.vkGetDeviceQueue(vv->act_dev, (uint32_t)get_graphics_queue_family(vv), 0, &self->vk_queue);
/* Transition export images UNDEFINED → GENERAL so GL can use them */
VkCommandBufferBeginInfo begin_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
};
self->vk.vkBeginCommandBuffer(self->command_buffer, &begin_info);
VkImageMemoryBarrier init_barriers[2];
for(int i = 0; i < 2; i++) {
init_barriers[i] = (VkImageMemoryBarrier){
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = 0,
.dstAccessMask = 0,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = VK_IMAGE_LAYOUT_GENERAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = self->export_images[i],
.subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.levelCount = 1,
.layerCount = 1,
},
};
}
self->vk.vkCmdPipelineBarrier(self->command_buffer,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
0, 0, NULL, 0, NULL, 2, init_barriers);
self->vk.vkEndCommandBuffer(self->command_buffer);
VkSubmitInfo submit_info = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.commandBufferCount = 1,
.pCommandBuffers = &self->command_buffer,
};
self->vk.vkQueueSubmit(self->vk_queue, 1, &submit_info, self->fence);
self->vk.vkWaitForFences(vv->act_dev, 1, &self->fence, VK_TRUE, UINT64_MAX);
self->vk.vkResetFences(vv->act_dev, 1, &self->fence);
self->vk.vkResetCommandBuffer(self->command_buffer, 0);
/* Create GL→Vulkan sync semaphore (binary, exported via OPAQUE_FD) */
if(self->params.egl->glGenSemaphoresEXT && self->params.egl->glImportSemaphoreFdEXT) {
VkExportSemaphoreCreateInfo exp_sem_info = {
.sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
.handleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
};
VkSemaphoreCreateInfo sem_info = {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
.pNext = &exp_sem_info,
};
if(self->vk.vkCreateSemaphore(vv->act_dev, &sem_info, NULL, &self->gl_ready_semaphore) == VK_SUCCESS) {
VkSemaphoreGetFdInfoKHR get_fd_info = {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
.semaphore = self->gl_ready_semaphore,
.handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
};
int sem_fd = -1;
if(self->vk.vkGetSemaphoreFdKHR(vv->act_dev, &get_fd_info, &sem_fd) == VK_SUCCESS) {
self->params.egl->glGenSemaphoresEXT(1, &self->gl_semaphore);
self->params.egl->glImportSemaphoreFdEXT(self->gl_semaphore, GL_HANDLE_TYPE_OPAQUE_FD_EXT, sem_fd);
} else {
self->vk.vkDestroySemaphore(vv->act_dev, self->gl_ready_semaphore, NULL);
self->gl_ready_semaphore = VK_NULL_HANDLE;
}
if (vkAllocateMemory(vv->act_dev, &mem_alloc_info, 0, &mem) !=
VK_SUCCESS)
return VK_NULL_HANDLE;
fprintf(stderr, "memory: %p\n", (void*)mem);
}
}
fprintf(stderr, "target surface id: %p, %zu, %zu\n", (void*)target_surface_id->mem[0], target_surface_id->offset[0], target_surface_id->offset[1]);
fprintf(stderr, "vkGetMemoryFdKHR: %p\n", (void*)vkGetMemoryFdKHR);
int fd = 0;
VkMemoryGetFdInfoKHR fd_info;
memset(&fd_info, 0, sizeof(fd_info));
fd_info.sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR;
fd_info.memory = target_surface_id->mem[0];
fd_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
if(vkGetMemoryFdKHR(vv->act_dev, &fd_info, &fd) != VK_SUCCESS) {
fprintf(stderr, "failed!\n");
} else {
fprintf(stderr, "fd: %d\n", fd);
}
fprintf(stderr, "glImportMemoryFdEXT: %p, size: %zu\n", (void*)self->params.egl->glImportMemoryFdEXT, target_surface_id->size[0]);
const int tiling = target_surface_id->tiling == VK_IMAGE_TILING_LINEAR ? GL_LINEAR_TILING_EXT : GL_OPTIMAL_TILING_EXT;
if(tiling != GL_OPTIMAL_TILING_EXT) {
fprintf(stderr, "tiling %d is not supported, only GL_OPTIMAL_TILING_EXT (%d) is supported\n", tiling, GL_OPTIMAL_TILING_EXT);
}
unsigned int gl_memory_obj = 0;
self->params.egl->glCreateMemoryObjectsEXT(1, &gl_memory_obj);
//const int dedicated = GL_TRUE;
//self->params.egl->glMemoryObjectParameterivEXT(gl_memory_obj, GL_DEDICATED_MEMORY_OBJECT_EXT, &dedicated);
self->params.egl->glImportMemoryFdEXT(gl_memory_obj, target_surface_id->size[0], GL_HANDLE_TYPE_OPAQUE_FD_EXT, fd);
if(!self->params.egl->glIsMemoryObjectEXT(gl_memory_obj))
fprintf(stderr, "failed to create object!\n");
fprintf(stderr, "gl memory obj: %u, error: %d\n", gl_memory_obj, self->params.egl->glGetError());
// fprintf(stderr, "0 gl error: %d\n", self->params.egl->glGetError());
// unsigned int vertex_buffer = 0;
// self->params.egl->glGenBuffers(1, &vertex_buffer);
// self->params.egl->glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
// self->params.egl->glBufferStorageMemEXT(GL_ARRAY_BUFFER, target_surface_id->size[0], gl_memory_obj, target_surface_id->offset[0]);
// fprintf(stderr, "1 gl error: %d\n", self->params.egl->glGetError());
// fprintf(stderr, "0 gl error: %d\n", self->params.egl->glGetError());
// unsigned int buffer = 0;
// self->params.egl->glCreateBuffers(1, &buffer);
// self->params.egl->glNamedBufferStorageMemEXT(buffer, target_surface_id->size[0], gl_memory_obj, target_surface_id->offset[0]);
// fprintf(stderr, "1 gl error: %d\n", self->params.egl->glGetError());
self->params.egl->glGenTextures(1, &self->target_textures[0]);
self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[0]);
fprintf(stderr, "1 gl error: %d\n", self->params.egl->glGetError());
self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_TILING_EXT, tiling);
fprintf(stderr, "tiling: %d\n", tiling);
fprintf(stderr, "2 gl error: %d\n", self->params.egl->glGetError());
self->params.egl->glTexStorageMem2DEXT(GL_TEXTURE_2D, 1, GL_R8, frame->width, frame->height, gl_memory_obj, target_surface_id->offset[0]);
fprintf(stderr, "3 gl error: %d\n", self->params.egl->glGetError());
self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
self->params.egl->glGenTextures(1, &self->target_textures[1]);
self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[1]);
fprintf(stderr, "1 gl error: %d\n", self->params.egl->glGetError());
self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_TILING_EXT, tiling);
fprintf(stderr, "tiling: %d\n", tiling);
fprintf(stderr, "2 gl error: %d\n", self->params.egl->glGetError());
self->params.egl->glTexStorageMem2DEXT(GL_TEXTURE_2D, 1, GL_RG8, frame->width/2, frame->height/2, gl_memory_obj, target_surface_id->offset[0] + luma_size);
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;
}
@@ -263,11 +488,332 @@ static bool gsr_video_encoder_vulkan_start(gsr_video_encoder *encoder, AVCodecCo
return true;
}
static void gsr_video_encoder_vulkan_copy_textures_to_frame(gsr_video_encoder *encoder, AVFrame *frame, gsr_color_conversion *color_conversion) {
(void)color_conversion;
gsr_video_encoder_vulkan *self = encoder->priv;
AVVkFrame *vk_frame = (AVVkFrame*)frame->data[0];
/* Wait for the previous frame's copy to finish before reusing the command buffer */
// if(self->fence_submitted) {
// self->vk.vkWaitForFences(self->vk_device, 1, &self->fence, VK_TRUE, UINT64_MAX);
self->vk.vkResetFences(self->vk_device, 1, &self->fence);
self->fence_submitted = false;
// }
if(self->gl_ready_semaphore != VK_NULL_HANDLE && self->params.egl->glSignalSemaphoreEXT) {
/* GPU-side GL→Vulkan sync: signal the semaphore from GL, then flush (no CPU stall) */
unsigned int gl_textures[2] = { self->target_textures[0], self->target_textures[1] };
unsigned int dst_layouts[2] = { GL_LAYOUT_GENERAL_EXT, GL_LAYOUT_GENERAL_EXT };
self->params.egl->glSignalSemaphoreEXT(self->gl_semaphore, 0, NULL, 2, gl_textures, dst_layouts);
self->params.egl->glFlush();
} else {
/* Fallback: CPU stall to ensure GL has finished */
self->params.egl->glFinish();
}
self->vk.vkResetCommandBuffer(self->command_buffer, 0);
VkCommandBufferBeginInfo begin_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
};
self->vk.vkBeginCommandBuffer(self->command_buffer, &begin_info);
/* Transition export images: GENERAL → TRANSFER_SRC_OPTIMAL */
VkImageMemoryBarrier src_barriers[2];
for(int i = 0; i < 2; i++) {
src_barriers[i] = (VkImageMemoryBarrier){
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
.oldLayout = VK_IMAGE_LAYOUT_GENERAL,
.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = self->export_images[i],
.subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.levelCount = 1,
.layerCount = 1,
},
};
}
self->vk.vkCmdPipelineBarrier(self->command_buffer,
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
0, 0, NULL, 0, NULL, 2, src_barriers);
/*
* Detect whether the encoder frame uses one multi-plane image (default NV12/P010
* in FFmpeg) or two separate single-plane images.
* Multi-plane: img[1] == VK_NULL_HANDLE or img[1] == img[0]
*/
const bool multiplane = (vk_frame->img[1] == VK_NULL_HANDLE || vk_frame->img[1] == vk_frame->img[0]);
if(multiplane) {
/* Transition the encoder's multi-plane image to TRANSFER_DST_OPTIMAL */
VkImageMemoryBarrier dst_barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
.oldLayout = vk_frame->layout[0],
.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = vk_frame->img[0],
.subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT,
.levelCount = 1,
.layerCount = 1,
},
};
self->vk.vkCmdPipelineBarrier(self->command_buffer,
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
0, 0, NULL, 0, NULL, 1, &dst_barrier);
/* Copy Y plane: export_images[0] (R8/R16) → encoder img PLANE_0 */
VkImageCopy copy_y = {
.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 },
.dstSubresource = { VK_IMAGE_ASPECT_PLANE_0_BIT, 0, 0, 1 },
.extent = { (uint32_t)frame->width, (uint32_t)frame->height, 1 },
};
self->vk.vkCmdCopyImage(self->command_buffer,
self->export_images[0], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
vk_frame->img[0], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1, &copy_y);
/* Copy UV plane: export_images[1] (RG8/RG16) → encoder img PLANE_1 */
VkImageCopy copy_uv = {
.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 },
.dstSubresource = { VK_IMAGE_ASPECT_PLANE_1_BIT, 0, 0, 1 },
.extent = { (uint32_t)frame->width / 2, (uint32_t)frame->height / 2, 1 },
};
self->vk.vkCmdCopyImage(self->command_buffer,
self->export_images[1], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
vk_frame->img[0], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1, &copy_uv);
/* Transition encoder image to GENERAL and update tracked layout */
VkImageMemoryBarrier dst_barrier_back = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.newLayout = VK_IMAGE_LAYOUT_GENERAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = vk_frame->img[0],
.subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT,
.levelCount = 1,
.layerCount = 1,
},
};
self->vk.vkCmdPipelineBarrier(self->command_buffer,
VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
0, 0, NULL, 0, NULL, 1, &dst_barrier_back);
vk_frame->layout[0] = VK_IMAGE_LAYOUT_GENERAL;
vk_frame->layout[1] = VK_IMAGE_LAYOUT_GENERAL;
} else {
/* Two separate single-plane images */
VkImageMemoryBarrier dst_barriers[2] = {
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
.oldLayout = vk_frame->layout[0],
.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = vk_frame->img[0],
.subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.levelCount = 1,
.layerCount = 1,
},
},
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
.oldLayout = vk_frame->layout[1],
.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = vk_frame->img[1],
.subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.levelCount = 1,
.layerCount = 1,
},
},
};
self->vk.vkCmdPipelineBarrier(self->command_buffer,
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
0, 0, NULL, 0, NULL, 2, dst_barriers);
for(int i = 0; i < 2; i++) {
VkImageCopy copy = {
.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 },
.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 },
.extent = {
(uint32_t)(i == 0 ? frame->width : frame->width / 2),
(uint32_t)(i == 0 ? frame->height : frame->height / 2),
1
},
};
self->vk.vkCmdCopyImage(self->command_buffer,
self->export_images[i], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
vk_frame->img[i], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1, &copy);
}
VkImageMemoryBarrier dst_barriers_back[2] = {
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.newLayout = VK_IMAGE_LAYOUT_GENERAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = vk_frame->img[0],
.subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.levelCount = 1,
.layerCount = 1,
},
},
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.newLayout = VK_IMAGE_LAYOUT_GENERAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = vk_frame->img[1],
.subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.levelCount = 1,
.layerCount = 1,
},
},
};
self->vk.vkCmdPipelineBarrier(self->command_buffer,
VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
0, 0, NULL, 0, NULL, 2, dst_barriers_back);
vk_frame->layout[0] = VK_IMAGE_LAYOUT_GENERAL;
vk_frame->layout[1] = VK_IMAGE_LAYOUT_GENERAL;
}
/* Transition export images back: TRANSFER_SRC_OPTIMAL → GENERAL for next GL frame */
VkImageMemoryBarrier src_barriers_back[2];
for(int i = 0; i < 2; i++) {
src_barriers_back[i] = (VkImageMemoryBarrier){
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
.dstAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
.newLayout = VK_IMAGE_LAYOUT_GENERAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = self->export_images[i],
.subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.levelCount = 1,
.layerCount = 1,
},
};
}
self->vk.vkCmdPipelineBarrier(self->command_buffer,
VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
0, 0, NULL, 0, NULL, 2, src_barriers_back);
self->vk.vkEndCommandBuffer(self->command_buffer);
/*
* Detect whether the encoder frame is multiplane to know how many timeline
* semaphores need to be signaled.
*/
const bool mp = (vk_frame->img[1] == VK_NULL_HANDLE || vk_frame->img[1] == vk_frame->img[0]);
const int num_sems = mp ? 1 : 2;
if(self->gl_ready_semaphore != VK_NULL_HANDLE) {
/*
* GPU-side sync path:
* - Wait on the GL binary semaphore before executing the copy.
* - Signal each AVVkFrame timeline semaphore so FFmpeg knows the frame is ready.
*/
uint64_t signal_values[2];
VkSemaphore signal_sems[2];
for(int i = 0; i < num_sems; i++) {
signal_values[i] = vk_frame->sem_value[i] + 1;
signal_sems[i] = vk_frame->sem[i];
}
VkTimelineSemaphoreSubmitInfo timeline_info = {
.sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO,
.signalSemaphoreValueCount = (uint32_t)num_sems,
.pSignalSemaphoreValues = signal_values,
};
const VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
VkSubmitInfo submit_info = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pNext = &timeline_info,
.waitSemaphoreCount = 1,
.pWaitSemaphores = &self->gl_ready_semaphore,
.pWaitDstStageMask = &wait_stage,
.commandBufferCount = 1,
.pCommandBuffers = &self->command_buffer,
.signalSemaphoreCount = (uint32_t)num_sems,
.pSignalSemaphores = signal_sems,
};
self->vk.vkQueueSubmit(self->vk_queue, 1, &submit_info, self->fence);
for(int i = 0; i < num_sems; i++)
vk_frame->sem_value[i]++;
} else {
/* Fallback: plain submit, we already stalled via glFinish() */
VkSubmitInfo submit_info = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.commandBufferCount = 1,
.pCommandBuffers = &self->command_buffer,
};
self->vk.vkQueueSubmit(self->vk_queue, 1, &submit_info, self->fence);
}
self->fence_submitted = true;
}
void gsr_video_encoder_vulkan_stop(gsr_video_encoder_vulkan *self, AVCodecContext *video_codec_context) {
self->params.egl->glDeleteTextures(2, self->target_textures);
self->target_textures[0] = 0;
self->target_textures[1] = 0;
if(self->vk_device) {
/* Drain any in-flight copy before freeing resources */
if(self->fence_submitted) {
self->vk.vkWaitForFences(self->vk_device, 1, &self->fence, VK_TRUE, UINT64_MAX);
self->fence_submitted = false;
}
if(self->gl_ready_semaphore)
self->vk.vkDestroySemaphore(self->vk_device, self->gl_ready_semaphore, NULL);
if(self->fence)
self->vk.vkDestroyFence(self->vk_device, self->fence, NULL);
/* Destroying the command pool also frees the command buffer */
if(self->command_pool)
self->vk.vkDestroyCommandPool(self->vk_device, self->command_pool, NULL);
for(int i = 0; i < 2; i++) {
if(self->export_images[i])
self->vk.vkDestroyImage(self->vk_device, self->export_images[i], NULL);
if(self->export_memory[i])
self->vk.vkFreeMemory(self->vk_device, self->export_memory[i], NULL);
}
}
if(video_codec_context->hw_frames_ctx)
av_buffer_unref(&video_codec_context->hw_frames_ctx);
if(self->device_ctx)
@@ -305,7 +851,7 @@ gsr_video_encoder* gsr_video_encoder_vulkan_create(const gsr_video_encoder_vulka
*encoder = (gsr_video_encoder) {
.start = gsr_video_encoder_vulkan_start,
.copy_textures_to_frame = NULL,
.copy_textures_to_frame = gsr_video_encoder_vulkan_copy_textures_to_frame,
.get_textures = gsr_video_encoder_vulkan_get_textures,
.destroy = gsr_video_encoder_vulkan_destroy,
.priv = encoder_vulkan

766
src/main.cpp
View File

File diff suppressed because it is too large Load Diff

36
src/pipewire_video.c
View File

@@ -134,7 +134,7 @@ static void on_process_cb(void *user_data) {
}
struct spa_buffer *buffer = pw_buf->buffer;
const bool has_buffer = buffer->datas[0].chunk->size != 0;
const bool has_buffer = buffer->n_datas > 0 && buffer->datas[0].chunk->size != 0;
pthread_mutex_lock(&self->mutex);
@@ -348,6 +348,7 @@ static void on_state_changed_cb(void *user_data, enum pw_stream_state prev_state
} else {
self->paused = false;
}
self->streaming = (new_state == PW_STREAM_STATE_STREAMING);
pthread_mutex_unlock(&self->mutex);
}
@@ -532,31 +533,36 @@ static bool spa_video_format_get_modifiers(gsr_pipewire_video *self, const enum
static void gsr_pipewire_video_init_modifiers(gsr_pipewire_video *self) {
for(size_t i = 0; i < GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS; i++) {
self->supported_video_formats[i].format = video_formats[i];
int32_t num_modifiers = 0;
spa_video_format_get_modifiers(self, self->supported_video_formats[i].format, self->modifiers + self->num_modifiers, GSR_PIPEWIRE_VIDEO_MAX_MODIFIERS - self->num_modifiers, &num_modifiers);
int32_t num_modifiers_video_format = 0;
spa_video_format_get_modifiers(self, self->supported_video_formats[i].format, self->modifiers + self->num_modifiers, GSR_PIPEWIRE_VIDEO_MAX_MODIFIERS - self->num_modifiers, &num_modifiers_video_format);
self->supported_video_formats[i].modifiers_index = self->num_modifiers;
self->supported_video_formats[i].modifiers_size = num_modifiers;
self->num_modifiers += num_modifiers;
self->supported_video_formats[i].modifiers_size = num_modifiers_video_format;
self->num_modifiers += num_modifiers_video_format;
}
}
static void gsr_pipewire_video_format_remove_modifier(gsr_pipewire_video *self, gsr_video_format *video_format, uint64_t modifier) {
/* Returns the number of modifiers */
static size_t gsr_pipewire_video_format_remove_modifier(gsr_pipewire_video *self, gsr_video_format *video_format, uint64_t modifier) {
for(size_t i = 0; i < video_format->modifiers_size; ++i) {
if(self->modifiers[video_format->modifiers_index + i] != modifier)
continue;
if(self->modifiers[video_format->modifiers_index + i] == modifier) {
for(size_t j = i + 1; j < video_format->modifiers_size; ++j) {
self->modifiers[video_format->modifiers_index + j - 1] = self->modifiers[video_format->modifiers_index + j];
}
for(size_t j = i + 1; j < video_format->modifiers_size; ++j) {
self->modifiers[j - 1] = self->modifiers[j];
--video_format->modifiers_size;
break;
}
--video_format->modifiers_size;
return;
}
return video_format->modifiers_size;
}
static void gsr_pipewire_video_remove_modifier(gsr_pipewire_video *self, uint64_t modifier) {
self->num_modifiers = 0;
for(size_t i = 0; i < GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS; i++) {
gsr_video_format *video_format = &self->supported_video_formats[i];
gsr_pipewire_video_format_remove_modifier(self, video_format, modifier);
const size_t num_modifiers_video_format = gsr_pipewire_video_format_remove_modifier(self, video_format, modifier);
video_format->modifiers_index = self->num_modifiers;
self->num_modifiers += num_modifiers_video_format;
}
}
@@ -793,7 +799,7 @@ static EGLImage gsr_pipewire_video_create_egl_image_with_fallback(gsr_pipewire_v
self->no_modifiers_fallback = true;
image = gsr_pipewire_video_create_egl_image(self, fds, offsets, pitches, modifiers, false);
} else {
fprintf(stderr, "gsr error: gsr_pipewire_video_create_egl_image_with_fallback: failed to create egl image with modifiers, renegotiating with a different modifier\n");
fprintf(stderr, "gsr error: gsr_pipewire_video_create_egl_image_with_fallback: failed to create egl image with modifier 0x%" PRIx64 ", renegotiating with a different modifier\n", self->format.info.raw.modifier);
self->negotiated = false;
pw_thread_loop_lock(self->thread_loop);
gsr_pipewire_video_remove_modifier(self, self->format.info.raw.modifier);
@@ -853,7 +859,7 @@ bool gsr_pipewire_video_map_texture(gsr_pipewire_video *self, gsr_texture_map te
output->rotation = GSR_MONITOR_ROT_0;
pthread_mutex_lock(&self->mutex);
if(!self->negotiated || self->dmabuf_data[0].fd <= 0) {
if(!self->negotiated || !self->streaming || self->dmabuf_data[0].fd <= 0) {
pthread_mutex_unlock(&self->mutex);
return false;
}

34
src/replay_buffer/replay_buffer.c
View File

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

14
src/replay_buffer/replay_buffer_disk.c
View File

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

21
src/replay_buffer/replay_buffer_ram.c
View File

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

1
src/shader.c
View File

@@ -91,6 +91,7 @@ static unsigned int load_program(gsr_egl *egl, const char *vertex_shader, const
if(!success) {
if(program_id)
egl->glDeleteProgram(program_id);
program_id = 0;
}
if(fragment_shader_id)
egl->glDeleteShader(fragment_shader_id);

92
src/sound.cpp
View File

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

6
src/utils.c
View File

@@ -121,6 +121,8 @@ void for_each_active_monitor_output_x11_not_cached(Display *display, active_moni
.name_len = out_info->nameLen,
.pos = { .x = crt_info->x, .y = crt_info->y },
.size = monitor_size,
.logical_pos = { .x = crt_info->x, .y = crt_info->y },
.logical_size = monitor_size,
.connector_id = x11_output_get_connector_id(display, screen_res->outputs[i], randr_connector_id_atom),
.rotation = rotation,
.monitor_identifier = out_info->crtc
@@ -229,6 +231,8 @@ static void for_each_active_monitor_output_drm(const char *card_path, active_mon
.name_len = display_name_len,
.pos = { .x = crtc->x, .y = crtc->y },
.size = { .x = (int)crtc->width, .y = (int)crtc->height },
.logical_pos = { .x = crtc->x, .y = crtc->y },
.logical_size = { .x = (int)crtc->width, .y = (int)crtc->height },
.connector_id = connector->connector_id,
.rotation = GSR_MONITOR_ROT_0,
.monitor_identifier = connector_type_index_name != -1 ? monitor_identifier_from_type_and_count(connector_type_index_name, connector->connector_type_id) : 0
@@ -264,6 +268,8 @@ static void get_monitor_by_name_callback(const gsr_monitor *monitor, void *userd
if(!data->found_monitor && strcmp(data->name, monitor->name) == 0) {
data->monitor->pos = monitor->pos;
data->monitor->size = monitor->size;
data->monitor->logical_pos = monitor->logical_pos;
data->monitor->logical_size = monitor->logical_size;
data->monitor->connector_id = monitor->connector_id;
data->monitor->rotation = monitor->rotation;
data->monitor->monitor_identifier = monitor->monitor_identifier;

70
src/window/wayland.c
View File

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

2
src/window/x11.c
View File

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