diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index 8b65b61caa..b1d5987dd9 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -18,30 +18,21 @@ jobs: steps: - name: Checkout repository - uses: actions/checkout@v2 - with: - # We must fetch at least the immediate parents so that if this is - # a pull request then we can checkout the head. - fetch-depth: 2 - - # If this run was triggered by a pull request event, then checkout - # the head of the pull request instead of the merge commit. - - run: git checkout HEAD^2 - if: ${{ github.event_name == 'pull_request' }} + uses: actions/checkout@v3 # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL - uses: github/codeql-action/init@v1 + uses: github/codeql-action/init@v2 with: languages: ${{ matrix.language }} # Install dependencies - - run: sudo apt update && sudo apt install libxext-dev libxcb1-dev libxcb-damage0-dev libxcb-xfixes0-dev libxcb-shape0-dev libxcb-render-util0-dev libxcb-render0-dev libxcb-randr0-dev libxcb-composite0-dev libxcb-image0-dev libxcb-present-dev libxcb-xinerama0-dev libxcb-glx0-dev libpixman-1-dev libdbus-1-dev libconfig-dev libgl1-mesa-dev libpcre2-dev libevdev-dev uthash-dev libev-dev libx11-xcb-dev meson ninja-build + - run: sudo apt update && sudo apt install libconfig-dev libdbus-1-dev libegl-dev libev-dev libgl-dev libpcre2-dev libpixman-1-dev libx11-xcb-dev libxcb1-dev libxcb-composite0-dev libxcb-damage0-dev libxcb-dpms0-dev libxcb-glx0-dev libxcb-image0-dev libxcb-present-dev libxcb-randr0-dev libxcb-render0-dev libxcb-render-util0-dev libxcb-shape0-dev libxcb-util-dev libxcb-xfixes0-dev libxext-dev meson ninja-build uthash-dev if: ${{ matrix.language == 'cpp' }} # Autobuild - name: Autobuild - uses: github/codeql-action/autobuild@v1 + uses: github/codeql-action/autobuild@v2 - name: Perform CodeQL Analysis - uses: github/codeql-action/analyze@v1 + uses: github/codeql-action/analyze@v2 diff --git a/.github/workflows/coding-style-pr.yml b/.github/workflows/coding-style-pr.yml index e25eaff9dd..5de4c67fcc 100644 --- a/.github/workflows/coding-style-pr.yml +++ b/.github/workflows/coding-style-pr.yml @@ -6,8 +6,8 @@ jobs: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 - run: git fetch --depth=1 origin ${{ github.event.pull_request.base.sha }} - - uses: yshui/git-clang-format-lint@v1.13 + - uses: yshui/git-clang-format-lint@v1.14 with: base: ${{ github.event.pull_request.base.sha }} diff --git a/.github/workflows/coding-style.yml b/.github/workflows/coding-style.yml index 0086225127..49f5379aaa 100644 --- a/.github/workflows/coding-style.yml +++ b/.github/workflows/coding-style.yml @@ -6,9 +6,9 @@ jobs: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 with: fetch-depth: 2 - - uses: yshui/git-clang-format-lint@v1.13 + - uses: yshui/git-clang-format-lint@v1.14 with: base: ${{ github.event.ref }}~1 diff --git a/.gitmodules b/.gitmodules deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 9512bf83d2..d4373abd99 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -1,85 +1,95 @@ -Sorted in alphabetical order -Open an issue or pull request if you don't want your name listed here. +Sorted in alphabetical order. Feel free to open an issue or create a +pull request if you want to change or remove your mention. -Adam Jackson -adelin-b -Alexander Kapshuna -Antonin Décimo -Antonio Vivace -Avi-D-coder -Ben Friesen -Bernd Busse -Bert Gijsbers -bhagwan -Bodhi -Brottweiler -Carl Worth -Christopher Jeffrey -Corax26 -Dan Elkouby -Dana Jansens -Daniel Kwan -Dave Airlie +Adam Jackson +adelin-b +Alexander Kapshuna +Antonin Décimo +Antonio Vivace +Avi ד +Ben Friesen +Bernd Busse +Bert Gijsbers +bhagwan +Bodhi +Brottweiler +Carl Worth +Christopher Jeffrey +Corax26 +Dan Elkouby +Dana Jansens +Daniel Kwan +Dave Airlie David Schlachter dolio -Duncan -Dylan Araps -Einar Lielmanis -Eric Anholt +Duncan +Dylan Araps +Einar Lielmanis +Eric Anholt +Evgeniy Baskov Greg Flynn -Harish Rajagopal -hasufell -Ignacio Taranto +h7x4 +Harish Rajagopal +hasufell +i-c-u-p +Ignacio Taranto Istvan Petres -James Cloos -Jamey Sharp -Jan Beich -Jarrad -Javeed Shaikh -Jerónimo Navarro -jialeens -Johnny Pribyl -Keith Packard -Kevin Kelley -ktprograms -Lukas Schmelzeisen -mæp -Mark Tiefenbruck -Matthew Allum -Maxim Solovyov -Michael Reed -Michele Lambertucci -Namkhai Bourquin -Nate Hart -nia -notfoss -Omar Polo -orbea -@Paradigm0001 +Jake +James Cloos +Jamey Sharp +Jan Beich +Jarrad +Javeed Shaikh +Jerónimo Navarro +jialeens +Johnny Pribyl +Keith Packard +Kevin Kelley +ktprograms +Kurenshe Nurdaulet +Lukas Schmelzeisen +Mark Tiefenbruck +Matthew Allum +Maxim Solovyov +Michael Reed +Michele Lambertucci +mæp +Namkhai Bourquin +Nate Hart +nia +Nikolay Borodin +notfoss +Omar Polo +oofsauce +orbea +Paradigm0001 Patrick Collins -Peter Mattern -Phil Blundell -Que Quotion -Rafael Kitover -Richard Grenville -Rytis Karpuska -Samuel Hand -Scott Leggett -scrouthtv -Sebastien Waegeneire -Subhaditya Nath -Tasos Sahanidis -Thiago Kenji Okada -Tilman Sauerbeck -Tim van Dalen -Tomas Janousek -Tom Dörr +Peter Mattern +Phil Blundell +Que Quotion +Rafael Kitover +Richard Grenville +Rytis Karpuska +Samuel Hand +Scott Leggett +scrouthtv +Sebastien Waegeneire +Stefan Radziuk +Subhaditya Nath +Tasos Sahanidis +Thiago Kenji Okada +Tilman Sauerbeck +Tim Siegel +Tim van Dalen +tokyoneon78 +Tom Dörr +Tomas Janousek Toni Jarjour -Tuomas Kinnunen -Uli Schlachter -Walter Lapchynski -Will Dietz -XeCycle -Yuxuan Shui +Tuomas Kinnunen +Uli Schlachter +Walter Lapchynski +Will Dietz +XeCycle +Yuxuan Shui zilrich -ಠ_ಠ +ಠ_ಠ diff --git a/README.md b/README.md index 5274b26136..1e6518f86c 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,13 @@ picom ===== +[![circleci](https://circleci.com/gh/yshui/picom.svg?style=shield)](https://circleci.com/gh/yshui/picom) +[![codecov](https://codecov.io/gh/yshui/picom/branch/next/graph/badge.svg?token=NRSegi0Gze)](https://codecov.io/gh/yshui/picom) +[![chat on discord](https://img.shields.io/discord/1106224720833159198?logo=discord)](https://discord.gg/SY5JJzPgME) + __picom__ is a compositor for X, and a [fork of Compton](History.md). -You can leave your feedback or thoughts in the [discussion tab](https://github.com/yshui/picom/discussions). +You can leave your feedback or thoughts in the [discussion tab](https://github.com/yshui/picom/discussions), or chat with other users on [discord](https://discord.gg/SY5JJzPgME)! ## Change Log @@ -20,7 +24,9 @@ Assuming you already have all the usual building tools installed (e.g. gcc, pyth * libXext * xproto * xcb +* xcb-util * xcb-damage +* xcb-dpms * xcb-xfixes * xcb-shape * xcb-renderutil @@ -29,26 +35,25 @@ Assuming you already have all the usual building tools installed (e.g. gcc, pyth * xcb-composite * xcb-image * xcb-present -* xcb-xinerama * xcb-glx * pixman * libdbus (optional, disable with the `-Ddbus=false` meson configure flag) * libconfig (optional, disable with the `-Dconfig_file=false` meson configure flag) * libGL, libEGL (optional, disable with the `-Dopengl=false` meson configure flag) -* libpcre (optional, disable with the `-Dregex=false` meson configure flag) +* libpcre2 (optional, disable with the `-Dregex=false` meson configure flag) * libev * uthash On Debian based distributions (e.g. Ubuntu), the needed packages are ``` -libxext-dev libxcb1-dev libxcb-damage0-dev libxcb-xfixes0-dev libxcb-shape0-dev libxcb-render-util0-dev libxcb-render0-dev libxcb-randr0-dev libxcb-composite0-dev libxcb-image0-dev libxcb-present-dev libxcb-xinerama0-dev libxcb-glx0-dev libpixman-1-dev libdbus-1-dev libconfig-dev libgl-dev libegl-dev libpcre2-dev libpcre3-dev libevdev-dev uthash-dev libev-dev libx11-xcb-dev meson +libconfig-dev libdbus-1-dev libegl-dev libev-dev libgl-dev libpcre2-dev libpixman-1-dev libx11-xcb-dev libxcb1-dev libxcb-composite0-dev libxcb-damage0-dev libxcb-dpms0-dev libxcb-glx0-dev libxcb-image0-dev libxcb-present-dev libxcb-randr0-dev libxcb-render0-dev libxcb-render-util0-dev libxcb-shape0-dev libxcb-util-dev libxcb-xfixes0-dev libxext-dev meson ninja-build uthash-dev ``` On Fedora, the needed packages are ``` -dbus-devel gcc git libconfig-devel libdrm-devel libev-devel libX11-devel libX11-xcb libXext-devel libxcb-devel libGL-devel libEGL-devel meson pcre-devel pixman-devel uthash-devel xcb-util-image-devel xcb-util-renderutil-devel xorg-x11-proto-devel +dbus-devel gcc git libconfig-devel libdrm-devel libev-devel libX11-devel libX11-xcb libXext-devel libxcb-devel libGL-devel libEGL-devel meson pcre2-devel pixman-devel uthash-devel xcb-util-image-devel xcb-util-renderutil-devel xorg-x11-proto-devel ``` To build the documents, you need `asciidoc` @@ -56,8 +61,7 @@ To build the documents, you need `asciidoc` ### To build ```bash -$ git submodule update --init --recursive -$ meson --buildtype=release . build +$ meson setup --buildtype=release build $ ninja -C build ``` @@ -68,13 +72,12 @@ If you have libraries and/or headers installed at non-default location (e.g. und You can do that by setting the `CPPFLAGS` and `LDFLAGS` environment variables when running `meson`. Like this: ```bash -$ LDFLAGS="-L/path/to/libraries" CPPFLAGS="-I/path/to/headers" meson --buildtype=release . build - +$ LDFLAGS="-L/path/to/libraries" CPPFLAGS="-I/path/to/headers" meson setup --buildtype=release build ``` As an example, on FreeBSD, you might have to run meson with: ```bash -$ LDFLAGS="-L/usr/local/lib" CPPFLAGS="-I/usr/local/include" meson --buildtype=release . build +$ LDFLAGS="-L/usr/local/lib" CPPFLAGS="-I/usr/local/include" meson setup --buildtype=release build $ ninja -C build ``` @@ -88,15 +91,21 @@ Default install prefix is `/usr/local`, you can change it with `meson configure ## How to Contribute -### Code +All contributions are welcome! + +New features you think should be included in picom, a fix for a bug you found - please open a PR! + +You can take a look at the [Issues](https://github.com/yshui/picom/issues). + +Contributions to the documents and wiki are also appreciated. -You can look at the [Projects](https://github.com/yshui/picom/projects) page, and see if there is anything that interests you. Or you can take a look at the [Issues](https://github.com/yshui/picom/issues). +Even if you don't want to add anything to picom, you are still helping by compiling and running this branch, and report any issue you can find. -### Non-code +### Become a Collaborator -Even if you don't want to contribute code, you can still contribute by compiling and running this branch, and report any issue you can find. +Becoming a collaborator of picom requires significant time commitment. You are expected to reply to issue reports, reviewing PRs, and sometimes fix bugs or implement new feature. You won't be able to push to the main branch directly, and all you code still has to go through code review. -Contributions to the documents and wiki will also be appreciated. +If this sounds good to you, feel free to contact me. ## Contributors diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000000..6afc8e3eb4 --- /dev/null +++ b/flake.lock @@ -0,0 +1,80 @@ +{ + "nodes": { + "flake-utils": { + "inputs": { + "systems": "systems" + }, + "locked": { + "lastModified": 1689068808, + "narHash": "sha256-6ixXo3wt24N/melDWjq70UuHQLxGV8jZvooRanIHXw0=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "919d646de7be200f3bf08cb76ae1f09402b6f9b4", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "git-ignore-nix": { + "inputs": { + "nixpkgs": [ + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1660459072, + "narHash": "sha256-8DFJjXG8zqoONA1vXtgeKXy68KdJL5UaXR8NtVMUbx8=", + "owner": "hercules-ci", + "repo": "gitignore.nix", + "rev": "a20de23b925fd8264fd7fad6454652e142fd7f73", + "type": "github" + }, + "original": { + "owner": "hercules-ci", + "ref": "master", + "repo": "gitignore.nix", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1691186842, + "narHash": "sha256-wxBVCvZUwq+XS4N4t9NqsHV4E64cPVqQ2fdDISpjcw0=", + "path": "/nix/store/d42v5grfq77vr10r336kks0qjp0wij8d-source", + "rev": "18036c0be90f4e308ae3ebcab0e14aae0336fe42", + "type": "path" + }, + "original": { + "id": "nixpkgs", + "type": "indirect" + } + }, + "root": { + "inputs": { + "flake-utils": "flake-utils", + "git-ignore-nix": "git-ignore-nix", + "nixpkgs": "nixpkgs" + } + }, + "systems": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000000..76c0db06c1 --- /dev/null +++ b/flake.nix @@ -0,0 +1,34 @@ +{ + inputs = { + flake-utils.url = github:numtide/flake-utils; + git-ignore-nix = { + url = github:hercules-ci/gitignore.nix/master; + inputs.nixpkgs.follows = "nixpkgs"; + }; + }; + outputs = { + self, flake-utils, nixpkgs, git-ignore-nix, ... + }: flake-utils.lib.eachDefaultSystem (system: let + overlay = self: super: { + picom = super.picom.overrideAttrs (oldAttrs: rec { + pname = "picom"; + buildInputs = [ + self.pcre2 self.xorg.xcbutil + ] ++ self.lib.remove self.xorg.libXinerama ( + self.lib.remove self.pcre oldAttrs.buildInputs + ); + src = git-ignore-nix.lib.gitignoreSource ./.; + }); + }; + pkgs = import nixpkgs { inherit system overlays; config.allowBroken = true; }; + overlays = [ overlay ]; + in rec { + inherit overlay overlays; + defaultPackage = pkgs.picom; + devShell = defaultPackage.overrideAttrs { + buildInputs = defaultPackage.buildInputs ++ [ + pkgs.clang-tools + ]; + }; + }); +} diff --git a/man/picom.1.asciidoc b/man/picom.1.asciidoc index 7dc070f1d4..dbd3ec6984 100644 --- a/man/picom.1.asciidoc +++ b/man/picom.1.asciidoc @@ -103,9 +103,15 @@ OPTIONS *--corner-radius* 'VALUE':: Sets the radius of rounded window corners. When > 0, the compositor will round the corners of windows. Does not interact well with *--transparent-clipping*. (defaults to 0). +*--corner-radius-rules* 'RADIUS':'CONDITION':: + Specify a list of corner radius rules. Overrides the corner radii of matching windows. This option takes precedence over the *--rounded-corners-exclude* option, and also overrides the default exclusion of fullscreen windows. The condition has the same format as *--opacity-rule*. + *--rounded-corners-exclude* 'CONDITION':: Exclude conditions for rounded corners. +*--no-frame-pacing*:: + Disable vsync-aware frame pacing. By default, the compositor tries to make sure it only renders once per vblank interval, and also the render happens as late as possible to minimize the latency from updates to the screen. However this can sometimes cause stuttering, or even lowered frame rate. This option can be used to disable frame pacing. + *--mark-wmwin-focused*:: Try to detect WM windows (a non-override-redirect window with no child that has 'WM_STATE') and mark them as active. @@ -134,7 +140,13 @@ OPTIONS Use EWMH '_NET_ACTIVE_WINDOW' to determine currently focused window, rather than listening to 'FocusIn'/'FocusOut' event. Might have more accuracy, provided that the WM supports it. *--unredir-if-possible*:: - Unredirect all windows if a full-screen opaque window is detected, to maximize performance for full-screen windows. Known to cause flickering when redirecting/unredirecting windows. + Unredirect all windows in some cases. Known to cause flickering when redirecting/unredirecting windows. Currently, unredirecting is triggered by following conditions: + * If the top level window is taking up the entire screen. In multi-monitor setup, this means ALL monitors. + * If there is no window. + * If a window is fullscreen according to its WM hints. (can be disabled with *--no-ewmh-fullscreen*). + * If a window requests to bypass the compositor ('_NET_WM_BYPASS_COMPOSITOR'). + Windows are also unredirected unconditionally when monitors are powered off, regardless if *--unredir-if-possible* is set. + *--unredir-if-possible-delay* 'MILLISECONDS':: Delay before unredirecting the window, in milliseconds. Defaults to 0. @@ -211,8 +223,8 @@ May also be one of the predefined kernels: `3x3box` (default), `5x5box`, `7x7box *--shadow-exclude-reg* 'GEOMETRY':: Specify a X geometry that describes the region in which shadow should not be painted in, such as a dock window region. Use `--shadow-exclude-reg x10+0-0`, for example, if the 10 pixels on the bottom of the screen should not have shadows painted on. -*--xinerama-shadow-crop*:: - Crop shadow of a window fully on a particular Xinerama screen to the screen. +*--crop-shadow-to-monitor*:: + Crop shadow of a window fully on a particular monitor to that monitor. This is currently implemented using the X RandR extension. *--backend* 'BACKEND':: Specify the backend to use: `xrender`, `glx`, or `xr_glx_hybrid`. `xrender` is the default one. @@ -230,7 +242,7 @@ May also be one of the predefined kernels: `3x3box` (default), `5x5box`, `7x7box GLX backend: Avoid rebinding pixmap on window damage. Probably could improve performance on rapid window content changes, but is known to break things on some drivers (LLVMpipe, xf86-video-intel, etc.). Recommended if it works. *--no-use-damage*:: - Disable the use of damage information. This cause the whole screen to be redrawn everytime, instead of the part of the screen has actually changed. Potentially degrades the performance, but might fix some artifacts. + Disable the use of damage information. This cause the whole screen to be redrawn every time, instead of the part of the screen has actually changed. Potentially degrades the performance, but might fix some artifacts. *--xrender-sync-fence*:: Use X Sync fence to sync clients' draw calls, to make sure all draw calls are finished before picom starts drawing. Needed on nvidia-drivers with GLX backend for some users. @@ -268,6 +280,9 @@ May also be one of the predefined kernels: `3x3box` (default), `5x5box`, `7x7box *--window-shader-fg-rule* 'SHADER':'CONDITION':: Specify GLSL fragment shader path for rendering window contents using patterns. Similar to *--opacity-rule*, arguments should be in the format of 'SHADER:CONDITION', e.g. "shader.frag:name = \'window\'". Leading and trailing whitespaces in 'SHADER' will be trimmed. If 'SHADER' is "default", then the default shader will be used for the matching windows. (This also unfortunately means you can't use a shader file named "default"). Does not work when *--legacy-backends* is enabled. +*--dithered-present* + Use higher precision during rendering, and apply dither when presenting the rendered screen. Reduces banding artifacts, but might cause performance degradation. Only works with OpenGL. + FORMAT OF CONDITIONS -------------------- Some options accept a condition string to match certain windows. A condition string is formed by one or more conditions, joined by logical operators. @@ -378,6 +393,7 @@ uniform float corner_radius; // corner radius of the window (pixels) uniform float border_width; // estimated border width of the window (pixels) uniform bool invert_color; // whether to invert the color of the window uniform sampler2D tex; // texture of the window +uniform vec2 effective_size; // effective dimensions of the texture (repeats pixels if larger than tex) uniform sampler2D brightness; // estimated brightness of the window, 1x1 texture uniform float max_brightness; // configured maximum brightness of the window (0.0 - 1.0) uniform float time; // time in milliseconds, counting from an unspecified starting point @@ -403,7 +419,8 @@ vec4 default_post_processing(vec4 c); // 1) fetch the specified pixel // 2) apply default post-processing vec4 window_shader() { - vec4 c = texelFetch(tex, ivec2(texcoord), 0); + vec2 texsize = textureSize(tex, 0); + vec4 c = texture2D(tex, texcoord / texsize, 0); return default_post_processing(c); } ---- @@ -481,7 +498,7 @@ Available options of the 'blur' section are: :: An integer in the range 0-20. The strength of the 'dual_kawase' blur method. Corresponds to the *--blur-strength* command line option. If set to zero, the value requested by *--blur-size* is approximated (default: 5). *kernel*::: - A string. The kernel to use for the 'kernel' blur method, specified in the same format as the *--blur-kerns* option. Corresponds to the *--blur-kerns* command line option. + A string. The kernel to use for the 'kernel' blur method, specified in the same format as the *--blur-kern* option. Corresponds to the *--blur-kern* command line option. SIGNALS ------- diff --git a/meson.build b/meson.build index 11da327cb0..528a53a029 100644 --- a/meson.build +++ b/meson.build @@ -1,4 +1,4 @@ -project('picom', 'c', version: '10', +project('picom', 'c', version: '11', default_options: ['c_std=c11', 'warning_level=1']) cc = meson.get_compiler('c') diff --git a/picom.sample.conf b/picom.sample.conf index 071a9945df..641db57d65 100644 --- a/picom.sample.conf +++ b/picom.sample.conf @@ -61,8 +61,9 @@ shadow-exclude = [ # # shadow-exclude-reg = "" -# Crop shadow of a window fully on a particular Xinerama screen to the screen. -# xinerama-shadow-crop = false +# Crop shadow of a window fully on a particular monitor to that monitor. This is +# currently implemented using the X RandR extension. +# crop-shadow-to-monitor = false ################################# @@ -209,19 +210,21 @@ blur-background-exclude = [ # Daemonize process. Fork to background after initialization. Causes issues with certain (badly-written) drivers. # daemon = false -# Specify the backend to use: `xrender`, `glx`, or `xr_glx_hybrid`. +# Specify the backend to use: `xrender`, `glx`, `egl` or `xr_glx_hybrid`. # `xrender` is the default one. # # backend = "glx" backend = "xrender"; +# Use higher precision during rendering, and apply dither when presenting the +# rendered screen. Reduces banding artifacts, but might cause performance +# degradation. Only works with OpenGL. +dithered-present = false; + # Enable/disable VSync. # vsync = false vsync = true; -# Enable remote control via D-Bus. See the *D-BUS API* section below for more details. -# dbus = false - # Try to detect WM windows (a non-override-redirect window with no # child that has 'WM_STATE') and mark them as active. # @@ -308,7 +311,7 @@ detect-transient = true; # glx-no-rebind-pixmap = false # Disable the use of damage information. -# This cause the whole screen to be redrawn everytime, instead of the part of the screen +# This cause the whole screen to be redrawn every time, instead of the part of the screen # has actually changed. Potentially degrades the performance, but might fix some artifacts. # The opposing option is use-damage # @@ -409,7 +412,7 @@ log-level = "warn"; # transparent, and you want shadows in those areas. # # clip-shadow-above::: -# Controls wether shadows that would have been drawn above the window should +# Controls whether shadows that would have been drawn above the window should # be clipped. Useful for dock windows that should have no shadow painted on top. # # redir-ignore::: diff --git a/src/atom.h b/src/atom.h index 6f4eae69f7..5ea7701c4b 100644 --- a/src/atom.h +++ b/src/atom.h @@ -3,8 +3,8 @@ #include -#include "meta.h" #include "cache.h" +#include "meta.h" // clang-format off // Splitted into 2 lists because of the limitation of our macros @@ -23,7 +23,10 @@ WM_CLIENT_MACHINE, \ _NET_ACTIVE_WINDOW, \ _COMPTON_SHADOW, \ - _NET_WM_WINDOW_TYPE + _NET_WM_WINDOW_TYPE, \ + _XROOTPMAP_ID, \ + ESETROOT_PMAP_ID, \ + _XSETROOT_ID #define ATOM_LIST2 \ _NET_WM_WINDOW_TYPE_DESKTOP, \ diff --git a/src/backend/backend.c b/src/backend/backend.c index 032c301b3f..5120672bc5 100644 --- a/src/backend/backend.c +++ b/src/backend/backend.c @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MPL-2.0 // Copyright (c) Yuxuan Shui +#include #include #include @@ -81,35 +82,43 @@ void handle_device_reset(session_t *ps) { } /// paint all windows -void paint_all_new(session_t *ps, struct managed_win *t, bool ignore_damage) { +/// +/// Returns if any render command is issued. IOW if nothing on the screen has changed, +/// this function will return false. +bool paint_all_new(session_t *ps, struct managed_win *const t) { + struct timespec now = get_time_timespec(); + auto paint_all_start_us = + (uint64_t)now.tv_sec * 1000000UL + (uint64_t)now.tv_nsec / 1000; if (ps->backend_data->ops->device_status && ps->backend_data->ops->device_status(ps->backend_data) != DEVICE_STATUS_NORMAL) { - return handle_device_reset(ps); + handle_device_reset(ps); + return false; } if (ps->o.xrender_sync_fence) { - if (ps->xsync_exists && !x_fence_sync(ps->c, ps->sync_fence)) { + if (ps->xsync_exists && !x_fence_sync(&ps->c, ps->sync_fence)) { log_error("x_fence_sync failed, xrender-sync-fence will be " "disabled from now on."); - xcb_sync_destroy_fence(ps->c, ps->sync_fence); + xcb_sync_destroy_fence(ps->c.c, ps->sync_fence); ps->sync_fence = XCB_NONE; ps->o.xrender_sync_fence = false; ps->xsync_exists = false; } } + + now = get_time_timespec(); + auto after_sync_fence_us = + (uint64_t)now.tv_sec * 1000000UL + (uint64_t)now.tv_nsec / 1000; + log_trace("Time spent on sync fence: %" PRIu64 " us", + after_sync_fence_us - paint_all_start_us); // All painting will be limited to the damage, if _some_ of // the paints bleed out of the damage region, it will destroy // part of the image we want to reuse region_t reg_damage; - if (!ignore_damage) { - reg_damage = get_damage(ps, ps->o.monitor_repaint || !ps->o.use_damage); - } else { - pixman_region32_init(®_damage); - pixman_region32_copy(®_damage, &ps->screen_reg); - } + reg_damage = get_damage(ps, ps->o.monitor_repaint || !ps->o.use_damage); if (!pixman_region32_not_empty(®_damage)) { pixman_region32_fini(®_damage); - return; + return false; } #ifdef DEBUG_REPAINT @@ -145,9 +154,11 @@ void paint_all_new(session_t *ps, struct managed_win *t, bool ignore_damage) { // region will be because of blur, we assume the worst case here. // That is, the damaged window is at the bottom of the stack, and // all other windows have semi-transparent background + // + // TODO(yshui): maybe we don't need to resize reg_damage, only reg_paint? int resize_factor = 1; if (t) { - resize_factor = t->stacking_rank; + resize_factor = t->stacking_rank + 1; } resize_region_in_place(®_damage, blur_width * resize_factor, blur_height * resize_factor); @@ -179,6 +190,20 @@ void paint_all_new(session_t *ps, struct managed_win *t, bool ignore_damage) { region_t reg_shadow_clip; pixman_region32_init(®_shadow_clip); + now = get_time_timespec(); + auto after_damage_us = (uint64_t)now.tv_sec * 1000000UL + (uint64_t)now.tv_nsec / 1000; + log_trace("Getting damage took %" PRIu64 " us", after_damage_us - after_sync_fence_us); + if (ps->next_render > 0) { + log_verbose("Render schedule deviation: %ld us (%s) %" PRIu64 " %ld", + labs((long)after_damage_us - (long)ps->next_render), + after_damage_us < ps->next_render ? "early" : "late", + after_damage_us, ps->next_render); + ps->last_schedule_delay = 0; + if (after_damage_us > ps->next_render) { + ps->last_schedule_delay = after_damage_us - ps->next_render; + } + } + if (ps->backend_data->ops->prepare) { ps->backend_data->ops->prepare(ps->backend_data, ®_paint); } @@ -197,7 +222,7 @@ void paint_all_new(session_t *ps, struct managed_win *t, bool ignore_damage) { // on top of that window. This is used to reduce the number of pixels painted. // // Whether this is beneficial is to be determined XXX - for (auto w = t; w; w = w->prev_trans) { + for (struct managed_win *w = t; w; w = w->prev_trans) { pixman_region32_subtract(®_visible, &ps->screen_reg, w->reg_ignore); assert(!(w->flags & WIN_FLAGS_IMAGE_ERROR)); assert(!(w->flags & WIN_FLAGS_PIXMAP_STALE)); @@ -325,18 +350,18 @@ void paint_all_new(session_t *ps, struct managed_win *t, bool ignore_damage) { ®_shadow_clip); } - if (ps->o.xinerama_shadow_crop && w->xinerama_scr >= 0 && - w->xinerama_scr < ps->xinerama_nscrs) { - // There can be a window where number of screens is - // updated, but the screen number attached to the windows + if (ps->o.crop_shadow_to_monitor && w->randr_monitor >= 0 && + w->randr_monitor < ps->monitors.count) { + // There can be a window where number of monitors is + // updated, but the monitor number attached to the window // have not. // - // Window screen number will be updated eventually, so + // Window monitor number will be updated eventually, so // here we just check to make sure we don't access out of // bounds. pixman_region32_intersect( ®_shadow, ®_shadow, - &ps->xinerama_scr_regs[w->xinerama_scr]); + &ps->monitors.regions[w->randr_monitor]); } if (ps->o.transparent_clipping) { @@ -519,6 +544,7 @@ void paint_all_new(session_t *ps, struct managed_win *t, bool ignore_damage) { for (win *w = t; w; w = w->prev_trans) log_trace(" %#010lx", w->id); #endif + return true; } // vim: set noet sw=8 ts=8 : diff --git a/src/backend/backend.h b/src/backend/backend.h index 191e814609..1b4df729d0 100644 --- a/src/backend/backend.h +++ b/src/backend/backend.h @@ -23,8 +23,7 @@ struct backend_operations; typedef struct backend_base { struct backend_operations *ops; - xcb_connection_t *c; - xcb_window_t root; + struct x_connection *c; struct ev_loop *loop; /// Whether the backend can accept new render request at the moment @@ -120,11 +119,7 @@ struct backend_operations { // =========== Initialization =========== /// Initialize the backend, prepare for rendering to the target window. - /// Here is how you should choose target window: - /// 1) if ps->overlay is not XCB_NONE, use that - /// 2) use ps->root otherwise - // TODO(yshui) make the target window a parameter - backend_t *(*init)(session_t *)attr_nonnull(1); + backend_t *(*init)(session_t *, xcb_window_t)attr_nonnull(1); void (*deinit)(backend_t *backend_data) attr_nonnull(1); /// Called when rendering will be stopped for an unknown amount of @@ -192,7 +187,7 @@ struct backend_operations { /// mask is. bool (*blur)(backend_t *backend_data, double opacity, void *blur_ctx, void *mask, coord_t mask_dst, const region_t *reg_blur, - const region_t *reg_visible) attr_nonnull(1, 3, 4, 6, 7); + const region_t *reg_visible) attr_nonnull(1, 3, 6, 7); /// Update part of the back buffer with the rendering buffer, then present the /// back buffer onto the target window (if not back buffered, update part of the @@ -216,18 +211,18 @@ struct backend_operations { struct xvisual_info fmt, bool owned); /// Create a shadow context for rendering shadows with radius `radius`. - /// Default implementation: default_backend_create_shadow_context + /// Default implementation: default_create_shadow_context struct backend_shadow_context *(*create_shadow_context)(backend_t *backend_data, double radius); /// Destroy a shadow context - /// Default implementation: default_backend_destroy_shadow_context + /// Default implementation: default_destroy_shadow_context void (*destroy_shadow_context)(backend_t *backend_data, struct backend_shadow_context *ctx); /// Create a shadow image based on the parameters. Resulting image should have a /// size of `width + radisu * 2` x `height + radius * 2`. Radius is set when the /// shadow context is created. - /// Default implementation: default_backend_render_shadow + /// Default implementation: default_render_shadow /// /// Required. void *(*render_shadow)(backend_t *backend_data, int width, int height, @@ -292,6 +287,14 @@ struct backend_operations { /// Optional int (*buffer_age)(backend_t *backend_data); + /// Get the render time of the last frame. If the render is still in progress, + /// returns false. The time is returned in `ts`. Frames are delimited by the + /// present() calls. i.e. after a present() call, last_render_time() should start + /// reporting the time of the just presen1ted frame. + /// + /// Optional, if not available, the most conservative estimation will be used. + bool (*last_render_time)(backend_t *backend_data, struct timespec *ts); + /// The maximum number buffer_age might return. int max_buffer_age; @@ -363,5 +366,8 @@ struct backend_operations { extern struct backend_operations *backend_list[]; -void paint_all_new(session_t *ps, struct managed_win *const t, bool ignore_damage) - attr_nonnull(1); +/// paint all windows +/// +/// Returns if any render command is issued. IOW if nothing on the screen has changed, +/// this function will return false. +bool paint_all_new(session_t *ps, struct managed_win *t) attr_nonnull(1); diff --git a/src/backend/backend_common.c b/src/backend/backend_common.c index d6fcce21ce..eef214593b 100644 --- a/src/backend/backend_common.c +++ b/src/backend/backend_common.c @@ -19,17 +19,18 @@ /** * Generate a 1x1 Picture of a particular color. */ -xcb_render_picture_t solid_picture(xcb_connection_t *c, xcb_drawable_t d, bool argb, - double a, double r, double g, double b) { +xcb_render_picture_t +solid_picture(struct x_connection *c, bool argb, double a, double r, double g, double b) { xcb_pixmap_t pixmap; xcb_render_picture_t picture; xcb_render_create_picture_value_list_t pa; xcb_render_color_t col; xcb_rectangle_t rect; - pixmap = x_create_pixmap(c, argb ? 32 : 8, d, 1, 1); - if (!pixmap) + pixmap = x_create_pixmap(c, argb ? 32 : 8, 1, 1); + if (!pixmap) { return XCB_NONE; + } pa.repeat = 1; picture = x_create_picture_with_standard_and_pixmap( @@ -37,7 +38,7 @@ xcb_render_picture_t solid_picture(xcb_connection_t *c, xcb_drawable_t d, bool a XCB_RENDER_CP_REPEAT, &pa); if (!picture) { - xcb_free_pixmap(c, pixmap); + xcb_free_pixmap(c->c, pixmap); return XCB_NONE; } @@ -51,14 +52,14 @@ xcb_render_picture_t solid_picture(xcb_connection_t *c, xcb_drawable_t d, bool a rect.width = 1; rect.height = 1; - xcb_render_fill_rectangles(c, XCB_RENDER_PICT_OP_SRC, picture, col, 1, &rect); - xcb_free_pixmap(c, pixmap); + xcb_render_fill_rectangles(c->c, XCB_RENDER_PICT_OP_SRC, picture, col, 1, &rect); + xcb_free_pixmap(c->c, pixmap); return picture; } -xcb_image_t * -make_shadow(xcb_connection_t *c, const conv *kernel, double opacity, int width, int height) { +xcb_image_t *make_shadow(struct x_connection *c, const conv *kernel, double opacity, + int width, int height) { /* * We classify shadows into 4 kinds of regions * r = shadow radius @@ -84,8 +85,9 @@ make_shadow(xcb_connection_t *c, const conv *kernel, double opacity, int width, assert(d % 2 == 1); assert(d > 0); - ximage = xcb_image_create_native(c, to_u16_checked(swidth), to_u16_checked(sheight), - XCB_IMAGE_FORMAT_Z_PIXMAP, 8, 0, 0, NULL); + ximage = + xcb_image_create_native(c->c, to_u16_checked(swidth), to_u16_checked(sheight), + XCB_IMAGE_FORMAT_Z_PIXMAP, 8, 0, 0, NULL); if (!ximage) { log_error("failed to create an X image"); return 0; @@ -193,7 +195,7 @@ make_shadow(xcb_connection_t *c, const conv *kernel, double opacity, int width, /** * Generate shadow Picture for a window. */ -bool build_shadow(xcb_connection_t *c, xcb_drawable_t d, double opacity, const int width, +bool build_shadow(struct x_connection *c, double opacity, const int width, const int height, const conv *kernel, xcb_render_picture_t shadow_pixel, xcb_pixmap_t *pixmap, xcb_render_picture_t *pict) { xcb_image_t *shadow_image = NULL; @@ -207,9 +209,9 @@ bool build_shadow(xcb_connection_t *c, xcb_drawable_t d, double opacity, const i return false; } - shadow_pixmap = x_create_pixmap(c, 8, d, shadow_image->width, shadow_image->height); + shadow_pixmap = x_create_pixmap(c, 8, shadow_image->width, shadow_image->height); shadow_pixmap_argb = - x_create_pixmap(c, 32, d, shadow_image->width, shadow_image->height); + x_create_pixmap(c, 32, shadow_image->width, shadow_image->height); if (!shadow_pixmap || !shadow_pixmap_argb) { log_error("Failed to create shadow pixmaps"); @@ -225,11 +227,11 @@ bool build_shadow(xcb_connection_t *c, xcb_drawable_t d, double opacity, const i } gc = x_new_id(c); - xcb_create_gc(c, gc, shadow_pixmap, 0, NULL); + xcb_create_gc(c->c, gc, shadow_pixmap, 0, NULL); // We need to make room for protocol metadata in the request. The metadata should // be 24 bytes plus padding, let's be generous and give it 1kb - auto maximum_image_size = xcb_get_maximum_request_length(c) * 4 - 1024; + auto maximum_image_size = xcb_get_maximum_request_length(c->c) * 4 - 1024; auto maximum_row = to_u16_checked(clamp(maximum_image_size / shadow_image->stride, 0, UINT16_MAX)); if (maximum_row <= 0) { @@ -248,23 +250,23 @@ bool build_shadow(xcb_connection_t *c, xcb_drawable_t d, double opacity, const i } uint32_t offset = row * shadow_image->stride / sizeof(*shadow_image->data); - xcb_put_image(c, (uint8_t)shadow_image->format, shadow_pixmap, gc, + xcb_put_image(c->c, (uint8_t)shadow_image->format, shadow_pixmap, gc, shadow_image->width, batch_height, 0, to_i16_checked(row), 0, shadow_image->depth, shadow_image->stride * batch_height, shadow_image->data + offset); } - xcb_render_composite(c, XCB_RENDER_PICT_OP_SRC, shadow_pixel, shadow_picture, + xcb_render_composite(c->c, XCB_RENDER_PICT_OP_SRC, shadow_pixel, shadow_picture, shadow_picture_argb, 0, 0, 0, 0, 0, 0, shadow_image->width, shadow_image->height); *pixmap = shadow_pixmap_argb; *pict = shadow_picture_argb; - xcb_free_gc(c, gc); + xcb_free_gc(c->c, gc); xcb_image_destroy(shadow_image); - xcb_free_pixmap(c, shadow_pixmap); - xcb_render_free_picture(c, shadow_picture); + xcb_free_pixmap(c->c, shadow_pixmap); + x_free_picture(c, shadow_picture); return true; @@ -273,41 +275,43 @@ bool build_shadow(xcb_connection_t *c, xcb_drawable_t d, double opacity, const i xcb_image_destroy(shadow_image); } if (shadow_pixmap) { - xcb_free_pixmap(c, shadow_pixmap); + xcb_free_pixmap(c->c, shadow_pixmap); } if (shadow_pixmap_argb) { - xcb_free_pixmap(c, shadow_pixmap_argb); + xcb_free_pixmap(c->c, shadow_pixmap_argb); } if (shadow_picture) { - xcb_render_free_picture(c, shadow_picture); + x_free_picture(c, shadow_picture); } if (shadow_picture_argb) { - xcb_render_free_picture(c, shadow_picture_argb); + x_free_picture(c, shadow_picture_argb); } if (gc) { - xcb_free_gc(c, gc); + xcb_free_gc(c->c, gc); } return false; } -void *default_backend_render_shadow(backend_t *backend_data, int width, int height, - struct backend_shadow_context *sctx, struct color color) { +void *default_render_shadow(backend_t *backend_data, int width, int height, + struct backend_shadow_context *sctx, struct color color) { const conv *kernel = (void *)sctx; - xcb_pixmap_t shadow_pixel = solid_picture(backend_data->c, backend_data->root, true, - 1, color.red, color.green, color.blue), - shadow = XCB_NONE; + xcb_render_picture_t shadow_pixel = + solid_picture(backend_data->c, true, 1, color.red, color.green, color.blue); + xcb_pixmap_t shadow = XCB_NONE; xcb_render_picture_t pict = XCB_NONE; - if (!build_shadow(backend_data->c, backend_data->root, color.alpha, width, height, - kernel, shadow_pixel, &shadow, &pict)) { + if (!build_shadow(backend_data->c, color.alpha, width, height, kernel, + shadow_pixel, &shadow, &pict)) { + x_free_picture(backend_data->c, shadow_pixel); return NULL; } auto visual = x_get_visual_for_standard(backend_data->c, XCB_PICT_STANDARD_ARGB_32); void *ret = backend_data->ops->bind_pixmap( backend_data, shadow, x_get_visual_info(backend_data->c, visual), true); - xcb_render_free_picture(backend_data->c, pict); + x_free_picture(backend_data->c, pict); + x_free_picture(backend_data->c, shadow_pixel); return ret; } @@ -401,31 +405,31 @@ struct dual_kawase_params *generate_dual_kawase_params(void *args) { int min_radius; /// Approximate gauss-blur with at least this /// radius and std-deviation } strength_levels[20] = { - {.iterations = 1, .offset = 1.25f, .min_radius = 1}, // LVL 1 - {.iterations = 1, .offset = 2.25f, .min_radius = 6}, // LVL 2 - {.iterations = 2, .offset = 2.00f, .min_radius = 11}, // LVL 3 - {.iterations = 2, .offset = 3.00f, .min_radius = 17}, // LVL 4 - {.iterations = 2, .offset = 4.25f, .min_radius = 24}, // LVL 5 - {.iterations = 3, .offset = 2.50f, .min_radius = 32}, // LVL 6 - {.iterations = 3, .offset = 3.25f, .min_radius = 40}, // LVL 7 - {.iterations = 3, .offset = 4.25f, .min_radius = 51}, // LVL 8 - {.iterations = 3, .offset = 5.50f, .min_radius = 67}, // LVL 9 - {.iterations = 4, .offset = 3.25f, .min_radius = 83}, // LVL 10 - {.iterations = 4, .offset = 4.00f, .min_radius = 101}, // LVL 11 - {.iterations = 4, .offset = 5.00f, .min_radius = 123}, // LVL 12 - {.iterations = 4, .offset = 6.00f, .min_radius = 148}, // LVL 13 - {.iterations = 4, .offset = 7.25f, .min_radius = 178}, // LVL 14 - {.iterations = 4, .offset = 8.25f, .min_radius = 208}, // LVL 15 - {.iterations = 5, .offset = 4.50f, .min_radius = 236}, // LVL 16 - {.iterations = 5, .offset = 5.25f, .min_radius = 269}, // LVL 17 - {.iterations = 5, .offset = 6.25f, .min_radius = 309}, // LVL 18 - {.iterations = 5, .offset = 7.25f, .min_radius = 357}, // LVL 19 - {.iterations = 5, .offset = 8.50f, .min_radius = 417}, // LVL 20 + {.iterations = 1, .offset = 1.25F, .min_radius = 1}, // LVL 1 + {.iterations = 1, .offset = 2.25F, .min_radius = 6}, // LVL 2 + {.iterations = 2, .offset = 2.00F, .min_radius = 11}, // LVL 3 + {.iterations = 2, .offset = 3.00F, .min_radius = 17}, // LVL 4 + {.iterations = 2, .offset = 4.25F, .min_radius = 24}, // LVL 5 + {.iterations = 3, .offset = 2.50F, .min_radius = 32}, // LVL 6 + {.iterations = 3, .offset = 3.25F, .min_radius = 40}, // LVL 7 + {.iterations = 3, .offset = 4.25F, .min_radius = 51}, // LVL 8 + {.iterations = 3, .offset = 5.50F, .min_radius = 67}, // LVL 9 + {.iterations = 4, .offset = 3.25F, .min_radius = 83}, // LVL 10 + {.iterations = 4, .offset = 4.00F, .min_radius = 101}, // LVL 11 + {.iterations = 4, .offset = 5.00F, .min_radius = 123}, // LVL 12 + {.iterations = 4, .offset = 6.00F, .min_radius = 148}, // LVL 13 + {.iterations = 4, .offset = 7.25F, .min_radius = 178}, // LVL 14 + {.iterations = 4, .offset = 8.25F, .min_radius = 208}, // LVL 15 + {.iterations = 5, .offset = 4.50F, .min_radius = 236}, // LVL 16 + {.iterations = 5, .offset = 5.25F, .min_radius = 269}, // LVL 17 + {.iterations = 5, .offset = 6.25F, .min_radius = 309}, // LVL 18 + {.iterations = 5, .offset = 7.25F, .min_radius = 357}, // LVL 19 + {.iterations = 5, .offset = 8.50F, .min_radius = 417}, // LVL 20 }; auto params = ccalloc(1, struct dual_kawase_params); params->iterations = 0; - params->offset = 1.0f; + params->offset = 1.0F; if (blur_args->strength <= 0 && blur_args->size) { // find highest level that approximates blur-strength with the selected @@ -449,7 +453,7 @@ struct dual_kawase_params *generate_dual_kawase_params(void *args) { // - Smallest texture dimensions are halved `iterations`-times // - Upsample needs pixels two-times `offset` away from the border // - Plus one for interpolation differences - params->expand = (1 << params->iterations) * 2 * (int)ceil(params->offset) + 1; + params->expand = (1 << params->iterations) * 2 * (int)ceilf(params->offset) + 1; return params; } @@ -504,9 +508,8 @@ struct backend_image *default_new_backend_image(int w, int h) { } void init_backend_base(struct backend_base *base, session_t *ps) { - base->c = ps->c; + base->c = &ps->c; base->loop = ps->loop; - base->root = ps->root; base->busy = false; base->ops = NULL; } diff --git a/src/backend/backend_common.h b/src/backend/backend_common.h index c72a1686b3..da9ccd0235 100644 --- a/src/backend/backend_common.h +++ b/src/backend/backend_common.h @@ -44,26 +44,18 @@ struct backend_image { int border_width; }; -bool build_shadow(xcb_connection_t *, xcb_drawable_t, double opacity, int width, - int height, const conv *kernel, xcb_render_picture_t shadow_pixel, +bool build_shadow(struct x_connection *, double opacity, int width, int height, + const conv *kernel, xcb_render_picture_t shadow_pixel, xcb_pixmap_t *pixmap, xcb_render_picture_t *pict); -xcb_render_picture_t solid_picture(xcb_connection_t *, xcb_drawable_t, bool argb, - double a, double r, double g, double b); +xcb_render_picture_t +solid_picture(struct x_connection *, bool argb, double a, double r, double g, double b); -xcb_image_t * -make_shadow(xcb_connection_t *c, const conv *kernel, double opacity, int width, int height); +xcb_image_t *make_shadow(struct x_connection *c, const conv *kernel, double opacity, + int width, int height); -/// The default implementation of `is_win_transparent`, it simply looks at win::mode. So -/// this is not suitable for backends that alter the content of windows -bool default_is_win_transparent(void *, win *, void *); - -/// The default implementation of `is_frame_transparent`, it uses win::frame_opacity. Same -/// caveat as `default_is_win_transparent` applies. -bool default_is_frame_transparent(void *, win *, void *); - -void *default_backend_render_shadow(backend_t *backend_data, int width, int height, - struct backend_shadow_context *sctx, struct color color); +void *default_render_shadow(backend_t *backend_data, int width, int height, + struct backend_shadow_context *sctx, struct color color); /// Implement `render_shadow` with `shadow_from_mask`. void * diff --git a/src/backend/driver.c b/src/backend/driver.c index a41d2fdc1f..f17743a4aa 100644 --- a/src/backend/driver.c +++ b/src/backend/driver.c @@ -15,12 +15,17 @@ /// Apply driver specified global workarounds. It's safe to call this multiple times. void apply_driver_workarounds(struct session *ps, enum driver driver) { if (driver & DRIVER_NVIDIA) { - // setenv("__GL_YIELD", "usleep", true); - setenv("__GL_MaxFramesAllowed", "1", true); ps->o.xrender_sync_fence = true; } } +enum vblank_scheduler_type choose_vblank_scheduler(enum driver driver) { + if (driver & DRIVER_NVIDIA) { + return VBLANK_SCHEDULER_SGI_VIDEO_SYNC; + } + return VBLANK_SCHEDULER_PRESENT; +} + enum driver detect_driver(xcb_connection_t *c, backend_t *backend_data, xcb_window_t window) { enum driver ret = 0; // First we try doing backend agnostic detection using RANDR diff --git a/src/backend/driver.h b/src/backend/driver.h index a37cda3b67..1b0877c14b 100644 --- a/src/backend/driver.h +++ b/src/backend/driver.h @@ -7,6 +7,7 @@ #include #include +#include "config.h" #include "utils.h" struct session; @@ -41,13 +42,15 @@ enum driver detect_driver(xcb_connection_t *, struct backend_base *, xcb_window_ /// Apply driver specified global workarounds. It's safe to call this multiple times. void apply_driver_workarounds(struct session *ps, enum driver); +/// Choose a vblank scheduler based on the driver. +enum vblank_scheduler_type choose_vblank_scheduler(enum driver driver); // Print driver names to stdout, for diagnostics static inline void print_drivers(enum driver drivers) { const char *seen_drivers[ARR_SIZE(driver_names)]; int driver_count = 0; for (size_t i = 0; i < ARR_SIZE(driver_names); i++) { - if (drivers & (1ul << i)) { + if (drivers & (1UL << i)) { seen_drivers[driver_count++] = driver_names[i]; } } diff --git a/src/backend/dummy/dummy.c b/src/backend/dummy/dummy.c index 7e06facecc..3e57c03955 100644 --- a/src/backend/dummy/dummy.c +++ b/src/backend/dummy/dummy.c @@ -17,6 +17,7 @@ struct dummy_image { xcb_pixmap_t pixmap; bool transparent; int *refcount; + bool owned; UT_hash_handle hh; }; @@ -27,11 +28,10 @@ struct dummy_data { struct backend_image mask; }; -struct backend_base *dummy_init(struct session *ps attr_unused) { +struct backend_base *dummy_init(session_t *ps attr_unused, xcb_window_t target attr_unused) { auto ret = (struct backend_base *)ccalloc(1, struct dummy_data); - ret->c = ps->c; + ret->c = &ps->c; ret->loop = ps->loop; - ret->root = ps->root; ret->busy = false; return ret; } @@ -42,6 +42,9 @@ void dummy_deinit(struct backend_base *data) { log_warn("Backend image for pixmap %#010x is not freed", img->pixmap); HASH_DEL(dummy->images, img); free(img->refcount); + if (img->owned) { + xcb_free_pixmap(data->c->c, img->pixmap); + } free(img); } free(dummy); @@ -82,7 +85,7 @@ bool dummy_blur(struct backend_base *backend_data attr_unused, double opacity at } void *dummy_bind_pixmap(struct backend_base *base, xcb_pixmap_t pixmap, - struct xvisual_info fmt, bool owned attr_unused) { + struct xvisual_info fmt, bool owned) { auto dummy = (struct dummy_data *)base; struct dummy_image *img = NULL; HASH_FIND_INT(dummy->images, &pixmap, img); @@ -96,6 +99,7 @@ void *dummy_bind_pixmap(struct backend_base *base, xcb_pixmap_t pixmap, img->transparent = fmt.alpha_size != 0; img->refcount = ccalloc(1, int); *img->refcount = 1; + img->owned = owned; HASH_ADD_INT(dummy->images, pixmap, img); return (void *)img; @@ -112,6 +116,9 @@ void dummy_release_image(backend_t *base, void *image) { if (*img->refcount == 0) { HASH_DEL(dummy->images, img); free(img->refcount); + if (img->owned) { + xcb_free_pixmap(base->c->c, img->pixmap); + } free(img); } } @@ -162,7 +169,7 @@ void dummy_destroy_blur_context(struct backend_base *base attr_unused, void *ctx } void dummy_get_blur_size(void *ctx attr_unused, int *width, int *height) { - // These numbers are arbitrary, to make sure the reisze_region code path is + // These numbers are arbitrary, to make sure the resize_region code path is // covered. *width = 5; *height = 5; @@ -177,7 +184,7 @@ struct backend_operations dummy_ops = { .bind_pixmap = dummy_bind_pixmap, .create_shadow_context = default_create_shadow_context, .destroy_shadow_context = default_destroy_shadow_context, - .render_shadow = default_backend_render_shadow, + .render_shadow = default_render_shadow, .make_mask = dummy_make_mask, .release_image = dummy_release_image, .is_image_transparent = dummy_is_image_transparent, diff --git a/src/backend/gl/blur.c b/src/backend/gl/blur.c index 41022f541c..328756fc30 100644 --- a/src/backend/gl/blur.c +++ b/src/backend/gl/blur.c @@ -150,6 +150,9 @@ bool gl_dual_kawase_blur(double opacity, struct gl_blur_context *bctx, const rec glUniform2f(down_pass->texorig_loc, (GLfloat)extent->x1, (GLfloat)dst_y_fb_coord); + glBindVertexArray(vao[1]); + int nelems = vao_nelems[1]; + for (int i = 0; i < iterations; ++i) { // Scale output width / height by half in each iteration scale_factor <<= 1; @@ -174,8 +177,6 @@ bool gl_dual_kawase_blur(double opacity, struct gl_blur_context *bctx, const rec assert(bctx->blur_fbos[i]); glBindTexture(GL_TEXTURE_2D, src_texture); - glBindVertexArray(vao[1]); - auto nelems = vao_nelems[1]; glBindFramebuffer(GL_DRAW_FRAMEBUFFER, bctx->blur_fbos[i]); glDrawBuffer(GL_COLOR_ATTACHMENT0); @@ -194,6 +195,15 @@ bool gl_dual_kawase_blur(double opacity, struct gl_blur_context *bctx, const rec glUniform2f(up_pass->texorig_loc, (GLfloat)extent->x1, (GLfloat)dst_y_fb_coord); + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_2D, default_mask); + + glUniform1i(up_pass->uniform_mask_tex, 1); + glUniform2f(up_pass->uniform_mask_offset, 0.0F, 0.0F); + glUniform1i(up_pass->uniform_mask_inverted, 0); + glUniform1f(up_pass->uniform_mask_corner_radius, 0.0F); + glUniform1f(up_pass->uniform_opacity, 1.0F); + for (int i = iterations - 1; i >= 0; --i) { // Scale output width / height back by two in each iteration scale_factor >>= 1; @@ -206,28 +216,15 @@ bool gl_dual_kawase_blur(double opacity, struct gl_blur_context *bctx, const rec int tex_width = src_size.width; int tex_height = src_size.height; - // The number of indices in the selected vertex array - GLsizei nelems; - glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, src_texture); - glActiveTexture(GL_TEXTURE1); - glBindTexture(GL_TEXTURE_2D, default_mask); - glUniform1i(up_pass->uniform_mask_tex, 1); - glUniform2f(up_pass->uniform_mask_offset, 0.0F, 0.0F); - glUniform1i(up_pass->uniform_mask_inverted, 0); - glUniform1f(up_pass->uniform_mask_corner_radius, 0.0F); if (i > 0) { assert(bctx->blur_fbos[i - 1]); // not last pass, draw into next framebuffer - glBindVertexArray(vao[1]); - nelems = vao_nelems[1]; glBindFramebuffer(GL_DRAW_FRAMEBUFFER, bctx->blur_fbos[i - 1]); glDrawBuffer(GL_COLOR_ATTACHMENT0); - - glUniform1f(up_pass->uniform_opacity, (GLfloat)1); } else { // last pass, draw directly into the back buffer if (mask) { @@ -259,10 +256,10 @@ bool gl_dual_kawase_blur(double opacity, struct gl_blur_context *bctx, const rec return true; } -bool gl_blur_impl(double opacity, struct gl_blur_context *bctx, void *mask, - coord_t mask_dst, const region_t *reg_blur, - const region_t *reg_visible attr_unused, GLuint source_texture, - geometry_t source_size, GLuint target_fbo, GLuint default_mask) { +bool gl_blur_impl(double opacity, struct gl_blur_context *bctx, void *mask, coord_t mask_dst, + const region_t *reg_blur, const region_t *reg_visible attr_unused, + GLuint source_texture, geometry_t source_size, GLuint target_fbo, + GLuint default_mask, bool high_precision) { bool ret = false; if (source_size.width != bctx->fb_width || source_size.height != bctx->fb_height) { @@ -284,7 +281,11 @@ bool gl_blur_impl(double opacity, struct gl_blur_context *bctx, void *mask, } glBindTexture(GL_TEXTURE_2D, bctx->blur_textures[i]); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, tex_size->width, + GLint format = GL_RGBA8; + if (high_precision) { + format = GL_RGBA16; + } + glTexImage2D(GL_TEXTURE_2D, 0, format, tex_size->width, tex_size->height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL); if (bctx->method == BLUR_METHOD_DUAL_KAWASE) { @@ -343,9 +344,9 @@ bool gl_blur_impl(double opacity, struct gl_blur_context *bctx, void *mask, glBindVertexArray(vao[0]); glBindBuffer(GL_ARRAY_BUFFER, bo[0]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bo[1]); - glBufferData(GL_ARRAY_BUFFER, (long)sizeof(*coord) * nrects * 16, coord, GL_STATIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, (long)sizeof(*coord) * nrects * 16, coord, GL_STREAM_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, (long)sizeof(*indices) * nrects * 6, - indices, GL_STATIC_DRAW); + indices, GL_STREAM_DRAW); glEnableVertexAttribArray(vert_coord_loc); glEnableVertexAttribArray(vert_in_texcoord_loc); glVertexAttribPointer(vert_coord_loc, 2, GL_INT, GL_FALSE, sizeof(GLint) * 4, NULL); @@ -356,10 +357,10 @@ bool gl_blur_impl(double opacity, struct gl_blur_context *bctx, void *mask, glBindBuffer(GL_ARRAY_BUFFER, bo[2]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bo[3]); glBufferData(GL_ARRAY_BUFFER, (long)sizeof(*coord_resized) * nrects_resized * 16, - coord_resized, GL_STATIC_DRAW); + coord_resized, GL_STREAM_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, (long)sizeof(*indices_resized) * nrects_resized * 6, indices_resized, - GL_STATIC_DRAW); + GL_STREAM_DRAW); glEnableVertexAttribArray(vert_coord_loc); glEnableVertexAttribArray(vert_in_texcoord_loc); glVertexAttribPointer(vert_coord_loc, 2, GL_INT, GL_FALSE, sizeof(GLint) * 4, NULL); @@ -406,7 +407,7 @@ bool gl_blur(backend_t *base, double opacity, void *ctx, void *mask, coord_t mas return gl_blur_impl(opacity, bctx, mask, mask_dst, reg_blur, reg_visible, gd->back_texture, (geometry_t){.width = gd->width, .height = gd->height}, - gd->back_fbo, gd->default_mask_texture); + gd->back_fbo, gd->default_mask_texture, gd->dithered_present); } static inline void gl_free_blur_shader(gl_blur_shader_t *shader) { @@ -603,9 +604,9 @@ bool gl_create_kernel_blur_context(void *blur_context, GLfloat *projection, bind_uniform(pass, mask_offset); bind_uniform(pass, mask_inverted); bind_uniform(pass, mask_corner_radius); - log_info("Uniform locations: %d %d %d %d %d", pass->uniform_mask_tex, - pass->uniform_mask_offset, pass->uniform_mask_inverted, - pass->uniform_mask_corner_radius, pass->uniform_opacity); + log_debug("Uniform locations: %d %d %d %d %d", pass->uniform_mask_tex, + pass->uniform_mask_offset, pass->uniform_mask_inverted, + pass->uniform_mask_corner_radius, pass->uniform_opacity); pass->texorig_loc = glGetUniformLocationChecked(pass->prog, "texorig"); // Setup projection matrix diff --git a/src/backend/gl/egl.c b/src/backend/gl/egl.c index 0c3c0d4840..ca70359173 100644 --- a/src/backend/gl/egl.c +++ b/src/backend/gl/egl.c @@ -36,20 +36,50 @@ struct egl_data { EGLContext ctx; }; +static PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC glEGLImageTargetTexStorage = NULL; +static PFNEGLCREATEIMAGEKHRPROC eglCreateImageProc = NULL; +static PFNEGLDESTROYIMAGEKHRPROC eglDestroyImageProc = NULL; +static PFNEGLGETPLATFORMDISPLAYPROC eglGetPlatformDisplayProc = NULL; +static PFNEGLCREATEPLATFORMWINDOWSURFACEPROC eglCreatePlatformWindowSurfaceProc = NULL; + +const char *eglGetErrorString(EGLint error) { +#define CASE_STR(value) \ + case value: return #value; + switch (error) { + CASE_STR(EGL_SUCCESS) + CASE_STR(EGL_NOT_INITIALIZED) + CASE_STR(EGL_BAD_ACCESS) + CASE_STR(EGL_BAD_ALLOC) + CASE_STR(EGL_BAD_ATTRIBUTE) + CASE_STR(EGL_BAD_CONTEXT) + CASE_STR(EGL_BAD_CONFIG) + CASE_STR(EGL_BAD_CURRENT_SURFACE) + CASE_STR(EGL_BAD_DISPLAY) + CASE_STR(EGL_BAD_SURFACE) + CASE_STR(EGL_BAD_MATCH) + CASE_STR(EGL_BAD_PARAMETER) + CASE_STR(EGL_BAD_NATIVE_PIXMAP) + CASE_STR(EGL_BAD_NATIVE_WINDOW) + CASE_STR(EGL_CONTEXT_LOST) + default: return "Unknown"; + } +#undef CASE_STR +} + /** - * Free a glx_texture_t. + * Free a gl_texture_t. */ static void egl_release_image(backend_t *base, struct gl_texture *tex) { struct egl_data *gd = (void *)base; struct egl_pixmap *p = tex->user_data; // Release binding if (p->image != EGL_NO_IMAGE) { - eglDestroyImage(gd->display, p->image); + eglDestroyImageProc(gd->display, p->image); p->image = EGL_NO_IMAGE; } if (p->owned) { - xcb_free_pixmap(base->c, p->pixmap); + xcb_free_pixmap(base->c->c, p->pixmap); p->pixmap = XCB_NONE; } @@ -58,14 +88,14 @@ static void egl_release_image(backend_t *base, struct gl_texture *tex) { } /** - * Destroy GLX related resources. + * Destroy EGL related resources. */ void egl_deinit(backend_t *base) { struct egl_data *gd = (void *)base; gl_deinit(&gd->gl); - // Destroy GLX context + // Destroy EGL context if (gd->ctx != EGL_NO_CONTEXT) { eglMakeCurrent(gd->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); eglDestroyContext(gd->display, gd->ctx); @@ -100,7 +130,22 @@ static bool egl_set_swap_interval(int interval, EGLDisplay dpy) { /** * Initialize OpenGL. */ -static backend_t *egl_init(session_t *ps) { +static backend_t *egl_init(session_t *ps, xcb_window_t target) { + bool success = false; + struct egl_data *gd = NULL; + +#define get_proc(name, type) \ + name##Proc = (type)eglGetProcAddress(#name); \ + if (!name##Proc) { \ + log_error("Failed to get EGL function " #name); \ + goto end; \ + } + get_proc(eglCreateImage, PFNEGLCREATEIMAGEKHRPROC); + get_proc(eglDestroyImage, PFNEGLDESTROYIMAGEKHRPROC); + get_proc(eglGetPlatformDisplay, PFNEGLGETPLATFORMDISPLAYPROC); + get_proc(eglCreatePlatformWindowSurface, PFNEGLCREATEPLATFORMWINDOWSURFACEPROC); +#undef get_proc + // Check if we have the X11 platform const char *exts = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS); if (strstr(exts, "EGL_EXT_platform_x11") == NULL) { @@ -108,14 +153,13 @@ static backend_t *egl_init(session_t *ps) { return NULL; } - bool success = false; - auto gd = ccalloc(1, struct egl_data); - gd->display = eglGetPlatformDisplay(EGL_PLATFORM_X11_EXT, ps->dpy, - (EGLAttrib[]){ - EGL_PLATFORM_X11_SCREEN_EXT, - ps->scr, - EGL_NONE, - }); + gd = ccalloc(1, struct egl_data); + gd->display = eglGetPlatformDisplayProc(EGL_PLATFORM_X11_EXT, ps->c.dpy, + (EGLAttrib[]){ + EGL_PLATFORM_X11_SCREEN_EXT, + ps->c.screen, + EGL_NONE, + }); if (gd->display == EGL_NO_DISPLAY) { log_error("Failed to get EGL display."); goto end; @@ -127,6 +171,11 @@ static backend_t *egl_init(session_t *ps) { goto end; } + if (major < 1 || (major == 1 && minor < 5)) { + log_error("EGL version too old, need at least 1.5."); + goto end; + } + // Check if EGL supports OpenGL const char *apis = eglQueryString(gd->display, EGL_CLIENT_APIS); if (strstr(apis, "OpenGL") == NULL) { @@ -141,14 +190,9 @@ static backend_t *egl_init(session_t *ps) { goto end; } - int ncfgs = 0; - if (eglGetConfigs(gd->display, NULL, 0, &ncfgs) != EGL_TRUE) { - log_error("Failed to get EGL configs."); - goto end; - } - - auto visual_info = x_get_visual_info(ps->c, ps->vis); - EGLConfig *cfgs = ccalloc(ncfgs, EGLConfig); + auto visual_info = x_get_visual_info(&ps->c, ps->c.screen_info->root_visual); + EGLConfig config = NULL; + int nconfigs = 1; // clang-format off if (eglChooseConfig(gd->display, (EGLint[]){ @@ -161,17 +205,14 @@ static backend_t *egl_init(session_t *ps) { EGL_STENCIL_SIZE, 1, EGL_CONFIG_CAVEAT, EGL_NONE, EGL_NONE, - }, cfgs, ncfgs, &ncfgs) != EGL_TRUE) { + }, &config, nconfigs, &nconfigs) != EGL_TRUE) { log_error("Failed to choose EGL config for the root window."); goto end; } // clang-format on - EGLConfig target_cfg = cfgs[0]; - free(cfgs); - - gd->target_win = eglCreatePlatformWindowSurface( - gd->display, target_cfg, (xcb_window_t[]){session_get_target_window(ps)}, NULL); + gd->target_win = + eglCreatePlatformWindowSurfaceProc(gd->display, config, &target, NULL); if (gd->target_win == EGL_NO_SURFACE) { log_error("Failed to create EGL surface."); goto end; @@ -182,14 +223,14 @@ static backend_t *egl_init(session_t *ps) { goto end; } - gd->ctx = eglCreateContext(gd->display, target_cfg, NULL, NULL); + gd->ctx = eglCreateContext(gd->display, config, NULL, NULL); if (gd->ctx == EGL_NO_CONTEXT) { - log_error("Failed to get GLX context."); + log_error("Failed to get EGL context."); goto end; } if (!eglMakeCurrent(gd->display, gd->target_win, gd->target_win, gd->ctx)) { - log_error("Failed to attach GLX context."); + log_error("Failed to attach EGL context."); goto end; } @@ -202,6 +243,14 @@ static backend_t *egl_init(session_t *ps) { goto end; } + glEGLImageTargetTexStorage = + (PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC)eglGetProcAddress("glEGLImageTargetTexS" + "torageEXT"); + if (glEGLImageTargetTexStorage == NULL) { + log_error("Failed to get glEGLImageTargetTexStorageEXT."); + goto end; + } + gd->gl.decouple_texture_user_data = egl_decouple_user_data; gd->gl.release_user_data = egl_release_image; @@ -217,7 +266,9 @@ static backend_t *egl_init(session_t *ps) { end: if (!success) { - egl_deinit(&gd->gl.base); + if (gd != NULL) { + egl_deinit(&gd->gl.base); + } return NULL; } @@ -229,7 +280,8 @@ egl_bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, b struct egl_data *gd = (void *)base; struct egl_pixmap *eglpixmap = NULL; - auto r = xcb_get_geometry_reply(base->c, xcb_get_geometry(base->c, pixmap), NULL); + auto r = + xcb_get_geometry_reply(base->c->c, xcb_get_geometry(base->c->c, pixmap), NULL); if (!r) { log_error("Invalid pixmap %#010x", pixmap); return NULL; @@ -250,12 +302,14 @@ egl_bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, b eglpixmap = cmalloc(struct egl_pixmap); eglpixmap->pixmap = pixmap; - eglpixmap->image = eglCreateImage(gd->display, gd->ctx, EGL_NATIVE_PIXMAP_KHR, - (EGLClientBuffer)(uintptr_t)pixmap, NULL); + eglpixmap->image = + eglCreateImageProc(gd->display, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, + (EGLClientBuffer)(uintptr_t)pixmap, NULL); eglpixmap->owned = owned; if (eglpixmap->image == EGL_NO_IMAGE) { - log_error("Failed to create eglpixmap for pixmap %#010x", pixmap); + log_error("Failed to create eglpixmap for pixmap %#010x: %s", pixmap, + eglGetErrorString(eglGetError())); goto err; } @@ -270,19 +324,19 @@ egl_bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, b wd->dim = 0; wd->inner->refcount = 1; glBindTexture(GL_TEXTURE_2D, inner->texture); - glEGLImageTargetTexStorageEXT(GL_TEXTURE_2D, eglpixmap->image, NULL); + glEGLImageTargetTexStorage(GL_TEXTURE_2D, eglpixmap->image, NULL); glBindTexture(GL_TEXTURE_2D, 0); gl_check_err(); return wd; err: if (eglpixmap && eglpixmap->image) { - eglDestroyImage(gd->display, eglpixmap->image); + eglDestroyImageProc(gd->display, eglpixmap->image); } free(eglpixmap); if (owned) { - xcb_free_pixmap(base->c, pixmap); + xcb_free_pixmap(base->c->c, pixmap); } free(wd); return NULL; @@ -292,9 +346,6 @@ static void egl_present(backend_t *base, const region_t *region attr_unused) { struct egl_data *gd = (void *)base; gl_present(base, region); eglSwapBuffers(gd->display, gd->target_win); - if (!gd->gl.is_nvidia) { - glFinish(); - } } static int egl_buffer_age(backend_t *base) { @@ -344,6 +395,7 @@ struct backend_operations egl_ops = { .deinit = egl_deinit, .bind_pixmap = egl_bind_pixmap, .release_image = gl_release_image, + .prepare = gl_prepare, .compose = gl_compose, .image_op = gl_image_op, .set_image_property = gl_set_image_property, @@ -352,6 +404,7 @@ struct backend_operations egl_ops = { .is_image_transparent = default_is_image_transparent, .present = egl_present, .buffer_age = egl_buffer_age, + .last_render_time = gl_last_render_time, .create_shadow_context = gl_create_shadow_context, .destroy_shadow_context = gl_destroy_shadow_context, .render_shadow = backend_render_shadow_from_mask, @@ -371,7 +424,7 @@ struct backend_operations egl_ops = { PFNEGLGETDISPLAYDRIVERNAMEPROC eglGetDisplayDriverName; /** - * Check if a GLX extension exists. + * Check if a EGL extension exists. */ static inline bool egl_has_extension(EGLDisplay dpy, const char *ext) { const char *egl_exts = eglQueryString(dpy, EGL_EXTENSIONS); diff --git a/src/backend/gl/egl.h b/src/backend/gl/egl.h index 171b173585..f482032b3e 100644 --- a/src/backend/gl/egl.h +++ b/src/backend/gl/egl.h @@ -1,13 +1,11 @@ // SPDX-License-Identifier: MPL-2.0 // Copyright (c) Yuxuan Shui #pragma once -#include -// Older version of glx.h defines function prototypes for these extensions... -// Rename them to avoid conflicts #include #include #include #include +#include #include #include diff --git a/src/backend/gl/gl_common.c b/src/backend/gl/gl_common.c index 7ade23398d..76d4571b08 100644 --- a/src/backend/gl/gl_common.c +++ b/src/backend/gl/gl_common.c @@ -22,6 +22,11 @@ #include "backend/backend_common.h" #include "backend/gl/gl_common.h" +void gl_prepare(backend_t *base, const region_t *reg attr_unused) { + auto gd = (struct gl_data *)base; + glBeginQuery(GL_TIME_ELAPSED, gd->frame_timing[gd->current_frame_timing]); +} + GLuint gl_create_shader(GLenum shader_type, const char *shader_str) { log_trace("===\n%s\n===", shader_str); @@ -304,9 +309,9 @@ static GLuint gl_average_texture_color(backend_t *base, struct backend_image *im // Allocate buffers for render input GLint coord[16] = {0}; GLuint indices[] = {0, 1, 2, 2, 3, 0}; - glBufferData(GL_ARRAY_BUFFER, (long)sizeof(*coord) * 16, coord, GL_DYNAMIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, (long)sizeof(*coord) * 16, coord, GL_STREAM_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, (long)sizeof(*indices) * 6, indices, - GL_STATIC_DRAW); + GL_STREAM_DRAW); // Do actual recursive render to 1x1 texture GLuint result_texture = _gl_average_texture_color( @@ -385,6 +390,10 @@ static void _gl_compose(backend_t *base, struct backend_image *img, GLuint targe if (win_shader->uniform_tex >= 0) { glUniform1i(win_shader->uniform_tex, 0); } + if (win_shader->uniform_effective_size >= 0) { + glUniform2f(win_shader->uniform_effective_size, (float)img->ewidth, + (float)img->eheight); + } if (win_shader->uniform_dim >= 0) { glUniform1f(win_shader->uniform_dim, (float)img->dim); } @@ -443,9 +452,9 @@ static void _gl_compose(backend_t *base, struct backend_image *img, GLuint targe glGenBuffers(2, bo); glBindBuffer(GL_ARRAY_BUFFER, bo[0]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bo[1]); - glBufferData(GL_ARRAY_BUFFER, (long)sizeof(*coord) * nrects * 16, coord, GL_STATIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, (long)sizeof(*coord) * nrects * 16, coord, GL_STREAM_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, (long)sizeof(*indices) * nrects * 6, - indices, GL_STATIC_DRAW); + indices, GL_STREAM_DRAW); glEnableVertexAttribArray(vert_coord_loc); glEnableVertexAttribArray(vert_in_texcoord_loc); @@ -477,8 +486,6 @@ static void _gl_compose(backend_t *base, struct backend_image *img, GLuint targe glUseProgram(0); gl_check_err(); - - return; } /// Convert rectangles in X coordinates to OpenGL vertex and texture coordinates @@ -596,6 +603,7 @@ static bool gl_win_shader_from_stringv(const char **vshader_strv, bind_uniform(ret, opacity); bind_uniform(ret, invert_color); bind_uniform(ret, tex); + bind_uniform(ret, effective_size); bind_uniform(ret, dim); bind_uniform(ret, brightness); bind_uniform(ret, max_brightness); @@ -627,7 +635,7 @@ void gl_resize(struct gl_data *gd, int width, int height) { assert(viewport_dimensions[1] >= gd->height); glBindTexture(GL_TEXTURE_2D, gd->back_texture); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, width, height, 0, GL_BGR, + glTexImage2D(GL_TEXTURE_2D, 0, gd->back_format, width, height, 0, GL_BGR, GL_UNSIGNED_BYTE, NULL); gl_check_err(); @@ -800,7 +808,10 @@ uint64_t gl_get_shader_attributes(backend_t *backend_data attr_unused, void *sha } bool gl_init(struct gl_data *gd, session_t *ps) { - // Initialize GLX data structure + glGenQueries(2, gd->frame_timing); + gd->current_frame_timing = 0; + + // Initialize GL data structure glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); @@ -873,7 +884,16 @@ bool gl_init(struct gl_data *gd, session_t *ps) { glUniformMatrix4fv(pml, 1, false, projection_matrix[0]); glUseProgram(0); - gd->present_prog = gl_create_program_from_str(present_vertex_shader, dummy_frag); + gd->dithered_present = ps->o.dithered_present; + if (gd->dithered_present) { + gd->present_prog = gl_create_program_from_strv( + (const char *[]){present_vertex_shader, NULL}, + (const char *[]){present_frag, dither_glsl, NULL}); + } else { + gd->present_prog = gl_create_program_from_strv( + (const char *[]){present_vertex_shader, NULL}, + (const char *[]){dummy_frag, NULL}); + } if (!gd->present_prog) { log_error("Failed to create the present shader"); return false; @@ -907,14 +927,23 @@ bool gl_init(struct gl_data *gd, session_t *ps) { glUniformMatrix4fv(pml, 1, false, projection_matrix[0]); glUseProgram(0); - // Set up the size of the back texture - gl_resize(gd, ps->root_width, ps->root_height); - + // Set up the size and format of the back texture glBindFramebuffer(GL_DRAW_FRAMEBUFFER, gd->back_fbo); - glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, - gd->back_texture, 0); glDrawBuffer(GL_COLOR_ATTACHMENT0); - if (!gl_check_fb_complete(GL_FRAMEBUFFER)) { + const GLint *format = gd->dithered_present ? (const GLint[]){GL_RGB16, GL_RGBA16} + : (const GLint[]){GL_RGB8, GL_RGBA8}; + for (int i = 0; i < 2; i++) { + gd->back_format = format[i]; + gl_resize(gd, ps->root_width, ps->root_height); + + glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, + GL_TEXTURE_2D, gd->back_texture, 0); + if (glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) { + log_info("Using back buffer format %#x", gd->back_format); + break; + } + } + if (!gl_check_fb_complete(GL_DRAW_FRAMEBUFFER)) { return false; } glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); @@ -927,7 +956,7 @@ bool gl_init(struct gl_data *gd, session_t *ps) { const char *vendor = (const char *)glGetString(GL_VENDOR); log_debug("GL_VENDOR = %s", vendor); if (strcmp(vendor, "NVIDIA Corporation") == 0) { - log_info("GL vendor is NVIDIA, don't use glFinish"); + log_info("GL vendor is NVIDIA, enable xrender sync fence."); gd->is_nvidia = true; } else { gd->is_nvidia = false; @@ -950,6 +979,9 @@ void gl_deinit(struct gl_data *gd) { gd->default_shader = NULL; } + glDeleteTextures(1, &gd->default_mask_texture); + glDeleteTextures(1, &gd->back_texture); + gl_check_err(); } @@ -1036,9 +1068,9 @@ static inline void gl_image_decouple(backend_t *base, struct backend_image *img) glGenBuffers(2, bo); glBindBuffer(GL_ARRAY_BUFFER, bo[0]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bo[1]); - glBufferData(GL_ARRAY_BUFFER, (long)sizeof(*coord) * 16, coord, GL_STATIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, (long)sizeof(*coord) * 16, coord, GL_STREAM_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, (long)sizeof(*indices) * 6, indices, - GL_STATIC_DRAW); + GL_STREAM_DRAW); glEnableVertexAttribArray(vert_coord_loc); glEnableVertexAttribArray(vert_in_texcoord_loc); @@ -1136,10 +1168,33 @@ void gl_present(backend_t *base, const region_t *region) { glDeleteBuffers(2, bo); glDeleteVertexArrays(1, &vao); + glEndQuery(GL_TIME_ELAPSED); + gd->current_frame_timing ^= 1; + + gl_check_err(); + free(coord); free(indices); } +bool gl_last_render_time(backend_t *base, struct timespec *ts) { + auto gd = (struct gl_data *)base; + GLint available = 0; + glGetQueryObjectiv(gd->frame_timing[gd->current_frame_timing ^ 1], + GL_QUERY_RESULT_AVAILABLE, &available); + if (!available) { + return false; + } + + GLuint64 time; + glGetQueryObjectui64v(gd->frame_timing[gd->current_frame_timing ^ 1], + GL_QUERY_RESULT, &time); + ts->tv_sec = (long)(time / 1000000000); + ts->tv_nsec = (long)(time % 1000000000); + gl_check_err(); + return true; +} + bool gl_image_op(backend_t *base, enum image_operations op, void *image_data, const region_t *reg_op, const region_t *reg_visible attr_unused, void *arg) { struct backend_image *tex = image_data; @@ -1174,18 +1229,28 @@ struct gl_shadow_context { struct backend_shadow_context *gl_create_shadow_context(backend_t *base, double radius) { auto ctx = ccalloc(1, struct gl_shadow_context); ctx->radius = radius; - - struct gaussian_blur_args args = { - .size = (int)radius, - .deviation = gaussian_kernel_std_for_size(radius, 0.5 / 256.0), - }; - ctx->blur_context = gl_create_blur_context(base, BLUR_METHOD_GAUSSIAN, &args); + ctx->blur_context = NULL; + + if (radius > 0) { + struct gaussian_blur_args args = { + .size = (int)radius, + .deviation = gaussian_kernel_std_for_size(radius, 0.5 / 256.0), + }; + ctx->blur_context = gl_create_blur_context(base, BLUR_METHOD_GAUSSIAN, &args); + if (!ctx->blur_context) { + log_error("Failed to create shadow context"); + free(ctx); + return NULL; + } + } return (struct backend_shadow_context *)ctx; } void gl_destroy_shadow_context(backend_t *base attr_unused, struct backend_shadow_context *ctx) { auto ctx_ = (struct gl_shadow_context *)ctx; - gl_destroy_blur_context(base, (struct backend_blur_context *)ctx_->blur_context); + if (ctx_->blur_context) { + gl_destroy_blur_context(base, (struct backend_blur_context *)ctx_->blur_context); + } free(ctx_); } @@ -1213,6 +1278,8 @@ void *gl_shadow_from_mask(backend_t *base, void *mask, auto source_texture = gl_new_texture(GL_TEXTURE_2D); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, source_texture); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, new_inner->width, new_inner->height, 0, GL_RED, GL_UNSIGNED_BYTE, NULL); glBindTexture(GL_TEXTURE_2D, 0); @@ -1244,27 +1311,32 @@ void *gl_shadow_from_mask(backend_t *base, void *mask, gl_check_err(); - glActiveTexture(GL_TEXTURE0); - auto tmp_texture = gl_new_texture(GL_TEXTURE_2D); - glBindTexture(GL_TEXTURE_2D, tmp_texture); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, new_inner->width, new_inner->height, 0, - GL_RED, GL_UNSIGNED_BYTE, NULL); - glBindTexture(GL_TEXTURE_2D, 0); - - glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo); - glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, - tmp_texture, 0); - - region_t reg_blur; - pixman_region32_init_rect(®_blur, 0, 0, (unsigned int)new_inner->width, - (unsigned int)new_inner->height); - // gl_blur expects reg_blur to be in X coordinate system (i.e. y flipped), but we - // are covering the whole texture so we don't need to worry about that. - gl_blur_impl(1.0, gsctx->blur_context, NULL, (coord_t){0}, ®_blur, NULL, - source_texture, - (geometry_t){.width = new_inner->width, .height = new_inner->height}, - fbo, gd->default_mask_texture); - pixman_region32_fini(®_blur); + auto tmp_texture = source_texture; + if (gsctx->blur_context != NULL) { + glActiveTexture(GL_TEXTURE0); + tmp_texture = gl_new_texture(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, tmp_texture); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, new_inner->width, + new_inner->height, 0, GL_RED, GL_UNSIGNED_BYTE, NULL); + glBindTexture(GL_TEXTURE_2D, 0); + + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo); + glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, + GL_TEXTURE_2D, tmp_texture, 0); + + region_t reg_blur; + pixman_region32_init_rect(®_blur, 0, 0, (unsigned int)new_inner->width, + (unsigned int)new_inner->height); + // gl_blur expects reg_blur to be in X coordinate system (i.e. y flipped), + // but we are covering the whole texture so we don't need to worry about + // that. + gl_blur_impl( + 1.0, gsctx->blur_context, NULL, (coord_t){0}, ®_blur, NULL, + source_texture, + (geometry_t){.width = new_inner->width, .height = new_inner->height}, + fbo, gd->default_mask_texture, gd->dithered_present); + pixman_region32_fini(®_blur); + } // Colorize the shadow with color. log_debug("Colorize shadow"); @@ -1280,8 +1352,11 @@ void *gl_shadow_from_mask(backend_t *base, void *mask, glBindTexture(GL_TEXTURE_2D, tmp_texture); glUseProgram(gd->shadow_shader.prog); - glUniform4f(gd->shadow_shader.uniform_color, (GLfloat)color.red, - (GLfloat)color.green, (GLfloat)color.blue, (GLfloat)color.alpha); + // The shadow color is converted to the premultiplied format to respect the + // globally set glBlendFunc and thus get the correct and expected result. + glUniform4f(gd->shadow_shader.uniform_color, (GLfloat)(color.red * color.alpha), + (GLfloat)(color.green * color.alpha), + (GLfloat)(color.blue * color.alpha), (GLfloat)color.alpha); // clang-format off GLuint indices[] = {0, 1, 2, 2, 3, 0}; @@ -1299,9 +1374,9 @@ void *gl_shadow_from_mask(backend_t *base, void *mask, glGenBuffers(2, bo); glBindBuffer(GL_ARRAY_BUFFER, bo[0]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bo[1]); - glBufferData(GL_ARRAY_BUFFER, (long)sizeof(*coord) * 8, coord, GL_STATIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, (long)sizeof(*coord) * 8, coord, GL_STREAM_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, (long)sizeof(*indices) * 6, indices, - GL_STATIC_DRAW); + GL_STREAM_DRAW); glEnableVertexAttribArray(vert_coord_loc); glVertexAttribPointer(vert_coord_loc, 2, GL_INT, GL_FALSE, sizeof(GLint) * 2, NULL); @@ -1316,7 +1391,10 @@ void *gl_shadow_from_mask(backend_t *base, void *mask, glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glDeleteBuffers(2, bo); - glDeleteTextures(1, (GLuint[]){source_texture, tmp_texture}); + glDeleteTextures(1, (GLuint[]){source_texture}); + if (tmp_texture != source_texture) { + glDeleteTextures(1, (GLuint[]){tmp_texture}); + } glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); glDeleteFramebuffers(1, &fbo); gl_check_err(); diff --git a/src/backend/gl/gl_common.h b/src/backend/gl/gl_common.h index 3a7886518b..c9cb600e81 100644 --- a/src/backend/gl/gl_common.h +++ b/src/backend/gl/gl_common.h @@ -35,6 +35,7 @@ typedef struct { GLint uniform_opacity; GLint uniform_invert_color; GLint uniform_tex; + GLint uniform_effective_size; GLint uniform_dim; GLint uniform_brightness; GLint uniform_max_brightness; @@ -77,7 +78,7 @@ typedef struct { GLint color_loc; } gl_fill_shader_t; -/// @brief Wrapper of a binded GLX texture. +/// @brief Wrapper of a binded GL texture. struct gl_texture { int refcount; bool has_alpha; @@ -107,8 +108,13 @@ struct gl_data { gl_fill_shader_t fill_shader; gl_shadow_shader_t shadow_shader; GLuint back_texture, back_fbo; + GLint back_format; + GLuint frame_timing[2]; + int current_frame_timing; GLuint present_prog; + bool dithered_present; + GLuint default_mask_texture; /// Called when an gl_texture is decoupled from the texture it refers. Returns @@ -126,6 +132,7 @@ typedef struct session session_t; #define GL_PROG_MAIN_INIT \ { .prog = 0, .unifm_opacity = -1, .unifm_invert_color = -1, .unifm_tex = -1, } +void gl_prepare(backend_t *base, const region_t *reg); void x_rect_to_coords(int nrects, const rect_t *rects, coord_t image_dst, int extent_height, int texture_height, int root_height, bool y_inverted, GLint *coord, GLuint *indices); @@ -139,6 +146,7 @@ void gl_destroy_window_shader(backend_t *backend_data, void *shader); uint64_t gl_get_shader_attributes(backend_t *backend_data, void *shader); bool gl_set_image_property(backend_t *backend_data, enum image_properties prop, void *image_data, void *args); +bool gl_last_render_time(backend_t *backend_data, struct timespec *time); /** * @brief Render a region with texture data. @@ -163,10 +171,10 @@ void *gl_clone(backend_t *base, const void *image_data, const region_t *reg_visi bool gl_blur(backend_t *base, double opacity, void *ctx, void *mask, coord_t mask_dst, const region_t *reg_blur, const region_t *reg_visible); -bool gl_blur_impl(double opacity, struct gl_blur_context *bctx, void *mask, - coord_t mask_dst, const region_t *reg_blur, - const region_t *reg_visible attr_unused, GLuint source_texture, - geometry_t source_size, GLuint target_fbo, GLuint default_mask); +bool gl_blur_impl(double opacity, struct gl_blur_context *bctx, void *mask, coord_t mask_dst, + const region_t *reg_blur, const region_t *reg_visible attr_unused, + GLuint source_texture, geometry_t source_size, GLuint target_fbo, + GLuint default_mask, bool high_precision); void *gl_create_blur_context(backend_t *base, enum blur_method, void *args); void gl_destroy_blur_context(backend_t *base, void *ctx); struct backend_shadow_context *gl_create_shadow_context(backend_t *base, double radius); @@ -181,10 +189,6 @@ void gl_present(backend_t *base, const region_t *); bool gl_read_pixel(backend_t *base, void *image_data, int x, int y, struct color *output); enum device_status gl_device_status(backend_t *base); -static inline void gl_delete_texture(GLuint texture) { - glDeleteTextures(1, &texture); -} - /** * Get a textual representation of an OpenGL error. */ @@ -211,7 +215,7 @@ static inline const char *gl_get_err_str(GLenum err) { } /** - * Check for GLX error. + * Check for GL error. * * http://blog.nobel-joergensen.com/2013/01/29/debugging-opengl-using-glgeterror/ */ @@ -222,10 +226,10 @@ static inline void gl_check_err_(const char *func, int line) { const char *errtext = gl_get_err_str(err); if (errtext) { log_printf(tls_logger, LOG_LEVEL_ERROR, func, - "GLX error at line %d: %s", line, errtext); + "GL error at line %d: %s", line, errtext); } else { log_printf(tls_logger, LOG_LEVEL_ERROR, func, - "GLX error at line %d: %d", line, err); + "GL error at line %d: %d", line, err); } } } @@ -262,7 +266,7 @@ static inline bool gl_check_fb_complete_(const char *func, int line, GLenum fb) #define gl_check_fb_complete(fb) gl_check_fb_complete_(__func__, __LINE__, (fb)) /** - * Check if a GLX extension exists. + * Check if a GL extension exists. */ static inline bool gl_has_extension(const char *ext) { int nexts = 0; @@ -288,5 +292,6 @@ static const GLuint vert_in_texcoord_loc = 1; #define QUOTE(...) #__VA_ARGS__ extern const char vertex_shader[], copy_with_mask_frag[], masking_glsl[], dummy_frag[], - fill_frag[], fill_vert[], interpolating_frag[], interpolating_vert[], win_shader_glsl[], - win_shader_default[], present_vertex_shader[], shadow_colorization_frag[]; + present_frag[], fill_frag[], fill_vert[], interpolating_frag[], interpolating_vert[], + win_shader_glsl[], win_shader_default[], present_vertex_shader[], dither_glsl[], + shadow_colorization_frag[]; diff --git a/src/backend/gl/glx.c b/src/backend/gl/glx.c index 109bec9429..78143a2b77 100644 --- a/src/backend/gl/glx.c +++ b/src/backend/gl/glx.c @@ -42,8 +42,6 @@ struct _glx_pixmap { struct _glx_data { struct gl_data gl; - Display *display; - int screen; xcb_window_t target_win; GLXContext ctx; }; @@ -52,18 +50,18 @@ struct _glx_data { do { \ if (glXGetFBConfigAttrib(a, b, attr, c)) { \ log_info("Cannot get FBConfig attribute " #attr); \ - continue; \ + break; \ } \ } while (0) -struct glx_fbconfig_info *glx_find_fbconfig(Display *dpy, int screen, struct xvisual_info m) { +struct glx_fbconfig_info *glx_find_fbconfig(struct x_connection *c, struct xvisual_info m) { log_debug("Looking for FBConfig for RGBA%d%d%d%d, depth %d", m.red_size, m.blue_size, m.green_size, m.alpha_size, m.visual_depth); int ncfg; // clang-format off GLXFBConfig *cfg = - glXChooseFBConfig(dpy, screen, (int[]){ + glXChooseFBConfig(c->dpy, c->screen, (int[]){ GLX_RENDER_TYPE, GLX_RGBA_BIT, GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT, GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR, @@ -87,25 +85,26 @@ struct glx_fbconfig_info *glx_find_fbconfig(Display *dpy, int screen, struct xvi GLXFBConfig ret; for (int i = 0; i < ncfg; i++) { int depthbuf, stencil, doublebuf, bufsize; - glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_BUFFER_SIZE, &bufsize); - glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_DEPTH_SIZE, &depthbuf); - glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_STENCIL_SIZE, &stencil); - glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_DOUBLEBUFFER, &doublebuf); + glXGetFBConfigAttribChecked(c->dpy, cfg[i], GLX_BUFFER_SIZE, &bufsize); + glXGetFBConfigAttribChecked(c->dpy, cfg[i], GLX_DEPTH_SIZE, &depthbuf); + glXGetFBConfigAttribChecked(c->dpy, cfg[i], GLX_STENCIL_SIZE, &stencil); + glXGetFBConfigAttribChecked(c->dpy, cfg[i], GLX_DOUBLEBUFFER, &doublebuf); if (depthbuf + stencil + bufsize * (doublebuf + 1) >= min_cost) { continue; } int red, green, blue; - glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_RED_SIZE, &red); - glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_BLUE_SIZE, &blue); - glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_GREEN_SIZE, &green); + glXGetFBConfigAttribChecked(c->dpy, cfg[i], GLX_RED_SIZE, &red); + glXGetFBConfigAttribChecked(c->dpy, cfg[i], GLX_BLUE_SIZE, &blue); + glXGetFBConfigAttribChecked(c->dpy, cfg[i], GLX_GREEN_SIZE, &green); if (red != m.red_size || green != m.green_size || blue != m.blue_size) { // Color size doesn't match, this cannot work continue; } int rgb, rgba; - glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_BIND_TO_TEXTURE_RGB_EXT, &rgb); - glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_BIND_TO_TEXTURE_RGBA_EXT, &rgba); + glXGetFBConfigAttribChecked(c->dpy, cfg[i], GLX_BIND_TO_TEXTURE_RGB_EXT, &rgb); + glXGetFBConfigAttribChecked(c->dpy, cfg[i], GLX_BIND_TO_TEXTURE_RGBA_EXT, + &rgba); if (!rgb && !rgba) { log_info("FBConfig is neither RGBA nor RGB, we cannot " "handle this setup."); @@ -113,10 +112,9 @@ struct glx_fbconfig_info *glx_find_fbconfig(Display *dpy, int screen, struct xvi } int visual; - glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_VISUAL_ID, &visual); + glXGetFBConfigAttribChecked(c->dpy, cfg[i], GLX_VISUAL_ID, &visual); if (m.visual_depth != -1 && - x_get_visual_depth(XGetXCBConnection(dpy), (xcb_visualid_t)visual) != - m.visual_depth) { + x_get_visual_depth(c, (xcb_visualid_t)visual) != m.visual_depth) { // FBConfig and the correspondent X Visual might not have the same // depth. (e.g. 32 bit FBConfig with a 24 bit Visual). This is // quite common, seen in both open source and proprietary drivers. @@ -129,9 +127,9 @@ struct glx_fbconfig_info *glx_find_fbconfig(Display *dpy, int screen, struct xvi // All check passed, we are using this one. found = true; ret = cfg[i]; - glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_BIND_TO_TEXTURE_TARGETS_EXT, - &texture_tgts); - glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_Y_INVERTED_EXT, &y_inverted); + glXGetFBConfigAttribChecked( + c->dpy, cfg[i], GLX_BIND_TO_TEXTURE_TARGETS_EXT, &texture_tgts); + glXGetFBConfigAttribChecked(c->dpy, cfg[i], GLX_Y_INVERTED_EXT, &y_inverted); // Prefer the texture format with matching alpha, with the other one as // fallback @@ -161,24 +159,22 @@ struct glx_fbconfig_info *glx_find_fbconfig(Display *dpy, int screen, struct xvi * Free a glx_texture_t. */ static void glx_release_image(backend_t *base, struct gl_texture *tex) { - struct _glx_data *gd = (void *)base; - struct _glx_pixmap *p = tex->user_data; // Release binding if (p->glpixmap && tex->texture) { glBindTexture(GL_TEXTURE_2D, tex->texture); - glXReleaseTexImageEXT(gd->display, p->glpixmap, GLX_FRONT_LEFT_EXT); + glXReleaseTexImageEXT(base->c->dpy, p->glpixmap, GLX_FRONT_LEFT_EXT); glBindTexture(GL_TEXTURE_2D, 0); } // Free GLX Pixmap if (p->glpixmap) { - glXDestroyPixmap(gd->display, p->glpixmap); + glXDestroyPixmap(base->c->dpy, p->glpixmap); p->glpixmap = 0; } if (p->owned) { - xcb_free_pixmap(base->c, p->pixmap); + xcb_free_pixmap(base->c->c, p->pixmap); p->pixmap = XCB_NONE; } @@ -196,8 +192,8 @@ void glx_deinit(backend_t *base) { // Destroy GLX context if (gd->ctx) { - glXMakeCurrent(gd->display, None, NULL); - glXDestroyContext(gd->display, gd->ctx); + glXMakeCurrent(base->c->dpy, None, NULL); + glXDestroyContext(base->c->dpy, gd->ctx); gd->ctx = 0; } @@ -231,15 +227,13 @@ static bool glx_set_swap_interval(int interval, Display *dpy, GLXDrawable drawab /** * Initialize OpenGL. */ -static backend_t *glx_init(session_t *ps) { +static backend_t *glx_init(session_t *ps, xcb_window_t target) { bool success = false; - glxext_init(ps->dpy, ps->scr); + glxext_init(ps->c.dpy, ps->c.screen); auto gd = ccalloc(1, struct _glx_data); init_backend_base(&gd->gl.base, ps); - gd->display = ps->dpy; - gd->screen = ps->scr; - gd->target_win = session_get_target_window(ps); + gd->target_win = target; XVisualInfo *pvis = NULL; @@ -251,8 +245,8 @@ static backend_t *glx_init(session_t *ps) { // Get XVisualInfo int nitems = 0; - XVisualInfo vreq = {.visualid = ps->vis}; - pvis = XGetVisualInfo(ps->dpy, VisualIDMask, &vreq, &nitems); + XVisualInfo vreq = {.visualid = ps->c.screen_info->root_visual}; + pvis = XGetVisualInfo(ps->c.dpy, VisualIDMask, &vreq, &nitems); if (!pvis) { log_error("Failed to acquire XVisualInfo for current visual."); goto end; @@ -260,22 +254,22 @@ static backend_t *glx_init(session_t *ps) { // Ensure the visual is double-buffered int value = 0; - if (glXGetConfig(ps->dpy, pvis, GLX_USE_GL, &value) || !value) { + if (glXGetConfig(ps->c.dpy, pvis, GLX_USE_GL, &value) || !value) { log_error("Root visual is not a GL visual."); goto end; } - if (glXGetConfig(ps->dpy, pvis, GLX_STENCIL_SIZE, &value) || !value) { + if (glXGetConfig(ps->c.dpy, pvis, GLX_STENCIL_SIZE, &value) || !value) { log_error("Root visual lacks stencil buffer."); goto end; } - if (glXGetConfig(ps->dpy, pvis, GLX_DOUBLEBUFFER, &value) || !value) { + if (glXGetConfig(ps->c.dpy, pvis, GLX_DOUBLEBUFFER, &value) || !value) { log_error("Root visual is not a double buffered GL visual."); goto end; } - if (glXGetConfig(ps->dpy, pvis, GLX_RGBA, &value) || !value) { + if (glXGetConfig(ps->c.dpy, pvis, GLX_RGBA, &value) || !value) { log_error("Root visual is a color index visual, not supported"); goto end; } @@ -293,11 +287,11 @@ static backend_t *glx_init(session_t *ps) { // Find a fbconfig with visualid matching the one from the target win, so we can // be sure that the fbconfig is compatible with our target window. int ncfgs; - GLXFBConfig *cfg = glXGetFBConfigs(gd->display, gd->screen, &ncfgs); + GLXFBConfig *cfg = glXGetFBConfigs(ps->c.dpy, ps->c.screen, &ncfgs); bool found = false; for (int i = 0; i < ncfgs; i++) { int visualid; - glXGetFBConfigAttribChecked(gd->display, cfg[i], GLX_VISUAL_ID, &visualid); + glXGetFBConfigAttribChecked(ps->c.dpy, cfg[i], GLX_VISUAL_ID, &visualid); if ((VisualID)visualid != pvis->visualid) { continue; } @@ -316,7 +310,7 @@ static backend_t *glx_init(session_t *ps) { attributes[7] = GLX_LOSE_CONTEXT_ON_RESET_ARB; } - gd->ctx = glXCreateContextAttribsARB(ps->dpy, cfg[i], 0, true, attributes); + gd->ctx = glXCreateContextAttribsARB(ps->c.dpy, cfg[i], 0, true, attributes); free(cfg); if (!gd->ctx) { @@ -334,7 +328,7 @@ static backend_t *glx_init(session_t *ps) { // Attach GLX context GLXDrawable tgt = gd->target_win; - if (!glXMakeCurrent(ps->dpy, tgt, gd->ctx)) { + if (!glXMakeCurrent(ps->c.dpy, tgt, gd->ctx)) { log_error("Failed to attach GLX context."); goto end; } @@ -348,11 +342,11 @@ static backend_t *glx_init(session_t *ps) { gd->gl.release_user_data = glx_release_image; if (ps->o.vsync) { - if (!glx_set_swap_interval(1, ps->dpy, tgt)) { + if (!glx_set_swap_interval(1, ps->c.dpy, tgt)) { log_error("Failed to enable vsync."); } } else { - glx_set_swap_interval(0, ps->dpy, tgt); + glx_set_swap_interval(0, ps->c.dpy, tgt); } success = true; @@ -372,21 +366,21 @@ static backend_t *glx_init(session_t *ps) { static void * glx_bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, bool owned) { - struct _glx_data *gd = (void *)base; struct _glx_pixmap *glxpixmap = NULL; // Retrieve pixmap parameters, if they aren't provided if (fmt.visual_depth > OPENGL_MAX_DEPTH) { log_error("Requested depth %d higher than max possible depth %d.", fmt.visual_depth, OPENGL_MAX_DEPTH); - return false; + return NULL; } if (fmt.visual_depth < 0) { log_error("Pixmap %#010x with invalid depth %d", pixmap, fmt.visual_depth); - return false; + return NULL; } - auto r = xcb_get_geometry_reply(base->c, xcb_get_geometry(base->c, pixmap), NULL); + auto r = + xcb_get_geometry_reply(base->c->c, xcb_get_geometry(base->c->c, pixmap), NULL); if (!r) { log_error("Invalid pixmap %#010x", pixmap); return NULL; @@ -400,7 +394,7 @@ glx_bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, b wd->inner = (struct backend_image_inner_base *)inner; free(r); - auto fbcfg = glx_find_fbconfig(gd->display, gd->screen, fmt); + auto fbcfg = glx_find_fbconfig(base->c, fmt); if (!fbcfg) { log_error("Couldn't find FBConfig with requested visual %x", fmt.visual); goto err; @@ -429,7 +423,7 @@ glx_bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, b glxpixmap = cmalloc(struct _glx_pixmap); glxpixmap->pixmap = pixmap; - glxpixmap->glpixmap = glXCreatePixmap(gd->display, fbcfg->cfg, pixmap, attrs); + glxpixmap->glpixmap = glXCreatePixmap(base->c->dpy, fbcfg->cfg, pixmap, attrs); glxpixmap->owned = owned; free(fbcfg); @@ -446,19 +440,19 @@ glx_bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, b inner->has_alpha = fmt.alpha_size != 0; wd->inner->refcount = 1; glBindTexture(GL_TEXTURE_2D, inner->texture); - glXBindTexImageEXT(gd->display, glxpixmap->glpixmap, GLX_FRONT_LEFT_EXT, NULL); + glXBindTexImageEXT(base->c->dpy, glxpixmap->glpixmap, GLX_FRONT_LEFT_EXT, NULL); glBindTexture(GL_TEXTURE_2D, 0); gl_check_err(); return wd; err: if (glxpixmap && glxpixmap->glpixmap) { - glXDestroyPixmap(gd->display, glxpixmap->glpixmap); + glXDestroyPixmap(base->c->dpy, glxpixmap->glpixmap); } free(glxpixmap); if (owned) { - xcb_free_pixmap(base->c, pixmap); + xcb_free_pixmap(base->c->c, pixmap); } free(wd); return NULL; @@ -467,10 +461,7 @@ glx_bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, b static void glx_present(backend_t *base, const region_t *region attr_unused) { struct _glx_data *gd = (void *)base; gl_present(base, region); - glXSwapBuffers(gd->display, gd->target_win); - if (!gd->gl.is_nvidia) { - glFinish(); - } + glXSwapBuffers(base->c->dpy, gd->target_win); } static int glx_buffer_age(backend_t *base) { @@ -480,15 +471,14 @@ static int glx_buffer_age(backend_t *base) { struct _glx_data *gd = (void *)base; unsigned int val; - glXQueryDrawable(gd->display, gd->target_win, GLX_BACK_BUFFER_AGE_EXT, &val); + glXQueryDrawable(base->c->dpy, gd->target_win, GLX_BACK_BUFFER_AGE_EXT, &val); return (int)val ?: -1; } static void glx_diagnostics(backend_t *base) { - struct _glx_data *gd = (void *)base; bool warn_software_rendering = false; const char *software_renderer_names[] = {"llvmpipe", "SWR", "softpipe"}; - auto glx_vendor = glXGetClientString(gd->display, GLX_VENDOR); + auto glx_vendor = glXGetClientString(base->c->dpy, GLX_VENDOR); printf("* Driver vendors:\n"); printf(" * GLX: %s\n", glx_vendor); printf(" * GL: %s\n", glGetString(GL_VENDOR)); @@ -528,6 +518,7 @@ struct backend_operations glx_ops = { .deinit = glx_deinit, .bind_pixmap = glx_bind_pixmap, .release_image = gl_release_image, + .prepare = gl_prepare, .compose = gl_compose, .image_op = gl_image_op, .set_image_property = gl_set_image_property, @@ -536,6 +527,7 @@ struct backend_operations glx_ops = { .is_image_transparent = default_is_image_transparent, .present = glx_present, .buffer_age = glx_buffer_age, + .last_render_time = gl_last_render_time, .create_shadow_context = gl_create_shadow_context, .destroy_shadow_context = gl_destroy_shadow_context, .render_shadow = backend_render_shadow_from_mask, @@ -623,7 +615,7 @@ void glxext_init(Display *dpy, int screen) { #endif #undef check_ext -#define lookup(name) (name = (__typeof__(name))glXGetProcAddress((GLubyte *)#name)) +#define lookup(name) ((name) = (__typeof__(name))glXGetProcAddress((GLubyte *)#name)) // Checking if the returned function pointer is NULL is not really necessary, // or maybe not even useful, since glXGetProcAddress might always return // something. We are doing it just for completeness' sake. diff --git a/src/backend/gl/glx.h b/src/backend/gl/glx.h index 44b4da0595..c7ff281c8b 100644 --- a/src/backend/gl/glx.h +++ b/src/backend/gl/glx.h @@ -12,11 +12,11 @@ #undef glXBindTexImageEXT #undef glXReleaseTexImageEXT #include -#include #include +#include -#include "log.h" #include "compiler.h" +#include "log.h" #include "utils.h" #include "x.h" @@ -41,8 +41,7 @@ struct glx_fbconfig_criteria { int visual_depth; }; -struct glx_fbconfig_info *glx_find_fbconfig(Display *, int screen, struct xvisual_info); - +struct glx_fbconfig_info *glx_find_fbconfig(struct x_connection *, struct xvisual_info); struct glxext_info { bool initialized; diff --git a/src/backend/gl/shaders.c b/src/backend/gl/shaders.c index 4a18e62874..ff6c5a09fa 100644 --- a/src/backend/gl/shaders.c +++ b/src/backend/gl/shaders.c @@ -9,6 +9,15 @@ const char dummy_frag[] = GLSL(330, } ); +const char present_frag[] = GLSL(330, + uniform sampler2D tex; + in vec2 texcoord; + vec4 dither(vec4, vec2); + void main() { + gl_FragColor = dither(texelFetch(tex, ivec2(texcoord.xy), 0), texcoord); + } +); + const char copy_with_mask_frag[] = GLSL(330, uniform sampler2D tex; in vec2 texcoord; @@ -88,6 +97,7 @@ const char win_shader_glsl[] = GLSL(330, uniform bool invert_color; in vec2 texcoord; uniform sampler2D tex; + uniform vec2 effective_size; uniform sampler2D brightness; uniform float max_brightness; // Signed distance field for rectangle center at (0, 0), with size of @@ -121,7 +131,7 @@ const char win_shader_glsl[] = GLSL(330, // Using mix() to avoid a branch here. vec4 rim_color = mix(c, border_color, clamp(border_width, 0.0f, 1.0f)); - vec2 outer_size = vec2(textureSize(tex, 0)); + vec2 outer_size = effective_size; vec2 inner_size = outer_size - vec2(corner_radius) * 2.0f; float rect_distance = rectangle_sdf(texcoord - outer_size / 2.0f, inner_size / 2.0f) - corner_radius; @@ -148,7 +158,8 @@ const char win_shader_default[] = GLSL(330, uniform sampler2D tex; vec4 default_post_processing(vec4 c); vec4 window_shader() { - vec4 c = texelFetch(tex, ivec2(texcoord), 0); + vec2 texsize = textureSize(tex, 0); + vec4 c = texture2D(tex, texcoord / texsize, 0); return default_post_processing(c); } ); @@ -174,6 +185,30 @@ const char vertex_shader[] = GLSL(330, texcoord = in_texcoord + texorig; } ); +const char dither_glsl[] = GLSL(330, + // Stolen from: https://www.shadertoy.com/view/7sfXDn + float bayer2(vec2 a) { + a = floor(a); + return fract(a.x / 2. + a.y * a.y * .75); + } + // 16 * 16 is 2^8, so in total we have equivalent of 16-bit + // color depth, should be enough? + float bayer(vec2 a16) { + vec2 a8 = a16 * .5; + vec2 a4 = a8 * .5; + vec2 a2 = a4 * .5; + float bayer32 = ((bayer2(a2) * .25 + bayer2( a4)) + * .25 + bayer2( a8)) + * .25 + bayer2(a16); + return bayer32; + } + vec4 dither(vec4 c, vec2 coord) { + vec4 residual = mod(c, 1.0 / 255.0); + residual = min(residual, vec4(1.0 / 255.0) - residual); + vec4 dithered = vec4(greaterThan(residual, vec4(1.0 / 65535.0))); + return vec4(c + dithered * bayer(coord) / 255.0); + } +); const char shadow_colorization_frag[] = GLSL(330, uniform vec4 color; uniform sampler2D tex; diff --git a/src/backend/xrender/xrender.c b/src/backend/xrender/xrender.c index 2b7f8e17af..b2ec3f2301 100644 --- a/src/backend/xrender/xrender.c +++ b/src/backend/xrender/xrender.c @@ -28,7 +28,6 @@ typedef struct _xrender_data { backend_t base; /// If vsync is enabled and supported by the current system bool vsync; - xcb_visualid_t default_visual; /// Target window xcb_window_t target_win; /// Painting target, it is either the root or the overlay @@ -104,9 +103,9 @@ struct xrender_image { /// Make a picture of size width x height, which has a rounded rectangle of corner_radius /// rendered in it. struct xrender_rounded_rectangle_cache * -make_rounded_corner_cache(xcb_connection_t *c, xcb_render_picture_t src, - xcb_drawable_t root, int width, int height, int corner_radius) { - auto picture = x_create_picture_with_standard(c, root, width, height, +make_rounded_corner_cache(struct x_connection *c, xcb_render_picture_t src, int width, + int height, int corner_radius) { + auto picture = x_create_picture_with_standard(c, width, height, XCB_PICT_STANDARD_ARGB_32, 0, NULL); if (picture == XCB_NONE) { return NULL; @@ -160,7 +159,7 @@ make_rounded_corner_cache(xcb_connection_t *c, xcb_render_picture_t src, } #undef ADD_POINT - XCB_AWAIT_VOID(xcb_render_tri_strip, c, XCB_RENDER_PICT_OP_SRC, src, picture, + XCB_AWAIT_VOID(xcb_render_tri_strip, c->c, XCB_RENDER_PICT_OP_SRC, src, picture, x_get_pictfmt_for_standard(c, XCB_PICT_STANDARD_A_8), 0, 0, (uint32_t)point_count, points); free(points); @@ -177,35 +176,34 @@ static xcb_render_picture_t process_mask(struct _xrender_data *xd, struct xrende *allocated = false; return inner->pict; } - const auto tmpw = to_u16_checked(inner->width); - const auto tmph = to_u16_checked(inner->height); + auto const tmpw = to_u16_checked(inner->width); + auto const tmph = to_u16_checked(inner->height); *allocated = true; x_clear_picture_clip_region(xd->base.c, inner->pict); auto ret = x_create_picture_with_visual( - xd->base.c, xd->base.root, inner->width, inner->height, inner->visual, - XCB_RENDER_CP_REPEAT, + xd->base.c, inner->width, inner->height, inner->visual, XCB_RENDER_CP_REPEAT, (xcb_render_create_picture_value_list_t[]){XCB_RENDER_REPEAT_PAD}); - xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_SRC, inner->pict, XCB_NONE, + xcb_render_composite(xd->base.c->c, XCB_RENDER_PICT_OP_SRC, inner->pict, XCB_NONE, ret, 0, 0, 0, 0, 0, 0, tmpw, tmph); // Remember: the mask has a 1-pixel border if (mask->base.corner_radius != 0) { if (mask->rounded_rectangle == NULL) { mask->rounded_rectangle = make_rounded_corner_cache( - xd->base.c, xd->white_pixel, xd->base.root, inner->width - 2, + xd->base.c, xd->white_pixel, inner->width - 2, inner->height - 2, (int)mask->base.corner_radius); } - xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_IN_REVERSE, + xcb_render_composite(xd->base.c->c, XCB_RENDER_PICT_OP_IN_REVERSE, mask->rounded_rectangle->p, XCB_NONE, ret, 0, 0, 0, 0, 1, 1, (uint16_t)(tmpw - 2), (uint16_t)(tmph - 2)); } if (mask->base.color_inverted) { - xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_XOR, xd->white_pixel, + xcb_render_composite(xd->base.c->c, XCB_RENDER_PICT_OP_XOR, xd->white_pixel, XCB_NONE, ret, 0, 0, 0, 0, 0, 0, tmpw, tmph); } if (alpha_pict != XCB_NONE) { - xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_SRC, ret, alpha_pict, + xcb_render_composite(xd->base.c->c, XCB_RENDER_PICT_OP_SRC, ret, alpha_pict, ret, 0, 0, 0, 0, 0, 0, to_u16_checked(inner->width), to_u16_checked(inner->height)); } @@ -228,13 +226,13 @@ compose_impl(struct _xrender_data *xd, struct xrender_image *xrimg, coord_t dst, region_t reg; bool has_alpha = inner->has_alpha || img->opacity != 1; - const auto tmpw = to_u16_checked(inner->width); - const auto tmph = to_u16_checked(inner->height); - const auto tmpew = to_u16_checked(img->ewidth); - const auto tmpeh = to_u16_checked(img->eheight); + auto const tmpw = to_u16_checked(inner->width); + auto const tmph = to_u16_checked(inner->height); + auto const tmpew = to_u16_checked(img->ewidth); + auto const tmpeh = to_u16_checked(img->eheight); // Remember: the mask has a 1-pixel border - const auto mask_dst_x = to_i16_checked(dst.x - mask_dst.x + 1); - const auto mask_dst_y = to_i16_checked(dst.y - mask_dst.y + 1); + auto const mask_dst_x = to_i16_checked(dst.x - mask_dst.x + 1); + auto const mask_dst_y = to_i16_checked(dst.y - mask_dst.y + 1); const xcb_render_color_t dim_color = { .red = 0, .green = 0, .blue = 0, .alpha = (uint16_t)(0xffff * img->dim)}; @@ -246,54 +244,54 @@ compose_impl(struct _xrender_data *xd, struct xrender_image *xrimg, coord_t dst, pixman_region32_intersect(®, (region_t *)reg_paint, (region_t *)reg_visible); x_set_picture_clip_region(xd->base.c, result, 0, 0, ®); if (img->corner_radius != 0 && xrimg->rounded_rectangle == NULL) { - xrimg->rounded_rectangle = make_rounded_corner_cache( - xd->base.c, xd->white_pixel, xd->base.root, inner->width, - inner->height, (int)img->corner_radius); + xrimg->rounded_rectangle = + make_rounded_corner_cache(xd->base.c, xd->white_pixel, inner->width, + inner->height, (int)img->corner_radius); } if (((img->color_inverted || img->dim != 0) && has_alpha) || img->corner_radius != 0) { // Apply image properties using a temporary image, because the source - // image is transparent. Otherwise the properties can be applied directly - // on the target image. - auto tmp_pict = - x_create_picture_with_visual(xd->base.c, xd->base.root, inner->width, - inner->height, inner->visual, 0, NULL); + // image is transparent or will get transparent corners. Otherwise the + // properties can be applied directly on the target image. + // Also force a 32-bit ARGB visual for transparent corners, otherwise the + // corners become black. + auto visual = + (img->corner_radius != 0 && inner->depth != 32) + ? x_get_visual_for_standard(xd->base.c, XCB_PICT_STANDARD_ARGB_32) + : inner->visual; + auto tmp_pict = x_create_picture_with_visual( + xd->base.c, inner->width, inner->height, visual, 0, NULL); // Set clip region translated to source coordinate x_set_picture_clip_region(xd->base.c, tmp_pict, to_i16_checked(-dst.x), to_i16_checked(-dst.y), ®); // Copy source -> tmp - xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_SRC, inner->pict, + xcb_render_composite(xd->base.c->c, XCB_RENDER_PICT_OP_SRC, inner->pict, XCB_NONE, tmp_pict, 0, 0, 0, 0, 0, 0, tmpw, tmph); - if (img->corner_radius != 0 && xrimg->rounded_rectangle != NULL) { - // Clip tmp_pict with a rounded rectangle - xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_IN_REVERSE, - xrimg->rounded_rectangle->p, XCB_NONE, - tmp_pict, 0, 0, 0, 0, 0, 0, tmpw, tmph); - } - if (img->color_inverted) { if (inner->has_alpha) { auto tmp_pict2 = x_create_picture_with_visual( - xd->base.c, xd->base.root, tmpw, tmph, inner->visual, - 0, NULL); - xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_SRC, + xd->base.c, tmpw, tmph, inner->visual, 0, NULL); + xcb_render_composite(xd->base.c->c, XCB_RENDER_PICT_OP_SRC, tmp_pict, XCB_NONE, tmp_pict2, 0, 0, 0, 0, 0, 0, tmpw, tmph); - xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_DIFFERENCE, + xcb_render_composite(xd->base.c->c, + XCB_RENDER_PICT_OP_DIFFERENCE, xd->white_pixel, XCB_NONE, tmp_pict, 0, 0, 0, 0, 0, 0, tmpw, tmph); xcb_render_composite( - xd->base.c, XCB_RENDER_PICT_OP_IN_REVERSE, tmp_pict2, + xd->base.c->c, XCB_RENDER_PICT_OP_IN_REVERSE, tmp_pict2, XCB_NONE, tmp_pict, 0, 0, 0, 0, 0, 0, tmpw, tmph); - xcb_render_free_picture(xd->base.c, tmp_pict2); + x_free_picture(xd->base.c, tmp_pict2); } else { - xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_DIFFERENCE, + xcb_render_composite(xd->base.c->c, + XCB_RENDER_PICT_OP_DIFFERENCE, xd->white_pixel, XCB_NONE, tmp_pict, 0, 0, 0, 0, 0, 0, tmpw, tmph); } } + if (img->dim != 0) { // Dim the actually content of window xcb_rectangle_t rect = { @@ -303,26 +301,34 @@ compose_impl(struct _xrender_data *xd, struct xrender_image *xrimg, coord_t dst, .height = tmph, }; - xcb_render_fill_rectangles(xd->base.c, XCB_RENDER_PICT_OP_OVER, + xcb_render_fill_rectangles(xd->base.c->c, XCB_RENDER_PICT_OP_OVER, tmp_pict, dim_color, 1, &rect); } - xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_OVER, tmp_pict, + if (img->corner_radius != 0 && xrimg->rounded_rectangle != NULL) { + // Clip tmp_pict with a rounded rectangle + xcb_render_composite(xd->base.c->c, XCB_RENDER_PICT_OP_IN_REVERSE, + xrimg->rounded_rectangle->p, XCB_NONE, + tmp_pict, 0, 0, 0, 0, 0, 0, tmpw, tmph); + } + + xcb_render_composite(xd->base.c->c, XCB_RENDER_PICT_OP_OVER, tmp_pict, mask_pict, result, 0, 0, mask_dst_x, mask_dst_y, to_i16_checked(dst.x), to_i16_checked(dst.y), tmpew, tmpeh); - xcb_render_free_picture(xd->base.c, tmp_pict); + xcb_render_free_picture(xd->base.c->c, tmp_pict); } else { uint8_t op = (has_alpha ? XCB_RENDER_PICT_OP_OVER : XCB_RENDER_PICT_OP_SRC); - xcb_render_composite(xd->base.c, op, inner->pict, mask_pict, result, 0, 0, - mask_dst_x, mask_dst_y, to_i16_checked(dst.x), + xcb_render_composite(xd->base.c->c, op, inner->pict, mask_pict, result, 0, + 0, mask_dst_x, mask_dst_y, to_i16_checked(dst.x), to_i16_checked(dst.y), tmpew, tmpeh); if (img->dim != 0 || img->color_inverted) { // Apply properties, if we reach here, then has_alpha == false assert(!has_alpha); if (img->color_inverted) { - xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_DIFFERENCE, + xcb_render_composite(xd->base.c->c, + XCB_RENDER_PICT_OP_DIFFERENCE, xd->white_pixel, XCB_NONE, result, 0, 0, 0, 0, to_i16_checked(dst.x), to_i16_checked(dst.y), tmpew, tmpeh); @@ -337,13 +343,14 @@ compose_impl(struct _xrender_data *xd, struct xrender_image *xrimg, coord_t dst, .height = tmpeh, }; - xcb_render_fill_rectangles(xd->base.c, XCB_RENDER_PICT_OP_OVER, + xcb_render_fill_rectangles(xd->base.c->c, + XCB_RENDER_PICT_OP_OVER, result, dim_color, 1, &rect); } } } if (mask_allocated) { - xcb_render_free_picture(xd->base.c, mask_pict); + x_free_picture(xd->base.c, mask_pict); } pixman_region32_fini(®); } @@ -361,7 +368,7 @@ static void fill(backend_t *base, struct color c, const region_t *clip) { x_set_picture_clip_region(base->c, xd->back[2], 0, 0, clip); // color is in X fixed point representation xcb_render_fill_rectangles( - base->c, XCB_RENDER_PICT_OP_OVER, xd->back[2], + base->c->c, XCB_RENDER_PICT_OP_OVER, xd->back[2], (xcb_render_color_t){.red = (uint16_t)(c.red * 0xffff), .green = (uint16_t)(c.green * 0xffff), .blue = (uint16_t)(c.blue * 0xffff), @@ -381,7 +388,7 @@ static bool blur(backend_t *backend_data, double opacity, void *ctx_, void *mask } struct _xrender_data *xd = (void *)backend_data; - xcb_connection_t *c = xd->base.c; + auto c = xd->base.c; region_t reg_op; pixman_region32_init(®_op); pixman_region32_intersect(®_op, (region_t *)reg_blur, (region_t *)reg_visible); @@ -394,8 +401,8 @@ static bool blur(backend_t *backend_data, double opacity, void *ctx_, void *mask resize_region(®_op, bctx->resize_width, bctx->resize_height); const pixman_box32_t *extent_resized = pixman_region32_extents(®_op_resized); - const auto height_resized = to_u16_checked(extent_resized->y2 - extent_resized->y1); - const auto width_resized = to_u16_checked(extent_resized->x2 - extent_resized->x1); + auto const height_resized = to_u16_checked(extent_resized->y2 - extent_resized->y1); + auto const width_resized = to_u16_checked(extent_resized->x2 - extent_resized->x1); static const char *filter0 = "Nearest"; // The "null" filter static const char *filter = "convolution"; @@ -404,10 +411,12 @@ static bool blur(backend_t *backend_data, double opacity, void *ctx_, void *mask const uint32_t pic_attrs_mask = XCB_RENDER_CP_REPEAT; const xcb_render_create_picture_value_list_t pic_attrs = {.repeat = XCB_RENDER_REPEAT_PAD}; xcb_render_picture_t tmp_picture[2] = { - x_create_picture_with_visual(xd->base.c, xd->base.root, width_resized, height_resized, - xd->default_visual, pic_attrs_mask, &pic_attrs), - x_create_picture_with_visual(xd->base.c, xd->base.root, width_resized, height_resized, - xd->default_visual, pic_attrs_mask, &pic_attrs)}; + x_create_picture_with_visual(xd->base.c, width_resized, height_resized, + xd->base.c->screen_info->root_visual, + pic_attrs_mask, &pic_attrs), + x_create_picture_with_visual(xd->base.c, width_resized, height_resized, + xd->base.c->screen_info->root_visual, + pic_attrs_mask, &pic_attrs)}; if (!tmp_picture[0] || !tmp_picture[1]) { log_error("Failed to build intermediate Picture."); @@ -444,8 +453,8 @@ static bool blur(backend_t *backend_data, double opacity, void *ctx_, void *mask // Copy from source picture to destination. The filter must // be applied on source picture, to get the nearby pixels outside the // window. - xcb_render_set_picture_filter(c, src_pict, to_u16_checked(strlen(filter)), - filter, + xcb_render_set_picture_filter(c->c, src_pict, + to_u16_checked(strlen(filter)), filter, to_u32_checked(bctx->x_blur_kernel[i]->size), bctx->x_blur_kernel[i]->kernel); @@ -453,21 +462,21 @@ static bool blur(backend_t *backend_data, double opacity, void *ctx_, void *mask // First pass, back buffer -> tmp picture // (we do this even if this is also the last pass, because we // cannot do back buffer -> back buffer) - xcb_render_composite(c, XCB_RENDER_PICT_OP_SRC, src_pict, XCB_NONE, + xcb_render_composite(c->c, XCB_RENDER_PICT_OP_SRC, src_pict, XCB_NONE, dst_pict, to_i16_checked(extent_resized->x1), to_i16_checked(extent_resized->y1), 0, 0, 0, 0, width_resized, height_resized); } else if (i < bctx->x_blur_kernel_count - 1) { // This is not the last pass or the first pass, // tmp picture 1 -> tmp picture 2 - xcb_render_composite(c, XCB_RENDER_PICT_OP_SRC, src_pict, + xcb_render_composite(c->c, XCB_RENDER_PICT_OP_SRC, src_pict, XCB_NONE, dst_pict, 0, 0, 0, 0, 0, 0, width_resized, height_resized); } else { x_set_picture_clip_region(c, xd->back[2], 0, 0, ®_op); // This is the last pass, and we are doing more than 1 pass xcb_render_composite( - c, XCB_RENDER_PICT_OP_OVER, src_pict, mask_pict, xd->back[2], + c->c, XCB_RENDER_PICT_OP_OVER, src_pict, mask_pict, xd->back[2], 0, 0, to_i16_checked(extent_resized->x1 - mask_dst.x + 1), to_i16_checked(extent_resized->y1 - mask_dst.y + 1), to_i16_checked(extent_resized->x1), @@ -476,7 +485,7 @@ static bool blur(backend_t *backend_data, double opacity, void *ctx_, void *mask // reset filter xcb_render_set_picture_filter( - c, src_pict, to_u16_checked(strlen(filter0)), filter0, 0, NULL); + c->c, src_pict, to_u16_checked(strlen(filter0)), filter0, 0, NULL); src_pict = tmp_picture[current]; dst_pict = tmp_picture[!current]; @@ -487,15 +496,18 @@ static bool blur(backend_t *backend_data, double opacity, void *ctx_, void *mask if (i == 1) { x_set_picture_clip_region(c, xd->back[2], 0, 0, ®_op); xcb_render_composite( - c, XCB_RENDER_PICT_OP_OVER, src_pict, mask_pict, xd->back[2], 0, 0, + c->c, XCB_RENDER_PICT_OP_OVER, src_pict, mask_pict, xd->back[2], 0, 0, to_i16_checked(extent_resized->x1 - mask_dst.x + 1), to_i16_checked(extent_resized->y1 - mask_dst.y + 1), to_i16_checked(extent_resized->x1), to_i16_checked(extent_resized->y1), width_resized, height_resized); } - xcb_render_free_picture(c, tmp_picture[0]); - xcb_render_free_picture(c, tmp_picture[1]); + if (mask_allocated) { + x_free_picture(c, mask_pict); + } + x_free_picture(c, tmp_picture[0]); + x_free_picture(c, tmp_picture[1]); pixman_region32_fini(®_op); pixman_region32_fini(®_op_resized); return true; @@ -504,10 +516,11 @@ static bool blur(backend_t *backend_data, double opacity, void *ctx_, void *mask static void * bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, bool owned) { xcb_generic_error_t *e; - auto r = xcb_get_geometry_reply(base->c, xcb_get_geometry(base->c, pixmap), &e); + auto r = xcb_get_geometry_reply(base->c->c, xcb_get_geometry(base->c->c, pixmap), &e); if (!r) { log_error("Invalid pixmap: %#010x", pixmap); x_print_error(e->full_sequence, e->major_code, e->minor_code, e->error_code); + free(e); return NULL; } @@ -518,8 +531,9 @@ bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, bool inner->height = img->base.eheight = r->height; inner->pixmap = pixmap; inner->has_alpha = fmt.alpha_size != 0; - inner->pict = - x_create_picture_with_visual_and_pixmap(base->c, fmt.visual, pixmap, 0, NULL); + xcb_render_create_picture_value_list_t pic_attrs = {.repeat = XCB_RENDER_REPEAT_NORMAL}; + inner->pict = x_create_picture_with_visual_and_pixmap( + base->c, fmt.visual, pixmap, XCB_RENDER_CP_REPEAT, &pic_attrs); inner->owned = owned; inner->visual = fmt.visual; inner->refcount = 1; @@ -537,9 +551,9 @@ bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, bool return img; } static void release_image_inner(backend_t *base, struct _xrender_image_data_inner *inner) { - xcb_render_free_picture(base->c, inner->pict); + x_free_picture(base->c, inner->pict); if (inner->owned) { - xcb_free_pixmap(base->c, inner->pixmap); + xcb_free_pixmap(base->c->c, inner->pixmap); } free(inner); } @@ -553,7 +567,7 @@ release_rounded_corner_cache(backend_t *base, struct xrender_rounded_rectangle_c assert(cache->refcount > 0); cache->refcount--; if (cache->refcount == 0) { - xcb_free_pixmap(base->c, cache->p); + x_free_picture(base->c, cache->p); free(cache); } } @@ -572,18 +586,22 @@ static void release_image(backend_t *base, void *image) { static void deinit(backend_t *backend_data) { struct _xrender_data *xd = (void *)backend_data; for (int i = 0; i < 256; i++) { - xcb_render_free_picture(xd->base.c, xd->alpha_pict[i]); + x_free_picture(xd->base.c, xd->alpha_pict[i]); } - xcb_render_free_picture(xd->base.c, xd->target); - for (int i = 0; i < 2; i++) { - xcb_render_free_picture(xd->base.c, xd->back[i]); - xcb_free_pixmap(xd->base.c, xd->back_pixmap[i]); + x_free_picture(xd->base.c, xd->target); + for (int i = 0; i < 3; i++) { + if (xd->back[i] != XCB_NONE) { + x_free_picture(xd->base.c, xd->back[i]); + } + if (xd->back_pixmap[i] != XCB_NONE) { + xcb_free_pixmap(xd->base.c->c, xd->back_pixmap[i]); + } } if (xd->present_event) { - xcb_unregister_for_special_event(xd->base.c, xd->present_event); + xcb_unregister_for_special_event(xd->base.c->c, xd->present_event); } - xcb_render_free_picture(xd->base.c, xd->white_pixel); - xcb_render_free_picture(xd->base.c, xd->black_pixel); + x_free_picture(xd->base.c, xd->white_pixel); + x_free_picture(xd->base.c, xd->black_pixel); free(xd); } @@ -594,25 +612,28 @@ static void present(backend_t *base, const region_t *region) { uint16_t region_width = to_u16_checked(extent->x2 - extent->x1), region_height = to_u16_checked(extent->y2 - extent->y1); - // compose() sets clip region on the back buffer, so clear it first - x_clear_picture_clip_region(base->c, xd->back[xd->curr_back]); - // limit the region of update x_set_picture_clip_region(base->c, xd->back[2], 0, 0, region); if (xd->vsync) { + // compose() sets clip region on the back buffer, so clear it first + x_clear_picture_clip_region(base->c, xd->back[xd->curr_back]); + // Update the back buffer first, then present - xcb_render_composite(base->c, XCB_RENDER_PICT_OP_SRC, xd->back[2], + xcb_render_composite(base->c->c, XCB_RENDER_PICT_OP_SRC, xd->back[2], XCB_NONE, xd->back[xd->curr_back], orig_x, orig_y, 0, 0, orig_x, orig_y, region_width, region_height); + auto xregion = x_create_region(base->c, region); + // Make sure we got reply from PresentPixmap before waiting for events, // to avoid deadlock auto e = xcb_request_check( - base->c, xcb_present_pixmap_checked( - xd->base.c, xd->target_win, - xd->back_pixmap[xd->curr_back], 0, XCB_NONE, XCB_NONE, 0, - 0, XCB_NONE, XCB_NONE, XCB_NONE, 0, 0, 0, 0, 0, NULL)); + base->c->c, xcb_present_pixmap_checked( + xd->base.c->c, xd->target_win, + xd->back_pixmap[xd->curr_back], 0, XCB_NONE, xregion, 0, + 0, XCB_NONE, XCB_NONE, XCB_NONE, 0, 0, 0, 0, 0, NULL)); + x_destroy_region(base->c, xregion); if (e) { log_error("Failed to present pixmap"); free(e); @@ -620,7 +641,7 @@ static void present(backend_t *base, const region_t *region) { } // TODO(yshui) don't block wait for present completion xcb_present_generic_event_t *pev = - (void *)xcb_wait_for_special_event(base->c, xd->present_event); + (void *)xcb_wait_for_special_event(base->c->c, xd->present_event); if (!pev) { // We don't know what happened, maybe X died // But reset buffer age, so in case we do recover, we will @@ -644,7 +665,7 @@ static void present(backend_t *base, const region_t *region) { free(pev); } else { // No vsync needed, draw into the target picture directly - xcb_render_composite(base->c, XCB_RENDER_PICT_OP_SRC, xd->back[2], + xcb_render_composite(base->c->c, XCB_RENDER_PICT_OP_SRC, xd->back[2], XCB_NONE, xd->target, orig_x, orig_y, 0, 0, orig_x, orig_y, region_width, region_height); } @@ -663,7 +684,7 @@ static int buffer_age(backend_t *backend_data) { static struct _xrender_image_data_inner * new_inner(backend_t *base, int w, int h, xcb_visualid_t visual, uint8_t depth) { auto new_inner = ccalloc(1, struct _xrender_image_data_inner); - new_inner->pixmap = x_create_pixmap(base->c, depth, base->root, w, h); + new_inner->pixmap = x_create_pixmap(base->c, depth, w, h); if (new_inner->pixmap == XCB_NONE) { log_error("Failed to create pixmap for copy"); free(new_inner); @@ -673,7 +694,7 @@ new_inner(backend_t *base, int w, int h, xcb_visualid_t visual, uint8_t depth) { base->c, visual, new_inner->pixmap, 0, NULL); if (new_inner->pict == XCB_NONE) { log_error("Failed to create picture for copy"); - xcb_free_pixmap(base->c, new_inner->pixmap); + xcb_free_pixmap(base->c->c, new_inner->pixmap); free(new_inner); return NULL; } @@ -695,12 +716,12 @@ static void *make_mask(backend_t *base, geometry_t size, const region_t *reg) { auto inner = new_inner(base, size.width + 2, size.height + 2, x_get_visual_for_standard(base->c, XCB_PICT_STANDARD_ARGB_32), 32); - xcb_render_change_picture(base->c, inner->pict, XCB_RENDER_CP_REPEAT, + xcb_render_change_picture(base->c->c, inner->pict, XCB_RENDER_CP_REPEAT, (uint32_t[]){XCB_RENDER_REPEAT_PAD}); const rect_t *extent = pixman_region32_extents((region_t *)reg); x_set_picture_clip_region(base->c, xd->back[2], 1, 1, reg); xcb_render_fill_rectangles( - base->c, XCB_RENDER_PICT_OP_SRC, inner->pict, + base->c->c, XCB_RENDER_PICT_OP_SRC, inner->pict, (xcb_render_color_t){.red = 0, .green = 0, .blue = 0, .alpha = 0xffff}, 1, (xcb_rectangle_t[]){{.x = to_i16_checked(extent->x1 + 1), .y = to_i16_checked(extent->y1 + 1), @@ -710,7 +731,7 @@ static void *make_mask(backend_t *base, geometry_t size, const region_t *reg) { // Paint the border transparent xcb_render_fill_rectangles( - base->c, XCB_RENDER_PICT_OP_SRC, inner->pict, + base->c->c, XCB_RENDER_PICT_OP_SRC, inner->pict, (xcb_render_color_t){.red = 0, .green = 0, .blue = 0, .alpha = 0}, 4, (xcb_rectangle_t[]){{.x = 0, .y = 0, .width = w16, .height = 1}, {.x = 0, .y = 0, .width = 1, .height = h16}, @@ -748,7 +769,7 @@ static bool decouple_image(backend_t *base, struct backend_image *img, const reg } x_set_picture_clip_region(base->c, inner->pict, 0, 0, reg); - xcb_render_composite(base->c, XCB_RENDER_PICT_OP_SRC, inner->pict, XCB_NONE, + xcb_render_composite(base->c->c, XCB_RENDER_PICT_OP_SRC, inner->pict, XCB_NONE, inner2->pict, 0, 0, 0, 0, 0, 0, to_u16_checked(inner->width), to_u16_checked(inner->height)); @@ -787,8 +808,8 @@ static bool image_op(backend_t *base, enum image_operations op, void *image, auto inner = (struct _xrender_image_data_inner *)img->inner; auto alpha_pict = xd->alpha_pict[(int)((1 - dargs[0]) * MAX_ALPHA)]; x_set_picture_clip_region(base->c, inner->pict, 0, 0, ®); - xcb_render_composite(base->c, XCB_RENDER_PICT_OP_OUT_REVERSE, alpha_pict, - XCB_NONE, inner->pict, 0, 0, 0, 0, 0, 0, + xcb_render_composite(base->c->c, XCB_RENDER_PICT_OP_OUT_REVERSE, + alpha_pict, XCB_NONE, inner->pict, 0, 0, 0, 0, 0, 0, to_u16_checked(inner->width), to_u16_checked(inner->height)); inner->has_alpha = true; @@ -857,42 +878,40 @@ static void get_blur_size(void *blur_context, int *width, int *height) { *height = ctx->resize_height; } -static backend_t *backend_xrender_init(session_t *ps) { +static backend_t *backend_xrender_init(session_t *ps, xcb_window_t target) { + if (ps->o.dithered_present) { + log_warn("\"dithered-present\" is not supported by the xrender backend."); + } + auto xd = ccalloc(1, struct _xrender_data); init_backend_base(&xd->base, ps); for (int i = 0; i <= MAX_ALPHA; ++i) { double o = (double)i / (double)MAX_ALPHA; - xd->alpha_pict[i] = solid_picture(ps->c, ps->root, false, o, 0, 0, 0); + xd->alpha_pict[i] = solid_picture(&ps->c, false, o, 0, 0, 0); assert(xd->alpha_pict[i] != XCB_NONE); } xd->target_width = ps->root_width; xd->target_height = ps->root_height; - xd->default_visual = ps->vis; - xd->black_pixel = solid_picture(ps->c, ps->root, true, 1, 0, 0, 0); - xd->white_pixel = solid_picture(ps->c, ps->root, true, 1, 1, 1, 1); + xd->black_pixel = solid_picture(&ps->c, true, 1, 0, 0, 0); + xd->white_pixel = solid_picture(&ps->c, true, 1, 1, 1, 1); - xd->target_win = session_get_target_window(ps); + xd->target_win = target; xcb_render_create_picture_value_list_t pa = { .subwindowmode = XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS, }; xd->target = x_create_picture_with_visual_and_pixmap( - ps->c, ps->vis, xd->target_win, XCB_RENDER_CP_SUBWINDOW_MODE, &pa); - - auto pictfmt = x_get_pictform_for_visual(ps->c, ps->vis); - if (!pictfmt) { - log_fatal("Default visual is invalid"); - abort(); - } + &ps->c, ps->c.screen_info->root_visual, xd->target_win, + XCB_RENDER_CP_SUBWINDOW_MODE, &pa); xd->vsync = ps->o.vsync; if (ps->present_exists) { - auto eid = x_new_id(ps->c); + auto eid = x_new_id(&ps->c); auto e = - xcb_request_check(ps->c, xcb_present_select_input_checked( - ps->c, eid, xd->target_win, - XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY)); + xcb_request_check(ps->c.c, xcb_present_select_input_checked( + ps->c.c, eid, xd->target_win, + XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY)); if (e) { log_error("Cannot select present input, vsync will be disabled"); xd->vsync = false; @@ -900,7 +919,7 @@ static backend_t *backend_xrender_init(session_t *ps) { } xd->present_event = - xcb_register_for_special_xge(ps->c, &xcb_present_id, eid, NULL); + xcb_register_for_special_xge(ps->c.c, &xcb_present_id, eid, NULL); if (!xd->present_event) { log_error("Cannot register for special XGE, vsync will be " "disabled"); @@ -914,14 +933,15 @@ static backend_t *backend_xrender_init(session_t *ps) { // double buffering. int first_buffer_index = xd->vsync ? 0 : 2; for (int i = first_buffer_index; i < 3; i++) { - xd->back_pixmap[i] = x_create_pixmap(ps->c, pictfmt->depth, ps->root, + xd->back_pixmap[i] = x_create_pixmap(&ps->c, ps->c.screen_info->root_depth, to_u16_checked(ps->root_width), to_u16_checked(ps->root_height)); const uint32_t pic_attrs_mask = XCB_RENDER_CP_REPEAT; const xcb_render_create_picture_value_list_t pic_attrs = { .repeat = XCB_RENDER_REPEAT_PAD}; - xd->back[i] = x_create_picture_with_pictfmt_and_pixmap( - ps->c, pictfmt, xd->back_pixmap[i], pic_attrs_mask, &pic_attrs); + xd->back[i] = x_create_picture_with_visual_and_pixmap( + &ps->c, ps->c.screen_info->root_visual, xd->back_pixmap[i], + pic_attrs_mask, &pic_attrs); xd->buffer_age[i] = -1; if (xd->back_pixmap[i] == XCB_NONE || xd->back[i] == XCB_NONE) { log_error("Cannot create pixmap for rendering"); @@ -970,10 +990,8 @@ struct backend_operations xrender_ops = { .release_image = release_image, .create_shadow_context = default_create_shadow_context, .destroy_shadow_context = default_destroy_shadow_context, - .render_shadow = default_backend_render_shadow, + .render_shadow = default_render_shadow, .make_mask = make_mask, - //.prepare_win = prepare_win, - //.release_win = release_win, .is_image_transparent = default_is_image_transparent, .buffer_age = buffer_age, .max_buffer_age = 2, diff --git a/src/c2.c b/src/c2.c index 80ecb24cd1..7f1f80e0f7 100644 --- a/src/c2.c +++ b/src/c2.c @@ -17,15 +17,8 @@ // libpcre #ifdef CONFIG_REGEX_PCRE -#include - -// For compatibility with #endif @@ -89,49 +82,52 @@ struct _c2_b { /// Structure for leaf element in a window condition struct _c2_l { bool neg : 1; - enum { C2_L_OEXISTS, - C2_L_OEQ, - C2_L_OGT, - C2_L_OGTEQ, - C2_L_OLT, - C2_L_OLTEQ, + enum { + C2_L_OEXISTS, + C2_L_OEQ, + C2_L_OGT, + C2_L_OGTEQ, + C2_L_OLT, + C2_L_OLTEQ, } op : 3; - enum { C2_L_MEXACT, - C2_L_MSTART, - C2_L_MCONTAINS, - C2_L_MWILDCARD, - C2_L_MPCRE, + enum { + C2_L_MEXACT, + C2_L_MSTART, + C2_L_MCONTAINS, + C2_L_MWILDCARD, + C2_L_MPCRE, } match : 3; bool match_ignorecase : 1; char *tgt; xcb_atom_t tgtatom; bool tgt_onframe; int index; - enum { C2_L_PUNDEFINED = -1, - C2_L_PID = 0, - C2_L_PX, - C2_L_PY, - C2_L_PX2, - C2_L_PY2, - C2_L_PWIDTH, - C2_L_PHEIGHT, - C2_L_PWIDTHB, - C2_L_PHEIGHTB, - C2_L_PBDW, - C2_L_PFULLSCREEN, - C2_L_POVREDIR, - C2_L_PARGB, - C2_L_PFOCUSED, - C2_L_PWMWIN, - C2_L_PBSHAPED, - C2_L_PROUNDED, - C2_L_PCLIENT, - C2_L_PWINDOWTYPE, - C2_L_PLEADER, - C2_L_PNAME, - C2_L_PCLASSG, - C2_L_PCLASSI, - C2_L_PROLE, + enum { + C2_L_PUNDEFINED = -1, + C2_L_PID = 0, + C2_L_PX, + C2_L_PY, + C2_L_PX2, + C2_L_PY2, + C2_L_PWIDTH, + C2_L_PHEIGHT, + C2_L_PWIDTHB, + C2_L_PHEIGHTB, + C2_L_PBDW, + C2_L_PFULLSCREEN, + C2_L_POVREDIR, + C2_L_PARGB, + C2_L_PFOCUSED, + C2_L_PWMWIN, + C2_L_PBSHAPED, + C2_L_PROUNDED, + C2_L_PCLIENT, + C2_L_PWINDOWTYPE, + C2_L_PLEADER, + C2_L_PNAME, + C2_L_PCLASSG, + C2_L_PCLASSI, + C2_L_PROLE, } predef; enum c2_l_type { C2_L_TUNDEFINED, @@ -142,15 +138,16 @@ struct _c2_l { C2_L_TDRAWABLE, } type; int format; - enum { C2_L_PTUNDEFINED, - C2_L_PTSTRING, - C2_L_PTINT, + enum { + C2_L_PTUNDEFINED, + C2_L_PTSTRING, + C2_L_PTINT, } ptntype; char *ptnstr; long ptnint; #ifdef CONFIG_REGEX_PCRE - pcre *regex_pcre; - pcre_extra *regex_pcre_extra; + pcre2_code *regex_pcre; + pcre2_match_data *regex_pcre_match; #endif }; @@ -236,14 +233,16 @@ static inline long winprop_get_int(winprop_t prop, size_t index) { */ static inline int strcmp_wd(const char *needle, const char *src) { int ret = mstrncmp(needle, src); - if (ret) + if (ret) { return ret; + } char c = src[strlen(needle)]; - if (isalnum((unsigned char)c) || '_' == c) + if (isalnum((unsigned char)c) || '_' == c) { return 1; - else - return 0; + } + + return 0; } /** @@ -257,8 +256,9 @@ static inline attr_unused bool c2_ptr_isempty(const c2_ptr_t p) { * Reset a c2_ptr_t. */ static inline void c2_ptr_reset(c2_ptr_t *pp) { - if (pp) + if (pp) { memcpy(pp, &C2_PTR_NULL, sizeof(c2_ptr_t)); + } } /** @@ -339,17 +339,19 @@ static bool c2_match_once(session_t *ps, const struct managed_win *w, const c2_p * Parse a condition string. */ c2_lptr_t *c2_parse(c2_lptr_t **pcondlst, const char *pattern, void *data) { - if (!pattern) + if (!pattern) { return NULL; + } // Parse the pattern c2_ptr_t result = C2_PTR_INIT; int offset = -1; - if (strlen(pattern) >= 2 && ':' == pattern[1]) + if (strlen(pattern) >= 2 && ':' == pattern[1]) { offset = c2_parse_legacy(pattern, 0, &result); - else + } else { offset = c2_parse_grp(pattern, 0, &result, 0); + } if (offset < 0) { c2_freep(&result); @@ -398,11 +400,13 @@ c2_lptr_t *c2_parse(c2_lptr_t **pcondlst, const char *pattern, void *data) { */ static int c2_parse_grp(const char *pattern, int offset, c2_ptr_t *presult, int level) { // Check for recursion levels - if (level > C2_MAX_LEVELS) + if (level > C2_MAX_LEVELS) { c2_error("Exceeded maximum recursion levels."); + } - if (!pattern) + if (!pattern) { return -1; + } // Expected end character const char endchar = (offset ? ')' : '\0'); @@ -431,17 +435,20 @@ static int c2_parse_grp(const char *pattern, int offset, c2_ptr_t *presult, int assert(elei <= 2); // Jump over spaces - if (isspace((unsigned char)pattern[offset])) + if (isspace((unsigned char)pattern[offset])) { continue; + } // Handle end of group - if (')' == pattern[offset]) + if (')' == pattern[offset]) { break; + } // Handle "!" if ('!' == pattern[offset]) { - if (!next_expected) + if (!next_expected) { c2_error("Unexpected \"!\"."); + } neg = !neg; continue; @@ -449,8 +456,9 @@ static int c2_parse_grp(const char *pattern, int offset, c2_ptr_t *presult, int // Handle AND and OR if ('&' == pattern[offset] || '|' == pattern[offset]) { - if (next_expected) + if (next_expected) { c2_error("Unexpected logical operator."); + } next_expected = true; if (!mstrncmp("&&", pattern + offset)) { @@ -459,15 +467,17 @@ static int c2_parse_grp(const char *pattern, int offset, c2_ptr_t *presult, int } else if (!mstrncmp("||", pattern + offset)) { ops[elei] = C2_B_OOR; ++offset; - } else + } else { c2_error("Illegal logical operator."); + } continue; } // Parsing an element - if (!next_expected) + if (!next_expected) { c2_error("Unexpected expression."); + } assert(!elei || ops[elei]); @@ -494,21 +504,25 @@ static int c2_parse_grp(const char *pattern, int offset, c2_ptr_t *presult, int // It's a subgroup if it starts with '(' if ('(' == pattern[offset]) { - if ((offset = c2_parse_grp(pattern, offset + 1, pele, level + 1)) < 0) + if ((offset = c2_parse_grp(pattern, offset + 1, pele, level + 1)) < 0) { goto fail; + } } // Otherwise it's a leaf else { - if ((offset = c2_parse_target(pattern, offset, pele)) < 0) + if ((offset = c2_parse_target(pattern, offset, pele)) < 0) { goto fail; + } assert(!pele->isbranch && !c2_ptr_isempty(*pele)); - if ((offset = c2_parse_op(pattern, offset, pele)) < 0) + if ((offset = c2_parse_op(pattern, offset, pele)) < 0) { goto fail; + } - if ((offset = c2_parse_pattern(pattern, offset, pele)) < 0) + if ((offset = c2_parse_pattern(pattern, offset, pele)) < 0) { goto fail; + } } // Decrement offset -- we will increment it in loop update --offset; @@ -516,10 +530,11 @@ static int c2_parse_grp(const char *pattern, int offset, c2_ptr_t *presult, int // Apply negation if (neg) { neg = false; - if (pele->isbranch) + if (pele->isbranch) { pele->b->neg = !pele->b->neg; - else + } else { pele->l->neg = !pele->l->neg; + } } next_expected = false; @@ -528,10 +543,12 @@ static int c2_parse_grp(const char *pattern, int offset, c2_ptr_t *presult, int } // Wrong end character? - if (pattern[offset] && !endchar) + if (pattern[offset] && !endchar) { c2_error("Expected end of string but found '%c'.", pattern[offset]); - if (!pattern[offset] && endchar) + } + if (!pattern[offset] && endchar) { c2_error("Expected '%c' but found end of string.", endchar); + } // Handle end of group if (!elei) { @@ -547,8 +564,9 @@ static int c2_parse_grp(const char *pattern, int offset, c2_ptr_t *presult, int *presult = eles[0]; - if (')' == pattern[offset]) + if (')' == pattern[offset]) { ++offset; + } return offset; @@ -781,11 +799,11 @@ static int c2_parse_op(const char *pattern, int offset, c2_ptr_t *presult) { // Parse operator while ('=' == pattern[offset] || '>' == pattern[offset] || '<' == pattern[offset]) { - if ('=' == pattern[offset] && C2_L_OGT == pleaf->op) + if ('=' == pattern[offset] && C2_L_OGT == pleaf->op) { pleaf->op = C2_L_OGTEQ; - else if ('=' == pattern[offset] && C2_L_OLT == pleaf->op) + } else if ('=' == pattern[offset] && C2_L_OLT == pleaf->op) { pleaf->op = C2_L_OLTEQ; - else if (pleaf->op) { + } else if (pleaf->op) { c2_error("Duplicate operator."); } else { switch (pattern[offset]) { @@ -800,9 +818,10 @@ static int c2_parse_op(const char *pattern, int offset, c2_ptr_t *presult) { } // Check for problems - if (C2_L_OEQ != pleaf->op && (pleaf->match || pleaf->match_ignorecase)) + if (C2_L_OEQ != pleaf->op && (pleaf->match || pleaf->match_ignorecase)) { c2_error("Exists/greater-than/less-than operators cannot have a " "qualifier."); + } return offset; @@ -894,9 +913,10 @@ static int c2_parse_pattern(const char *pattern, int offset, c2_ptr_t *presult) char *pstr = NULL; long val = strtol( tstr, &pstr, ('o' == pattern[offset] ? 8 : 16)); - if (pstr != &tstr[2] || val <= 0) + if (pstr != &tstr[2] || val <= 0) { c2_error("Invalid octal/hex escape " "sequence."); + } *(ptptnstr++) = to_char_checked(val); offset += 2; break; @@ -907,8 +927,9 @@ static int c2_parse_pattern(const char *pattern, int offset, c2_ptr_t *presult) *(ptptnstr++) = pattern[offset]; } } - if (!pattern[offset]) + if (!pattern[offset]) { c2_error("Premature end of pattern string."); + } ++offset; *ptptnstr = '\0'; pleaf->ptnstr = strdup(tptnstr); @@ -917,27 +938,32 @@ static int c2_parse_pattern(const char *pattern, int offset, c2_ptr_t *presult) C2H_SKIP_SPACES(); - if (!pleaf->ptntype) + if (!pleaf->ptntype) { c2_error("Invalid pattern type."); + } // Check if the type is correct if (!(((C2_L_TSTRING == pleaf->type || C2_L_TATOM == pleaf->type) && C2_L_PTSTRING == pleaf->ptntype) || ((C2_L_TCARDINAL == pleaf->type || C2_L_TWINDOW == pleaf->type || C2_L_TDRAWABLE == pleaf->type) && - C2_L_PTINT == pleaf->ptntype))) + C2_L_PTINT == pleaf->ptntype))) { c2_error("Pattern type incompatible with target type."); + } - if (C2_L_PTINT == pleaf->ptntype && pleaf->match) + if (C2_L_PTINT == pleaf->ptntype && pleaf->match) { c2_error("Integer/boolean pattern cannot have operator qualifiers."); + } - if (C2_L_PTINT == pleaf->ptntype && pleaf->match_ignorecase) + if (C2_L_PTINT == pleaf->ptntype && pleaf->match_ignorecase) { c2_error("Integer/boolean pattern cannot have flags."); + } if (C2_L_PTSTRING == pleaf->ptntype && (C2_L_OGT == pleaf->op || C2_L_OGTEQ == pleaf->op || C2_L_OLT == pleaf->op || - C2_L_OLTEQ == pleaf->op)) + C2_L_OLTEQ == pleaf->op)) { c2_error("String pattern cannot have an arithmetic operator."); + } return offset; @@ -965,7 +991,7 @@ static int c2_parse_legacy(const char *pattern, int offset, c2_ptr_t *presult) { // Determine the pattern target #define TGTFILL(pdefid) \ - (pleaf->predef = pdefid, pleaf->type = C2_PREDEFS[pdefid].type, \ + (pleaf->predef = (pdefid), pleaf->type = C2_PREDEFS[pdefid].type, \ pleaf->format = C2_PREDEFS[pdefid].format) switch (pattern[offset]) { case 'n': TGTFILL(C2_L_PNAME); break; @@ -1059,32 +1085,31 @@ static bool c2_l_postprocess(session_t *ps, c2_l_t *pleaf) { // PCRE patterns if (C2_L_PTSTRING == pleaf->ptntype && C2_L_MPCRE == pleaf->match) { #ifdef CONFIG_REGEX_PCRE - const char *error = NULL; - int erroffset = 0; - int options = 0; + int errorcode = 0; + PCRE2_SIZE erroffset = 0; + unsigned int options = 0; // Ignore case flag - if (pleaf->match_ignorecase) - options |= PCRE_CASELESS; + if (pleaf->match_ignorecase) { + options |= PCRE2_CASELESS; + } // Compile PCRE expression pleaf->regex_pcre = - pcre_compile(pleaf->ptnstr, options, &error, &erroffset, NULL); - if (!pleaf->regex_pcre) { - log_error("Pattern \"%s\": PCRE regular expression parsing " + pcre2_compile((PCRE2_SPTR)pleaf->ptnstr, PCRE2_ZERO_TERMINATED, + options, &errorcode, &erroffset, NULL); + if (pleaf->regex_pcre == NULL) { + PCRE2_UCHAR buffer[256]; + pcre2_get_error_message(errorcode, buffer, sizeof(buffer)); + log_error("Pattern \"%s\": PCRE regular expression " + "parsing " "failed on " - "offset %d: %s", - pleaf->ptnstr, erroffset, error); + "offset %zu: %s", + pleaf->ptnstr, erroffset, buffer); return false; } -#ifdef CONFIG_REGEX_PCRE_JIT - pleaf->regex_pcre_extra = - pcre_study(pleaf->regex_pcre, PCRE_STUDY_JIT_COMPILE, &error); - if (!pleaf->regex_pcre_extra) { - printf("Pattern \"%s\": PCRE regular expression study failed: %s", - pleaf->ptnstr, error); - } -#endif + pleaf->regex_pcre_match = + pcre2_match_data_create_from_pattern(pleaf->regex_pcre, NULL); // Free the target string // free(pleaf->tgt); @@ -1102,16 +1127,18 @@ static bool c2_tree_postprocess(session_t *ps, c2_ptr_t node) { if (!node.isbranch) { return c2_l_postprocess(ps, node.l); } - if (!c2_tree_postprocess(ps, node.b->opr1)) + if (!c2_tree_postprocess(ps, node.b->opr1)) { return false; + } return c2_tree_postprocess(ps, node.b->opr2); } bool c2_list_postprocess(session_t *ps, c2_lptr_t *list) { c2_lptr_t *head = list; while (head) { - if (!c2_tree_postprocess(ps, head->ptr)) + if (!c2_tree_postprocess(ps, head->ptr)) { return false; + } head = head->next; } return true; @@ -1124,8 +1151,9 @@ static void c2_free(c2_ptr_t p) { if (p.isbranch) { c2_b_t *const pbranch = p.b; - if (!pbranch) + if (!pbranch) { return; + } c2_free(pbranch->opr1); c2_free(pbranch->opr2); @@ -1135,14 +1163,15 @@ static void c2_free(c2_ptr_t p) { else { c2_l_t *const pleaf = p.l; - if (!pleaf) + if (!pleaf) { return; + } free(pleaf->tgt); free(pleaf->ptnstr); #ifdef CONFIG_REGEX_PCRE - pcre_free(pleaf->regex_pcre); - LPCRE_FREE_STUDY(pleaf->regex_pcre_extra); + pcre2_code_free(pleaf->regex_pcre); + pcre2_match_data_free(pleaf->regex_pcre_match); #endif free(pleaf); } @@ -1173,9 +1202,8 @@ c2_lptr_t *c2_free_lptr(c2_lptr_t *lp, c2_userdata_free f) { static const char *c2h_dump_str_tgt(const c2_l_t *pleaf) { if (pleaf->predef != C2_L_PUNDEFINED) { return C2_PREDEFS[pleaf->predef].name; - } else { - return pleaf->tgt; } + return pleaf->tgt; } /** @@ -1308,7 +1336,7 @@ static xcb_atom_t c2_get_atom_type(const c2_l_t *pleaf) { case C2_L_TDRAWABLE: return XCB_ATOM_DRAWABLE; default: assert(0); break; } - unreachable; + unreachable(); } /** @@ -1378,11 +1406,11 @@ static inline void c2_match_once_leaf(session_t *ps, const struct managed_win *w int word_count = 1; if (pleaf->index < 0) { // Get length of property in 32-bit multiples - auto prop_info = x_get_prop_info(ps->c, wid, pleaf->tgtatom); + auto prop_info = x_get_prop_info(&ps->c, wid, pleaf->tgtatom); word_count = to_int_checked((prop_info.length + 4 - 1) / 4); } winprop_t prop = x_get_prop_with_offset( - ps->c, wid, pleaf->tgtatom, idx, word_count, + &ps->c, wid, pleaf->tgtatom, idx, word_count, c2_get_atom_type(pleaf), pleaf->format); ntargets = (pleaf->index < 0 ? prop.nitems : min2(prop.nitems, 1)); @@ -1455,11 +1483,11 @@ static inline void c2_match_once_leaf(session_t *ps, const struct managed_win *w int word_count = 1; if (pleaf->index < 0) { // Get length of property in 32-bit multiples - auto prop_info = x_get_prop_info(ps->c, wid, pleaf->tgtatom); + auto prop_info = x_get_prop_info(&ps->c, wid, pleaf->tgtatom); word_count = to_int_checked((prop_info.length + 4 - 1) / 4); } winprop_t prop = x_get_prop_with_offset( - ps->c, wid, pleaf->tgtatom, idx, word_count, + &ps->c, wid, pleaf->tgtatom, idx, word_count, c2_get_atom_type(pleaf), pleaf->format); ntargets = (pleaf->index < 0 ? prop.nitems : min2(prop.nitems, 1)); @@ -1470,7 +1498,7 @@ static inline void c2_match_once_leaf(session_t *ps, const struct managed_win *w xcb_atom_t atom = (xcb_atom_t)winprop_get_int(prop, i); if (atom) { xcb_get_atom_name_reply_t *reply = xcb_get_atom_name_reply( - ps->c, xcb_get_atom_name(ps->c, atom), NULL); + ps->c.c, xcb_get_atom_name(ps->c.c, atom), NULL); if (reply) { targets[i] = targets_free_inner[i] = strndup( xcb_get_atom_name_name(reply), @@ -1550,9 +1578,10 @@ static inline void c2_match_once_leaf(session_t *ps, const struct managed_win *w case C2_L_MPCRE: #ifdef CONFIG_REGEX_PCRE assert(strlen(tgt) <= INT_MAX); - res = (pcre_exec(pleaf->regex_pcre, - pleaf->regex_pcre_extra, tgt, - (int)strlen(tgt), 0, 0, NULL, 0) >= 0); + assert(pleaf->regex_pcre); + res = (pcre2_match(pleaf->regex_pcre, (PCRE2_SPTR)tgt, + strlen(tgt), 0, 0, + pleaf->regex_pcre_match, NULL) > 0); #else assert(0); #endif @@ -1598,8 +1627,9 @@ static bool c2_match_once(session_t *ps, const struct managed_win *w, const c2_p if (cond.isbranch) { const c2_b_t *pb = cond.b; - if (!pb) + if (!pb) { return false; + } error = false; @@ -1629,8 +1659,9 @@ static bool c2_match_once(session_t *ps, const struct managed_win *w, const c2_p else { const c2_l_t *pleaf = cond.l; - if (!pleaf) + if (!pleaf) { return false; + } c2_match_once_leaf(ps, w, pleaf, &result, &error); @@ -1650,11 +1681,13 @@ static bool c2_match_once(session_t *ps, const struct managed_win *w, const c2_p } // Postprocess the result - if (error) + if (error) { result = false; + } - if (cond.isbranch ? cond.b->neg : cond.l->neg) + if (cond.isbranch ? cond.b->neg : cond.l->neg) { result = !result; + } return result; } @@ -1672,8 +1705,9 @@ bool c2_match(session_t *ps, const struct managed_win *w, const c2_lptr_t *condl // Then go through the whole linked list for (; condlst; condlst = condlst->next) { if (c2_match_once(ps, w, condlst->ptr)) { - if (pdata) + if (pdata) { *pdata = condlst->data; + } return true; } } diff --git a/src/common.h b/src/common.h index bc38c7b334..52967e600d 100644 --- a/src/common.h +++ b/src/common.h @@ -58,6 +58,7 @@ #include "list.h" #include "region.h" #include "render.h" +#include "statistics.h" #include "types.h" #include "utils.h" #include "win_defs.h" @@ -83,11 +84,6 @@ struct glx_session; struct atom; struct conv; -typedef struct _ignore { - struct _ignore *next; - unsigned long sequence; -} ignore_t; - #ifdef CONFIG_OPENGL #ifdef DEBUG_GLX_DEBUG_CONTEXT typedef GLXContext (*f_glXCreateContextAttribsARB)(Display *dpy, GLXFBConfig config, @@ -147,10 +143,9 @@ typedef struct session { ev_timer unredir_timer; /// Timer for fading ev_timer fade_timer; - /// Use an ev_idle callback for drawing - /// So we only start drawing when events are processed - ev_idle draw_idle; - /// Called everytime we have timeouts or new data on socket, + /// Use an ev_timer callback for drawing + ev_timer draw_timer; + /// Called every time we have timeouts or new data on socket, /// so we can be sure if xcb read from X socket at anytime during event /// handling, we will not left any event unhandled in the queue ev_prepare event_check; @@ -174,28 +169,14 @@ typedef struct session { struct shader_info *shaders; // === Display related === + /// X connection + struct x_connection c; /// Whether the X server is grabbed by us bool server_grabbed; - /// Display in use. - Display *dpy; - /// Previous handler of X errors - XErrorHandler previous_xerror_handler; - /// Default screen. - int scr; - /// XCB connection. - xcb_connection_t *c; - /// Default visual. - xcb_visualid_t vis; - /// Default depth. - int depth; - /// Root window. - xcb_window_t root; - /// Height of root window. - int root_height; /// Width of root window. int root_width; - // Damage of root window. - // Damage root_damage; + /// Height of root window. + int root_height; /// X Composite overlay window. xcb_window_t overlay; /// The target window for debug mode @@ -229,6 +210,24 @@ typedef struct session { xcb_sync_fence_t sync_fence; /// Whether we are rendering the first frame after screen is redirected bool first_frame; + /// Whether screen has been turned off + bool screen_is_off; + /// When last MSC event happened, in useconds. + uint64_t last_msc_instant; + /// The last MSC number + uint64_t last_msc; + /// The delay between when the last frame was scheduled to be rendered, and when + /// the render actually started. + uint64_t last_schedule_delay; + /// When do we want our next frame to start rendering. + uint64_t next_render; + /// Whether we can perform frame pacing. + bool frame_pacing; + /// Vblank event scheduler + struct vblank_scheduler *vblank_scheduler; + + /// Render statistics + struct render_statistics render_stats; // === Operation related === /// Flags related to the root window @@ -237,10 +236,20 @@ typedef struct session { options_t o; /// Whether we have hit unredirection timeout. bool tmout_unredir_hit; - /// Whether we need to redraw the screen - bool redraw_needed; - - /// Cache a xfixes region so we don't need to allocate it everytime. + /// If the backend is busy. This means two things: + /// Either the backend is currently rendering a frame, or a frame has been + /// rendered but has yet to be presented. In either case, we should not start + /// another render right now. As if we start issuing rendering commands now, we + /// will have to wait for either the the current render to finish, or the current + /// back buffer to be become available again. In either case, we will be wasting + /// time. + bool backend_busy; + /// Whether a render is queued. This generally means there are pending updates + /// to the screen that's neither included in the current render, nor on the + /// screen. + bool render_queued; + + /// Cache a xfixes region so we don't need to allocate it every time. /// A workaround for yshui/picom#301 xcb_xfixes_region_t damaged_region; /// The region needs to painted on next paint. @@ -255,19 +264,14 @@ typedef struct session { xcb_render_picture_t *alpha_picts; /// Time of last fading. In milliseconds. long long fade_time; - /// Head pointer of the error ignore linked list. - ignore_t *ignore_head; - /// Pointer to the next member of tail element of the error - /// ignore linked list. - ignore_t **ignore_tail; // Cached blur convolution kernels. struct x_convolution_kernel **blur_kerns_cache; /// If we should quit - bool quit:1; + bool quit : 1; // TODO(yshui) use separate flags for dfferent kinds of updates so we don't // waste our time. /// Whether there are pending updates, like window creation, etc. - bool pending_updates:1; + bool pending_updates : 1; // === Expose event related === /// Pointer to an array of XRectangle-s of exposed region. @@ -335,6 +339,8 @@ typedef struct session { int composite_error; /// Major opcode for X Composite extension. int composite_opcode; + /// Whether X DPMS extension exists + bool dpms_exists; /// Whether X Shape extension exists. bool shape_exists; /// Event base number for X Shape extension. @@ -355,12 +361,8 @@ typedef struct session { int glx_event; /// Error base number for X GLX extension. int glx_error; - /// Whether X Xinerama extension exists. - bool xinerama_exists; - /// Xinerama screen regions. - region_t *xinerama_scr_regs; - /// Number of Xinerama screens. - int xinerama_nscrs; + /// Information about monitors. + struct x_monitors monitors; /// Whether X Sync extension exists. bool xsync_exists; /// Event base number for X Sync extension. @@ -458,7 +460,7 @@ static inline struct timespec get_time_timespec(void) { * Return the painting target window. */ static inline xcb_window_t get_tgt_window(session_t *ps) { - return ps->overlay != XCB_NONE ? ps->overlay : ps->root; + return ps->overlay != XCB_NONE ? ps->overlay : ps->c.screen_info->root; } /** @@ -468,27 +470,6 @@ static inline bool bkend_use_glx(session_t *ps) { return BKEND_GLX == ps->o.backend || BKEND_XR_GLX_HYBRID == ps->o.backend; } -static void set_ignore(session_t *ps, unsigned long sequence) { - if (ps->o.show_all_xerrors) - return; - - auto i = cmalloc(ignore_t); - if (!i) - return; - - i->sequence = sequence; - i->next = 0; - *ps->ignore_tail = i; - ps->ignore_tail = &i->next; -} - -/** - * Ignore X errors caused by given X request. - */ -static inline void set_ignore_cookie(session_t *ps, xcb_void_cookie_t cookie) { - set_ignore(ps, cookie.sequence); -} - /** * Determine if a window has a specific property. * @@ -499,7 +480,8 @@ static inline void set_ignore_cookie(session_t *ps, xcb_void_cookie_t cookie) { */ static inline bool wid_has_prop(const session_t *ps, xcb_window_t w, xcb_atom_t atom) { auto r = xcb_get_property_reply( - ps->c, xcb_get_property(ps->c, 0, w, atom, XCB_GET_PROPERTY_TYPE_ANY, 0, 0), NULL); + ps->c.c, + xcb_get_property(ps->c.c, 0, w, atom, XCB_GET_PROPERTY_TYPE_ANY, 0, 0), NULL); if (!r) { return false; } diff --git a/src/compiler.h b/src/compiler.h index 00da4cb5b8..edc370bd0e 100644 --- a/src/compiler.h +++ b/src/compiler.h @@ -7,7 +7,9 @@ #endif // clang-format off +#if __STDC_VERSION__ <= 201710L #define auto __auto_type +#endif #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #define likely_if(x) if (likely(x)) @@ -101,10 +103,12 @@ # endif #endif -#if defined(__GNUC__) || defined(__clang__) -# define unreachable __builtin_unreachable() -#else -# define unreachable do {} while(0) +#ifndef unreachable +# if defined(__GNUC__) || defined(__clang__) +# define unreachable() __builtin_unreachable() +# else +# define unreachable() do {} while(0) +# endif #endif #ifndef __has_include diff --git a/src/config.c b/src/config.c index d9b2dd9122..22774f7ff7 100644 --- a/src/config.c +++ b/src/config.c @@ -8,6 +8,8 @@ #include #include #include +#include +#include #include #include #include @@ -133,8 +135,9 @@ bool parse_long(const char *s, long *dest) { log_error("Invalid number: %s", s); return false; } - while (isspace((unsigned char)*endptr)) + while (isspace((unsigned char)*endptr)) { ++endptr; + } if (*endptr) { log_error("Trailing characters: %s", s); return false; @@ -182,20 +185,19 @@ const char *parse_readnum(const char *src, double *dest) { } enum blur_method parse_blur_method(const char *src) { - if (strcmp(src, "kernel") == 0) { - return BLUR_METHOD_KERNEL; - } else if (strcmp(src, "box") == 0) { + if (strcmp(src, "box") == 0) { return BLUR_METHOD_BOX; - } else if (strcmp(src, "gaussian") == 0) { - return BLUR_METHOD_GAUSSIAN; - } else if (strcmp(src, "dual_kawase") == 0) { - return BLUR_METHOD_DUAL_KAWASE; - } else if (strcmp(src, "kawase") == 0) { - log_warn("Blur method 'kawase' has been renamed to 'dual_kawase'. " - "Interpreted as 'dual_kawase', but this will stop working " - "soon."); + } + if (strcmp(src, "dual_kawase") == 0) { return BLUR_METHOD_DUAL_KAWASE; - } else if (strcmp(src, "none") == 0) { + } + if (strcmp(src, "gaussian") == 0) { + return BLUR_METHOD_GAUSSIAN; + } + if (strcmp(src, "kernel") == 0) { + return BLUR_METHOD_KERNEL; + } + if (strcmp(src, "none") == 0) { return BLUR_METHOD_NONE; } return BLUR_METHOD_INVALID; @@ -216,12 +218,14 @@ conv *parse_blur_kern(const char *src, const char **endptr, bool *hasneg) { // Get matrix width and height double val = 0.0; - if (src == (pc = parse_readnum(src, &val))) + if (src == (pc = parse_readnum(src, &val))) { goto err1; + } src = pc; width = (int)val; - if (src == (pc = parse_readnum(src, &val))) + if (src == (pc = parse_readnum(src, &val))) { goto err1; + } src = pc; height = (int)val; @@ -234,9 +238,10 @@ conv *parse_blur_kern(const char *src, const char **endptr, bool *hasneg) { log_error("Blur kernel width/height must be odd."); goto err1; } - if (width > 16 || height > 16) + if (width > 16 || height > 16) { log_warn("Blur kernel width/height too large, may slow down" "rendering, and/or consume lots of memory"); + } // Allocate memory conv *matrix = cvalloc(sizeof(conv) + (size_t)(width * height) * sizeof(double)); @@ -362,8 +367,9 @@ struct conv **parse_blur_kern_lst(const char *src, bool *hasneg, int *count) { *hasneg = false; for (unsigned int i = 0; i < sizeof(CONV_KERN_PREDEF) / sizeof(CONV_KERN_PREDEF[0]); ++i) { - if (!strcmp(CONV_KERN_PREDEF[i].name, src)) + if (!strcmp(CONV_KERN_PREDEF[i].name, src)) { return parse_blur_kern_lst(CONV_KERN_PREDEF[i].kern_str, hasneg, count); + } } int nkernels = 1; @@ -509,32 +515,37 @@ bool parse_geometry(session_t *ps, const char *src, region_t *dest) { } /** - * Parse a list of opacity rules. + * Parse a list of window rules, prefixed with a number, separated by a ':' */ -bool parse_rule_opacity(c2_lptr_t **res, const char *src) { - // Find opacity value +bool parse_numeric_window_rule(c2_lptr_t **res, const char *src, long min, long max) { + if (!src) { + return false; + } + + // Find numeric value char *endptr = NULL; long val = strtol(src, &endptr, 0); if (!endptr || endptr == src) { - log_error("No opacity specified: %s", src); + log_error("No number specified: %s", src); return false; } - if (val > 100 || val < 0) { - log_error("Opacity %ld invalid: %s", val, src); + + if (val < min || val > max) { + log_error("Number not in range (%ld <= n <= %ld): %s", min, max, src); return false; } // Skip over spaces - while (*endptr && isspace((unsigned char)*endptr)) + while (*endptr && isspace((unsigned char)*endptr)) { ++endptr; + } if (':' != *endptr) { - log_error("Opacity terminator not found: %s", src); + log_error("Number separator (':') not found: %s", src); return false; } ++endptr; // Parse pattern - // I hope 1-100 is acceptable for (void *) return c2_parse(res, endptr, (void *)val); } @@ -587,15 +598,17 @@ char *locate_auxiliary_file(const char *scope, const char *path, const char *inc // Fall back to searching in user config directory scoped_charp picom_scope = mstrjoin("/picom/", scope); scoped_charp config_home = (char *)xdg_config_home(); - char *ret = locate_auxiliary_file_at(config_home, picom_scope, path); - if (ret) { - return ret; + if (config_home) { + char *ret = locate_auxiliary_file_at(config_home, picom_scope, path); + if (ret) { + return ret; + } } // Fall back to searching in system config directory auto config_dirs = xdg_config_dirs(); for (int i = 0; config_dirs[i]; i++) { - ret = locate_auxiliary_file_at(config_dirs[i], picom_scope, path); + char *ret = locate_auxiliary_file_at(config_dirs[i], picom_scope, path); if (ret) { free(config_dirs); return ret; @@ -603,7 +616,83 @@ char *locate_auxiliary_file(const char *scope, const char *path, const char *inc } free(config_dirs); - return ret; + return NULL; +} + +struct debug_options_entry { + const char *name; + const char **choices; + size_t offset; +}; + +// clang-format off +const char *vblank_scheduler_str[] = { + [VBLANK_SCHEDULER_PRESENT] = "present", + [VBLANK_SCHEDULER_SGI_VIDEO_SYNC] = "sgi_video_sync", + [LAST_VBLANK_SCHEDULER] = NULL +}; +static const struct debug_options_entry debug_options_entries[] = { + {"smart_frame_pacing", NULL, offsetof(struct debug_options, smart_frame_pacing)}, + {"force_vblank_sched", vblank_scheduler_str, offsetof(struct debug_options, force_vblank_scheduler)}, +}; +// clang-format on + +void parse_debug_option_single(char *setting, struct debug_options *debug_options) { + char *equal = strchr(setting, '='); + size_t name_len = equal ? (size_t)(equal - setting) : strlen(setting); + for (size_t i = 0; i < ARR_SIZE(debug_options_entries); i++) { + if (strncmp(setting, debug_options_entries[i].name, name_len) != 0) { + continue; + } + if (debug_options_entries[i].name[name_len] != '\0') { + continue; + } + auto value = (int *)((void *)debug_options + debug_options_entries[i].offset); + if (equal) { + const char *const arg = equal + 1; + if (debug_options_entries[i].choices != NULL) { + for (size_t j = 0; debug_options_entries[i].choices[j]; j++) { + if (strcmp(arg, debug_options_entries[i].choices[j]) == + 0) { + *value = (int)j; + return; + } + } + } + if (!parse_int(arg, value)) { + log_error("Invalid value for debug option %s: %s, it " + "will be ignored.", + debug_options_entries[i].name, arg); + } + } else if (debug_options_entries[i].choices == NULL) { + *value = 1; + } else { + log_error( + "Missing value for debug option %s, it will be ignored.", setting); + } + return; + } + log_error("Invalid debug option: %s", setting); +} + +/// Parse debug options from environment variable `PICOM_DEBUG`. +void parse_debug_options(struct debug_options *debug_options) { + const char *debug = getenv("PICOM_DEBUG"); + const struct debug_options default_debug_options = { + .force_vblank_scheduler = LAST_VBLANK_SCHEDULER, + }; + + *debug_options = default_debug_options; + if (!debug) { + return; + } + + scoped_charp debug_copy = strdup(debug); + char *tmp, *needle = strtok_r(debug_copy, ";", &tmp); + while (needle) { + parse_debug_option_single(needle, debug_options); + needle = strtok_r(NULL, ";", &tmp); + } } /** @@ -650,11 +739,13 @@ bool parse_rule_window_shader(c2_lptr_t **res, const char *src, const char *incl * Add a pattern to a condition linked list. */ bool condlst_add(c2_lptr_t **pcondlst, const char *pattern) { - if (!pattern) + if (!pattern) { return false; + } - if (!c2_parse(pcondlst, pattern, NULL)) + if (!c2_parse(pcondlst, pattern, NULL)) { exit(1); + } return true; } @@ -737,6 +828,7 @@ char *parse_config(options_t *opt, const char *config_file, bool *shadow_enable, .logpath = NULL, .use_damage = true, + .no_frame_pacing = false, .shadow_red = 0.0, .shadow_green = 0.0, @@ -747,7 +839,7 @@ char *parse_config(options_t *opt, const char *config_file, bool *shadow_enable, .shadow_opacity = .75, .shadow_blacklist = NULL, .shadow_ignore_shaped = false, - .xinerama_shadow_crop = false, + .crop_shadow_to_monitor = false, .shadow_clip_list = NULL, .corner_radius = 0, @@ -805,5 +897,6 @@ char *parse_config(options_t *opt, const char *config_file, bool *shadow_enable, (void)hasneg; (void)winopt_mask; #endif + parse_debug_options(&opt->debug_options); return ret; } diff --git a/src/config.h b/src/config.h index 7259dc1d35..d91dbb4563 100644 --- a/src/config.h +++ b/src/config.h @@ -73,6 +73,27 @@ enum blur_method { typedef struct _c2_lptr c2_lptr_t; +enum vblank_scheduler_type { + /// X Present extension based vblank events + VBLANK_SCHEDULER_PRESENT, + /// GLX_SGI_video_sync based vblank events + VBLANK_SCHEDULER_SGI_VIDEO_SYNC, + /// An invalid scheduler, served as a scheduler count, and + /// as a sentinel value. + LAST_VBLANK_SCHEDULER, +}; + +extern const char *vblank_scheduler_str[]; + +/// Internal, private options for debugging and development use. +struct debug_options { + /// Try to reduce frame latency by using vblank interval and render time + /// estimates. Right now it's not working well across drivers. + int smart_frame_pacing; + /// Override the vblank scheduler chosen by the compositor. + int force_vblank_scheduler; +}; + /// Structure representing all options. typedef struct options { // === Debugging === @@ -140,6 +161,8 @@ typedef struct options { bool vsync_use_glfinish; /// Whether use damage information to help limit the area to paint bool use_damage; + /// Disable frame pacing + bool no_frame_pacing; // === Shadow === /// Red, green and blue tone of the shadow. @@ -153,8 +176,8 @@ typedef struct options { c2_lptr_t *shadow_blacklist; /// Whether bounding-shaped window should be ignored. bool shadow_ignore_shaped; - /// Whether to crop shadow to the very Xinerama screen. - bool xinerama_shadow_crop; + /// Whether to crop shadow to the very X RandR monitor. + bool crop_shadow_to_monitor; /// Don't draw shadow over these windows. A linked list of conditions. c2_lptr_t *shadow_clip_list; @@ -228,6 +251,8 @@ typedef struct options { int corner_radius; /// Rounded corners blacklist. A linked list of conditions. c2_lptr_t *rounded_corners_blacklist; + /// Rounded corner rules. A linked list of conditions. + c2_lptr_t *corner_radius_rules; // === Focus related === /// Whether to try to detect WM windows and mark them as focused. @@ -256,6 +281,10 @@ typedef struct options { /// A list of conditions of windows to which transparent clipping /// should not apply c2_lptr_t *transparent_clipping_blacklist; + + bool dithered_present; + + struct debug_options debug_options; } options_t; extern const char *const BACKEND_STRS[NUM_BKEND + 1]; @@ -264,7 +293,7 @@ bool must_use parse_long(const char *, long *); bool must_use parse_int(const char *, int *); struct conv **must_use parse_blur_kern_lst(const char *, bool *hasneg, int *count); bool must_use parse_geometry(session_t *, const char *, region_t *); -bool must_use parse_rule_opacity(c2_lptr_t **, const char *); +bool must_use parse_numeric_window_rule(c2_lptr_t **, const char *, long, long); bool must_use parse_rule_window_shader(c2_lptr_t **, const char *, const char *); char *must_use locate_auxiliary_file(const char *scope, const char *path, const char *include_dir); diff --git a/src/config_libconfig.c b/src/config_libconfig.c index 461fff3be9..ed2097eb76 100644 --- a/src/config_libconfig.c +++ b/src/config_libconfig.c @@ -73,24 +73,27 @@ FILE *open_config_file(const char *cpath, char **ppath) { if (cpath) { FILE *ret = fopen(cpath, "r"); - if (ret && ppath) + if (ret && ppath) { *ppath = strdup(cpath); + } return ret; } // First search for config file in user config directory auto config_home = xdg_config_home(); - auto ret = open_config_file_at(config_home, ppath); - free((void *)config_home); - if (ret) { - return ret; + if (config_home) { + auto ret = open_config_file_at(config_home, ppath); + free((void *)config_home); + if (ret) { + return ret; + } } // Fall back to legacy config file in user home directory const char *home = getenv("HOME"); if (home && strlen(home)) { auto path = mstrjoin(home, config_filename_legacy); - ret = fopen(path, "r"); + auto ret = fopen(path, "r"); if (ret && ppath) { *ppath = path; } else { @@ -104,7 +107,7 @@ FILE *open_config_file(const char *cpath, char **ppath) { // Fall back to config file in system config directory auto config_dirs = xdg_config_dirs(); for (int i = 0; config_dirs[i]; i++) { - ret = open_config_file_at(config_dirs[i], ppath); + auto ret = open_config_file_at(config_dirs[i], ppath); if (ret) { free(config_dirs); return ret; @@ -124,9 +127,10 @@ void parse_cfg_condlst(const config_t *pcfg, c2_lptr_t **pcondlst, const char *n // Parse an array of options if (config_setting_is_array(setting)) { int i = config_setting_length(setting); - while (i--) + while (i--) { condlst_add(pcondlst, config_setting_get_string_elem(setting, i)); + } } // Treat it as a single pattern if it's a string else if (CONFIG_TYPE_STRING == config_setting_type(setting)) { @@ -135,6 +139,36 @@ void parse_cfg_condlst(const config_t *pcfg, c2_lptr_t **pcondlst, const char *n } } +/** + * Parse a window corner radius rule list in configuration file. + */ +static inline void +parse_cfg_condlst_corner(options_t *opt, const config_t *pcfg, const char *name) { + config_setting_t *setting = config_lookup(pcfg, name); + if (setting) { + // Parse an array of options + if (config_setting_is_array(setting)) { + int i = config_setting_length(setting); + while (i--) { + if (!parse_numeric_window_rule( + &opt->corner_radius_rules, + config_setting_get_string_elem(setting, i), 0, + INT_MAX)) { + exit(1); + } + } + } + // Treat it as a single pattern if it's a string + else if (config_setting_type(setting) == CONFIG_TYPE_STRING) { + if (!parse_numeric_window_rule(&opt->corner_radius_rules, + config_setting_get_string(setting), + 0, INT_MAX)) { + exit(1); + } + } + } +} + /** * Parse an opacity rule list in configuration file. */ @@ -145,17 +179,21 @@ parse_cfg_condlst_opct(options_t *opt, const config_t *pcfg, const char *name) { // Parse an array of options if (config_setting_is_array(setting)) { int i = config_setting_length(setting); - while (i--) - if (!parse_rule_opacity( + while (i--) { + if (!parse_numeric_window_rule( &opt->opacity_rules, - config_setting_get_string_elem(setting, i))) + config_setting_get_string_elem(setting, i), 0, 100)) { exit(1); + } + } } // Treat it as a single pattern if it's a string else if (config_setting_type(setting) == CONFIG_TYPE_STRING) { - if (!parse_rule_opacity(&opt->opacity_rules, - config_setting_get_string(setting))) + if (!parse_numeric_window_rule(&opt->opacity_rules, + config_setting_get_string(setting), + 0, 100)) { exit(1); + } } } } @@ -334,6 +372,12 @@ char *parse_config_libconfig(options_t *opt, const char *config_file, bool *shad config_lookup_int(&cfg, "corner-radius", &opt->corner_radius); // --rounded-corners-exclude parse_cfg_condlst(&cfg, &opt->rounded_corners_blacklist, "rounded-corners-exclude"); + // --corner-radius-rules + parse_cfg_condlst_corner(opt, &cfg, "corner-radius-rules"); + + // --no-frame-pacing + lcfg_lookup_bool(&cfg, "no-frame-pacing", &opt->no_frame_pacing); + // -e (frame_opacity) config_lookup_float(&cfg, "frame-opacity", &opt->frame_opacity); // -c (shadow_enable) @@ -349,8 +393,9 @@ char *parse_config_libconfig(options_t *opt, const char *config_file, bool *shad winopt_mask[WINTYPE_POPUP_MENU].opacity = true; } // -f (fading_enable) - if (config_lookup_bool(&cfg, "fading", &ival)) + if (config_lookup_bool(&cfg, "fading", &ival)) { *fading_enable = ival; + } // --no-fading-open-close lcfg_lookup_bool(&cfg, "no-fading-openclose", &opt->no_fading_openclose); // --no-fading-destroyed-argb @@ -370,8 +415,9 @@ char *parse_config_libconfig(options_t *opt, const char *config_file, bool *shad opt->shadow_blue = rgb.blue; } // --shadow-exclude-reg - if (config_lookup_string(&cfg, "shadow-exclude-reg", &sval)) + if (config_lookup_string(&cfg, "shadow-exclude-reg", &sval)) { opt->shadow_exclude_reg_str = strdup(sval); + } // --inactive-opacity-override lcfg_lookup_bool(&cfg, "inactive-opacity-override", &opt->inactive_opacity_override); // --inactive-dim @@ -384,8 +430,12 @@ char *parse_config_libconfig(options_t *opt, const char *config_file, bool *shad lcfg_lookup_bool(&cfg, "shadow-ignore-shaped", &opt->shadow_ignore_shaped); // --detect-rounded-corners lcfg_lookup_bool(&cfg, "detect-rounded-corners", &opt->detect_rounded_corners); - // --xinerama-shadow-crop - lcfg_lookup_bool(&cfg, "xinerama-shadow-crop", &opt->xinerama_shadow_crop); + // --crop-shadow-to-monitor + if (lcfg_lookup_bool(&cfg, "xinerama-shadow-crop", &opt->crop_shadow_to_monitor)) { + log_warn("xinerama-shadow-crop is deprecated. Use crop-shadow-to-monitor " + "instead."); + } + lcfg_lookup_bool(&cfg, "crop-shadow-to-monitor", &opt->crop_shadow_to_monitor); // --detect-client-opacity lcfg_lookup_bool(&cfg, "detect-client-opacity", &opt->detect_client_opacity); // --refresh-rate @@ -452,6 +502,8 @@ char *parse_config_libconfig(options_t *opt, const char *config_file, bool *shad lcfg_lookup_bool(&cfg, "no-ewmh-fullscreen", &opt->no_ewmh_fullscreen); // --transparent-clipping lcfg_lookup_bool(&cfg, "transparent-clipping", &opt->transparent_clipping); + // --dithered_present + lcfg_lookup_bool(&cfg, "dithered-present", &opt->dithered_present); // --transparent-clipping-exclude parse_cfg_condlst(&cfg, &opt->transparent_clipping_blacklist, "transparent-clipping-exclude"); @@ -563,9 +615,10 @@ char *parse_config_libconfig(options_t *opt, const char *config_file, bool *shad // --xrender-sync-fence lcfg_lookup_bool(&cfg, "xrender-sync-fence", &opt->xrender_sync_fence); - if (lcfg_lookup_bool(&cfg, "clear-shadow", &bval)) + if (lcfg_lookup_bool(&cfg, "clear-shadow", &bval)) { log_warn("\"clear-shadow\" is removed as an option, and is always" " enabled now. Consider removing it from your config file"); + } config_setting_t *blur_cfg = config_lookup(&cfg, "blur"); if (blur_cfg) { diff --git a/src/dbus.c b/src/dbus.c index 8b17b30d45..861d424e26 100644 --- a/src/dbus.c +++ b/src/dbus.c @@ -253,8 +253,9 @@ static dbus_bool_t cdbus_callback_add_timeout(DBusTimeout *timeout, void *data) t->t = timeout; dbus_timeout_set_data(timeout, t, NULL); - if (dbus_timeout_get_enabled(timeout)) + if (dbus_timeout_get_enabled(timeout)) { ev_timer_start(ps->loop, &t->w); + } return true; } @@ -302,10 +303,12 @@ typedef struct ev_dbus_io { void cdbus_io_callback(EV_P attr_unused, ev_io *w, int revents) { ev_dbus_io *dw = (void *)w; DBusWatchFlags flags = 0; - if (revents & EV_READ) + if (revents & EV_READ) { flags |= DBUS_WATCH_READABLE; - if (revents & EV_WRITE) + } + if (revents & EV_WRITE) { flags |= DBUS_WATCH_WRITABLE; + } dbus_watch_handle(dw->dw, flags); while (dbus_connection_dispatch(dw->cd->dbus_conn) != DBUS_DISPATCH_COMPLETE) ; @@ -317,10 +320,12 @@ void cdbus_io_callback(EV_P attr_unused, ev_io *w, int revents) { static inline int cdbus_get_watch_cond(DBusWatch *watch) { const unsigned flags = dbus_watch_get_flags(watch); int condition = 0; - if (flags & DBUS_WATCH_READABLE) + if (flags & DBUS_WATCH_READABLE) { condition |= EV_READ; - if (flags & DBUS_WATCH_WRITABLE) + } + if (flags & DBUS_WATCH_WRITABLE) { condition |= EV_WRITE; + } return condition; } @@ -338,8 +343,9 @@ static dbus_bool_t cdbus_callback_add_watch(DBusWatch *watch, void *data) { cdbus_get_watch_cond(watch)); // Leave disabled watches alone - if (dbus_watch_get_enabled(watch)) + if (dbus_watch_get_enabled(watch)) { ev_io_start(ps->loop, &w->w); + } dbus_watch_set_data(watch, w, NULL); @@ -363,10 +369,11 @@ static void cdbus_callback_remove_watch(DBusWatch *watch, void *data) { static void cdbus_callback_watch_toggled(DBusWatch *watch, void *data) { session_t *ps = data; ev_io *w = dbus_watch_get_data(watch); - if (dbus_watch_get_enabled(watch)) + if (dbus_watch_get_enabled(watch)) { ev_io_start(ps->loop, w); - else + } else { ev_io_stop(ps->loop, w); + } } ///@} @@ -513,8 +520,9 @@ static bool cdbus_apdarg_enum(session_t *ps attr_unused, DBusMessage *msg, const static bool cdbus_apdarg_string(session_t *ps attr_unused, DBusMessage *msg, const void *data) { const char *str = data; - if (!str) + if (!str) { str = ""; + } if (!dbus_message_append_args(msg, DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID)) { log_error("Failed to append argument."); @@ -1050,32 +1058,36 @@ static bool cdbus_process_win_set(session_t *ps, DBusMessage *msg) { if (!strcmp("shadow_force", target)) { cdbus_enum_t val = UNSET; - if (!cdbus_msg_get_arg(msg, 2, CDBUS_TYPE_ENUM, &val)) + if (!cdbus_msg_get_arg(msg, 2, CDBUS_TYPE_ENUM, &val)) { return false; + } win_set_shadow_force(ps, w, val); goto cdbus_process_win_set_success; } if (!strcmp("fade_force", target)) { cdbus_enum_t val = UNSET; - if (!cdbus_msg_get_arg(msg, 2, CDBUS_TYPE_ENUM, &val)) + if (!cdbus_msg_get_arg(msg, 2, CDBUS_TYPE_ENUM, &val)) { return false; + } win_set_fade_force(w, val); goto cdbus_process_win_set_success; } if (!strcmp("focused_force", target)) { cdbus_enum_t val = UNSET; - if (!cdbus_msg_get_arg(msg, 2, CDBUS_TYPE_ENUM, &val)) + if (!cdbus_msg_get_arg(msg, 2, CDBUS_TYPE_ENUM, &val)) { return false; + } win_set_focused_force(ps, w, val); goto cdbus_process_win_set_success; } if (!strcmp("invert_color_force", target)) { cdbus_enum_t val = UNSET; - if (!cdbus_msg_get_arg(msg, 2, CDBUS_TYPE_ENUM, &val)) + if (!cdbus_msg_get_arg(msg, 2, CDBUS_TYPE_ENUM, &val)) { return false; + } win_set_invert_color_force(ps, w, val); goto cdbus_process_win_set_success; } @@ -1087,8 +1099,9 @@ static bool cdbus_process_win_set(session_t *ps, DBusMessage *msg) { return true; cdbus_process_win_set_success: - if (!dbus_message_get_no_reply(msg)) + if (!dbus_message_get_no_reply(msg)) { cdbus_reply_bool(ps, msg, true); + } return true; } @@ -1098,16 +1111,18 @@ static bool cdbus_process_win_set(session_t *ps, DBusMessage *msg) { static bool cdbus_process_find_win(session_t *ps, DBusMessage *msg) { const char *target = NULL; - if (!cdbus_msg_get_arg(msg, 0, DBUS_TYPE_STRING, &target)) + if (!cdbus_msg_get_arg(msg, 0, DBUS_TYPE_STRING, &target)) { return false; + } xcb_window_t wid = XCB_NONE; // Find window by client window if (!strcmp("client", target)) { cdbus_window_t client = XCB_NONE; - if (!cdbus_msg_get_arg(msg, 1, CDBUS_TYPE_WINDOW, &client)) + if (!cdbus_msg_get_arg(msg, 1, CDBUS_TYPE_WINDOW, &client)) { return false; + } auto w = find_toplevel(ps, client); if (w) { wid = w->base.id; @@ -1136,8 +1151,9 @@ static bool cdbus_process_find_win(session_t *ps, DBusMessage *msg) { static bool cdbus_process_opts_get(session_t *ps, DBusMessage *msg) { const char *target = NULL; - if (!cdbus_msg_get_arg(msg, 0, DBUS_TYPE_STRING, &target)) + if (!cdbus_msg_get_arg(msg, 0, DBUS_TYPE_STRING, &target)) { return false; + } #define cdbus_m_opts_get_do(tgt, apdarg_func) \ if (!strcmp(#tgt, target)) { \ @@ -1165,7 +1181,7 @@ static bool cdbus_process_opts_get(session_t *ps, DBusMessage *msg) { // display if (!strcmp("display", target)) { - cdbus_reply_string(ps, msg, DisplayString(ps->dpy)); + cdbus_reply_string(ps, msg, DisplayString(ps->c.dpy)); return true; } @@ -1202,7 +1218,7 @@ static bool cdbus_process_opts_get(session_t *ps, DBusMessage *msg) { cdbus_m_opts_get_do(shadow_offset_x, cdbus_reply_int32); cdbus_m_opts_get_do(shadow_offset_y, cdbus_reply_int32); cdbus_m_opts_get_do(shadow_opacity, cdbus_reply_double); - cdbus_m_opts_get_do(xinerama_shadow_crop, cdbus_reply_bool); + cdbus_m_opts_get_do(crop_shadow_to_monitor, cdbus_reply_bool); cdbus_m_opts_get_do(fade_delta, cdbus_reply_int32); cdbus_m_opts_get_do(fade_in_step, cdbus_reply_double); @@ -1246,8 +1262,9 @@ void queue_redraw(session_t *ps); static bool cdbus_process_opts_set(session_t *ps, DBusMessage *msg) { const char *target = NULL; - if (!cdbus_msg_get_arg(msg, 0, DBUS_TYPE_STRING, &target)) + if (!cdbus_msg_get_arg(msg, 0, DBUS_TYPE_STRING, &target)) { return false; + } #define cdbus_m_opts_set_do(tgt, type, real_type) \ if (!strcmp(#tgt, target)) { \ @@ -1274,8 +1291,9 @@ static bool cdbus_process_opts_set(session_t *ps, DBusMessage *msg) { // fade_in_step if (!strcmp("fade_in_step", target)) { double val = 0.0; - if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_DOUBLE, &val)) + if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_DOUBLE, &val)) { return false; + } ps->o.fade_in_step = normalize_d(val); goto cdbus_process_opts_set_success; } @@ -1283,8 +1301,9 @@ static bool cdbus_process_opts_set(session_t *ps, DBusMessage *msg) { // fade_out_step if (!strcmp("fade_out_step", target)) { double val = 0.0; - if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_DOUBLE, &val)) + if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_DOUBLE, &val)) { return false; + } ps->o.fade_out_step = normalize_d(val); goto cdbus_process_opts_set_success; } @@ -1292,8 +1311,9 @@ static bool cdbus_process_opts_set(session_t *ps, DBusMessage *msg) { // no_fading_openclose if (!strcmp("no_fading_openclose", target)) { dbus_bool_t val = FALSE; - if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_BOOLEAN, &val)) + if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_BOOLEAN, &val)) { return false; + } opts_set_no_fading_openclose(ps, val); goto cdbus_process_opts_set_success; } @@ -1301,8 +1321,9 @@ static bool cdbus_process_opts_set(session_t *ps, DBusMessage *msg) { // unredir_if_possible if (!strcmp("unredir_if_possible", target)) { dbus_bool_t val = FALSE; - if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_BOOLEAN, &val)) + if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_BOOLEAN, &val)) { return false; + } if (ps->o.unredir_if_possible != val) { ps->o.unredir_if_possible = val; queue_redraw(ps); @@ -1323,8 +1344,9 @@ static bool cdbus_process_opts_set(session_t *ps, DBusMessage *msg) { // redirected_force if (!strcmp("redirected_force", target)) { cdbus_enum_t val = UNSET; - if (!cdbus_msg_get_arg(msg, 1, CDBUS_TYPE_ENUM, &val)) + if (!cdbus_msg_get_arg(msg, 1, CDBUS_TYPE_ENUM, &val)) { return false; + } ps->o.redirected_force = val; force_repaint(ps); goto cdbus_process_opts_set_success; @@ -1341,8 +1363,9 @@ static bool cdbus_process_opts_set(session_t *ps, DBusMessage *msg) { return true; cdbus_process_opts_set_success: - if (!dbus_message_get_no_reply(msg)) + if (!dbus_message_get_no_reply(msg)) { cdbus_reply_bool(ps, msg, true); + } return true; } @@ -1435,7 +1458,10 @@ static bool cdbus_process_windows_root_introspect(session_t *ps, DBusMessage *ms continue; } char *tmp = NULL; - asprintf(&tmp, "\n", w->id); + if (asprintf(&tmp, "\n", w->id) < 0) { + log_fatal("Failed to allocate memory."); + abort(); + } mstrextend(&ret, tmp); free(tmp); } @@ -1509,13 +1535,15 @@ cdbus_process(DBusConnection *c attr_unused, DBusMessage *msg, void *ud) { if (cdbus_m_ismethod("reset")) { log_info("picom is resetting..."); ev_break(ps->loop, EVBREAK_ALL); - if (!dbus_message_get_no_reply(msg)) + if (!dbus_message_get_no_reply(msg)) { cdbus_reply_bool(ps, msg, true); + } handled = true; } else if (cdbus_m_ismethod("repaint")) { force_repaint(ps); - if (!dbus_message_get_no_reply(msg)) + if (!dbus_message_get_no_reply(msg)) { cdbus_reply_bool(ps, msg, true); + } handled = true; } else if (cdbus_m_ismethod("list_win")) { handled = cdbus_process_list_win(ps, msg); @@ -1563,8 +1591,9 @@ cdbus_process(DBusConnection *c attr_unused, DBusMessage *msg, void *ud) { dbus_message_get_member(msg)); } if (DBUS_MESSAGE_TYPE_METHOD_CALL == dbus_message_get_type(msg) && - !dbus_message_get_no_reply(msg)) + !dbus_message_get_no_reply(msg)) { cdbus_reply_err(ps, msg, CDBUS_ERROR_BADMSG, CDBUS_ERROR_BADMSG_S); + } handled = true; } @@ -1590,8 +1619,9 @@ cdbus_process_windows(DBusConnection *c attr_unused, DBusMessage *msg, void *ud) const char *last_segment = strrchr(path, '/'); if (last_segment == NULL) { if (DBUS_MESSAGE_TYPE_METHOD_CALL == dbus_message_get_type(msg) && - !dbus_message_get_no_reply(msg)) + !dbus_message_get_no_reply(msg)) { cdbus_reply_err(ps, msg, CDBUS_ERROR_BADMSG, CDBUS_ERROR_BADMSG_S); + } return DBUS_HANDLER_RESULT_HANDLED; } bool is_root = strncmp(last_segment, "/windows", 8) == 0; diff --git a/src/diagnostic.c b/src/diagnostic.c index 2cb3c8fe1f..ce93cfc0c2 100644 --- a/src/diagnostic.c +++ b/src/diagnostic.c @@ -13,10 +13,10 @@ void print_diagnostics(session_t *ps, const char *config_file, bool compositor_running) { printf("**Version:** " PICOM_VERSION "\n"); - //printf("**CFLAGS:** %s\n", "??"); + // printf("**CFLAGS:** %s\n", "??"); printf("\n### Extensions:\n\n"); printf("* Shape: %s\n", ps->shape_exists ? "Yes" : "No"); - printf("* XRandR: %s\n", ps->randr_exists ? "Yes" : "No"); + printf("* RandR: %s\n", ps->randr_exists ? "Yes" : "No"); printf("* Present: %s\n", ps->present_exists ? "Present" : "Not Present"); printf("\n### Misc:\n\n"); printf("* Use Overlay: %s\n", ps->overlay != XCB_NONE ? "Yes" : "No"); @@ -39,7 +39,7 @@ void print_diagnostics(session_t *ps, const char *config_file, bool compositor_r for (int i = 0; i < NUM_BKEND; i++) { if (backend_list[i] && backend_list[i]->diagnostics) { printf("\n### Backend: %s\n\n", BACKEND_STRS[i]); - auto data = backend_list[i]->init(ps); + auto data = backend_list[i]->init(ps, session_get_target_window(ps)); if (!data) { printf(" Cannot initialize this backend\n"); } else { diff --git a/src/event.c b/src/event.c index e6052f1de1..739540dc9a 100644 --- a/src/event.c +++ b/src/event.c @@ -7,6 +7,7 @@ #include #include #include +#include #include "atom.h" #include "common.h" @@ -56,7 +57,7 @@ static inline const char *ev_window_name(session_t *ps, xcb_window_t wid) { char *name = ""; if (wid) { name = "(Failed to get title)"; - if (ps->root == wid) { + if (ps->c.screen_info->root == wid) { name = "(Root window)"; } else if (ps->overlay == wid) { name = "(Overlay)"; @@ -106,7 +107,7 @@ static inline xcb_window_t attr_pure ev_window(session_t *ps, xcb_generic_event_ static inline const char *ev_name(session_t *ps, xcb_generic_event_t *ev) { static char buf[128]; - switch (ev->response_type & 0x7f) { + switch (XCB_EVENT_RESPONSE_TYPE(ev)) { CASESTRRET(FocusIn); CASESTRRET(FocusOut); CASESTRRET(CreateNotify); @@ -121,11 +122,13 @@ static inline const char *ev_name(session_t *ps, xcb_generic_event_t *ev) { CASESTRRET(ClientMessage); } - if (ps->damage_event + XCB_DAMAGE_NOTIFY == ev->response_type) + if (ps->damage_event + XCB_DAMAGE_NOTIFY == ev->response_type) { return "Damage"; + } - if (ps->shape_exists && ev->response_type == ps->shape_event) + if (ps->shape_exists && ev->response_type == ps->shape_event) { return "ShapeNotify"; + } if (ps->xsync_exists) { int o = ev->response_type - ps->xsync_event; @@ -181,7 +184,7 @@ static inline void ev_focus_out(session_t *ps, xcb_focus_out_event_t *ev) { } static inline void ev_create_notify(session_t *ps, xcb_create_notify_event_t *ev) { - if (ev->parent == ps->root) { + if (ev->parent == ps->c.screen_info->root) { add_win_top(ps, ev->window); } } @@ -235,8 +238,8 @@ static void configure_win(session_t *ps, xcb_configure_notify_event_t *ce) { win_set_flags(mw, WIN_FLAGS_SIZE_STALE); } - // Recalculate which screen this window is on - win_update_screen(ps->xinerama_nscrs, ps->xinerama_scr_regs, mw); + // Recalculate which monitor this window is on + win_update_monitor(&ps->monitors, mw); } // override_redirect flag cannot be changed after window creation, as far @@ -247,7 +250,7 @@ static void configure_win(session_t *ps, xcb_configure_notify_event_t *ce) { static inline void ev_configure_notify(session_t *ps, xcb_configure_notify_event_t *ev) { log_debug("{ send_event: %d, id: %#010x, above: %#010x, override_redirect: %d }", ev->event, ev->window, ev->above_sibling, ev->override_redirect); - if (ev->window == ps->root) { + if (ev->window == ps->c.screen_info->root) { set_root_flags(ps, ROOT_FLAGS_CONFIGURED); } else { configure_win(ps, ev); @@ -281,7 +284,8 @@ static inline void ev_map_notify(session_t *ps, xcb_map_notify_event_t *ev) { // in redirected state. if (ps->overlay && ev->window == ps->overlay && !ps->redirected) { log_debug("Overlay is mapped while we are not redirected"); - auto e = xcb_request_check(ps->c, xcb_unmap_window(ps->c, ps->overlay)); + auto e = xcb_request_check( + ps->c.c, xcb_unmap_window_checked(ps->c.c, ps->overlay)); if (e) { log_error("Failed to unmap the overlay window"); free(e); @@ -319,7 +323,7 @@ static inline void ev_reparent_notify(session_t *ps, xcb_reparent_notify_event_t ps->pending_updates = true; } - if (ev->parent == ps->root) { + if (ev->parent == ps->c.screen_info->root) { // X will generate reparent notifiy even if the parent didn't actually // change (i.e. reparent again to current parent). So we check if that's // the case @@ -347,7 +351,7 @@ static inline void ev_reparent_notify(session_t *ps, xcb_reparent_notify_event_t // Reset event mask in case something wrong happens xcb_change_window_attributes( - ps->c, ev->window, XCB_CW_EVENT_MASK, + ps->c.c, ev->window, XCB_CW_EVENT_MASK, (const uint32_t[]){determine_evmask(ps, ev->window, WIN_EVMODE_UNKNOWN)}); if (!wid_has_prop(ps, ev->window, ps->atoms->aWM_STATE)) { @@ -356,7 +360,7 @@ static inline void ev_reparent_notify(session_t *ps, xcb_reparent_notify_event_t "property change in case it gains one.", ev->window); xcb_change_window_attributes( - ps->c, ev->window, XCB_CW_EVENT_MASK, + ps->c.c, ev->window, XCB_CW_EVENT_MASK, (const uint32_t[]){determine_evmask(ps, ev->window, WIN_EVMODE_UNKNOWN) | XCB_EVENT_MASK_PROPERTY_CHANGE}); } else { @@ -369,9 +373,9 @@ static inline void ev_reparent_notify(session_t *ps, xcb_reparent_notify_event_t win_set_flags(w_real_top, WIN_FLAGS_CLIENT_STALE); ps->pending_updates = true; } else { - if (!w_real_top) + if (!w_real_top) { log_debug("parent %#010x not found", ev->parent); - else { + } else { // Window is not currently mapped, unmark its // client to trigger a client recheck when it is // mapped later. @@ -388,8 +392,9 @@ static inline void ev_reparent_notify(session_t *ps, xcb_reparent_notify_event_t static inline void ev_circulate_notify(session_t *ps, xcb_circulate_notify_event_t *ev) { auto w = find_win(ps, ev->window); - if (!w) + if (!w) { return; + } if (ev->place == PlaceOnTop) { restack_top(ps, w); @@ -406,7 +411,8 @@ static inline void expose_root(session_t *ps, const rect_t *rects, int nrects) { } static inline void ev_expose(session_t *ps, xcb_expose_event_t *ev) { - if (ev->window == ps->root || (ps->overlay && ev->window == ps->overlay)) { + if (ev->window == ps->c.screen_info->root || + (ps->overlay && ev->window == ps->overlay)) { int more = ev->count + 1; if (ps->n_expose == ps->size_expose) { if (ps->expose_rects) { @@ -435,8 +441,8 @@ static inline void ev_expose(session_t *ps, xcb_expose_event_t *ev) { static inline void ev_property_notify(session_t *ps, xcb_property_notify_event_t *ev) { if (unlikely(log_get_level_tls() <= LOG_LEVEL_TRACE)) { // Print out changed atom - xcb_get_atom_name_reply_t *reply = - xcb_get_atom_name_reply(ps->c, xcb_get_atom_name(ps->c, ev->atom), NULL); + xcb_get_atom_name_reply_t *reply = xcb_get_atom_name_reply( + ps->c.c, xcb_get_atom_name(ps->c.c, ev->atom), NULL); const char *name = "?"; int name_len = 1; if (reply) { @@ -448,7 +454,7 @@ static inline void ev_property_notify(session_t *ps, xcb_property_notify_event_t free(reply); } - if (ps->root == ev->window) { + if (ps->c.screen_info->root == ev->window) { if (ps->o.use_ewmh_active_win && ps->atoms->a_NET_ACTIVE_WINDOW == ev->atom) { // to update focus ps->pending_updates = true; @@ -469,7 +475,7 @@ static inline void ev_property_notify(session_t *ps, xcb_property_notify_event_t // Check whether it could be a client window if (!find_toplevel(ps, ev->window)) { // Reset event mask anyway - xcb_change_window_attributes(ps->c, ev->window, XCB_CW_EVENT_MASK, + xcb_change_window_attributes(ps->c.c, ev->window, XCB_CW_EVENT_MASK, (const uint32_t[]){determine_evmask( ps, ev->window, WIN_EVMODE_UNKNOWN)}); @@ -582,12 +588,16 @@ static inline void repair_win(session_t *ps, struct managed_win *w) { if (!w->ever_damaged) { win_extents(w, &parts); - set_ignore_cookie( - ps, xcb_damage_subtract(ps->c, w->damage, XCB_NONE, XCB_NONE)); + if (!ps->o.show_all_xerrors) { + set_ignore_cookie(&ps->c, xcb_damage_subtract(ps->c.c, w->damage, + XCB_NONE, XCB_NONE)); + } } else { - set_ignore_cookie( - ps, xcb_damage_subtract(ps->c, w->damage, XCB_NONE, ps->damaged_region)); - x_fetch_region(ps->c, ps->damaged_region, &parts); + if (!ps->o.show_all_xerrors) { + set_ignore_cookie(&ps->c, xcb_damage_subtract(ps->c.c, w->damage, XCB_NONE, + ps->damaged_region)); + } + x_fetch_region(&ps->c, ps->damaged_region, &parts); pixman_region32_translate(&parts, w->g.x + w->g.border_width, w->g.y + w->g.border_width); } @@ -662,8 +672,8 @@ ev_selection_clear(session_t *ps, xcb_selection_clear_event_t attr_unused *ev) { } void ev_handle(session_t *ps, xcb_generic_event_t *ev) { - if ((ev->response_type & 0x7f) != KeymapNotify) { - discard_ignore(ps, ev->full_sequence); + if (XCB_EVENT_RESPONSE_TYPE(ev) != KeymapNotify) { + x_discard_pending(&ps->c, ev->full_sequence); } xcb_window_t wid = ev_window(ps, ev); @@ -684,9 +694,10 @@ void ev_handle(session_t *ps, xcb_generic_event_t *ev) { // For even more details, see: // https://bugs.freedesktop.org/show_bug.cgi?id=35945 // https://lists.freedesktop.org/archives/xcb/2011-November/007337.html - auto proc = XESetWireToEvent(ps->dpy, ev->response_type, 0); + auto response_type = XCB_EVENT_RESPONSE_TYPE(ev); + auto proc = XESetWireToEvent(ps->c.dpy, response_type, 0); if (proc) { - XESetWireToEvent(ps->dpy, ev->response_type, proc); + XESetWireToEvent(ps->c.dpy, response_type, proc); XEvent dummy; // Stop Xlib from complaining about lost sequence numbers. @@ -695,13 +706,18 @@ void ev_handle(session_t *ps, xcb_generic_event_t *ev) { // missing sequence numbers. // // We only need the low 16 bits - ev->sequence = (uint16_t)(LastKnownRequestProcessed(ps->dpy) & 0xffff); - proc(ps->dpy, &dummy, (xEvent *)ev); + uint16_t seq = ev->sequence; + ev->sequence = (uint16_t)(LastKnownRequestProcessed(ps->c.dpy) & 0xffff); + proc(ps->c.dpy, &dummy, (xEvent *)ev); + // Restore the sequence number + ev->sequence = seq; } // XXX redraw needs to be more fine grained queue_redraw(ps); + // We intentionally ignore events sent via SendEvent. Those events has the 8th bit + // of response_type set, meaning they will match none of the cases below. switch (ev->response_type) { case FocusIn: ev_focus_in(ps, (xcb_focus_in_event_t *)ev); break; case FocusOut: ev_focus_out(ps, (xcb_focus_out_event_t *)ev); break; @@ -727,7 +743,7 @@ void ev_handle(session_t *ps, xcb_generic_event_t *ev) { case SelectionClear: ev_selection_clear(ps, (xcb_selection_clear_event_t *)ev); break; - case 0: ev_xcb_error(ps, (xcb_generic_error_t *)ev); break; + case 0: x_handle_error(&ps->c, (xcb_generic_error_t *)ev); break; default: if (ps->shape_exists && ev->response_type == ps->shape_event) { ev_shape_notify(ps, (xcb_shape_notify_event_t *)ev); diff --git a/src/kernel.c b/src/kernel.c index cbb5cd12bf..b5e1a487d5 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -54,8 +54,9 @@ static inline double attr_const gaussian(double r, double x, double y) { // Formula can be found here: // https://en.wikipedia.org/wiki/Gaussian_blur#Mathematics // Except a special case for r == 0 to produce sharp shadows - if (r == 0) + if (r == 0) { return 1; + } return exp(-0.5 * (x * x + y * y) / (r * r)) / (2 * M_PI * r * r); } diff --git a/src/log.c b/src/log.c index c8b158b57b..664b9f41be 100644 --- a/src/log.c +++ b/src/log.c @@ -68,6 +68,7 @@ log_default_writev(struct log_target *tgt, const struct iovec *vec, int vcnt) { static attr_const const char *log_level_to_string(enum log_level level) { switch (level) { case LOG_LEVEL_TRACE: return "TRACE"; + case LOG_LEVEL_VERBOSE: return "VERBOSE"; case LOG_LEVEL_DEBUG: return "DEBUG"; case LOG_LEVEL_INFO: return "INFO"; case LOG_LEVEL_WARN: return "WARN"; @@ -78,16 +79,24 @@ static attr_const const char *log_level_to_string(enum log_level level) { } enum log_level string_to_log_level(const char *str) { - if (strcasecmp(str, "TRACE") == 0) + if (strcasecmp(str, "TRACE") == 0) { return LOG_LEVEL_TRACE; - else if (strcasecmp(str, "DEBUG") == 0) + } + if (strcasecmp(str, "VERBOSE") == 0) { + return LOG_LEVEL_VERBOSE; + } + if (strcasecmp(str, "DEBUG") == 0) { return LOG_LEVEL_DEBUG; - else if (strcasecmp(str, "INFO") == 0) + } + if (strcasecmp(str, "INFO") == 0) { return LOG_LEVEL_INFO; - else if (strcasecmp(str, "WARN") == 0) + } + if (strcasecmp(str, "WARN") == 0) { return LOG_LEVEL_WARN; - else if (strcasecmp(str, "ERROR") == 0) + } + if (strcasecmp(str, "ERROR") == 0) { return LOG_LEVEL_ERROR; + } return LOG_LEVEL_INVALID; } @@ -143,8 +152,9 @@ enum log_level log_get_level(const struct log *l) { attr_printf(4, 5) void log_printf(struct log *l, int level, const char *func, const char *fmt, ...) { assert(level <= LOG_LEVEL_FATAL && level >= 0); - if (level < l->log_level) + if (level < l->log_level) { return; + } char *buf = NULL; va_list args; @@ -228,12 +238,10 @@ struct log_target *null_logger_new(void) { static void null_logger_write(struct log_target *tgt attr_unused, const char *str attr_unused, size_t len attr_unused) { - return; } static void null_logger_writev(struct log_target *tgt attr_unused, const struct iovec *vec attr_unused, int vcnt attr_unused) { - return; } static const struct log_ops null_logger_ops = { @@ -256,7 +264,7 @@ static void file_logger_write(struct log_target *tgt, const char *str, size_t le static void file_logger_writev(struct log_target *tgt, const struct iovec *vec, int vcnt) { auto f = (struct file_logger *)tgt; fflush(f->f); - writev(fileno(f->f), vec, vcnt); + ssize_t _ attr_unused = writev(fileno(f->f), vec, vcnt); } static void file_logger_destroy(struct log_target *tgt) { @@ -269,6 +277,7 @@ static void file_logger_destroy(struct log_target *tgt) { static const char *terminal_colorize_begin(enum log_level level) { switch (level) { case LOG_LEVEL_TRACE: return ANSI("30;2"); + case LOG_LEVEL_VERBOSE: case LOG_LEVEL_DEBUG: return ANSI("37;2"); case LOG_LEVEL_INFO: return ANSI("92"); case LOG_LEVEL_WARN: return ANSI("33"); @@ -358,8 +367,9 @@ struct log_target *gl_string_marker_logger_new(void) { } void *fnptr = glXGetProcAddress((GLubyte *)"glStringMarkerGREMEDY"); - if (!fnptr) + if (!fnptr) { return NULL; + } auto ret = cmalloc(struct gl_string_marker_logger); ret->tgt.ops = &gl_string_marker_logger_ops; diff --git a/src/log.h b/src/log.h index e40fe3c8f4..6d74126c06 100644 --- a/src/log.h +++ b/src/log.h @@ -9,11 +9,19 @@ enum log_level { LOG_LEVEL_INVALID = -1, + /// Very noisy debug messages, many lines per frame. LOG_LEVEL_TRACE = 0, + /// Frequent debug messages, a few lines per frame. + LOG_LEVEL_VERBOSE, + /// Less frequent debug messages. LOG_LEVEL_DEBUG, + /// Informational messages. LOG_LEVEL_INFO, + /// Warnings. LOG_LEVEL_WARN, + /// Errors. LOG_LEVEL_ERROR, + /// Fatal errors. LOG_LEVEL_FATAL, }; @@ -31,6 +39,7 @@ enum log_level { } \ } while (0) #define log_trace(x, ...) LOG_UNLIKELY(TRACE, x, ##__VA_ARGS__) +#define log_verbose(x, ...) LOG_UNLIKELY(VERBOSE, x, ##__VA_ARGS__) #define log_debug(x, ...) LOG_UNLIKELY(DEBUG, x, ##__VA_ARGS__) #define log_info(x, ...) LOG(INFO, x, ##__VA_ARGS__) #define log_warn(x, ...) LOG(WARN, x, ##__VA_ARGS__) diff --git a/src/meson.build b/src/meson.build index 60d83a891f..a2f9c36c73 100644 --- a/src/meson.build +++ b/src/meson.build @@ -9,18 +9,21 @@ base_deps = [ srcs = [ files('picom.c', 'win.c', 'c2.c', 'x.c', 'config.c', 'vsync.c', 'utils.c', 'diagnostic.c', 'string_utils.c', 'render.c', 'kernel.c', 'log.c', - 'options.c', 'event.c', 'cache.c', 'atom.c', 'file_watch.c') ] + 'options.c', 'event.c', 'cache.c', 'atom.c', 'file_watch.c', 'statistics.c', + 'vblank.c') ] picom_inc = include_directories('.') cflags = [] required_xcb_packages = [ - 'xcb-render', 'xcb-damage', 'xcb-randr', 'xcb-sync', 'xcb-composite', - 'xcb-shape', 'xcb-xinerama', 'xcb-xfixes', 'xcb-present', 'xcb-glx', 'xcb' + 'xcb', 'xcb-composite', 'xcb-damage', 'xcb-dpms', 'xcb-glx', 'xcb-present', + 'xcb-randr', 'xcb-render', 'xcb-shape', 'xcb-sync', 'xcb-xfixes' ] +# Some XCB packages are here because their versioning differs (see check below). required_packages = [ - 'x11', 'x11-xcb', 'xcb-renderutil', 'xcb-image', 'xext', 'pixman-1' + 'pixman-1', 'x11', 'x11-xcb', 'xcb-image', 'xcb-renderutil', 'xcb-util', + 'xext' ] foreach i : required_packages @@ -44,11 +47,8 @@ if get_option('config_file') srcs += [ 'config_libconfig.c' ] endif if get_option('regex') - pcre = dependency('libpcre', required: true) + pcre = dependency('libpcre2-8', required: true) cflags += ['-DCONFIG_REGEX_PCRE'] - if pcre.version().version_compare('>=8.20') - cflags += ['-DCONFIG_REGEX_PCRE_JIT'] - endif deps += [pcre] endif @@ -59,7 +59,7 @@ endif if get_option('opengl') cflags += ['-DCONFIG_OPENGL', '-DGL_GLEXT_PROTOTYPES'] - deps += [dependency('gl', required: true), dependency('egl', required: true)] + deps += [dependency('gl', required: true), dependency('egl', required: true), dependency('threads', required:true)] srcs += [ 'opengl.c' ] endif diff --git a/src/opengl.c b/src/opengl.c index 5d2d66cb8c..4031e41bd5 100644 --- a/src/opengl.c +++ b/src/opengl.c @@ -39,7 +39,7 @@ static inline XVisualInfo *get_visualinfo_from_visual(session_t *ps, xcb_visuali XVisualInfo vreq = {.visualid = visual}; int nitems = 0; - return XGetVisualInfo(ps->dpy, VisualIDMask, &vreq, &nitems); + return XGetVisualInfo(ps->c.dpy, VisualIDMask, &vreq, &nitems); } /** @@ -56,7 +56,7 @@ bool glx_init(session_t *ps, bool need_render) { } // Get XVisualInfo - pvis = get_visualinfo_from_visual(ps, ps->vis); + pvis = get_visualinfo_from_visual(ps, ps->c.screen_info->root_visual); if (!pvis) { log_error("Failed to acquire XVisualInfo for current visual."); goto glx_init_end; @@ -65,20 +65,22 @@ bool glx_init(session_t *ps, bool need_render) { // Ensure the visual is double-buffered if (need_render) { int value = 0; - if (Success != glXGetConfig(ps->dpy, pvis, GLX_USE_GL, &value) || !value) { + if (Success != glXGetConfig(ps->c.dpy, pvis, GLX_USE_GL, &value) || !value) { log_error("Root visual is not a GL visual."); goto glx_init_end; } - if (Success != glXGetConfig(ps->dpy, pvis, GLX_DOUBLEBUFFER, &value) || !value) { + if (Success != glXGetConfig(ps->c.dpy, pvis, GLX_DOUBLEBUFFER, &value) || + !value) { log_error("Root visual is not a double buffered GL visual."); goto glx_init_end; } } // Ensure GLX_EXT_texture_from_pixmap exists - if (need_render && !glxext.has_GLX_EXT_texture_from_pixmap) + if (need_render && !glxext.has_GLX_EXT_texture_from_pixmap) { goto glx_init_end; + } // Initialize GLX data structure if (!ps->psglx) { @@ -112,7 +114,7 @@ bool glx_init(session_t *ps, bool need_render) { if (!psglx->context) { // Get GLX context #ifndef DEBUG_GLX_DEBUG_CONTEXT - psglx->context = glXCreateContext(ps->dpy, pvis, None, GL_TRUE); + psglx->context = glXCreateContext(ps->c.dpy, pvis, None, GL_TRUE); #else { GLXFBConfig fbconfig = get_fbconfig_from_visualinfo(ps, pvis); @@ -134,7 +136,7 @@ bool glx_init(session_t *ps, bool need_render) { static const int attrib_list[] = { GLX_CONTEXT_FLAGS_ARB, GLX_CONTEXT_DEBUG_BIT_ARB, None}; psglx->context = p_glXCreateContextAttribsARB( - ps->dpy, fbconfig, NULL, GL_TRUE, attrib_list); + ps->c.dpy, fbconfig, NULL, GL_TRUE, attrib_list); } #endif @@ -144,7 +146,7 @@ bool glx_init(session_t *ps, bool need_render) { } // Attach GLX context - if (!glXMakeCurrent(ps->dpy, get_tgt_window(ps), psglx->context)) { + if (!glXMakeCurrent(ps->c.dpy, get_tgt_window(ps), psglx->context)) { log_error("Failed to attach GLX context."); goto glx_init_end; } @@ -177,9 +179,10 @@ bool glx_init(session_t *ps, bool need_render) { // Check GL_ARB_texture_non_power_of_two, requires a GLX context and // must precede FBConfig fetching - if (need_render) + if (need_render) { psglx->has_texture_non_power_of_two = gl_has_extension("GL_ARB_texture_non_power_of_two"); + } // Render preparations if (need_render) { @@ -199,9 +202,9 @@ bool glx_init(session_t *ps, bool need_render) { } // Clear screen - glClearColor(0.0f, 0.0f, 0.0f, 1.0f); + glClearColor(0.0F, 0.0F, 0.0F, 1.0F); // glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - // glXSwapBuffers(ps->dpy, get_tgt_window(ps)); + // glXSwapBuffers(ps->c.dpy, get_tgt_window(ps)); } success = true; @@ -209,15 +212,17 @@ bool glx_init(session_t *ps, bool need_render) { glx_init_end: XFree(pvis); - if (!success) + if (!success) { glx_destroy(ps); + } return success; } static void glx_free_prog_main(glx_prog_main_t *pprogram) { - if (!pprogram) + if (!pprogram) { return; + } if (pprogram->prog) { glDeleteProgram(pprogram->prog); pprogram->prog = 0; @@ -231,8 +236,9 @@ static void glx_free_prog_main(glx_prog_main_t *pprogram) { * Destroy GLX related resources. */ void glx_destroy(session_t *ps) { - if (!ps->psglx) + if (!ps->psglx) { return; + } // Free all GLX resources of windows win_stack_foreach_managed(w, &ps->window_stack) { @@ -266,8 +272,8 @@ void glx_destroy(session_t *ps) { // Destroy GLX context if (ps->psglx->context) { - glXMakeCurrent(ps->dpy, None, NULL); - glXDestroyContext(ps->dpy, ps->psglx->context); + glXMakeCurrent(ps->c.dpy, None, NULL); + glXDestroyContext(ps->c.dpy, ps->psglx->context); ps->psglx->context = NULL; } @@ -372,8 +378,9 @@ bool glx_init_blur(session_t *ps) { double sum = 0.0; for (int j = 0; j < height; ++j) { for (int k = 0; k < width; ++k) { - if (height / 2 == j && width / 2 == k) + if (height / 2 == j && width / 2 == k) { continue; + } double val = kern->data[j * width + k]; if (val == 0) { continue; @@ -690,8 +697,9 @@ bool glx_bind_texture(session_t *ps attr_unused, glx_texture_t **pptex, int x, i */ bool glx_bind_pixmap(session_t *ps, glx_texture_t **pptex, xcb_pixmap_t pixmap, int width, int height, bool repeat, const struct glx_fbconfig_info *fbcfg) { - if (ps->o.backend != BKEND_GLX && ps->o.backend != BKEND_XR_GLX_HYBRID) + if (ps->o.backend != BKEND_GLX && ps->o.backend != BKEND_XR_GLX_HYBRID) { return true; + } if (!pixmap) { log_error("Binding to an empty pixmap %#010x. This can't work.", pixmap); @@ -732,7 +740,7 @@ bool glx_bind_pixmap(session_t *ps, glx_texture_t **pptex, xcb_pixmap_t pixmap, // Retrieve pixmap parameters, if they aren't provided if (!width || !height) { auto r = xcb_get_geometry_reply( - ps->c, xcb_get_geometry(ps->c, pixmap), NULL); + ps->c.c, xcb_get_geometry(ps->c.c, pixmap), NULL); if (!r) { log_error("Failed to query info of pixmap %#010x.", pixmap); return false; @@ -753,14 +761,15 @@ bool glx_bind_pixmap(session_t *ps, glx_texture_t **pptex, xcb_pixmap_t pixmap, // pixmap-specific parameters, and this may change in the future GLenum tex_tgt = 0; if (GLX_TEXTURE_2D_BIT_EXT & fbcfg->texture_tgts && - ps->psglx->has_texture_non_power_of_two) + ps->psglx->has_texture_non_power_of_two) { tex_tgt = GLX_TEXTURE_2D_EXT; - else if (GLX_TEXTURE_RECTANGLE_BIT_EXT & fbcfg->texture_tgts) + } else if (GLX_TEXTURE_RECTANGLE_BIT_EXT & fbcfg->texture_tgts) { tex_tgt = GLX_TEXTURE_RECTANGLE_EXT; - else if (!(GLX_TEXTURE_2D_BIT_EXT & fbcfg->texture_tgts)) + } else if (!(GLX_TEXTURE_2D_BIT_EXT & fbcfg->texture_tgts)) { tex_tgt = GLX_TEXTURE_RECTANGLE_EXT; - else + } else { tex_tgt = GLX_TEXTURE_2D_EXT; + } log_debug("depth %d, tgt %#x, rgba %d", depth, tex_tgt, (GLX_TEXTURE_FORMAT_RGBA_EXT == fbcfg->texture_fmt)); @@ -773,7 +782,7 @@ bool glx_bind_pixmap(session_t *ps, glx_texture_t **pptex, xcb_pixmap_t pixmap, 0, }; - ptex->glpixmap = glXCreatePixmap(ps->dpy, fbcfg->cfg, pixmap, attrs); + ptex->glpixmap = glXCreatePixmap(ps->c.dpy, fbcfg->cfg, pixmap, attrs); ptex->pixmap = pixmap; ptex->target = (GLX_TEXTURE_2D_EXT == tex_tgt ? GL_TEXTURE_2D : GL_TEXTURE_RECTANGLE); @@ -819,10 +828,11 @@ bool glx_bind_pixmap(session_t *ps, glx_texture_t **pptex, xcb_pixmap_t pixmap, // The specification requires rebinding whenever the content changes... // We can't follow this, too slow. - if (need_release) - glXReleaseTexImageEXT(ps->dpy, ptex->glpixmap, GLX_FRONT_LEFT_EXT); + if (need_release) { + glXReleaseTexImageEXT(ps->c.dpy, ptex->glpixmap, GLX_FRONT_LEFT_EXT); + } - glXBindTexImageEXT(ps->dpy, ptex->glpixmap, GLX_FRONT_LEFT_EXT, NULL); + glXBindTexImageEXT(ps->c.dpy, ptex->glpixmap, GLX_FRONT_LEFT_EXT, NULL); // Cleanup glBindTexture(ptex->target, 0); @@ -840,13 +850,13 @@ void glx_release_pixmap(session_t *ps, glx_texture_t *ptex) { // Release binding if (ptex->glpixmap && ptex->texture) { glBindTexture(ptex->target, ptex->texture); - glXReleaseTexImageEXT(ps->dpy, ptex->glpixmap, GLX_FRONT_LEFT_EXT); + glXReleaseTexImageEXT(ps->c.dpy, ptex->glpixmap, GLX_FRONT_LEFT_EXT); glBindTexture(ptex->target, 0); } // Free GLX Pixmap if (ptex->glpixmap) { - glXDestroyPixmap(ps->dpy, ptex->glpixmap); + glXDestroyPixmap(ps->c.dpy, ptex->glpixmap); ptex->glpixmap = 0; } @@ -858,14 +868,16 @@ void glx_release_pixmap(session_t *ps, glx_texture_t *ptex) { */ void glx_set_clip(session_t *ps, const region_t *reg) { // Quit if we aren't using stencils - if (ps->o.glx_no_stencil) + if (ps->o.glx_no_stencil) { return; + } glDisable(GL_STENCIL_TEST); glDisable(GL_SCISSOR_TEST); - if (!reg) + if (!reg) { return; + } int nrects; const rect_t *rects = pixman_region32_rectangles((region_t *)reg, &nrects); @@ -913,8 +925,9 @@ bool glx_blur_dst(session_t *ps, int dx, int dy, int width, int height, float z, // Calculate copy region size glx_blur_cache_t ibc = {.width = 0, .height = 0}; - if (!pbc) + if (!pbc) { pbc = &ibc; + } int mdx = dx, mdy = dy, mwidth = width, mheight = height; // log_trace("%d, %d, %d, %d", mdx, mdy, mwidth, mheight); @@ -941,24 +954,29 @@ bool glx_blur_dst(session_t *ps, int dx, int dy, int width, int height, float z, */ GLenum tex_tgt = GL_TEXTURE_RECTANGLE; - if (ps->psglx->has_texture_non_power_of_two) + if (ps->psglx->has_texture_non_power_of_two) { tex_tgt = GL_TEXTURE_2D; + } // Free textures if size inconsistency discovered - if (mwidth != pbc->width || mheight != pbc->height) + if (mwidth != pbc->width || mheight != pbc->height) { free_glx_bc_resize(ps, pbc); + } // Generate FBO and textures if needed - if (!pbc->textures[0]) + if (!pbc->textures[0]) { pbc->textures[0] = glx_gen_texture(tex_tgt, mwidth, mheight); + } GLuint tex_scr = pbc->textures[0]; - if (more_passes && !pbc->textures[1]) + if (more_passes && !pbc->textures[1]) { pbc->textures[1] = glx_gen_texture(tex_tgt, mwidth, mheight); + } pbc->width = mwidth; pbc->height = mheight; GLuint tex_scr2 = pbc->textures[1]; - if (more_passes && !pbc->fbo) + if (more_passes && !pbc->fbo) { glGenFramebuffers(1, &pbc->fbo); + } const GLuint fbo = pbc->fbo; if (!tex_scr || (more_passes && !tex_scr2)) { @@ -986,7 +1004,7 @@ bool glx_blur_dst(session_t *ps, int dx, int dy, int width, int height, float z, } */ // Texture scaling factor - GLfloat texfac_x = 1.0f, texfac_y = 1.0f; + GLfloat texfac_x = 1.0F, texfac_y = 1.0F; if (tex_tgt == GL_TEXTURE_2D) { texfac_x /= (GLfloat)mwidth; texfac_y /= (GLfloat)mheight; @@ -1019,10 +1037,12 @@ bool glx_blur_dst(session_t *ps, int dx, int dy, int width, int height, float z, } else { glBindFramebuffer(GL_FRAMEBUFFER, 0); glDrawBuffer(GL_BACK); - if (have_scissors) + if (have_scissors) { glEnable(GL_SCISSOR_TEST); - if (have_stencil) + } + if (have_stencil) { glEnable(GL_STENCIL_TEST); + } } // Color negation for testing... @@ -1032,12 +1052,15 @@ bool glx_blur_dst(session_t *ps, int dx, int dy, int width, int height, float z, glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glUseProgram(ppass->prog); - if (ppass->unifm_offset_x >= 0) + if (ppass->unifm_offset_x >= 0) { glUniform1f(ppass->unifm_offset_x, texfac_x); - if (ppass->unifm_offset_y >= 0) + } + if (ppass->unifm_offset_y >= 0) { glUniform1f(ppass->unifm_offset_y, texfac_y); - if (ppass->unifm_factor_center >= 0) + } + if (ppass->unifm_factor_center >= 0) { glUniform1f(ppass->unifm_factor_center, factor_center); + } P_PAINTREG_START(crect) { auto rx = (GLfloat)(crect.x1 - mdx) * texfac_x; @@ -1087,10 +1110,12 @@ bool glx_blur_dst(session_t *ps, int dx, int dy, int width, int height, float z, glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindTexture(tex_tgt, 0); glDisable(tex_tgt); - if (have_scissors) + if (have_scissors) { glEnable(GL_SCISSOR_TEST); - if (have_stencil) + } + if (have_stencil) { glEnable(GL_STENCIL_TEST); + } if (&ibc == pbc) { free_glx_bc(ps, pbc); @@ -1275,7 +1300,7 @@ bool glx_dim_dst(session_t *ps, int dx, int dy, int width, int height, int z, // considering all those mess in color negation and modulation glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); - glColor4f(0.0f, 0.0f, 0.0f, factor); + glColor4f(0.0F, 0.0F, 0.0F, factor); P_PAINTREG_START(crect) { // XXX what does all of these variables mean? @@ -1291,7 +1316,7 @@ bool glx_dim_dst(session_t *ps, int dx, int dy, int width, int height, int z, } P_PAINTREG_END(); - glColor4f(0.0f, 0.0f, 0.0f, 0.0f); + glColor4f(0.0F, 0.0F, 0.0F, 0.0F); glDisable(GL_BLEND); gl_check_err(); @@ -1411,15 +1436,19 @@ bool glx_render(session_t *ps, const glx_texture_t *ptex, int x, int y, int dx, glUseProgram(pprogram->prog); struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); - if (pprogram->unifm_opacity >= 0) + if (pprogram->unifm_opacity >= 0) { glUniform1f(pprogram->unifm_opacity, (float)opacity); - if (pprogram->unifm_invert_color >= 0) + } + if (pprogram->unifm_invert_color >= 0) { glUniform1i(pprogram->unifm_invert_color, neg); - if (pprogram->unifm_tex >= 0) + } + if (pprogram->unifm_tex >= 0) { glUniform1i(pprogram->unifm_tex, 0); - if (pprogram->unifm_time >= 0) - glUniform1f(pprogram->unifm_time, (float)ts.tv_sec * 1000.0f + - (float)ts.tv_nsec / 1.0e6f); + } + if (pprogram->unifm_time >= 0) { + glUniform1f(pprogram->unifm_time, (float)ts.tv_sec * 1000.0F + + (float)ts.tv_nsec / 1.0e6F); + } } // log_trace("Draw: %d, %d, %d, %d -> %d, %d (%d, %d) z %d", x, y, width, height, @@ -1459,8 +1488,8 @@ bool glx_render(session_t *ps, const glx_texture_t *ptex, int x, int y, int dx, // Invert Y if needed, this may not work as expected, though. I // don't have such a FBConfig to test with. if (!ptex->y_inverted) { - ry = 1.0f - ry; - rye = 1.0f - rye; + ry = 1.0F - ry; + rye = 1.0F - rye; } // log_trace("Rect %d: %f, %f, %f, %f -> %d, %d, %d, %d", ri, rx, @@ -1492,7 +1521,7 @@ bool glx_render(session_t *ps, const glx_texture_t *ptex, int x, int y, int dx, // Cleanup glBindTexture(ptex->target, 0); - glColor4f(0.0f, 0.0f, 0.0f, 0.0f); + glColor4f(0.0F, 0.0F, 0.0F, 0.0F); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glDisable(GL_BLEND); glDisable(GL_COLOR_LOGIC_OP); @@ -1505,8 +1534,9 @@ bool glx_render(session_t *ps, const glx_texture_t *ptex, int x, int y, int dx, glActiveTexture(GL_TEXTURE0); } - if (has_prog) + if (has_prog) { glUseProgram(0); + } gl_check_err(); diff --git a/src/opengl.h b/src/opengl.h index dcd8697b41..affad2499a 100644 --- a/src/opengl.h +++ b/src/opengl.h @@ -156,10 +156,11 @@ static inline bool glx_has_context(session_t *ps) { */ static inline bool ensure_glx_context(session_t *ps) { // Create GLX context - if (!glx_has_context(ps)) + if (!glx_has_context(ps)) { glx_init(ps, false); + } - return ps->psglx->context; + return glx_has_context(ps); } /** diff --git a/src/options.c b/src/options.c index ba7485dd59..834b66f0a9 100644 --- a/src/options.c +++ b/src/options.c @@ -46,7 +46,7 @@ static const struct picom_option picom_options[] = { {"fade-delta" , required_argument, 'D', NULL , "The time between steps in a fade in milliseconds. (default 10)"}, {"menu-opacity" , required_argument, 'm', NULL , "The opacity for menus. (default 1.0)"}, {"shadow" , no_argument , 'c', NULL , "Enabled client-side shadows on windows."}, - {"clear-shadow" , no_argument , 'z', NULL , "Don't dreaw shadow behind the window."}, + {"clear-shadow" , no_argument , 'z', NULL , "Don't draw shadow behind the window."}, {"fading" , no_argument , 'f', NULL , "Fade windows in/out when opening/closing and when opacity changes, " "unless --no-fading-openclose is used."}, {"inactive-opacity" , required_argument, 'i', NULL , "Opacity of inactive windows. (0.1 - 1.0)"}, @@ -72,6 +72,9 @@ static const struct picom_option picom_options[] = { "managers not passing _NET_WM_WINDOW_OPACITY of client windows to frame"}, {"refresh-rate" , required_argument, 269, NULL , NULL}, {"vsync" , optional_argument, 270, NULL , "Enable VSync"}, + {"crop-shadow-to-monitor" , no_argument , 271, NULL , "Crop shadow of a window fully on a particular monitor to that monitor. " + "This is currently implemented using the X RandR extension"}, + {"xinerama-shadow-crop" , no_argument , 272, NULL , NULL}, {"sw-opti" , no_argument , 274, NULL , NULL}, {"vsync-aggressive" , no_argument , 275, NULL , NULL}, {"use-ewmh-active-win" , no_argument , 276, NULL , "Use _NET_WM_ACTIVE_WINDOW on the root window to determine which window is " @@ -119,7 +122,6 @@ static const struct picom_option picom_options[] = { {"opacity-rule" , required_argument, 304, "OPACITY:COND", "Specify a list of opacity rules, see man page for more details"}, {"shadow-exclude-reg" , required_argument, 305, NULL , NULL}, {"paint-exclude" , required_argument, 306, NULL , NULL}, - {"xinerama-shadow-crop" , no_argument , 307, NULL , "Crop shadow of a window fully on a particular Xinerama screen to the screen."}, {"unredir-if-possible-exclude" , required_argument, 308, "COND" , "Conditions of windows that shouldn't be considered full-screen for " "unredirecting screen."}, {"unredir-if-possible-delay" , required_argument, 309, NULL, "Delay before unredirecting the window, in milliseconds. Defaults to 0."}, @@ -139,7 +141,7 @@ static const struct picom_option picom_options[] = { {"log-file" , required_argument, 322, NULL , "Path to the log file."}, {"use-damage" , no_argument , 323, NULL , "Render only the damaged (changed) part of the screen"}, {"no-use-damage" , no_argument , 324, NULL , "Disable the use of damage information. This cause the whole screen to be" - "redrawn everytime, instead of the part of the screen that has actually " + "redrawn every time, instead of the part of the screen that has actually " "changed. Potentially degrades the performance, but might fix some artifacts."}, {"no-vsync" , no_argument , 325, NULL , "Disable VSync"}, {"max-brightness" , required_argument, 326, NULL , "Dims windows which average brightness is above this threshold. Requires " @@ -159,6 +161,7 @@ static const struct picom_option picom_options[] = { {"corner-radius" , required_argument, 333, NULL , "Sets the radius of rounded window corners. When > 0, the compositor will " "round the corners of windows. (defaults to 0)."}, {"rounded-corners-exclude" , required_argument, 334, "COND" , "Exclude conditions for rounded corners."}, + {"corner-radius-rules" , required_argument, 340, "RADIUS:COND" , "Window rules for specific rounded corner radii."}, {"clip-shadow-above" , required_argument, 335, NULL , "Specify a list of conditions of windows to not paint a shadow over, such " "as a dock window."}, {"window-shader-fg" , required_argument, 336, "PATH" , "Specify GLSL fragment shader path for rendering window contents. Does not" @@ -168,6 +171,12 @@ static const struct picom_option picom_options[] = { "similar to --opacity-rule. SHADER_PATH can be \"default\", in which case " "the default shader will be used. Does not work when --legacy-backends is " "enabled. See man page for more details"}, + // 338 is transparent-clipping-exclude + {"dithered-present" , no_argument , 339, NULL , "Use higher precision during rendering, and apply dither when presenting the " + "rendered screen. Reduces banding artifacts, but might cause performance " + "degradation. Only works with OpenGL."}, + // 340 is corner-radius-rules + {"no-frame-pacing" , no_argument , 341, NULL , "Disable frame pacing. This might increase the latency."}, {"legacy-backends" , no_argument , 733, NULL , "Use deprecated version of the backends."}, {"monitor-repaint" , no_argument , 800, NULL , "Highlight the updated area of the screen. For debugging."}, {"diagnostics" , no_argument , 801, NULL , "Print diagnostic information"}, @@ -481,8 +490,8 @@ bool get_cfg(options_t *opt, int argc, char *const *argv, bool shadow_enable, P_CASEBOOL(267, detect_rounded_corners); P_CASEBOOL(268, detect_client_opacity); case 269: - log_warn("--refresh-rate has been deprecated, please remove it from" - "your command line options"); + log_warn("--refresh-rate has been deprecated, please remove it " + "from your command line options"); break; case 270: if (optarg) { @@ -495,6 +504,12 @@ bool get_cfg(options_t *opt, int argc, char *const *argv, bool shadow_enable, opt->vsync = true; } break; + P_CASEBOOL(271, crop_shadow_to_monitor); + case 272: + opt->crop_shadow_to_monitor = true; + log_warn("--xinerama-shadow-crop is deprecated. Use " + "--crop-shadow-to-monitor instead."); + break; case 274: log_warn("--sw-opti has been deprecated, please remove it from the " "command line options"); @@ -502,7 +517,7 @@ bool get_cfg(options_t *opt, int argc, char *const *argv, bool shadow_enable, case 275: // --vsync-aggressive log_error("--vsync-aggressive has been removed, please remove it" - " from the command line options"); + " from the command line options"); failed = true; break; P_CASEBOOL(276, use_ewmh_active_win); @@ -546,8 +561,9 @@ bool get_cfg(options_t *opt, int argc, char *const *argv, bool shadow_enable, case 290: // --backend opt->backend = parse_backend(optarg); - if (opt->backend >= NUM_BKEND) + if (opt->backend >= NUM_BKEND) { exit(1); + } break; P_CASEBOOL(291, glx_no_stencil); P_CASEINT(293, benchmark); @@ -607,8 +623,9 @@ bool get_cfg(options_t *opt, int argc, char *const *argv, bool shadow_enable, break; case 304: // --opacity-rule - if (!parse_rule_opacity(&opt->opacity_rules, optarg)) + if (!parse_numeric_window_rule(&opt->opacity_rules, optarg, 0, 100)) { exit(1); + } break; case 305: // --shadow-exclude-reg @@ -621,7 +638,6 @@ bool get_cfg(options_t *opt, int argc, char *const *argv, bool shadow_enable, // --paint-exclude condlst_add(&opt->paint_blacklist, optarg); break; - P_CASEBOOL(307, xinerama_shadow_crop); case 308: // --unredir-if-possible-exclude condlst_add(&opt->unredir_if_possible_blacklist, optarg); @@ -712,10 +728,21 @@ bool get_cfg(options_t *opt, int argc, char *const *argv, bool shadow_enable, // --rounded-corners-exclude condlst_add(&opt->rounded_corners_blacklist, optarg); break; + case 340: + // --corner-radius-rules + if (!parse_numeric_window_rule(&opt->corner_radius_rules, optarg, 0, INT_MAX)) { + exit(1); + } + break; case 335: // --clip-shadow-above condlst_add(&opt->shadow_clip_list, optarg); break; + case 339: + // --dithered-present + opt->dithered_present = true; + break; + P_CASEBOOL(341, no_frame_pacing); P_CASEBOOL(733, legacy_backends); P_CASEBOOL(800, monitor_repaint); case 801: @@ -779,14 +806,13 @@ bool get_cfg(options_t *opt, int argc, char *const *argv, bool shadow_enable, } if (opt->window_shader_fg || opt->window_shader_fg_rules) { - if (opt->legacy_backends || opt->backend != BKEND_GLX) { - log_warn("The new window shader interface does not work with the " - "legacy glx backend.%s", - (opt->backend == BKEND_GLX) ? " You may want to use " - "\"--glx-fshader-win\" " - "instead on the legacy " - "glx backend." - : ""); + if (opt->backend == BKEND_XRENDER || opt->legacy_backends) { + log_warn(opt->backend == BKEND_XRENDER + ? "Shader interface is not supported by the xrender " + "backend." + : "The new shader interface is not supported by the " + "legacy glx backend. You may want to use " + "--glx-fshader-win instead."); opt->window_shader_fg = NULL; c2_list_free(&opt->window_shader_fg_rules, free); } @@ -801,18 +827,16 @@ bool get_cfg(options_t *opt, int argc, char *const *argv, bool shadow_enable, opt->inactive_dim = normalize_d(opt->inactive_dim); opt->frame_opacity = normalize_d(opt->frame_opacity); opt->shadow_opacity = normalize_d(opt->shadow_opacity); - opt->max_brightness = normalize_d(opt->max_brightness); if (opt->max_brightness < 1.0) { - if (opt->use_damage) { - log_warn("--max-brightness requires --no-use-damage. Falling " - "back to 1.0"); + if (opt->backend == BKEND_XRENDER || opt->legacy_backends) { + log_warn("--max-brightness is not supported by the %s backend. " + "Falling back to 1.0.", + opt->backend == BKEND_XRENDER ? "xrender" : "legacy glx"); opt->max_brightness = 1.0; - } - - if (opt->legacy_backends || opt->backend != BKEND_GLX) { - log_warn("--max-brightness requires the new glx " - "backend. Falling back to 1.0"); + } else if (opt->use_damage) { + log_warn("--max-brightness requires --no-use-damage. Falling " + "back to 1.0."); opt->max_brightness = 1.0; } } diff --git a/src/picom.c b/src/picom.c index fd693fc927..044a9eb1ea 100644 --- a/src/picom.c +++ b/src/picom.c @@ -16,18 +16,23 @@ #include #include #include +#include +#include +#include #include #include +#include +#include #include #include #include +#include #include #include #include #include #include #include -#include #include #include @@ -43,7 +48,6 @@ #endif #include "backend/backend.h" #include "c2.h" -#include "config.h" #include "diagnostic.h" #include "log.h" #include "region.h" @@ -60,7 +64,9 @@ #include "file_watch.h" #include "list.h" #include "options.h" +#include "statistics.h" #include "uthash_extra.h" +#include "vblank.h" /// Get session_t pointer from a pointer to a member of session_t #define session_ptr(ptr, member) \ @@ -110,21 +116,6 @@ void quit(session_t *ps) { ev_break(ps->loop, EVBREAK_ALL); } -/** - * Free Xinerama screen info. - * - * XXX consider moving to x.c - */ -static inline void free_xinerama_info(session_t *ps) { - if (ps->xinerama_scr_regs) { - for (int i = 0; i < ps->xinerama_nscrs; ++i) - pixman_region32_fini(&ps->xinerama_scr_regs[i]); - free(ps->xinerama_scr_regs); - ps->xinerama_scr_regs = NULL; - } - ps->xinerama_nscrs = 0; -} - /** * Get current system clock in milliseconds. */ @@ -134,64 +125,301 @@ static inline int64_t get_time_ms(void) { return (int64_t)tp.tv_sec * 1000 + (int64_t)tp.tv_nsec / 1000000; } -// XXX Move to x.c -void cxinerama_upd_scrs(session_t *ps) { - // XXX Consider deprecating Xinerama, switch to RandR when necessary - free_xinerama_info(ps); - - if (!ps->o.xinerama_shadow_crop || !ps->xinerama_exists) - return; - - xcb_xinerama_is_active_reply_t *active = - xcb_xinerama_is_active_reply(ps->c, xcb_xinerama_is_active(ps->c), NULL); - if (!active || !active->state) { - free(active); - return; - } - free(active); - - auto xinerama_scrs = - xcb_xinerama_query_screens_reply(ps->c, xcb_xinerama_query_screens(ps->c), NULL); - if (!xinerama_scrs) { - return; - } - - xcb_xinerama_screen_info_t *scrs = - xcb_xinerama_query_screens_screen_info(xinerama_scrs); - ps->xinerama_nscrs = xcb_xinerama_query_screens_screen_info_length(xinerama_scrs); - - ps->xinerama_scr_regs = ccalloc(ps->xinerama_nscrs, region_t); - for (int i = 0; i < ps->xinerama_nscrs; ++i) { - const xcb_xinerama_screen_info_t *const s = &scrs[i]; - pixman_region32_init_rect(&ps->xinerama_scr_regs[i], s->x_org, s->y_org, - s->width, s->height); - } - free(xinerama_scrs); -} - /** * Find matched window. * * XXX move to win.c */ static inline struct managed_win *find_win_all(session_t *ps, const xcb_window_t wid) { - if (!wid || PointerRoot == wid || wid == ps->root || wid == ps->overlay) + if (!wid || PointerRoot == wid || wid == ps->c.screen_info->root || wid == ps->overlay) { return NULL; + } auto w = find_managed_win(ps, wid); - if (!w) + if (!w) { w = find_toplevel(ps, wid); - if (!w) + } + if (!w) { w = find_managed_window_or_parent(ps, wid); + } return w; } +enum vblank_callback_action check_render_finish(struct vblank_event *e attr_unused, void *ud) { + auto ps = (session_t *)ud; + if (!ps->backend_busy) { + return VBLANK_CALLBACK_DONE; + } + + struct timespec render_time; + bool completed = + ps->backend_data->ops->last_render_time(ps->backend_data, &render_time); + if (!completed) { + // Render hasn't completed yet, we can't start another render. + // Check again at the next vblank. + log_debug("Last render did not complete during vblank, msc: " + "%" PRIu64, + ps->last_msc); + return VBLANK_CALLBACK_AGAIN; + } + + // The frame has been finished and presented, record its render time. + if (ps->o.debug_options.smart_frame_pacing) { + int render_time_us = + (int)(render_time.tv_sec * 1000000L + render_time.tv_nsec / 1000L); + render_statistics_add_render_time_sample( + &ps->render_stats, render_time_us + (int)ps->last_schedule_delay); + log_verbose("Last render call took: %d (gpu) + %d (cpu) us, " + "last_msc: %" PRIu64, + render_time_us, (int)ps->last_schedule_delay, ps->last_msc); + } + ps->backend_busy = false; + return VBLANK_CALLBACK_DONE; +} + +enum vblank_callback_action +collect_vblank_interval_statistics(struct vblank_event *e, void *ud) { + auto ps = (session_t *)ud; + double vblank_interval = NAN; + assert(ps->frame_pacing); + assert(ps->vblank_scheduler); + + if (!ps->o.debug_options.smart_frame_pacing) { + // We don't need to collect statistics if we are not doing smart frame + // pacing. + return VBLANK_CALLBACK_DONE; + } + + // TODO(yshui): this naive method of estimating vblank interval does not handle + // the variable refresh rate case very well. This includes the case + // of a VRR enabled monitor; or a monitor that's turned off, in which + // case the vblank events might slow down or stop all together. + // I tried using DPMS to detect monitor power state, and stop adding + // samples when the monitor is off, but I had a hard time to get it + // working reliably, there are just too many corner cases. + + // Don't add sample again if we already collected statistics for this vblank + if (ps->last_msc < e->msc) { + if (ps->last_msc_instant != 0) { + auto frame_count = e->msc - ps->last_msc; + auto frame_time = + (int)((e->ust - ps->last_msc_instant) / frame_count); + if (frame_count == 1) { + render_statistics_add_vblank_time_sample( + &ps->render_stats, frame_time); + log_trace("Frame count %lu, frame time: %d us, ust: " + "%" PRIu64 "", + frame_count, frame_time, e->ust); + } else { + log_trace("Frame count %lu, frame time: %d us, msc: " + "%" PRIu64 ", not adding sample.", + frame_count, frame_time, e->ust); + } + } + ps->last_msc_instant = e->ust; + ps->last_msc = e->msc; + } else if (ps->last_msc > e->msc) { + log_warn("PresentCompleteNotify msc is going backwards, last_msc: " + "%" PRIu64 ", current msc: %" PRIu64, + ps->last_msc, e->msc); + ps->last_msc_instant = 0; + ps->last_msc = 0; + } + + vblank_interval = render_statistics_get_vblank_time(&ps->render_stats); + log_trace("Vblank interval estimate: %f us", vblank_interval); + if (vblank_interval == 0) { + // We don't have enough data for vblank interval estimate, schedule + // another vblank event. + return VBLANK_CALLBACK_AGAIN; + } + return VBLANK_CALLBACK_DONE; +} + +void schedule_render(session_t *ps, bool triggered_by_vblank); + +/// vblank callback scheduled by schedule_render, when a render is ongoing. +/// +/// Check if previously queued render has finished, and reschedule render if it has. +enum vblank_callback_action reschedule_render_at_vblank(struct vblank_event *e, void *ud) { + auto ps = (session_t *)ud; + assert(ps->frame_pacing); + assert(ps->render_queued); + assert(ps->vblank_scheduler); + + log_verbose("Rescheduling render at vblank, msc: %" PRIu64, e->msc); + + collect_vblank_interval_statistics(e, ud); + check_render_finish(e, ud); + + if (ps->backend_busy) { + return VBLANK_CALLBACK_AGAIN; + } + + schedule_render(ps, false); + return VBLANK_CALLBACK_DONE; +} + +/// How many seconds into the future should we start rendering the next frame. +/// +/// Renders are scheduled like this: +/// +/// 1. queue_redraw() queues a new render by calling schedule_render, if there +/// is no render currently scheduled. i.e. render_queued == false. +/// 2. then, we need to figure out the best time to start rendering. we need to +/// at least know when the next vblank will start, as we can't start render +/// before the current rendered frame is diplayed on screen. we have this +/// information from the vblank scheduler, it will notify us when that happens. +/// we might also want to delay the rendering even further to reduce latency, +/// this is discussed below, in FUTURE WORKS. +/// 3. we schedule a render for that target point in time. +/// 4. draw_callback() is called at the schedule time (i.e. when scheduled +/// vblank event is delivered). Backend APIs are called to issue render +/// commands. render_queued is set to false, and backend_busy is set to true. +/// +/// There are some considerations in step 2: +/// +/// First of all, a vblank event being delivered +/// doesn't necessarily mean the frame has been displayed on screen. If a frame +/// takes too long to render, it might miss the current vblank, and will be +/// displayed on screen during one of the subsequent vblanks. So in +/// schedule_render_at_vblank, we ask the backend to see if it has finished +/// rendering. if not, render_queued is unchanged, and another vblank is +/// scheduled; otherwise, draw_callback_impl will be scheduled to be call at +/// an appropriate time. Second, we might not have rendered for the previous vblank, +/// in which case the last vblank event we received could be many frames in the past, +/// so we can't make scheduling decisions based on that. So we always schedule +/// a vblank event when render is queued, and make scheduling decisions when the +/// event is delivered. +/// +/// All of the above is what happens when frame_pacing is true. Otherwise +/// render_in_progress is either QUEUED or IDLE, and queue_redraw will always +/// schedule a render to be started immediately. PresentCompleteNotify will not +/// be received, and handle_end_of_vblank will not be called. +/// +/// The `triggered_by_timer` parameter is used to indicate whether this function +/// is triggered by a steady timer, i.e. we are rendering for each vblank. The +/// other case is when we stop rendering for a while because there is no changes +/// on screen, then something changed and schedule_render is triggered by a +/// DamageNotify. The idea is that when the schedule is triggered by a steady +/// timer, schedule_render will be called at a predictable offset into each +/// vblank. +/// +/// # FUTURE WORKS +/// +/// As discussed in step 2 above, we might want to delay the rendering even +/// further. If we know the time it takes to render a frame, and the interval +/// between vblanks, we can try to schedule the render to start at a point in +/// time that's closer to the next vblank. We should be able to get this +/// information by doing statistics on the render time of previous frames, which +/// is available from the backends; and the interval between vblank events, +/// which is available from the vblank scheduler. +/// +/// The code that does this is already implemented below, but disabled by +/// default. There are several problems with it, see bug #1072. +void schedule_render(session_t *ps, bool triggered_by_vblank attr_unused) { + // If the backend is busy, we will try again at the next vblank. + if (ps->backend_busy) { + // We should never have set backend_busy to true unless frame_pacing is + // enabled. + assert(ps->vblank_scheduler); + assert(ps->frame_pacing); + log_verbose("Backend busy, will reschedule render at next vblank."); + if (!vblank_scheduler_schedule(ps->vblank_scheduler, + reschedule_render_at_vblank, ps)) { + // TODO(yshui): handle error here + abort(); + } + return; + } + + // By default, we want to schedule render immediately, later in this function we + // might adjust that and move the render later, based on render timing statistics. + double delay_s = 0; + unsigned int divisor = 0; + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + auto now_us = (uint64_t)now.tv_sec * 1000000 + (uint64_t)now.tv_nsec / 1000; + + ps->next_render = now_us; + + if (!ps->frame_pacing || !ps->redirected) { + // If not doing frame pacing, schedule a render immediately; if + // not redirected, we schedule immediately to have a chance to + // redirect. We won't have frame or render timing information + // anyway. + assert(!ev_is_active(&ps->draw_timer)); + goto schedule; + } + + // if ps->o.debug_options.smart_frame_pacing is false, we won't have any render + // time or vblank interval estimates, so we would naturally fallback to schedule + // render immediately. + auto render_budget = render_statistics_get_budget(&ps->render_stats); + auto frame_time = render_statistics_get_vblank_time(&ps->render_stats); + if (frame_time == 0) { + // We don't have enough data for render time estimates, maybe there's + // no frame rendered yet, or the backend doesn't support render timing + // information, schedule render immediately. + log_verbose("Not enough data for render time estimates."); + goto schedule; + } + + if (render_budget >= frame_time) { + // If the estimated render time is already longer than the estimated + // vblank interval, there is no way we can make it. Instead of always + // dropping frames, we try desperately to catch up and schedule a + // render immediately. + log_verbose("Render budget: %u us >= frame time: %" PRIu32 " us", + render_budget, frame_time); + goto schedule; + } + + auto target_frame = (now_us + render_budget - ps->last_msc_instant) / frame_time + 1; + auto const deadline = ps->last_msc_instant + target_frame * frame_time; + unsigned int available = 0; + if (deadline > now_us) { + available = (unsigned int)(deadline - now_us); + } + + if (available > render_budget) { + delay_s = (double)(available - render_budget) / 1000000.0; + ps->next_render = deadline - render_budget; + } + + if (delay_s > 1) { + log_warn("Delay too long: %f s, render_budget: %d us, frame_time: " + "%" PRIu32 " us, now_us: %" PRIu64 " us, next_msc: %" PRIu64 " u" + "s", + delay_s, render_budget, frame_time, now_us, deadline); + } + + log_verbose("Delay: %.6lf s, last_msc: %" PRIu64 ", render_budget: %d, " + "frame_time: %" PRIu32 ", now_us: %" PRIu64 ", next_render: %" PRIu64 + ", next_msc: %" PRIu64 ", divisor: " + "%d", + delay_s, ps->last_msc_instant, render_budget, frame_time, now_us, + ps->next_render, deadline, divisor); + +schedule: + // If the backend is not busy, we just need to schedule the render at the + // specified time; otherwise we need to wait for the next vblank event and + // reschedule. + ps->last_schedule_delay = 0; + assert(!ev_is_active(&ps->draw_timer)); + ev_timer_set(&ps->draw_timer, delay_s, 0); + ev_timer_start(ps->loop, &ps->draw_timer); +} + void queue_redraw(session_t *ps) { - // If --benchmark is used, redraw is always queued - if (!ps->redraw_needed && !ps->o.benchmark) { - ev_idle_start(ps->loop, &ps->draw_idle); + log_verbose("Queue redraw, render_queued: %d, backend_busy: %d", + ps->render_queued, ps->backend_busy); + + if (ps->render_queued) { + return; } - ps->redraw_needed = true; + ps->render_queued = true; + schedule_render(ps, false); } /** @@ -226,8 +454,9 @@ void add_damage(session_t *ps, const region_t *damage) { */ static double fade_timeout(session_t *ps) { auto now = get_time_ms(); - if (ps->o.fade_delta + ps->fade_time < now) + if (ps->o.fade_delta + ps->fade_time < now) { return 0; + } auto diff = ps->o.fade_delta + ps->fade_time - now; @@ -280,32 +509,6 @@ static bool run_fade(session_t *ps, struct managed_win **_w, long long steps) { return true; } -// === Error handling === - -void discard_ignore(session_t *ps, unsigned long sequence) { - while (ps->ignore_head) { - if (sequence > ps->ignore_head->sequence) { - ignore_t *next = ps->ignore_head->next; - free(ps->ignore_head); - ps->ignore_head = next; - if (!ps->ignore_head) { - ps->ignore_tail = &ps->ignore_head; - } - } else { - break; - } - } -} - -static int should_ignore(session_t *ps, unsigned long sequence) { - if (ps == NULL) { - // Do not ignore errors until the session has been initialized - return false; - } - discard_ignore(ps, sequence); - return ps->ignore_head && ps->ignore_head->sequence == sequence; -} - // === Windows === /** @@ -341,8 +544,8 @@ uint32_t determine_evmask(session_t *ps, xcb_window_t wid, win_evmode_t mode) { */ void update_ewmh_active_win(session_t *ps) { // Search for the window - xcb_window_t wid = - wid_get_prop_window(ps->c, ps->root, ps->atoms->a_NET_ACTIVE_WINDOW); + xcb_window_t wid = wid_get_prop_window(&ps->c, ps->c.screen_info->root, + ps->atoms->a_NET_ACTIVE_WINDOW); auto w = find_win_all(ps, wid); // Mark the window focused. No need to unfocus the previous one. @@ -369,7 +572,7 @@ static void recheck_focus(session_t *ps) { // opacity on it xcb_window_t wid = XCB_NONE; xcb_get_input_focus_reply_t *reply = - xcb_get_input_focus_reply(ps->c, xcb_get_input_focus(ps->c), NULL); + xcb_get_input_focus_reply(ps->c.c, xcb_get_input_focus(ps->c.c), NULL); if (reply) { wid = reply->focus; @@ -400,8 +603,9 @@ static void rebuild_screen_reg(session_t *ps) { */ static void rebuild_shadow_exclude_reg(session_t *ps) { bool ret = parse_geometry(ps, ps->o.shadow_exclude_reg_str, &ps->shadow_exclude_reg); - if (!ret) + if (!ret) { exit(1); + } } /// Free up all the images and deinit the backend @@ -503,7 +707,8 @@ static bool initialize_backend(session_t *ps) { assert(!ps->backend_data); // Reinitialize win_data assert(backend_list[ps->o.backend]); - ps->backend_data = backend_list[ps->o.backend]->init(ps); + ps->backend_data = + backend_list[ps->o.backend]->init(ps, session_get_target_window(ps)); if (!ps->backend_data) { log_fatal("Failed to initialize backend, aborting..."); quit(ps); @@ -539,8 +744,8 @@ static bool initialize_backend(session_t *ps) { } else { shader->attributes = 0; } - log_debug("Shader %s has attributes %ld", shader->key, - shader->attributes); + log_debug("Shader %s has attributes %" PRIu64, + shader->key, shader->attributes); } } @@ -578,7 +783,7 @@ static bool initialize_backend(session_t *ps) { /// Handle configure event of the root window static void configure_root(session_t *ps) { - auto r = XCB_AWAIT(xcb_get_geometry, ps->c, ps->root); + auto r = XCB_AWAIT(xcb_get_geometry, ps->c.c, ps->c.screen_info->root); if (!r) { log_fatal("Failed to fetch root geometry"); abort(); @@ -650,13 +855,12 @@ static void configure_root(session_t *ps) { } force_repaint(ps); } - return; } static void handle_root_flags(session_t *ps) { if ((ps->root_flags & ROOT_FLAGS_SCREEN_CHANGE) != 0) { - if (ps->o.xinerama_shadow_crop) { - cxinerama_upd_scrs(ps); + if (ps->o.crop_shadow_to_monitor && ps->randr_exists) { + x_update_monitors(&ps->c, &ps->monitors); } ps->root_flags &= ~(uint64_t)ROOT_FLAGS_SCREEN_CHANGE; } @@ -667,13 +871,19 @@ static void handle_root_flags(session_t *ps) { } } -static struct managed_win * -paint_preprocess(session_t *ps, bool *fade_running, bool *animation) { +/** + * Go through the window stack and calculate some parameters for rendering. + * + * @return whether the operation succeeded + */ +static bool paint_preprocess(session_t *ps, bool *fade_running, bool *animation, + struct managed_win **out_bottom) { // XXX need better, more general name for `fade_running`. It really // means if fade is still ongoing after the current frame is rendered struct managed_win *bottom = NULL; *fade_running = false; *animation = false; + *out_bottom = NULL; // Fading step calculation long long steps = 0L; @@ -921,12 +1131,13 @@ paint_preprocess(session_t *ps, bool *fade_running, bool *animation) { ev_timer_stop(ps->loop, &ps->unredir_timer); if (!ps->redirected) { if (!redirect_start(ps)) { - return NULL; + return false; } } } - return bottom; + *out_bottom = bottom; + return true; } void root_damaged(session_t *ps) { @@ -941,11 +1152,13 @@ void root_damaged(session_t *ps) { if (ps->backend_data) { if (ps->root_image) { ps->backend_data->ops->release_image(ps->backend_data, ps->root_image); + ps->root_image = NULL; } - auto pixmap = x_get_root_back_pixmap(ps->c, ps->root, ps->atoms); + auto pixmap = x_get_root_back_pixmap(&ps->c, ps->atoms); if (pixmap != XCB_NONE) { ps->root_image = ps->backend_data->ops->bind_pixmap( - ps->backend_data, pixmap, x_get_visual_info(ps->c, ps->vis), false); + ps->backend_data, pixmap, + x_get_visual_info(&ps->c, ps->c.screen_info->root_visual), false); if (ps->root_image) { ps->backend_data->ops->set_image_property( ps->backend_data, IMAGE_PROPERTY_EFFECTIVE_SIZE, @@ -960,25 +1173,6 @@ void root_damaged(session_t *ps) { force_repaint(ps); } -/** - * Xlib error handler function. - */ -static int xerror(Display attr_unused *dpy, XErrorEvent *ev) { - if (!should_ignore(ps_g, ev->serial)) { - x_print_error(ev->serial, ev->request_code, ev->minor_code, ev->error_code); - } - return 0; -} - -/** - * XCB error handler function. - */ -void ev_xcb_error(session_t *ps, xcb_generic_error_t *err) { - if (!should_ignore(ps, err->sequence)) { - x_print_error(err->sequence, err->major_code, err->minor_code, err->error_code); - } -} - /** * Force a full-screen repaint. */ @@ -1013,10 +1207,11 @@ void opts_set_no_fading_openclose(session_t *ps, bool newval) { static int register_cm(session_t *ps) { assert(!ps->reg_win); - ps->reg_win = x_new_id(ps->c); + ps->reg_win = x_new_id(&ps->c); auto e = xcb_request_check( - ps->c, xcb_create_window_checked(ps->c, XCB_COPY_FROM_PARENT, ps->reg_win, ps->root, - 0, 0, 1, 1, 0, XCB_NONE, ps->vis, 0, NULL)); + ps->c.c, xcb_create_window_checked(ps->c.c, XCB_COPY_FROM_PARENT, ps->reg_win, + ps->c.screen_info->root, 0, 0, 1, 1, 0, XCB_NONE, + ps->c.screen_info->root_visual, 0, NULL)); if (e) { log_fatal("Failed to create window."); @@ -1035,10 +1230,10 @@ static int register_cm(session_t *ps) { // Set names and classes for (size_t i = 0; i < ARR_SIZE(prop_atoms); i++) { e = xcb_request_check( - ps->c, xcb_change_property_checked( - ps->c, XCB_PROP_MODE_REPLACE, ps->reg_win, prop_atoms[i], - prop_is_utf8[i] ? ps->atoms->aUTF8_STRING : XCB_ATOM_STRING, - 8, strlen("picom"), "picom")); + ps->c.c, xcb_change_property_checked( + ps->c.c, XCB_PROP_MODE_REPLACE, ps->reg_win, prop_atoms[i], + prop_is_utf8[i] ? ps->atoms->aUTF8_STRING : XCB_ATOM_STRING, + 8, strlen("picom"), "picom")); if (e) { log_error_x_error(e, "Failed to set window property %d", prop_atoms[i]); @@ -1048,9 +1243,9 @@ static int register_cm(session_t *ps) { const char picom_class[] = "picom\0picom"; e = xcb_request_check( - ps->c, xcb_change_property_checked(ps->c, XCB_PROP_MODE_REPLACE, ps->reg_win, - ps->atoms->aWM_CLASS, XCB_ATOM_STRING, 8, - ARR_SIZE(picom_class), picom_class)); + ps->c.c, xcb_change_property_checked(ps->c.c, XCB_PROP_MODE_REPLACE, ps->reg_win, + ps->atoms->aWM_CLASS, XCB_ATOM_STRING, 8, + ARR_SIZE(picom_class), picom_class)); if (e) { log_error_x_error(e, "Failed to set the WM_CLASS property"); free(e); @@ -1059,15 +1254,15 @@ static int register_cm(session_t *ps) { // Set WM_CLIENT_MACHINE. As per EWMH, because we set _NET_WM_PID, we must also // set WM_CLIENT_MACHINE. { - const auto hostname_max = (unsigned long)sysconf(_SC_HOST_NAME_MAX); + auto const hostname_max = (unsigned long)sysconf(_SC_HOST_NAME_MAX); char *hostname = malloc(hostname_max); if (gethostname(hostname, hostname_max) == 0) { e = xcb_request_check( - ps->c, xcb_change_property_checked( - ps->c, XCB_PROP_MODE_REPLACE, ps->reg_win, - ps->atoms->aWM_CLIENT_MACHINE, XCB_ATOM_STRING, 8, - (uint32_t)strlen(hostname), hostname)); + ps->c.c, xcb_change_property_checked( + ps->c.c, XCB_PROP_MODE_REPLACE, ps->reg_win, + ps->atoms->aWM_CLIENT_MACHINE, XCB_ATOM_STRING, + 8, (uint32_t)strlen(hostname), hostname)); if (e) { log_error_x_error(e, "Failed to set the WM_CLIENT_MACHINE" " property"); @@ -1083,16 +1278,16 @@ static int register_cm(session_t *ps) { // Set _NET_WM_PID { auto pid = getpid(); - xcb_change_property(ps->c, XCB_PROP_MODE_REPLACE, ps->reg_win, + xcb_change_property(ps->c.c, XCB_PROP_MODE_REPLACE, ps->reg_win, ps->atoms->a_NET_WM_PID, XCB_ATOM_CARDINAL, 32, 1, &pid); } // Set COMPTON_VERSION e = xcb_request_check( - ps->c, xcb_change_property_checked( - ps->c, XCB_PROP_MODE_REPLACE, ps->reg_win, - get_atom(ps->atoms, "COMPTON_VERSION"), XCB_ATOM_STRING, 8, - (uint32_t)strlen(PICOM_VERSION), PICOM_VERSION)); + ps->c.c, xcb_change_property_checked( + ps->c.c, XCB_PROP_MODE_REPLACE, ps->reg_win, + get_atom(ps->atoms, "COMPTON_VERSION"), XCB_ATOM_STRING, 8, + (uint32_t)strlen(PICOM_VERSION), PICOM_VERSION)); if (e) { log_error_x_error(e, "Failed to set COMPTON_VERSION."); free(e); @@ -1104,7 +1299,7 @@ static int register_cm(session_t *ps) { xcb_atom_t atom; char *buf = NULL; - if (asprintf(&buf, "%s%d", register_prop, ps->scr) < 0) { + if (asprintf(&buf, "%s%d", register_prop, ps->c.screen) < 0) { log_fatal("Failed to allocate memory"); return -1; } @@ -1112,7 +1307,7 @@ static int register_cm(session_t *ps) { free(buf); xcb_get_selection_owner_reply_t *reply = xcb_get_selection_owner_reply( - ps->c, xcb_get_selection_owner(ps->c, atom), NULL); + ps->c.c, xcb_get_selection_owner(ps->c.c, atom), NULL); if (reply && reply->owner != XCB_NONE) { // Another compositor already running @@ -1120,7 +1315,7 @@ static int register_cm(session_t *ps) { return 1; } free(reply); - xcb_set_selection_owner(ps->c, ps->reg_win, atom, 0); + xcb_set_selection_owner(ps->c.c, ps->reg_win, atom, 0); } return 0; @@ -1150,9 +1345,8 @@ static inline bool write_pid(session_t *ps) { * Initialize X composite overlay window. */ static bool init_overlay(session_t *ps) { - xcb_composite_get_overlay_window_reply_t *reply = - xcb_composite_get_overlay_window_reply( - ps->c, xcb_composite_get_overlay_window(ps->c, ps->root), NULL); + xcb_composite_get_overlay_window_reply_t *reply = xcb_composite_get_overlay_window_reply( + ps->c.c, xcb_composite_get_overlay_window(ps->c.c, ps->c.screen_info->root), NULL); if (reply) { ps->overlay = reply->overlay_win; free(reply); @@ -1162,13 +1356,13 @@ static bool init_overlay(session_t *ps) { if (ps->overlay != XCB_NONE) { // Set window region of the overlay window, code stolen from // compiz-0.8.8 - if (!XCB_AWAIT_VOID(xcb_shape_mask, ps->c, XCB_SHAPE_SO_SET, + if (!XCB_AWAIT_VOID(xcb_shape_mask, ps->c.c, XCB_SHAPE_SO_SET, XCB_SHAPE_SK_BOUNDING, ps->overlay, 0, 0, 0)) { log_fatal("Failed to set the bounding shape of overlay, giving " "up."); return false; } - if (!XCB_AWAIT_VOID(xcb_shape_rectangles, ps->c, XCB_SHAPE_SO_SET, + if (!XCB_AWAIT_VOID(xcb_shape_rectangles, ps->c.c, XCB_SHAPE_SO_SET, XCB_SHAPE_SK_INPUT, XCB_CLIP_ORDERING_UNSORTED, ps->overlay, 0, 0, 0, NULL)) { log_fatal("Failed to set the input shape of overlay, giving up."); @@ -1176,7 +1370,7 @@ static bool init_overlay(session_t *ps) { } // Listen to Expose events on the overlay - xcb_change_window_attributes(ps->c, ps->overlay, XCB_CW_EVENT_MASK, + xcb_change_window_attributes(ps->c.c, ps->overlay, XCB_CW_EVENT_MASK, (const uint32_t[]){XCB_EVENT_MASK_EXPOSURE}); // Retrieve DamageNotify on root window if we are painting on an @@ -1184,7 +1378,7 @@ static bool init_overlay(session_t *ps) { // root_damage = XDamageCreate(ps->dpy, root, XDamageReportNonEmpty); // Unmap the overlay, we will map it when needed in redirect_start - XCB_AWAIT_VOID(xcb_unmap_window, ps->c, ps->overlay); + XCB_AWAIT_VOID(xcb_unmap_window, ps->c.c, ps->overlay); } else { log_error("Cannot get X Composite overlay window. Falling " "back to painting on root window."); @@ -1195,27 +1389,29 @@ static bool init_overlay(session_t *ps) { } static bool init_debug_window(session_t *ps) { - xcb_colormap_t colormap = x_new_id(ps->c); - ps->debug_window = x_new_id(ps->c); + xcb_colormap_t colormap = x_new_id(&ps->c); + ps->debug_window = x_new_id(&ps->c); auto err = xcb_request_check( - ps->c, xcb_create_colormap_checked(ps->c, XCB_COLORMAP_ALLOC_NONE, colormap, - ps->root, ps->vis)); + ps->c.c, xcb_create_colormap_checked(ps->c.c, XCB_COLORMAP_ALLOC_NONE, + colormap, ps->c.screen_info->root, + ps->c.screen_info->root_visual)); if (err) { goto err_out; } err = xcb_request_check( - ps->c, xcb_create_window_checked(ps->c, (uint8_t)ps->depth, ps->debug_window, - ps->root, 0, 0, to_u16_checked(ps->root_width), - to_u16_checked(ps->root_height), 0, - XCB_WINDOW_CLASS_INPUT_OUTPUT, ps->vis, - XCB_CW_COLORMAP, (uint32_t[]){colormap, 0})); + ps->c.c, xcb_create_window_checked( + ps->c.c, (uint8_t)ps->c.screen_info->root_depth, + ps->debug_window, ps->c.screen_info->root, 0, 0, + to_u16_checked(ps->root_width), to_u16_checked(ps->root_height), + 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, ps->c.screen_info->root_visual, + XCB_CW_COLORMAP, (uint32_t[]){colormap, 0})); if (err) { goto err_out; } - err = xcb_request_check(ps->c, xcb_map_window(ps->c, ps->debug_window)); + err = xcb_request_check(ps->c.c, xcb_map_window_checked(ps->c.c, ps->debug_window)); if (err) { goto err_out; } @@ -1230,7 +1426,7 @@ xcb_window_t session_get_target_window(session_t *ps) { if (ps->o.debug_mode) { return ps->debug_window; } - return ps->overlay != XCB_NONE ? ps->overlay : ps->root; + return ps->overlay != XCB_NONE ? ps->overlay : ps->c.screen_info->root; } uint8_t session_redirection_mode(session_t *ps) { @@ -1260,18 +1456,18 @@ static bool redirect_start(session_t *ps) { // Map overlay window. Done firstly according to this: // https://bugzilla.gnome.org/show_bug.cgi?id=597014 if (ps->overlay != XCB_NONE) { - xcb_map_window(ps->c, ps->overlay); + xcb_map_window(ps->c.c, ps->overlay); } - bool success = XCB_AWAIT_VOID(xcb_composite_redirect_subwindows, ps->c, ps->root, - session_redirection_mode(ps)); + bool success = XCB_AWAIT_VOID(xcb_composite_redirect_subwindows, ps->c.c, + ps->c.screen_info->root, session_redirection_mode(ps)); if (!success) { log_fatal("Another composite manager is already running " "(and does not handle _NET_WM_CM_Sn correctly)"); return false; } - x_sync(ps->c); + x_sync(&ps->c); if (!initialize_backend(ps)) { return false; @@ -1290,16 +1486,51 @@ static bool redirect_start(session_t *ps) { pixman_region32_init(&ps->damage_ring[i]); } + ps->frame_pacing = !ps->o.no_frame_pacing && ps->o.vsync; + if ((ps->o.legacy_backends || ps->o.benchmark || !ps->backend_data->ops->last_render_time) && + ps->frame_pacing) { + // Disable frame pacing if we are using a legacy backend or if we are in + // benchmark mode, or if the backend doesn't report render time + log_info("Disabling frame pacing."); + ps->frame_pacing = false; + } + + // Re-detect driver since we now have a backend + ps->drivers = detect_driver(ps->c.c, ps->backend_data, ps->c.screen_info->root); + apply_driver_workarounds(ps, ps->drivers); + + if (ps->present_exists && ps->frame_pacing) { + // Initialize rendering and frame timing statistics, and frame pacing + // states. + ps->last_msc_instant = 0; + ps->last_msc = 0; + ps->last_schedule_delay = 0; + render_statistics_reset(&ps->render_stats); + enum vblank_scheduler_type scheduler_type = + choose_vblank_scheduler(ps->drivers); + if (ps->o.debug_options.force_vblank_scheduler != LAST_VBLANK_SCHEDULER) { + scheduler_type = + (enum vblank_scheduler_type)ps->o.debug_options.force_vblank_scheduler; + } + log_info("Using vblank scheduler: %s.", vblank_scheduler_str[scheduler_type]); + ps->vblank_scheduler = vblank_scheduler_new( + ps->loop, &ps->c, session_get_target_window(ps), scheduler_type); + if (!ps->vblank_scheduler) { + return false; + } + vblank_scheduler_schedule(ps->vblank_scheduler, + collect_vblank_interval_statistics, ps); + } else if (ps->frame_pacing) { + log_error("Present extension is not supported, frame pacing disabled."); + ps->frame_pacing = false; + } + // Must call XSync() here - x_sync(ps->c); + x_sync(&ps->c); ps->redirected = true; ps->first_frame = true; - // Re-detect driver since we now have a backend - ps->drivers = detect_driver(ps->c, ps->backend_data, ps->root); - apply_driver_workarounds(ps, ps->drivers); - root_damaged(ps); // Repaint the whole screen @@ -1317,10 +1548,11 @@ static void unredirect(session_t *ps) { destroy_backend(ps); - xcb_composite_unredirect_subwindows(ps->c, ps->root, session_redirection_mode(ps)); + xcb_composite_unredirect_subwindows(ps->c.c, ps->c.screen_info->root, + session_redirection_mode(ps)); // Unmap overlay window if (ps->overlay != XCB_NONE) { - xcb_unmap_window(ps->c, ps->overlay); + xcb_unmap_window(ps->c.c, ps->overlay); } // Free the damage ring @@ -1331,8 +1563,13 @@ static void unredirect(session_t *ps) { free(ps->damage_ring); ps->damage_ring = ps->damage = NULL; + if (ps->vblank_scheduler) { + vblank_scheduler_free(ps->vblank_scheduler); + ps->vblank_scheduler = NULL; + } + // Must call XSync() here - x_sync(ps->c); + x_sync(&ps->c); ps->redirected = false; log_debug("Screen unredirected."); @@ -1341,8 +1578,12 @@ static void unredirect(session_t *ps) { // Handle queued events before we go to sleep static void handle_queued_x_events(EV_P attr_unused, ev_prepare *w, int revents attr_unused) { session_t *ps = session_ptr(w, event_check); + if (ps->vblank_scheduler) { + vblank_handle_x_events(ps->vblank_scheduler); + } + xcb_generic_event_t *ev; - while ((ev = xcb_poll_for_queued_event(ps->c))) { + while ((ev = xcb_poll_for_queued_event(ps->c.c))) { ev_handle(ps, ev); free(ev); }; @@ -1351,9 +1592,9 @@ static void handle_queued_x_events(EV_P attr_unused, ev_prepare *w, int revents // for an indefinite amount of time. // Use XFlush here too, we might still use some Xlib functions // because OpenGL. - XFlush(ps->dpy); - xcb_flush(ps->c); - int err = xcb_connection_has_error(ps->c); + XFlush(ps->c.dpy); + xcb_flush(ps->c.c); + int err = xcb_connection_has_error(ps->c.c); if (err) { log_fatal("X11 server connection broke (error %d)", err); exit(1); @@ -1402,6 +1643,8 @@ static void tmout_unredir_callback(EV_P attr_unused, ev_timer *w, int revents at } static void fade_timer_callback(EV_P attr_unused, ev_timer *w, int revents attr_unused) { + // TODO(yshui): do we still need the fade timer? we queue redraw automatically in + // draw_callback_impl if animation is running. session_t *ps = session_ptr(w, fade_timer); queue_redraw(ps); } @@ -1409,9 +1652,10 @@ static void fade_timer_callback(EV_P attr_unused, ev_timer *w, int revents attr_ static void handle_pending_updates(EV_P_ struct session *ps) { if (ps->pending_updates) { log_debug("Delayed handling of events, entering critical section"); - auto e = xcb_request_check(ps->c, xcb_grab_server_checked(ps->c)); + auto e = xcb_request_check(ps->c.c, xcb_grab_server_checked(ps->c.c)); if (e) { log_fatal_x_error(e, "failed to grab x server"); + free(e); return quit(ps); } @@ -1434,7 +1678,7 @@ static void handle_pending_updates(EV_P_ struct session *ps) { { auto r = xcb_get_input_focus_reply( - ps->c, xcb_get_input_focus(ps->c), NULL); + ps->c.c, xcb_get_input_focus(ps->c.c), NULL); if (!ps->active_win || (r && r->focus != ps->active_win->base.id)) { recheck_focus(ps); } @@ -1444,9 +1688,10 @@ static void handle_pending_updates(EV_P_ struct session *ps) { // Process window flags (stale images) refresh_images(ps); - e = xcb_request_check(ps->c, xcb_ungrab_server_checked(ps->c)); + e = xcb_request_check(ps->c.c, xcb_ungrab_server_checked(ps->c.c)); if (e) { log_fatal_x_error(e, "failed to ungrab x server"); + free(e); return quit(ps); } @@ -1457,8 +1702,27 @@ static void handle_pending_updates(EV_P_ struct session *ps) { } static void draw_callback_impl(EV_P_ session_t *ps, int revents attr_unused) { + assert(!ps->backend_busy); + assert(ps->render_queued); + + struct timespec now; + int64_t draw_callback_enter_us; + clock_gettime(CLOCK_MONOTONIC, &now); + + draw_callback_enter_us = (now.tv_sec * 1000000LL + now.tv_nsec / 1000); + if (ps->next_render != 0) { + log_trace("Schedule delay: %" PRIi64 " us", + draw_callback_enter_us - (int64_t)ps->next_render); + } + handle_pending_updates(EV_A_ ps); + int64_t after_handle_pending_updates_us; + clock_gettime(CLOCK_MONOTONIC, &now); + after_handle_pending_updates_us = (now.tv_sec * 1000000LL + now.tv_nsec / 1000); + log_trace("handle_pending_updates took: %" PRIi64 " us", + after_handle_pending_updates_us - draw_callback_enter_us); + if (ps->first_frame) { // If we are still rendering the first frame, if some of the windows are // unmapped/destroyed during the above handle_pending_updates() call, they @@ -1492,7 +1756,12 @@ static void draw_callback_impl(EV_P_ session_t *ps, int revents attr_unused) { bool fade_running = false; bool animation = false; bool was_redirected = ps->redirected; - auto bottom = paint_preprocess(ps, &fade_running, &animation); + struct managed_win *bottom = NULL; + if (!paint_preprocess(ps, &fade_running, &animation, &bottom)) { + log_fatal("Pre-render preparation has failed, exiting..."); + exit(1); + } + ps->tmout_unredir_hit = false; if (!was_redirected && ps->redirected) { @@ -1515,17 +1784,24 @@ static void draw_callback_impl(EV_P_ session_t *ps, int revents attr_unused) { ev_timer_start(EV_A_ & ps->fade_timer); } - // If the screen is unredirected, free all_damage to stop painting + int64_t after_preprocess_us; + clock_gettime(CLOCK_MONOTONIC, &now); + after_preprocess_us = (now.tv_sec * 1000000LL + now.tv_nsec / 1000); + log_trace("paint_preprocess took: %" PRIi64 " us", + after_preprocess_us - after_handle_pending_updates_us); + + // If the screen is unredirected, we don't render anything. + bool did_render = false; if (ps->redirected && ps->o.stoppaint_force != ON) { static int paint = 0; - log_trace("Render start, frame %d", paint); + log_verbose("Render start, frame %d", paint); if (!ps->o.legacy_backends) { - paint_all_new(ps, bottom, false); + did_render = paint_all_new(ps, bottom); } else { - paint_all(ps, bottom, false); + paint_all(ps, bottom); } - log_trace("Render end"); + log_verbose("Render end"); ps->first_frame = false; paint++; @@ -1534,31 +1810,54 @@ static void draw_callback_impl(EV_P_ session_t *ps, int revents attr_unused) { } } + // With frame pacing, we set backend_busy to true after the end of + // vblank. Without frame pacing, we won't be receiving vblank events, so + // we set backend_busy to false here, right after we issue the render + // commands. + // The other case is if we decided there is no change to render, in that + // case no render command is issued, so we also set backend_busy to + // false. + ps->backend_busy = (ps->frame_pacing && did_render); + ps->next_render = 0; + if (!fade_running) { ps->fade_time = 0L; } + ps->render_queued = false; + // TODO(yshui) Investigate how big the X critical section needs to be. There are // suggestions that rendering should be in the critical section as well. - ps->redraw_needed = animation; + // Queue redraw if animation is running. This should be picked up by next present + // event. + if (animation) { + queue_redraw(ps); + } + if (ps->vblank_scheduler) { + // Even if we might not want to render during next vblank, we want to keep + // `backend_busy` up to date, so when the next render comes, we can + // immediately know if we can render. + vblank_scheduler_schedule(ps->vblank_scheduler, check_render_finish, ps); + } } -static void draw_callback(EV_P_ ev_idle *w, int revents) { - session_t *ps = session_ptr(w, draw_idle); +static void draw_callback(EV_P_ ev_timer *w, int revents) { + session_t *ps = session_ptr(w, draw_timer); draw_callback_impl(EV_A_ ps, revents); + ev_timer_stop(EV_A_ w); - // Don't do painting non-stop unless we are in benchmark mode, or if - // draw_callback_impl thinks we should continue painting. - if (!ps->o.benchmark && !ps->redraw_needed) { - ev_idle_stop(EV_A_ & ps->draw_idle); + // Immediately start next frame if we are in benchmark mode. + if (ps->o.benchmark) { + ev_timer_set(w, 0, 0); + ev_timer_start(EV_A_ w); } } static void x_event_callback(EV_P attr_unused, ev_io *w, int revents attr_unused) { session_t *ps = (session_t *)w; - xcb_generic_event_t *ev = xcb_poll_for_event(ps->c); + xcb_generic_event_t *ev = xcb_poll_for_event(ps->c.c); if (ev) { ev_handle(ps, ev); free(ev); @@ -1656,12 +1955,6 @@ static session_t *session_init(int argc, char **argv, Display *dpy, const char *config_file, bool all_xerrors, bool fork) { static const session_t s_def = { .backend_data = NULL, - .dpy = NULL, - .scr = 0, - .c = NULL, - .vis = 0, - .depth = 0, - .root = XCB_NONE, .root_height = 0, .root_width = 0, // .root_damage = XCB_NONE, @@ -1677,8 +1970,6 @@ static session_t *session_init(int argc, char **argv, Display *dpy, .redirected = false, .alpha_picts = NULL, .fade_time = 0L, - .ignore_head = NULL, - .ignore_tail = NULL, .quit = false, .expose_rects = NULL, @@ -1694,6 +1985,8 @@ static session_t *session_init(int argc, char **argv, Display *dpy, .white_picture = XCB_NONE, .shadow_context = NULL, + .last_msc = 0, + #ifdef CONFIG_VSYNC_DRM .drm_fd = -1, #endif @@ -1740,51 +2033,45 @@ static session_t *session_init(int argc, char **argv, Display *dpy, ps->loop = EV_DEFAULT; pixman_region32_init(&ps->screen_reg); - ps->ignore_tail = &ps->ignore_head; + // TODO(yshui) investigate what's the best window size + render_statistics_init(&ps->render_stats, 128); ps->o.show_all_xerrors = all_xerrors; // Use the same Display across reset, primarily for resource leak checking - ps->dpy = dpy; - ps->c = XGetXCBConnection(ps->dpy); + x_connection_init(&ps->c, dpy); + // We store width/height from screen_info instead using them directly because they + // can change, see configure_root(). + ps->root_width = ps->c.screen_info->width_in_pixels; + ps->root_height = ps->c.screen_info->height_in_pixels; const xcb_query_extension_reply_t *ext_info; - ps->previous_xerror_handler = XSetErrorHandler(xerror); - - ps->scr = DefaultScreen(ps->dpy); - - auto screen = x_screen_of_display(ps->c, ps->scr); - ps->vis = screen->root_visual; - ps->depth = screen->root_depth; - ps->root = screen->root; - ps->root_width = screen->width_in_pixels; - ps->root_height = screen->height_in_pixels; - // Start listening to events on root earlier to catch all possible // root geometry changes auto e = xcb_request_check( - ps->c, xcb_change_window_attributes_checked( - ps->c, ps->root, XCB_CW_EVENT_MASK, - (const uint32_t[]){XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | - XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY | - XCB_EVENT_MASK_PROPERTY_CHANGE})); + ps->c.c, xcb_change_window_attributes_checked( + ps->c.c, ps->c.screen_info->root, XCB_CW_EVENT_MASK, + (const uint32_t[]){XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | + XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY | + XCB_EVENT_MASK_PROPERTY_CHANGE})); if (e) { log_error_x_error(e, "Failed to setup root window event mask"); + free(e); } - xcb_prefetch_extension_data(ps->c, &xcb_render_id); - xcb_prefetch_extension_data(ps->c, &xcb_composite_id); - xcb_prefetch_extension_data(ps->c, &xcb_damage_id); - xcb_prefetch_extension_data(ps->c, &xcb_shape_id); - xcb_prefetch_extension_data(ps->c, &xcb_xfixes_id); - xcb_prefetch_extension_data(ps->c, &xcb_randr_id); - xcb_prefetch_extension_data(ps->c, &xcb_xinerama_id); - xcb_prefetch_extension_data(ps->c, &xcb_present_id); - xcb_prefetch_extension_data(ps->c, &xcb_sync_id); - xcb_prefetch_extension_data(ps->c, &xcb_glx_id); + xcb_prefetch_extension_data(ps->c.c, &xcb_render_id); + xcb_prefetch_extension_data(ps->c.c, &xcb_composite_id); + xcb_prefetch_extension_data(ps->c.c, &xcb_damage_id); + xcb_prefetch_extension_data(ps->c.c, &xcb_shape_id); + xcb_prefetch_extension_data(ps->c.c, &xcb_xfixes_id); + xcb_prefetch_extension_data(ps->c.c, &xcb_randr_id); + xcb_prefetch_extension_data(ps->c.c, &xcb_present_id); + xcb_prefetch_extension_data(ps->c.c, &xcb_sync_id); + xcb_prefetch_extension_data(ps->c.c, &xcb_glx_id); + xcb_prefetch_extension_data(ps->c.c, &xcb_dpms_id); - ext_info = xcb_get_extension_data(ps->c, &xcb_render_id); + ext_info = xcb_get_extension_data(ps->c.c, &xcb_render_id); if (!ext_info || !ext_info->present) { log_fatal("No render extension"); exit(1); @@ -1792,7 +2079,7 @@ static session_t *session_init(int argc, char **argv, Display *dpy, ps->render_event = ext_info->first_event; ps->render_error = ext_info->first_error; - ext_info = xcb_get_extension_data(ps->c, &xcb_composite_id); + ext_info = xcb_get_extension_data(ps->c.c, &xcb_composite_id); if (!ext_info || !ext_info->present) { log_fatal("No composite extension"); exit(1); @@ -1803,8 +2090,8 @@ static session_t *session_init(int argc, char **argv, Display *dpy, { xcb_composite_query_version_reply_t *reply = xcb_composite_query_version_reply( - ps->c, - xcb_composite_query_version(ps->c, XCB_COMPOSITE_MAJOR_VERSION, + ps->c.c, + xcb_composite_query_version(ps->c.c, XCB_COMPOSITE_MAJOR_VERSION, XCB_COMPOSITE_MINOR_VERSION), NULL); @@ -1816,41 +2103,47 @@ static session_t *session_init(int argc, char **argv, Display *dpy, free(reply); } - ext_info = xcb_get_extension_data(ps->c, &xcb_damage_id); + ext_info = xcb_get_extension_data(ps->c.c, &xcb_damage_id); if (!ext_info || !ext_info->present) { log_fatal("No damage extension"); exit(1); } ps->damage_event = ext_info->first_event; ps->damage_error = ext_info->first_error; - xcb_discard_reply(ps->c, xcb_damage_query_version(ps->c, XCB_DAMAGE_MAJOR_VERSION, - XCB_DAMAGE_MINOR_VERSION) - .sequence); + xcb_discard_reply(ps->c.c, xcb_damage_query_version(ps->c.c, XCB_DAMAGE_MAJOR_VERSION, + XCB_DAMAGE_MINOR_VERSION) + .sequence); - ext_info = xcb_get_extension_data(ps->c, &xcb_xfixes_id); + ext_info = xcb_get_extension_data(ps->c.c, &xcb_xfixes_id); if (!ext_info || !ext_info->present) { log_fatal("No XFixes extension"); exit(1); } ps->xfixes_event = ext_info->first_event; ps->xfixes_error = ext_info->first_error; - xcb_discard_reply(ps->c, xcb_xfixes_query_version(ps->c, XCB_XFIXES_MAJOR_VERSION, - XCB_XFIXES_MINOR_VERSION) - .sequence); + xcb_discard_reply(ps->c.c, xcb_xfixes_query_version(ps->c.c, XCB_XFIXES_MAJOR_VERSION, + XCB_XFIXES_MINOR_VERSION) + .sequence); - ps->damaged_region = x_new_id(ps->c); - if (!XCB_AWAIT_VOID(xcb_xfixes_create_region, ps->c, ps->damaged_region, 0, NULL)) { + ps->damaged_region = x_new_id(&ps->c); + if (!XCB_AWAIT_VOID(xcb_xfixes_create_region, ps->c.c, ps->damaged_region, 0, NULL)) { log_fatal("Failed to create a XFixes region"); goto err; } - ext_info = xcb_get_extension_data(ps->c, &xcb_glx_id); + ext_info = xcb_get_extension_data(ps->c.c, &xcb_glx_id); if (ext_info && ext_info->present) { ps->glx_exists = true; ps->glx_error = ext_info->first_error; ps->glx_event = ext_info->first_event; } + ext_info = xcb_get_extension_data(ps->c.c, &xcb_dpms_id); + ps->dpms_exists = ext_info && ext_info->present; + if (!ps->dpms_exists) { + log_warn("No DPMS extension"); + } + // Parse configuration file win_option_mask_t winopt_mask[NUM_WINTYPES] = {{0}}; bool shadow_enabled = false, fading_enable = false, hasneg = false; @@ -1894,7 +2187,7 @@ static session_t *session_init(int argc, char **argv, Display *dpy, "binary will not be installed in the future."); } - ps->atoms = init_atoms(ps->c); + ps->atoms = init_atoms(ps->c.c); ps->atoms_wintypes[WINTYPE_UNKNOWN] = 0; #define SET_WM_TYPE_ATOM(x) \ ps->atoms_wintypes[WINTYPE_##x] = ps->atoms->a_NET_WM_WINDOW_TYPE_##x @@ -1955,25 +2248,25 @@ static session_t *session_init(int argc, char **argv, Display *dpy, rebuild_shadow_exclude_reg(ps); // Query X Shape - ext_info = xcb_get_extension_data(ps->c, &xcb_shape_id); + ext_info = xcb_get_extension_data(ps->c.c, &xcb_shape_id); if (ext_info && ext_info->present) { ps->shape_event = ext_info->first_event; ps->shape_error = ext_info->first_error; ps->shape_exists = true; } - ext_info = xcb_get_extension_data(ps->c, &xcb_randr_id); + ext_info = xcb_get_extension_data(ps->c.c, &xcb_randr_id); if (ext_info && ext_info->present) { ps->randr_exists = true; ps->randr_event = ext_info->first_event; ps->randr_error = ext_info->first_error; } - ext_info = xcb_get_extension_data(ps->c, &xcb_present_id); + ext_info = xcb_get_extension_data(ps->c.c, &xcb_present_id); if (ext_info && ext_info->present) { auto r = xcb_present_query_version_reply( - ps->c, - xcb_present_query_version(ps->c, XCB_PRESENT_MAJOR_VERSION, + ps->c.c, + xcb_present_query_version(ps->c.c, XCB_PRESENT_MAJOR_VERSION, XCB_PRESENT_MINOR_VERSION), NULL); if (r) { @@ -1983,14 +2276,14 @@ static session_t *session_init(int argc, char **argv, Display *dpy, } // Query X Sync - ext_info = xcb_get_extension_data(ps->c, &xcb_sync_id); + ext_info = xcb_get_extension_data(ps->c.c, &xcb_sync_id); if (ext_info && ext_info->present) { ps->xsync_error = ext_info->first_error; ps->xsync_event = ext_info->first_event; // Need X Sync 3.1 for fences auto r = xcb_sync_initialize_reply( - ps->c, - xcb_sync_initialize(ps->c, XCB_SYNC_MAJOR_VERSION, XCB_SYNC_MINOR_VERSION), + ps->c.c, + xcb_sync_initialize(ps->c.c, XCB_SYNC_MAJOR_VERSION, XCB_SYNC_MINOR_VERSION), NULL); if (r && (r->major_version > 3 || (r->major_version == 3 && r->minor_version >= 1))) { @@ -2001,9 +2294,10 @@ static session_t *session_init(int argc, char **argv, Display *dpy, ps->sync_fence = XCB_NONE; if (ps->xsync_exists) { - ps->sync_fence = x_new_id(ps->c); + ps->sync_fence = x_new_id(&ps->c); e = xcb_request_check( - ps->c, xcb_sync_create_fence(ps->c, ps->root, ps->sync_fence, 0)); + ps->c.c, xcb_sync_create_fence_checked( + ps->c.c, ps->c.screen_info->root, ps->sync_fence, 0)); if (e) { if (ps->o.xrender_sync_fence) { log_error_x_error(e, "Failed to create a XSync fence. " @@ -2021,18 +2315,10 @@ static session_t *session_init(int argc, char **argv, Display *dpy, } // Query X RandR - if (ps->o.xinerama_shadow_crop) { - if (!ps->randr_exists) { - log_fatal("No XRandR extension. xinerama-shadow-crop cannot be " - "enabled."); - goto err; - } - } - - // Query X Xinerama extension - if (ps->o.xinerama_shadow_crop) { - ext_info = xcb_get_extension_data(ps->c, &xcb_xinerama_id); - ps->xinerama_exists = ext_info && ext_info->present; + if (ps->o.crop_shadow_to_monitor && !ps->randr_exists) { + log_fatal("No X RandR extension. crop-shadow-to-monitor cannot be " + "enabled."); + goto err; } rebuild_screen_reg(ps); @@ -2088,7 +2374,7 @@ static session_t *session_init(int argc, char **argv, Display *dpy, } } - ps->drivers = detect_driver(ps->c, ps->backend_data, ps->root); + ps->drivers = detect_driver(ps->c.c, ps->backend_data, ps->c.screen_info->root); apply_driver_workarounds(ps, ps->drivers); // Initialize filters, must be preceded by OpenGL context creation @@ -2127,31 +2413,34 @@ static session_t *session_init(int argc, char **argv, Display *dpy, } // Monitor screen changes if vsync_sw is enabled and we are using - // an auto-detected refresh rate, or when Xinerama features are enabled - if (ps->randr_exists && ps->o.xinerama_shadow_crop) { - xcb_randr_select_input(ps->c, ps->root, XCB_RANDR_NOTIFY_MASK_SCREEN_CHANGE); + // an auto-detected refresh rate, or when X RandR features are enabled + if (ps->randr_exists && ps->o.crop_shadow_to_monitor) { + xcb_randr_select_input(ps->c.c, ps->c.screen_info->root, + XCB_RANDR_NOTIFY_MASK_SCREEN_CHANGE); + x_update_monitors(&ps->c, &ps->monitors); } - cxinerama_upd_scrs(ps); - { xcb_render_create_picture_value_list_t pa = { .subwindowmode = IncludeInferiors, }; ps->root_picture = x_create_picture_with_visual_and_pixmap( - ps->c, ps->vis, ps->root, XCB_RENDER_CP_SUBWINDOW_MODE, &pa); + &ps->c, ps->c.screen_info->root_visual, ps->c.screen_info->root, + XCB_RENDER_CP_SUBWINDOW_MODE, &pa); if (ps->overlay != XCB_NONE) { ps->tgt_picture = x_create_picture_with_visual_and_pixmap( - ps->c, ps->vis, ps->overlay, XCB_RENDER_CP_SUBWINDOW_MODE, &pa); - } else + &ps->c, ps->c.screen_info->root_visual, ps->overlay, + XCB_RENDER_CP_SUBWINDOW_MODE, &pa); + } else { ps->tgt_picture = ps->root_picture; + } } - ev_io_init(&ps->xiow, x_event_callback, ConnectionNumber(ps->dpy), EV_READ); + ev_io_init(&ps->xiow, x_event_callback, ConnectionNumber(ps->c.dpy), EV_READ); ev_io_start(ps->loop, &ps->xiow); ev_init(&ps->unredir_timer, tmout_unredir_callback); - ev_idle_init(&ps->draw_idle, draw_callback); + ev_init(&ps->draw_timer, draw_callback); ev_init(&ps->fade_timer, fade_timer_callback); @@ -2185,7 +2474,7 @@ static session_t *session_init(int argc, char **argv, Display *dpy, // functions if (ps->o.dbus) { #ifdef CONFIG_DBUS - cdbus_init(ps, DisplayString(ps->dpy)); + cdbus_init(ps, DisplayString(ps->c.dpy)); if (!ps->dbus_data) { ps->o.dbus = false; } @@ -2195,7 +2484,7 @@ static session_t *session_init(int argc, char **argv, Display *dpy, #endif } - e = xcb_request_check(ps->c, xcb_grab_server_checked(ps->c)); + e = xcb_request_check(ps->c.c, xcb_grab_server_checked(ps->c.c)); if (e) { log_fatal_x_error(e, "Failed to grab X server"); free(e); @@ -2208,12 +2497,12 @@ static session_t *session_init(int argc, char **argv, Display *dpy, // earlier is irrelavant at this point. // A better solution is probably grabbing the server from the very start. But I // think there still could be race condition that mandates discarding the events. - x_discard_events(ps->c); + x_discard_events(&ps->c); - xcb_query_tree_reply_t *query_tree_reply = - xcb_query_tree_reply(ps->c, xcb_query_tree(ps->c, ps->root), NULL); + xcb_query_tree_reply_t *query_tree_reply = xcb_query_tree_reply( + ps->c.c, xcb_query_tree(ps->c.c, ps->c.screen_info->root), NULL); - e = xcb_request_check(ps->c, xcb_ungrab_server(ps->c)); + e = xcb_request_check(ps->c.c, xcb_ungrab_server_checked(ps->c.c)); if (e) { log_fatal_x_error(e, "Failed to ungrab server"); free(e); @@ -2254,6 +2543,36 @@ static session_t *session_init(int argc, char **argv, Display *dpy, return NULL; } +/// Switch to real-time scheduling policy (SCHED_RR) if possible +/// +/// Make picom realtime to reduce latency, and make rendering times more predictable to +/// help pacing. +/// +/// This requires the user to set up permissions for the real-time scheduling. e.g. by +/// setting `ulimit -r`, or giving us the CAP_SYS_NICE capability. +void set_rr_scheduling(void) { + int priority = sched_get_priority_min(SCHED_RR); + + int ret; + struct sched_param param; + + ret = sched_getparam(0, ¶m); + if (ret != 0) { + log_debug("Failed to get old scheduling priority"); + return; + } + + param.sched_priority = priority; + ret = sched_setscheduler(0, SCHED_RR, ¶m); + if (ret != 0) { + log_info("Failed to set real-time scheduling priority to %d. Consider " + "giving picom the CAP_SYS_NICE capability", + priority); + return; + } + log_info("Set real-time scheduling priority to %d", priority); +} + /** * Destroy a session. * @@ -2276,7 +2595,7 @@ static void session_destroy(session_t *ps) { ps->file_watch_handle = NULL; // Stop listening to events on root window - xcb_change_window_attributes(ps->c, ps->root, XCB_CW_EVENT_MASK, + xcb_change_window_attributes(ps->c.c, ps->c.screen_info->root, XCB_CW_EVENT_MASK, (const uint32_t[]){0}); #ifdef CONFIG_DBUS @@ -2327,30 +2646,17 @@ static void session_destroy(session_t *ps) { ps->track_atom_lst = NULL; } - // Free ignore linked list - { - ignore_t *next = NULL; - for (ignore_t *ign = ps->ignore_head; ign; ign = next) { - next = ign->next; - - free(ign); - } - - // Reset head and tail - ps->ignore_head = NULL; - ps->ignore_tail = &ps->ignore_head; - } - // Free tgt_{buffer,picture} and root_picture - if (ps->tgt_buffer.pict == ps->tgt_picture) + if (ps->tgt_buffer.pict == ps->tgt_picture) { ps->tgt_buffer.pict = XCB_NONE; + } - if (ps->tgt_picture == ps->root_picture) - ps->tgt_picture = XCB_NONE; - else - free_picture(ps->c, &ps->tgt_picture); + if (ps->tgt_picture != ps->root_picture) { + x_free_picture(&ps->c, ps->tgt_picture); + } + x_free_picture(&ps->c, ps->root_picture); + ps->tgt_picture = ps->root_picture = XCB_NONE; - free_picture(ps->c, &ps->root_picture); free_paint(ps, &ps->tgt_buffer); pixman_region32_fini(&ps->screen_reg); @@ -2363,7 +2669,9 @@ static void session_destroy(session_t *ps) { } free(ps->o.blur_kerns); free(ps->o.glx_fshader_win_str); - free_xinerama_info(ps); + x_free_monitor_info(&ps->monitors); + + render_statistics_destroy(&ps->render_stats); // Release custom window shaders free(ps->o.window_shader_fg); @@ -2386,28 +2694,28 @@ static void session_destroy(session_t *ps) { // Release overlay window if (ps->overlay) { - xcb_composite_release_overlay_window(ps->c, ps->overlay); + xcb_composite_release_overlay_window(ps->c.c, ps->overlay); ps->overlay = XCB_NONE; } if (ps->sync_fence != XCB_NONE) { - xcb_sync_destroy_fence(ps->c, ps->sync_fence); + xcb_sync_destroy_fence(ps->c.c, ps->sync_fence); ps->sync_fence = XCB_NONE; } // Free reg_win if (ps->reg_win != XCB_NONE) { - xcb_destroy_window(ps->c, ps->reg_win); + xcb_destroy_window(ps->c.c, ps->reg_win); ps->reg_win = XCB_NONE; } if (ps->debug_window != XCB_NONE) { - xcb_destroy_window(ps->c, ps->debug_window); + xcb_destroy_window(ps->c.c, ps->debug_window); ps->debug_window = XCB_NONE; } if (ps->damaged_region != XCB_NONE) { - xcb_xfixes_destroy_region(ps->c, ps->damaged_region); + xcb_xfixes_destroy_region(ps->c.c, ps->damaged_region); ps->damaged_region = XCB_NONE; } @@ -2426,7 +2734,7 @@ static void session_destroy(session_t *ps) { #endif // Flush all events - x_sync(ps->c); + x_sync(&ps->c); ev_io_stop(ps->loop, &ps->xiow); if (ps->o.legacy_backends) { free_conv((conv *)ps->shadow_context); @@ -2438,15 +2746,15 @@ static void session_destroy(session_t *ps) { xrc_report_xid(); #endif - XSetErrorHandler(ps->previous_xerror_handler); - // Stop libev event handlers ev_timer_stop(ps->loop, &ps->unredir_timer); ev_timer_stop(ps->loop, &ps->fade_timer); - ev_idle_stop(ps->loop, &ps->draw_idle); + ev_timer_stop(ps->loop, &ps->draw_timer); ev_prepare_stop(ps->loop, &ps->event_check); ev_signal_stop(ps->loop, &ps->usr1_signal); ev_signal_stop(ps->loop, &ps->int_signal); + + free_x_connection(&ps->c); } /** @@ -2455,9 +2763,11 @@ static void session_destroy(session_t *ps) { * @param ps current session */ static void session_run(session_t *ps) { - // In benchmark mode, we want draw_idle handler to always be active + set_rr_scheduling(); + // In benchmark mode, we want draw_timer handler to always be active if (ps->o.benchmark) { - ev_idle_start(ps->loop, &ps->draw_idle); + ev_timer_set(&ps->draw_timer, 0, 0); + ev_timer_start(ps->loop, &ps->draw_timer); } else { // Let's draw our first frame! queue_redraw(ps); @@ -2511,10 +2821,9 @@ int main(int argc, char **argv) { // Failed to read, the child has most likely died // We can probably waitpid() here. return 1; - } else { - // We are done - return 0; } + // We are done + return 0; } // We are the child close(pfds[0]); @@ -2559,7 +2868,11 @@ int main(int argc, char **argv) { // Notify the parent that we are done. This might cause the parent // to quit, so only do this after setsid() int tmp = 1; - write(pfds[1], &tmp, sizeof tmp); + if (write(pfds[1], &tmp, sizeof tmp) != sizeof tmp) { + log_fatal("Failed to notify parent process"); + ret_code = 1; + break; + } close(pfds[1]); // We only do this once need_fork = false; diff --git a/src/picom.h b/src/picom.h index 7ee289bd00..d42ae04208 100644 --- a/src/picom.h +++ b/src/picom.h @@ -42,11 +42,9 @@ void circulate_win(session_t *ps, xcb_circulate_notify_event_t *ce); void root_damaged(session_t *ps); -void cxinerama_upd_scrs(session_t *ps); - void queue_redraw(session_t *ps); -void discard_ignore(session_t *ps, unsigned long sequence); +void discard_pending(session_t *ps, uint32_t sequence); void set_root_flags(session_t *ps, uint64_t flags); @@ -62,9 +60,11 @@ uint8_t session_redirection_mode(session_t *ps); static inline void wintype_arr_enable_unset(switch_t arr[]) { wintype_t i; - for (i = 0; i < NUM_WINTYPES; ++i) - if (UNSET == arr[i]) + for (i = 0; i < NUM_WINTYPES; ++i) { + if (UNSET == arr[i]) { arr[i] = ON; + } + } } /** @@ -96,7 +96,7 @@ free_win_res_glx(session_t *ps attr_unused, struct managed_win *w attr_unused) { * Dump an drawable's info. */ static inline void dump_drawable(session_t *ps, xcb_drawable_t drawable) { - auto r = xcb_get_geometry_reply(ps->c, xcb_get_geometry(ps->c, drawable), NULL); + auto r = xcb_get_geometry_reply(ps->c.c, xcb_get_geometry(ps->c.c, drawable), NULL); if (!r) { log_trace("Drawable %#010x: Failed", drawable); return; diff --git a/src/region.h b/src/region.h index bda66e237c..770f6992a6 100644 --- a/src/region.h +++ b/src/region.h @@ -23,9 +23,10 @@ static inline void dump_region(const region_t *x) { int nrects; const rect_t *rects = pixman_region32_rectangles((region_t *)x, &nrects); log_trace("nrects: %d", nrects); - for (int i = 0; i < nrects; i++) + for (int i = 0; i < nrects; i++) { log_trace("(%d, %d) - (%d, %d)", rects[i].x1, rects[i].y1, rects[i].x2, rects[i].y2); + } } /// Convert one xcb rectangle to our rectangle type @@ -51,8 +52,7 @@ static inline rect_t *from_x_rects(int nrects, const xcb_rectangle_t *rects) { /** * Resize a region. */ -static inline void _resize_region(const region_t *region, region_t *output, int dx, - int dy) { +static inline void _resize_region(const region_t *region, region_t *output, int dx, int dy) { if (!region || !output) { return; } @@ -77,8 +77,7 @@ static inline void _resize_region(const region_t *region, region_t *output, int if (wid <= 0 || hei <= 0) { continue; } - newrects[nnewrects] = - (rect_t){.x1 = x1, .x2 = x2, .y1 = y1, .y2 = y2}; + newrects[nnewrects] = (rect_t){.x1 = x1, .x2 = x2, .y1 = y1, .y2 = y2}; ++nnewrects; } diff --git a/src/render.c b/src/render.c index db627de303..ec50d8a3ec 100644 --- a/src/render.c +++ b/src/render.c @@ -48,20 +48,20 @@ static inline bool paint_bind_tex(session_t *ps, paint_t *ppaint, int wid, int h bool repeat, int depth, xcb_visualid_t visual, bool force) { #ifdef CONFIG_OPENGL // XXX This is a mess. But this will go away after the backend refactor. - if (!ppaint->pixmap) + if (!ppaint->pixmap) { return false; + } struct glx_fbconfig_info *fbcfg; if (!visual) { assert(depth == 32); if (!ps->argb_fbconfig) { - ps->argb_fbconfig = - glx_find_fbconfig(ps->dpy, ps->scr, - (struct xvisual_info){.red_size = 8, - .green_size = 8, - .blue_size = 8, - .alpha_size = 8, - .visual_depth = 32}); + ps->argb_fbconfig = glx_find_fbconfig( + &ps->c, (struct xvisual_info){.red_size = 8, + .green_size = 8, + .blue_size = 8, + .alpha_size = 8, + .visual_depth = 32}); } if (!ps->argb_fbconfig) { log_error("Failed to find appropriate FBConfig for 32 bit depth"); @@ -69,7 +69,7 @@ static inline bool paint_bind_tex(session_t *ps, paint_t *ppaint, int wid, int h } fbcfg = ps->argb_fbconfig; } else { - auto m = x_get_visual_info(ps->c, visual); + auto m = x_get_visual_info(&ps->c, visual); if (m.visual_depth < 0) { return false; } @@ -80,7 +80,7 @@ static inline bool paint_bind_tex(session_t *ps, paint_t *ppaint, int wid, int h } if (!ppaint->fbcfg) { - ppaint->fbcfg = glx_find_fbconfig(ps->dpy, ps->scr, m); + ppaint->fbcfg = glx_find_fbconfig(&ps->c, m); } if (!ppaint->fbcfg) { log_error("Failed to find appropriate FBConfig for X pixmap"); @@ -89,9 +89,10 @@ static inline bool paint_bind_tex(session_t *ps, paint_t *ppaint, int wid, int h fbcfg = ppaint->fbcfg; } - if (force || !glx_tex_binded(ppaint->ptex, ppaint->pixmap)) + if (force || !glx_tex_binded(ppaint->ptex, ppaint->pixmap)) { return glx_bind_pixmap(ps, &ppaint->ptex, ppaint->pixmap, wid, hei, repeat, fbcfg); + } #else (void)ps; (void)ppaint; @@ -129,7 +130,7 @@ static int get_buffer_age(session_t *ps) { } if (ps->o.use_damage) { unsigned int val; - glXQueryDrawable(ps->dpy, get_tgt_window(ps), + glXQueryDrawable(ps->c.dpy, get_tgt_window(ps), GLX_BACK_BUFFER_AGE_EXT, &val); return (int)val ?: -1; } @@ -144,7 +145,7 @@ static int get_buffer_age(session_t *ps) { */ static inline void xrfilter_reset(session_t *ps, xcb_render_picture_t p) { #define FILTER "Nearest" - xcb_render_set_picture_filter(ps->c, p, strlen(FILTER), FILTER, 0, NULL); + xcb_render_set_picture_filter(ps->c.c, p, strlen(FILTER), FILTER, 0, NULL); #undef FILTER } @@ -153,7 +154,7 @@ static inline void attr_nonnull(1, 2) set_tgt_clip(session_t *ps, region_t *reg) switch (ps->o.backend) { case BKEND_XRENDER: case BKEND_XR_GLX_HYBRID: - x_set_picture_clip_region(ps->c, ps->tgt_buffer.pict, 0, 0, reg); + x_set_picture_clip_region(&ps->c, ps->tgt_buffer.pict, 0, 0, reg); break; #ifdef CONFIG_OPENGL case BKEND_GLX: glx_set_clip(ps, reg); break; @@ -162,16 +163,6 @@ static inline void attr_nonnull(1, 2) set_tgt_clip(session_t *ps, region_t *reg) } } -/** - * Destroy a Picture. - */ -void free_picture(xcb_connection_t *c, xcb_render_picture_t *p) { - if (*p) { - xcb_render_free_picture(c, *p); - *p = XCB_NONE; - } -} - /** * Free paint_t. */ @@ -179,10 +170,14 @@ void free_paint(session_t *ps, paint_t *ppaint) { #ifdef CONFIG_OPENGL free_paint_glx(ps, ppaint); #endif - free_picture(ps->c, &ppaint->pict); - if (ppaint->pixmap) - xcb_free_pixmap(ps->c, ppaint->pixmap); - ppaint->pixmap = XCB_NONE; + if (ppaint->pict != XCB_NONE) { + x_free_picture(&ps->c, ppaint->pict); + ppaint->pict = XCB_NONE; + } + if (ppaint->pixmap) { + xcb_free_pixmap(ps->c.c, ppaint->pixmap); + ppaint->pixmap = XCB_NONE; + } } uint32_t @@ -253,8 +248,7 @@ void render(session_t *ps, int x, int y, int dx, int dy, int wid, int hei, int f if (alpha_step != 0) { if (cr) { xcb_render_picture_t p_tmp = x_create_picture_with_standard( - ps->c, ps->root, fullwid, fullhei, - XCB_PICT_STANDARD_ARGB_32, 0, 0); + &ps->c, fullwid, fullhei, XCB_PICT_STANDARD_ARGB_32, 0, 0); xcb_render_color_t trans = { .red = 0, .blue = 0, .green = 0, .alpha = 0}; const xcb_rectangle_t rect = { @@ -262,7 +256,7 @@ void render(session_t *ps, int x, int y, int dx, int dy, int wid, int hei, int f .y = 0, .width = to_u16_checked(fullwid), .height = to_u16_checked(fullhei)}; - xcb_render_fill_rectangles(ps->c, XCB_RENDER_PICT_OP_SRC, + xcb_render_fill_rectangles(ps->c.c, XCB_RENDER_PICT_OP_SRC, p_tmp, trans, 1, &rect); uint32_t max_ntraps = to_u32_checked(cr); @@ -272,25 +266,24 @@ void render(session_t *ps, int x, int y, int dx, int dy, int wid, int hei, int f traps, max_ntraps, cr, fullwid, fullhei); xcb_render_trapezoids( - ps->c, XCB_RENDER_PICT_OP_OVER, alpha_pict, p_tmp, - x_get_pictfmt_for_standard(ps->c, XCB_PICT_STANDARD_A_8), + ps->c.c, XCB_RENDER_PICT_OP_OVER, alpha_pict, p_tmp, + x_get_pictfmt_for_standard(&ps->c, XCB_PICT_STANDARD_A_8), 0, 0, n, traps); xcb_render_composite( - ps->c, XCB_RENDER_PICT_OP_OVER, pict, p_tmp, + ps->c.c, XCB_RENDER_PICT_OP_OVER, pict, p_tmp, ps->tgt_buffer.pict, to_i16_checked(x), to_i16_checked(y), to_i16_checked(x), to_i16_checked(y), to_i16_checked(dx), to_i16_checked(dy), to_u16_checked(wid), to_u16_checked(hei)); - xcb_render_free_picture(ps->c, p_tmp); + x_free_picture(&ps->c, p_tmp); } else { xcb_render_picture_t p_tmp = alpha_pict; if (clip) { p_tmp = x_create_picture_with_standard( - ps->c, ps->root, wid, hei, - XCB_PICT_STANDARD_ARGB_32, 0, 0); + &ps->c, wid, hei, XCB_PICT_STANDARD_ARGB_32, 0, 0); xcb_render_color_t black = { .red = 255, .blue = 255, .green = 255, .alpha = 255}; @@ -299,17 +292,18 @@ void render(session_t *ps, int x, int y, int dx, int dy, int wid, int hei, int f .y = 0, .width = to_u16_checked(wid), .height = to_u16_checked(hei)}; - xcb_render_fill_rectangles(ps->c, XCB_RENDER_PICT_OP_SRC, + xcb_render_fill_rectangles(ps->c.c, + XCB_RENDER_PICT_OP_SRC, p_tmp, black, 1, &rect); if (alpha_pict) { xcb_render_composite( - ps->c, XCB_RENDER_PICT_OP_SRC, + ps->c.c, XCB_RENDER_PICT_OP_SRC, alpha_pict, XCB_NONE, p_tmp, 0, 0, 0, 0, 0, 0, to_u16_checked(wid), to_u16_checked(hei)); } xcb_render_composite( - ps->c, XCB_RENDER_PICT_OP_OUT_REVERSE, + ps->c.c, XCB_RENDER_PICT_OP_OUT_REVERSE, clip->pict, XCB_NONE, p_tmp, 0, 0, 0, 0, to_i16_checked(clip->x), to_i16_checked(clip->y), to_u16_checked(wid), to_u16_checked(hei)); @@ -319,12 +313,12 @@ void render(session_t *ps, int x, int y, int dx, int dy, int wid, int hei, int f : XCB_RENDER_PICT_OP_OVER); xcb_render_composite( - ps->c, op, pict, p_tmp, ps->tgt_buffer.pict, + ps->c.c, op, pict, p_tmp, ps->tgt_buffer.pict, to_i16_checked(x), to_i16_checked(y), 0, 0, to_i16_checked(dx), to_i16_checked(dy), to_u16_checked(wid), to_u16_checked(hei)); if (clip) { - xcb_render_free_picture(ps->c, p_tmp); + x_free_picture(&ps->c, p_tmp); } } } @@ -375,15 +369,18 @@ paint_region(session_t *ps, const struct managed_win *w, int x, int y, int wid, static inline bool paint_isvalid(session_t *ps, const paint_t *ppaint) { // Don't check for presence of Pixmap here, because older X Composite doesn't // provide it - if (!ppaint) + if (!ppaint) { return false; + } - if (bkend_use_xrender(ps) && !ppaint->pict) + if (bkend_use_xrender(ps) && !ppaint->pict) { return false; + } #ifdef CONFIG_OPENGL - if (BKEND_GLX == ps->o.backend && !glx_tex_binded(ppaint->ptex, XCB_NONE)) + if (BKEND_GLX == ps->o.backend && !glx_tex_binded(ppaint->ptex, XCB_NONE)) { return false; + } #endif return true; @@ -395,9 +392,9 @@ static inline bool paint_isvalid(session_t *ps, const paint_t *ppaint) { void paint_one(session_t *ps, struct managed_win *w, const region_t *reg_paint) { // Fetch Pixmap if (!w->paint.pixmap) { - w->paint.pixmap = x_new_id(ps->c); - set_ignore_cookie(ps, xcb_composite_name_window_pixmap(ps->c, w->base.id, - w->paint.pixmap)); + w->paint.pixmap = x_new_id(&ps->c); + set_ignore_cookie(&ps->c, xcb_composite_name_window_pixmap( + ps->c.c, w->base.id, w->paint.pixmap)); } xcb_drawable_t draw = w->paint.pixmap; @@ -415,7 +412,7 @@ void paint_one(session_t *ps, struct managed_win *w, const region_t *reg_paint) }; w->paint.pict = x_create_picture_with_pictfmt_and_pixmap( - ps->c, w->pictfmt, draw, XCB_RENDER_CP_SUBWINDOW_MODE, &pa); + &ps->c, w->pictfmt, draw, XCB_RENDER_CP_SUBWINDOW_MODE, &pa); } // GLX: Build texture @@ -442,8 +439,8 @@ void paint_one(session_t *ps, struct managed_win *w, const region_t *reg_paint) // Invert window color, if required if (bkend_use_xrender(ps) && w->invert_color) { - xcb_render_picture_t newpict = x_create_picture_with_pictfmt( - ps->c, ps->root, wid, hei, w->pictfmt, 0, NULL); + xcb_render_picture_t newpict = + x_create_picture_with_pictfmt(&ps->c, wid, hei, w->pictfmt, 0, NULL); if (newpict) { // Apply clipping region to save some CPU if (reg_paint) { @@ -456,17 +453,18 @@ void paint_one(session_t *ps, struct managed_win *w, const region_t *reg_paint) pixman_region32_fini(®); } - xcb_render_composite(ps->c, XCB_RENDER_PICT_OP_SRC, pict, XCB_NONE, - newpict, 0, 0, 0, 0, 0, 0, wid, hei); - xcb_render_composite(ps->c, XCB_RENDER_PICT_OP_DIFFERENCE, + xcb_render_composite(ps->c.c, XCB_RENDER_PICT_OP_SRC, pict, + XCB_NONE, newpict, 0, 0, 0, 0, 0, 0, wid, hei); + xcb_render_composite(ps->c.c, XCB_RENDER_PICT_OP_DIFFERENCE, ps->white_picture, XCB_NONE, newpict, 0, 0, 0, 0, 0, 0, wid, hei); // We use an extra PictOpInReverse operation to get correct // pixel alpha. There could be a better solution. - if (win_has_alpha(w)) - xcb_render_composite(ps->c, XCB_RENDER_PICT_OP_IN_REVERSE, + if (win_has_alpha(w)) { + xcb_render_composite(ps->c.c, XCB_RENDER_PICT_OP_IN_REVERSE, pict, XCB_NONE, newpict, 0, 0, 0, 0, 0, 0, wid, hei); + } pict = newpict; } } @@ -476,10 +474,10 @@ void paint_one(session_t *ps, struct managed_win *w, const region_t *reg_paint) } else { // Painting parameters const margin_t extents = win_calc_frame_extents(w); - const auto t = extents.top; - const auto l = extents.left; - const auto b = extents.bottom; - const auto r = extents.right; + auto const t = extents.top; + auto const l = extents.left; + auto const b = extents.bottom; + auto const r = extents.right; #define COMP_BDR(cx, cy, cwid, chei) \ paint_region(ps, w, (cx), (cy), (cwid), (chei), w->frame_opacity * w->opacity, \ @@ -494,43 +492,51 @@ void paint_one(session_t *ps, struct managed_win *w, const region_t *reg_paint) // ctop = checked top // Make sure top margin is smaller than height int ctop = min2(body_height, t); - if (ctop > 0) + if (ctop > 0) { COMP_BDR(0, 0, wid, ctop); + } body_height -= ctop; - if (body_height <= 0) + if (body_height <= 0) { break; + } // bottom // cbot = checked bottom // Make sure bottom margin is not too large int cbot = min2(body_height, b); - if (cbot > 0) + if (cbot > 0) { COMP_BDR(0, hei - cbot, wid, cbot); + } // Height of window exclude the margin body_height -= cbot; - if (body_height <= 0) + if (body_height <= 0) { break; + } // left int body_width = wid; int cleft = min2(body_width, l); - if (cleft > 0) + if (cleft > 0) { COMP_BDR(0, ctop, cleft, body_height); + } body_width -= cleft; - if (body_width <= 0) + if (body_width <= 0) { break; + } // right int cright = min2(body_width, r); - if (cright > 0) + if (cright > 0) { COMP_BDR(wid - cright, ctop, cright, body_height); + } body_width -= cright; - if (body_width <= 0) + if (body_width <= 0) { break; + } // body paint_region(ps, w, cleft, ctop, body_width, body_height, @@ -540,14 +546,17 @@ void paint_one(session_t *ps, struct managed_win *w, const region_t *reg_paint) #undef COMP_BDR - if (pict != w->paint.pict) - free_picture(ps->c, &pict); + if (pict != w->paint.pict) { + x_free_picture(&ps->c, pict); + pict = XCB_NONE; + } // Dimming the window if needed if (w->dim) { double dim_opacity = ps->o.inactive_dim; - if (!ps->o.inactive_dim_fixed) + if (!ps->o.inactive_dim_fixed) { dim_opacity *= w->opacity; + } switch (ps->o.backend) { case BKEND_XRENDER: @@ -569,7 +578,7 @@ void paint_one(session_t *ps, struct managed_win *w, const region_t *reg_paint) .height = hei, }; - xcb_render_fill_rectangles(ps->c, XCB_RENDER_PICT_OP_OVER, + xcb_render_fill_rectangles(ps->c.c, XCB_RENDER_PICT_OP_OVER, ps->tgt_buffer.pict, color, 1, &rect); } break; #ifdef CONFIG_OPENGL @@ -583,8 +592,6 @@ void paint_one(session_t *ps, struct managed_win *w, const region_t *reg_paint) } } -extern const char *background_props_str[]; - static bool get_root_tile(session_t *ps) { /* if (ps->o.paint_on_overlay) { @@ -595,15 +602,17 @@ static bool get_root_tile(session_t *ps) { ps->root_tile_fill = false; bool fill = false; - xcb_pixmap_t pixmap = x_get_root_back_pixmap(ps->c, ps->root, ps->atoms); + xcb_pixmap_t pixmap = x_get_root_back_pixmap(&ps->c, ps->atoms); // Make sure the pixmap we got is valid - if (pixmap && !x_validate_pixmap(ps->c, pixmap)) + if (pixmap && !x_validate_pixmap(&ps->c, pixmap)) { pixmap = XCB_NONE; + } // Create a pixmap if there isn't any if (!pixmap) { - pixmap = x_create_pixmap(ps->c, (uint8_t)ps->depth, ps->root, 1, 1); + pixmap = + x_create_pixmap(&ps->c, (uint8_t)ps->c.screen_info->root_depth, 1, 1); if (pixmap == XCB_NONE) { log_error("Failed to create pixmaps for root tile."); return false; @@ -616,7 +625,7 @@ static bool get_root_tile(session_t *ps) { .repeat = true, }; ps->root_tile_paint.pict = x_create_picture_with_visual_and_pixmap( - ps->c, ps->vis, pixmap, XCB_RENDER_CP_REPEAT, &pa); + &ps->c, ps->c.screen_info->root_visual, pixmap, XCB_RENDER_CP_REPEAT, &pa); // Fill pixmap if needed if (fill) { @@ -629,15 +638,17 @@ static bool get_root_tile(session_t *ps) { rect.x = rect.y = 0; rect.width = rect.height = 1; - xcb_render_fill_rectangles(ps->c, XCB_RENDER_PICT_OP_SRC, + xcb_render_fill_rectangles(ps->c.c, XCB_RENDER_PICT_OP_SRC, ps->root_tile_paint.pict, col, 1, &rect); } ps->root_tile_fill = fill; ps->root_tile_paint.pixmap = pixmap; #ifdef CONFIG_OPENGL - if (BKEND_GLX == ps->o.backend) - return paint_bind_tex(ps, &ps->root_tile_paint, 0, 0, true, 0, ps->vis, false); + if (BKEND_GLX == ps->o.backend) { + return paint_bind_tex(ps, &ps->root_tile_paint, 0, 0, true, 0, + ps->c.screen_info->root_visual, false); + } #endif return true; @@ -670,16 +681,16 @@ static bool win_build_shadow(session_t *ps, struct managed_win *w, double opacit xcb_render_picture_t shadow_picture = XCB_NONE, shadow_picture_argb = XCB_NONE; xcb_gcontext_t gc = XCB_NONE; - shadow_image = make_shadow(ps->c, (conv *)ps->shadow_context, opacity, width, height); + shadow_image = + make_shadow(&ps->c, (conv *)ps->shadow_context, opacity, width, height); if (!shadow_image) { log_error("failed to make shadow"); return XCB_NONE; } - shadow_pixmap = - x_create_pixmap(ps->c, 8, ps->root, shadow_image->width, shadow_image->height); + shadow_pixmap = x_create_pixmap(&ps->c, 8, shadow_image->width, shadow_image->height); shadow_pixmap_argb = - x_create_pixmap(ps->c, 32, ps->root, shadow_image->width, shadow_image->height); + x_create_pixmap(&ps->c, 32, shadow_image->width, shadow_image->height); if (!shadow_pixmap || !shadow_pixmap_argb) { log_error("failed to create shadow pixmaps"); @@ -687,18 +698,18 @@ static bool win_build_shadow(session_t *ps, struct managed_win *w, double opacit } shadow_picture = x_create_picture_with_standard_and_pixmap( - ps->c, XCB_PICT_STANDARD_A_8, shadow_pixmap, 0, NULL); + &ps->c, XCB_PICT_STANDARD_A_8, shadow_pixmap, 0, NULL); shadow_picture_argb = x_create_picture_with_standard_and_pixmap( - ps->c, XCB_PICT_STANDARD_ARGB_32, shadow_pixmap_argb, 0, NULL); + &ps->c, XCB_PICT_STANDARD_ARGB_32, shadow_pixmap_argb, 0, NULL); if (!shadow_picture || !shadow_picture_argb) { goto shadow_picture_err; } - gc = x_new_id(ps->c); - xcb_create_gc(ps->c, gc, shadow_pixmap, 0, NULL); + gc = x_new_id(&ps->c); + xcb_create_gc(ps->c.c, gc, shadow_pixmap, 0, NULL); - xcb_image_put(ps->c, shadow_pixmap, gc, shadow_image, 0, 0, 0); - xcb_render_composite(ps->c, XCB_RENDER_PICT_OP_SRC, ps->cshadow_picture, + xcb_image_put(ps->c.c, shadow_pixmap, gc, shadow_image, 0, 0, 0); + xcb_render_composite(ps->c.c, XCB_RENDER_PICT_OP_SRC, ps->cshadow_picture, shadow_picture, shadow_picture_argb, 0, 0, 0, 0, 0, 0, shadow_image->width, shadow_image->height); @@ -707,26 +718,32 @@ static bool win_build_shadow(session_t *ps, struct managed_win *w, double opacit assert(!w->shadow_paint.pict); w->shadow_paint.pict = shadow_picture_argb; - xcb_free_gc(ps->c, gc); + xcb_free_gc(ps->c.c, gc); xcb_image_destroy(shadow_image); - xcb_free_pixmap(ps->c, shadow_pixmap); - xcb_render_free_picture(ps->c, shadow_picture); + xcb_free_pixmap(ps->c.c, shadow_pixmap); + x_free_picture(&ps->c, shadow_picture); return true; shadow_picture_err: - if (shadow_image) + if (shadow_image) { xcb_image_destroy(shadow_image); - if (shadow_pixmap) - xcb_free_pixmap(ps->c, shadow_pixmap); - if (shadow_pixmap_argb) - xcb_free_pixmap(ps->c, shadow_pixmap_argb); - if (shadow_picture) - xcb_render_free_picture(ps->c, shadow_picture); - if (shadow_picture_argb) - xcb_render_free_picture(ps->c, shadow_picture_argb); - if (gc) - xcb_free_gc(ps->c, gc); + } + if (shadow_pixmap) { + xcb_free_pixmap(ps->c.c, shadow_pixmap); + } + if (shadow_pixmap_argb) { + xcb_free_pixmap(ps->c.c, shadow_pixmap_argb); + } + if (shadow_picture) { + x_free_picture(&ps->c, shadow_picture); + } + if (shadow_picture_argb) { + x_free_picture(&ps->c, shadow_picture_argb); + } + if (gc) { + xcb_free_gc(ps->c.c, gc); + } return false; } @@ -755,23 +772,22 @@ win_paint_shadow(session_t *ps, struct managed_win *w, region_t *reg_paint) { traps, max_ntraps, w->corner_radius, w->widthb, w->heightb); td = x_create_picture_with_standard( - ps->c, ps->root, w->widthb, w->heightb, - XCB_PICT_STANDARD_ARGB_32, 0, 0); + &ps->c, w->widthb, w->heightb, XCB_PICT_STANDARD_ARGB_32, 0, 0); xcb_render_color_t trans = { .red = 0, .blue = 0, .green = 0, .alpha = 0}; const xcb_rectangle_t rect = {.x = 0, .y = 0, .width = to_u16_checked(w->widthb), .height = to_u16_checked(w->heightb)}; - xcb_render_fill_rectangles(ps->c, XCB_RENDER_PICT_OP_SRC, td, + xcb_render_fill_rectangles(ps->c.c, XCB_RENDER_PICT_OP_SRC, td, trans, 1, &rect); - auto solid = solid_picture(ps->c, ps->root, false, 1, 0, 0, 0); + auto solid = solid_picture(&ps->c, false, 1, 0, 0, 0); xcb_render_trapezoids( - ps->c, XCB_RENDER_PICT_OP_OVER, solid, td, - x_get_pictfmt_for_standard(ps->c, XCB_PICT_STANDARD_A_8), 0, + ps->c.c, XCB_RENDER_PICT_OP_OVER, solid, td, + x_get_pictfmt_for_standard(&ps->c, XCB_PICT_STANDARD_A_8), 0, 0, n, traps); - xcb_render_free_picture(ps->c, solid); + x_free_picture(&ps->c, solid); } else { // Not implemented } @@ -787,7 +803,7 @@ win_paint_shadow(session_t *ps, struct managed_win *w, region_t *reg_paint) { w->shadow_paint.pict, w->shadow_paint.ptex, reg_paint, NULL, should_clip ? &clip : NULL); if (td) { - xcb_render_free_picture(ps->c, td); + x_free_picture(&ps->c, td); } } @@ -815,16 +831,17 @@ xr_blur_dst(session_t *ps, xcb_render_picture_t tgt_buffer, int16_t x, int16_t y // Directly copying from tgt_buffer to it does not work, so we create a // Picture in the middle. - xcb_render_picture_t tmp_picture = - x_create_picture_with_visual(ps->c, ps->root, wid, hei, ps->vis, 0, NULL); + xcb_render_picture_t tmp_picture = x_create_picture_with_visual( + &ps->c, wid, hei, ps->c.screen_info->root_visual, 0, NULL); if (!tmp_picture) { log_error("Failed to build intermediate Picture."); return false; } - if (reg_clip && tmp_picture) - x_set_picture_clip_region(ps->c, tmp_picture, 0, 0, reg_clip); + if (reg_clip && tmp_picture) { + x_set_picture_clip_region(&ps->c, tmp_picture, 0, 0, reg_clip); + } xcb_render_picture_t src_pict = tgt_buffer, dst_pict = tmp_picture; for (int i = 0; i < nkernels; ++i) { @@ -838,9 +855,9 @@ xr_blur_dst(session_t *ps, xcb_render_picture_t tgt_buffer, int16_t x, int16_t y // be applied on source picture, to get the nearby pixels outside the // window. xcb_render_set_picture_filter( - ps->c, src_pict, strlen(XRFILTER_CONVOLUTION), XRFILTER_CONVOLUTION, + ps->c.c, src_pict, strlen(XRFILTER_CONVOLUTION), XRFILTER_CONVOLUTION, (uint32_t)(kwid * khei + 2), convolution_blur); - xcb_render_composite(ps->c, XCB_RENDER_PICT_OP_SRC, src_pict, XCB_NONE, + xcb_render_composite(ps->c.c, XCB_RENDER_PICT_OP_SRC, src_pict, XCB_NONE, dst_pict, (rd_from_tgt ? x : 0), (rd_from_tgt ? y : 0), 0, 0, (rd_from_tgt ? 0 : x), (rd_from_tgt ? 0 : y), wid, hei); @@ -853,11 +870,12 @@ xr_blur_dst(session_t *ps, xcb_render_picture_t tgt_buffer, int16_t x, int16_t y } } - if (src_pict != tgt_buffer) - xcb_render_composite(ps->c, XCB_RENDER_PICT_OP_OVER, src_pict, rounded, + if (src_pict != tgt_buffer) { + xcb_render_composite(ps->c.c, XCB_RENDER_PICT_OP_OVER, src_pict, rounded, tgt_buffer, 0, 0, 0, 0, x, y, wid, hei); + } - free_picture(ps->c, &tmp_picture); + x_free_picture(&ps->c, tmp_picture); return true; } @@ -870,8 +888,8 @@ win_blur_background(session_t *ps, struct managed_win *w, xcb_render_picture_t t const region_t *reg_paint) { const int16_t x = w->g.x; const int16_t y = w->g.y; - const auto wid = to_u16_checked(w->widthb); - const auto hei = to_u16_checked(w->heightb); + auto const wid = to_u16_checked(w->widthb); + auto const hei = to_u16_checked(w->heightb); const int cr = w ? w->corner_radius : 0; double factor_center = 1.0; @@ -912,23 +930,23 @@ win_blur_background(session_t *ps, struct managed_win *w, xcb_render_picture_t t make_rounded_window_shape(traps, max_ntraps, cr, wid, hei); td = x_create_picture_with_standard( - ps->c, ps->root, wid, hei, XCB_PICT_STANDARD_ARGB_32, 0, 0); + &ps->c, wid, hei, XCB_PICT_STANDARD_ARGB_32, 0, 0); xcb_render_color_t trans = { .red = 0, .blue = 0, .green = 0, .alpha = 0}; const xcb_rectangle_t rect = {.x = 0, .y = 0, .width = to_u16_checked(wid), .height = to_u16_checked(hei)}; - xcb_render_fill_rectangles(ps->c, XCB_RENDER_PICT_OP_SRC, td, + xcb_render_fill_rectangles(ps->c.c, XCB_RENDER_PICT_OP_SRC, td, trans, 1, &rect); - auto solid = solid_picture(ps->c, ps->root, false, 1, 0, 0, 0); + auto solid = solid_picture(&ps->c, false, 1, 0, 0, 0); xcb_render_trapezoids( - ps->c, XCB_RENDER_PICT_OP_OVER, solid, td, - x_get_pictfmt_for_standard(ps->c, XCB_PICT_STANDARD_A_8), 0, + ps->c.c, XCB_RENDER_PICT_OP_OVER, solid, td, + x_get_pictfmt_for_standard(&ps->c, XCB_PICT_STANDARD_A_8), 0, 0, n, traps); - xcb_render_free_picture(ps->c, solid); + x_free_picture(&ps->c, solid); } // Minimize the region we try to blur, if the window itself is not @@ -948,14 +966,14 @@ win_blur_background(session_t *ps, struct managed_win *w, xcb_render_picture_t t xr_blur_dst(ps, tgt_buffer, x, y, wid, hei, ps->blur_kerns_cache, ps->o.blur_kernel_count, ®_blur, td); if (td) { - xcb_render_free_picture(ps->c, td); + x_free_picture(&ps->c, td); } pixman_region32_clear(®_blur); } break; #ifdef CONFIG_OPENGL case BKEND_GLX: // TODO(compton) Handle frame opacity - glx_blur_dst(ps, x, y, wid, hei, (float)ps->psglx->z - 0.5f, + glx_blur_dst(ps, x, y, wid, hei, (float)ps->psglx->z - 0.5F, (float)factor_center, reg_paint, &w->glx_blur_cache); break; #endif @@ -969,12 +987,12 @@ win_blur_background(session_t *ps, struct managed_win *w, xcb_render_picture_t t /// paint all windows /// region = ?? /// region_real = the damage region -void paint_all(session_t *ps, struct managed_win *t, bool ignore_damage) { +void paint_all(session_t *ps, struct managed_win *t) { if (ps->o.xrender_sync_fence || (ps->drivers & DRIVER_NVIDIA)) { - if (ps->xsync_exists && !x_fence_sync(ps->c, ps->sync_fence)) { + if (ps->xsync_exists && !x_fence_sync(&ps->c, ps->sync_fence)) { log_error("x_fence_sync failed, xrender-sync-fence will be " "disabled from now on."); - xcb_sync_destroy_fence(ps->c, ps->sync_fence); + xcb_sync_destroy_fence(ps->c.c, ps->sync_fence); ps->sync_fence = XCB_NONE; ps->o.xrender_sync_fence = false; ps->xsync_exists = false; @@ -984,7 +1002,7 @@ void paint_all(session_t *ps, struct managed_win *t, bool ignore_damage) { region_t region; pixman_region32_init(®ion); int buffer_age = get_buffer_age(ps); - if (buffer_age == -1 || buffer_age > ps->ndamage || ignore_damage) { + if (buffer_age == -1 || buffer_age > ps->ndamage) { pixman_region32_copy(®ion, &ps->screen_reg); } else { for (int i = 0; i < get_buffer_age(ps); i++) { @@ -1012,7 +1030,7 @@ void paint_all(session_t *ps, struct managed_win *t, bool ignore_damage) { if (!ps->tgt_buffer.pixmap) { free_paint(ps, &ps->tgt_buffer); ps->tgt_buffer.pixmap = - x_create_pixmap(ps->c, (uint8_t)ps->depth, ps->root, + x_create_pixmap(&ps->c, ps->c.screen_info->root_depth, ps->root_width, ps->root_height); if (ps->tgt_buffer.pixmap == XCB_NONE) { log_fatal("Failed to allocate a screen-sized pixmap for" @@ -1021,18 +1039,20 @@ void paint_all(session_t *ps, struct managed_win *t, bool ignore_damage) { } } - if (BKEND_GLX != ps->o.backend) + if (BKEND_GLX != ps->o.backend) { ps->tgt_buffer.pict = x_create_picture_with_visual_and_pixmap( - ps->c, ps->vis, ps->tgt_buffer.pixmap, 0, 0); + &ps->c, ps->c.screen_info->root_visual, ps->tgt_buffer.pixmap, + 0, 0); + } } if (BKEND_XRENDER == ps->o.backend) { - x_set_picture_clip_region(ps->c, ps->tgt_picture, 0, 0, ®ion); + x_set_picture_clip_region(&ps->c, ps->tgt_picture, 0, 0, ®ion); } #ifdef CONFIG_OPENGL if (bkend_use_glx(ps)) { - ps->psglx->z = 0.0; + ps->psglx->z = 0; } #endif @@ -1068,18 +1088,21 @@ void paint_all(session_t *ps, struct managed_win *t, bool ignore_damage) { // Painting shadow if (w->shadow) { // Lazy shadow building - if (!w->shadow_paint.pixmap) - if (!win_build_shadow(ps, w, 1)) + if (!w->shadow_paint.pixmap) { + if (!win_build_shadow(ps, w, 1)) { log_error("build shadow failed"); + } + } // Shadow doesn't need to be painted underneath the body // of the windows above. Because no one can see it pixman_region32_subtract(®_tmp, ®ion, w->reg_ignore); // Mask out the region we don't want shadow on - if (pixman_region32_not_empty(&ps->shadow_exclude_reg)) + if (pixman_region32_not_empty(&ps->shadow_exclude_reg)) { pixman_region32_subtract(®_tmp, ®_tmp, &ps->shadow_exclude_reg); + } if (pixman_region32_not_empty(®_shadow_clip)) { pixman_region32_subtract(®_tmp, ®_tmp, ®_shadow_clip); } @@ -1095,21 +1118,23 @@ void paint_all(session_t *ps, struct managed_win *t, bool ignore_damage) { // needed Doing it here instead of in make_shadow() for // saving GPU power and handling shaped windows (XXX // unconfirmed) - if (!ps->o.wintype_option[w->window_type].full_shadow) + if (!ps->o.wintype_option[w->window_type].full_shadow) { pixman_region32_subtract(®_tmp, ®_tmp, &bshape_no_corners); + } - if (ps->o.xinerama_shadow_crop && w->xinerama_scr >= 0 && - w->xinerama_scr < ps->xinerama_nscrs) - // There can be a window where number of screens - // is updated, but the screen number attached to - // the windows have not. + if (ps->o.crop_shadow_to_monitor && w->randr_monitor >= 0 && + w->randr_monitor < ps->monitors.count) { + // There can be a window where number of monitors is + // updated, but the monitor number attached to the window + // have not. // - // Window screen number will be updated - // eventually, so here we just check to make sure - // we don't access out of bounds. + // Window monitor number will be updated eventually, so + // here we just check to make sure we don't access out of + // bounds. pixman_region32_intersect( ®_tmp, ®_tmp, - &ps->xinerama_scr_regs[w->xinerama_scr]); + &ps->monitors.regions[w->randr_monitor]); + } // Detect if the region is empty before painting if (pixman_region32_not_empty(®_tmp)) { @@ -1149,8 +1174,8 @@ void paint_all(session_t *ps, struct managed_win *t, bool ignore_damage) { if (w->corner_radius > 0 && ps->o.backend == BKEND_GLX) { const int16_t x = w->g.x; const int16_t y = w->g.y; - const auto wid = to_u16_checked(w->widthb); - const auto hei = to_u16_checked(w->heightb); + auto const wid = to_u16_checked(w->widthb); + auto const hei = to_u16_checked(w->heightb); glx_bind_texture(ps, &w->glx_texture_bg, x, y, wid, hei); } #endif @@ -1170,8 +1195,8 @@ void paint_all(session_t *ps, struct managed_win *t, bool ignore_damage) { // Rounded corners for XRender is implemented inside render() // Round window corners if (w->corner_radius > 0 && ps->o.backend == BKEND_GLX) { - const auto wid = to_u16_checked(w->widthb); - const auto hei = to_u16_checked(w->heightb); + auto const wid = to_u16_checked(w->widthb); + auto const hei = to_u16_checked(w->heightb); glx_round_corners_dst(ps, w, w->glx_texture_bg, w->g.x, w->g.y, wid, hei, (float)ps->psglx->z - 0.5F, @@ -1198,13 +1223,14 @@ void paint_all(session_t *ps, struct managed_win *t, bool ignore_damage) { if (ps->o.vsync) { // Make sure all previous requests are processed to achieve best // effect - x_sync(ps->c); + x_sync(&ps->c); #ifdef CONFIG_OPENGL if (glx_has_context(ps)) { - if (ps->o.vsync_use_glfinish) + if (ps->o.vsync_use_glfinish) { glFinish(); - else + } else { glFlush(); + } glXWaitX(); } #endif @@ -1225,57 +1251,63 @@ void paint_all(session_t *ps, struct managed_win *t, bool ignore_damage) { // First we create a new picture, and copy content from the buffer // to it - auto pictfmt = x_get_pictform_for_visual(ps->c, ps->vis); + auto pictfmt = x_get_pictform_for_visual( + &ps->c, ps->c.screen_info->root_visual); xcb_render_picture_t new_pict = x_create_picture_with_pictfmt( - ps->c, ps->root, rwidth, rheight, pictfmt, 0, NULL); - xcb_render_composite(ps->c, XCB_RENDER_PICT_OP_SRC, + &ps->c, rwidth, rheight, pictfmt, 0, NULL); + xcb_render_composite(ps->c.c, XCB_RENDER_PICT_OP_SRC, ps->tgt_buffer.pict, XCB_NONE, new_pict, 0, 0, 0, 0, 0, 0, rwidth, rheight); // Next, we set the region of paint and highlight it - x_set_picture_clip_region(ps->c, new_pict, 0, 0, ®ion); - xcb_render_composite(ps->c, XCB_RENDER_PICT_OP_OVER, ps->white_picture, + x_set_picture_clip_region(&ps->c, new_pict, 0, 0, ®ion); + xcb_render_composite(ps->c.c, XCB_RENDER_PICT_OP_OVER, ps->white_picture, ps->alpha_picts[MAX_ALPHA / 2], new_pict, 0, 0, 0, 0, 0, 0, rwidth, rheight); // Finally, clear clip regions of new_pict and the screen, and put // the whole thing on screen - x_set_picture_clip_region(ps->c, new_pict, 0, 0, &ps->screen_reg); - x_set_picture_clip_region(ps->c, ps->tgt_picture, 0, 0, &ps->screen_reg); - xcb_render_composite(ps->c, XCB_RENDER_PICT_OP_SRC, new_pict, + x_set_picture_clip_region(&ps->c, new_pict, 0, 0, &ps->screen_reg); + x_set_picture_clip_region(&ps->c, ps->tgt_picture, 0, 0, + &ps->screen_reg); + xcb_render_composite(ps->c.c, XCB_RENDER_PICT_OP_SRC, new_pict, XCB_NONE, ps->tgt_picture, 0, 0, 0, 0, 0, 0, rwidth, rheight); - xcb_render_free_picture(ps->c, new_pict); - } else - xcb_render_composite(ps->c, XCB_RENDER_PICT_OP_SRC, + x_free_picture(&ps->c, new_pict); + } else { + xcb_render_composite(ps->c.c, XCB_RENDER_PICT_OP_SRC, ps->tgt_buffer.pict, XCB_NONE, ps->tgt_picture, 0, 0, 0, 0, 0, 0, rwidth, rheight); + } break; #ifdef CONFIG_OPENGL case BKEND_XR_GLX_HYBRID: - x_sync(ps->c); - if (ps->o.vsync_use_glfinish) + x_sync(&ps->c); + if (ps->o.vsync_use_glfinish) { glFinish(); - else + } else { glFlush(); + } glXWaitX(); assert(ps->tgt_buffer.pixmap); paint_bind_tex(ps, &ps->tgt_buffer, ps->root_width, ps->root_height, - false, ps->depth, ps->vis, !ps->o.glx_no_rebind_pixmap); - if (ps->o.vsync_use_glfinish) + false, ps->c.screen_info->root_depth, + ps->c.screen_info->root_visual, !ps->o.glx_no_rebind_pixmap); + if (ps->o.vsync_use_glfinish) { glFinish(); - else + } else { glFlush(); + } glXWaitX(); glx_render(ps, ps->tgt_buffer.ptex, 0, 0, 0, 0, ps->root_width, ps->root_height, 0, 1.0, false, false, ®ion, NULL); fallthrough(); - case BKEND_GLX: glXSwapBuffers(ps->dpy, get_tgt_window(ps)); break; + case BKEND_GLX: glXSwapBuffers(ps->c.dpy, get_tgt_window(ps)); break; #endif default: assert(0); } - x_sync(ps->c); + x_sync(&ps->c); #ifdef CONFIG_OPENGL if (glx_has_context(ps)) { @@ -1305,7 +1337,7 @@ void paint_all(session_t *ps, struct managed_win *t, bool ignore_damage) { static bool xr_init_blur(session_t *ps) { // Query filters xcb_render_query_filters_reply_t *pf = xcb_render_query_filters_reply( - ps->c, xcb_render_query_filters(ps->c, get_tgt_window(ps)), NULL); + ps->c.c, xcb_render_query_filters(ps->c.c, get_tgt_window(ps)), NULL); if (pf) { xcb_str_iterator_t iter = xcb_render_query_filters_filters_iterator(pf); for (; iter.rem; xcb_str_next(&iter)) { @@ -1313,8 +1345,9 @@ static bool xr_init_blur(session_t *ps) { char *name = xcb_str_name(iter.data); // Check for the convolution filter if (strlen(XRFILTER_CONVOLUTION) == len && - !memcmp(XRFILTER_CONVOLUTION, name, strlen(XRFILTER_CONVOLUTION))) + !memcmp(XRFILTER_CONVOLUTION, name, strlen(XRFILTER_CONVOLUTION))) { ps->xrfilter_convolution_exists = true; + } } free(pf); } @@ -1338,9 +1371,10 @@ static bool init_alpha_picts(session_t *ps) { for (int i = 0; i <= MAX_ALPHA; ++i) { double o = (double)i / MAX_ALPHA; - ps->alpha_picts[i] = solid_picture(ps->c, ps->root, false, o, 0, 0, 0); - if (ps->alpha_picts[i] == XCB_NONE) + ps->alpha_picts[i] = solid_picture(&ps->c, false, o, 0, 0, 0); + if (ps->alpha_picts[i] == XCB_NONE) { return false; + } } return true; } @@ -1352,12 +1386,13 @@ bool init_render(session_t *ps) { // Initialize OpenGL as early as possible #ifdef CONFIG_OPENGL - glxext_init(ps->dpy, ps->scr); + glxext_init(ps->c.dpy, ps->c.screen); #endif if (bkend_use_glx(ps)) { #ifdef CONFIG_OPENGL - if (!glx_init(ps, true)) + if (!glx_init(ps, true)) { return false; + } #else log_error("GLX backend support not compiled in."); return false; @@ -1372,8 +1407,9 @@ bool init_render(session_t *ps) { // Initialize window GL shader if (BKEND_GLX == ps->o.backend && ps->o.glx_fshader_win_str) { #ifdef CONFIG_OPENGL - if (!glx_load_prog_main(NULL, ps->o.glx_fshader_win_str, &ps->glx_prog_win)) + if (!glx_load_prog_main(NULL, ps->o.glx_fshader_win_str, &ps->glx_prog_win)) { return false; + } #else log_error("GLSL supported not compiled in, can't load " "shader."); @@ -1412,8 +1448,8 @@ bool init_render(session_t *ps) { } } - ps->black_picture = solid_picture(ps->c, ps->root, true, 1, 0, 0, 0); - ps->white_picture = solid_picture(ps->c, ps->root, true, 1, 1, 1, 1); + ps->black_picture = solid_picture(&ps->c, true, 1, 0, 0, 0); + ps->white_picture = solid_picture(&ps->c, true, 1, 1, 1, 1); if (ps->black_picture == XCB_NONE || ps->white_picture == XCB_NONE) { log_error("Failed to create solid xrender pictures."); @@ -1425,7 +1461,7 @@ bool init_render(session_t *ps) { if (ps->o.shadow_red == 0 && ps->o.shadow_green == 0 && ps->o.shadow_blue == 0) { ps->cshadow_picture = ps->black_picture; } else { - ps->cshadow_picture = solid_picture(ps->c, ps->root, true, 1, ps->o.shadow_red, + ps->cshadow_picture = solid_picture(&ps->c, true, 1, ps->o.shadow_red, ps->o.shadow_green, ps->o.shadow_blue); if (ps->cshadow_picture == XCB_NONE) { log_error("Failed to create shadow picture."); @@ -1451,14 +1487,14 @@ bool init_render(session_t *ps) { * Free root tile related things. */ void free_root_tile(session_t *ps) { - free_picture(ps->c, &ps->root_tile_paint.pict); + x_free_picture(&ps->c, ps->root_tile_paint.pict); #ifdef CONFIG_OPENGL free_texture(ps, &ps->root_tile_paint.ptex); #else assert(!ps->root_tile_paint.ptex); #endif if (ps->root_tile_fill) { - xcb_free_pixmap(ps->c, ps->root_tile_paint.pixmap); + xcb_free_pixmap(ps->c.c, ps->root_tile_paint.pixmap); ps->root_tile_paint.pixmap = XCB_NONE; } ps->root_tile_paint.pixmap = XCB_NONE; @@ -1467,19 +1503,20 @@ void free_root_tile(session_t *ps) { void deinit_render(session_t *ps) { // Free alpha_picts - for (int i = 0; i <= MAX_ALPHA; ++i) - free_picture(ps->c, &ps->alpha_picts[i]); + for (int i = 0; i <= MAX_ALPHA; ++i) { + x_free_picture(&ps->c, ps->alpha_picts[i]); + } free(ps->alpha_picts); ps->alpha_picts = NULL; // Free cshadow_picture and black_picture - if (ps->cshadow_picture == ps->black_picture) - ps->cshadow_picture = XCB_NONE; - else - free_picture(ps->c, &ps->cshadow_picture); + if (ps->cshadow_picture != ps->black_picture) { + x_free_picture(&ps->c, ps->cshadow_picture); + } - free_picture(ps->c, &ps->black_picture); - free_picture(ps->c, &ps->white_picture); + x_free_picture(&ps->c, ps->black_picture); + x_free_picture(&ps->c, ps->white_picture); + ps->cshadow_picture = ps->black_picture = ps->white_picture = XCB_NONE; // Free other X resources free_root_tile(ps); diff --git a/src/render.h b/src/render.h index 95a46dbee0..4e0c7a8162 100644 --- a/src/render.h +++ b/src/render.h @@ -37,9 +37,7 @@ void render(session_t *ps, int x, int y, int dx, int dy, int w, int h, int fullw const glx_prog_main_t *pprogram, clip_t *clip); void paint_one(session_t *ps, struct managed_win *w, const region_t *reg_paint); -void paint_all(session_t *ps, struct managed_win *const t, bool ignore_damage); - -void free_picture(xcb_connection_t *c, xcb_render_picture_t *p); +void paint_all(session_t *ps, struct managed_win *const t); void free_paint(session_t *ps, paint_t *ppaint); void free_root_tile(session_t *ps); diff --git a/src/statistics.c b/src/statistics.c new file mode 100644 index 0000000000..11c7466ef6 --- /dev/null +++ b/src/statistics.c @@ -0,0 +1,89 @@ +//! Rendering statistics +//! +//! Tracks how long it takes to render a frame, for measuring performance, and for pacing +//! the frames. + +#include "statistics.h" +#include "log.h" +#include "utils.h" + +void render_statistics_init(struct render_statistics *rs, int window_size) { + *rs = (struct render_statistics){0}; + + rolling_window_init(&rs->render_times, window_size); + rolling_quantile_init_with_tolerance(&rs->render_time_quantile, window_size, + /* q */ 0.98, /* tolerance */ 0.01); +} + +void render_statistics_add_vblank_time_sample(struct render_statistics *rs, int time_us) { + auto sample_sd = sqrt(cumulative_mean_and_var_get_var(&rs->vblank_time_us)); + auto current_estimate = render_statistics_get_vblank_time(rs); + if (current_estimate != 0 && fabs((double)time_us - current_estimate) > sample_sd * 3) { + // Deviated from the mean by more than 3 sigma (p < 0.003) + log_debug("vblank time outlier: %d %f %f", time_us, rs->vblank_time_us.mean, + cumulative_mean_and_var_get_var(&rs->vblank_time_us)); + // An outlier sample, this could mean things like refresh rate changes, so + // we reset the statistics. This could also be benign, but we like to be + // cautious. + cumulative_mean_and_var_init(&rs->vblank_time_us); + } + + if (rs->vblank_time_us.mean != 0) { + auto nframes_in_10_seconds = + (unsigned int)(10. * 1000000. / rs->vblank_time_us.mean); + if (rs->vblank_time_us.n > 20 && rs->vblank_time_us.n > nframes_in_10_seconds) { + // We collected 10 seconds worth of samples, we assume the + // estimated refresh rate is stable. We will still reset the + // statistics if we get an outlier sample though, see above. + return; + } + } + cumulative_mean_and_var_update(&rs->vblank_time_us, time_us); +} + +void render_statistics_add_render_time_sample(struct render_statistics *rs, int time_us) { + int oldest; + if (rolling_window_push_back(&rs->render_times, time_us, &oldest)) { + rolling_quantile_pop_front(&rs->render_time_quantile, oldest); + } + + rolling_quantile_push_back(&rs->render_time_quantile, time_us); +} + +/// How much time budget we should give to the backend for rendering, in microseconds. +/// +/// A `divisor` is also returned, indicating the target framerate. The divisor is +/// the number of vblanks we should wait between each frame. A divisor of 1 means +/// full framerate, 2 means half framerate, etc. +unsigned int render_statistics_get_budget(struct render_statistics *rs) { + if (rs->render_times.nelem < rs->render_times.window_size) { + // No valid render time estimates yet. Assume maximum budget. + return UINT_MAX; + } + + // N-th percentile of render times, see render_statistics_init for N. + auto render_time_percentile = + rolling_quantile_estimate(&rs->render_time_quantile, &rs->render_times); + return (unsigned int)render_time_percentile; +} + +unsigned int render_statistics_get_vblank_time(struct render_statistics *rs) { + if (rs->vblank_time_us.n <= 20 || rs->vblank_time_us.mean < 100) { + // Not enough samples yet, or the vblank time is too short to be + // meaningful. Assume maximum budget. + return 0; + } + return (unsigned int)rs->vblank_time_us.mean; +} + +void render_statistics_reset(struct render_statistics *rs) { + rolling_window_reset(&rs->render_times); + rolling_quantile_reset(&rs->render_time_quantile); + rs->vblank_time_us = (struct cumulative_mean_and_var){0}; +} + +void render_statistics_destroy(struct render_statistics *rs) { + render_statistics_reset(rs); + rolling_window_destroy(&rs->render_times); + rolling_quantile_destroy(&rs->render_time_quantile); +} diff --git a/src/statistics.h b/src/statistics.h new file mode 100644 index 0000000000..a111486111 --- /dev/null +++ b/src/statistics.h @@ -0,0 +1,30 @@ +#pragma once + +#include "utils.h" + +#define NTIERS (3) + +struct render_statistics { + /// Rolling window of rendering times (in us) and the tiers they belong to. + /// We keep track of the tiers because the vblank time estimate can change over + /// time. + struct rolling_window render_times; + /// Estimate the 95-th percentile of rendering times + struct rolling_quantile render_time_quantile; + /// Time between each vblanks + struct cumulative_mean_and_var vblank_time_us; +}; + +void render_statistics_init(struct render_statistics *rs, int window_size); +void render_statistics_reset(struct render_statistics *rs); +void render_statistics_destroy(struct render_statistics *rs); + +void render_statistics_add_vblank_time_sample(struct render_statistics *rs, int time_us); +void render_statistics_add_render_time_sample(struct render_statistics *rs, int time_us); + +/// How much time budget we should give to the backend for rendering, in microseconds. +unsigned int render_statistics_get_budget(struct render_statistics *rs); + +/// Return the measured vblank interval in microseconds. Returns 0 if not enough +/// samples have been collected yet. +unsigned int render_statistics_get_vblank_time(struct render_statistics *rs); diff --git a/src/string_utils.h b/src/string_utils.h index 461173a346..d4781e2d9a 100644 --- a/src/string_utils.h +++ b/src/string_utils.h @@ -24,8 +24,9 @@ static inline int uitostr(unsigned int n, char *buf) { ret++; } - if (ret == 0) + if (ret == 0) { ret = 1; + } int pos = ret; while (pos--) { @@ -36,18 +37,22 @@ static inline int uitostr(unsigned int n, char *buf) { } static inline const char *skip_space_const(const char *src) { - if (!src) + if (!src) { return NULL; - while (*src && isspace((unsigned char)*src)) + } + while (*src && isspace((unsigned char)*src)) { src++; + } return src; } static inline char *skip_space_mut(char *src) { - if (!src) + if (!src) { return NULL; - while (*src && isspace((unsigned char)*src)) + } + while (*src && isspace((unsigned char)*src)) { src++; + } return src; } diff --git a/src/utils.c b/src/utils.c index c236a4a8d9..5709fa21d2 100644 --- a/src/utils.c +++ b/src/utils.c @@ -4,6 +4,7 @@ #include "compiler.h" #include "string_utils.h" +#include "test.h" #include "utils.h" /// Report allocation failure without allocating memory @@ -26,10 +27,10 @@ void report_allocation_failure(const char *func, const char *file, unsigned int {.iov_base = (void *)msg2, .iov_len = sizeof(msg2) - 1}, }; - writev(STDERR_FILENO, v, ARR_SIZE(v)); + ssize_t _ attr_unused = writev(STDERR_FILENO, v, ARR_SIZE(v)); abort(); - unreachable; + unreachable(); } /// @@ -47,4 +48,228 @@ int next_power_of_two(int n) { return n; } +void rolling_window_destroy(struct rolling_window *rw) { + free(rw->elem); + rw->elem = NULL; +} + +void rolling_window_reset(struct rolling_window *rw) { + rw->nelem = 0; + rw->elem_head = 0; +} + +void rolling_window_init(struct rolling_window *rw, int size) { + rw->elem = ccalloc(size, int); + rw->window_size = size; + rolling_window_reset(rw); +} + +int rolling_window_pop_front(struct rolling_window *rw) { + assert(rw->nelem > 0); + auto ret = rw->elem[rw->elem_head]; + rw->elem_head = (rw->elem_head + 1) % rw->window_size; + rw->nelem--; + return ret; +} + +bool rolling_window_push_back(struct rolling_window *rw, int val, int *front) { + bool full = rw->nelem == rw->window_size; + if (full) { + *front = rolling_window_pop_front(rw); + } + rw->elem[(rw->elem_head + rw->nelem) % rw->window_size] = val; + rw->nelem++; + return full; +} + +/// Track the maximum member of a FIFO queue of integers. Integers are pushed to the back +/// and popped from the front, the maximum of the current members in the queue is +/// tracked. +struct rolling_max { + /// A priority queue holding the indices of the maximum element candidates. + /// The head of the queue is the index of the maximum element. + /// The indices in the queue are the "original" indices. + /// + /// There are only `capacity` elements in `elem`, all previous elements are + /// discarded. But the discarded elements' indices are not forgotten, that's why + /// it's called the "original" indices. + int *p; + int p_head, np; + /// The maximum number of in flight elements. + int capacity; +}; + +void rolling_max_destroy(struct rolling_max *rm) { + free(rm->p); + free(rm); +} + +struct rolling_max *rolling_max_new(int capacity) { + auto rm = ccalloc(1, struct rolling_max); + if (!rm) { + return NULL; + } + + rm->p = ccalloc(capacity, int); + if (!rm->p) { + goto err; + } + rm->capacity = capacity; + + return rm; + +err: + rolling_max_destroy(rm); + return NULL; +} + +void rolling_max_reset(struct rolling_max *rm) { + rm->p_head = 0; + rm->np = 0; +} + +#define IDX(n) ((n) % rm->capacity) +/// Remove the oldest element in the window. The caller must maintain the list of elements +/// themselves, i.e. the behavior is undefined if `front` does not 1match the oldest +/// element. +void rolling_max_pop_front(struct rolling_max *rm, int front) { + if (rm->p[rm->p_head] == front) { + // rm->p.pop_front() + rm->p_head = IDX(rm->p_head + 1); + rm->np--; + } +} + +void rolling_max_push_back(struct rolling_max *rm, int val) { + // Update the prority queue. + // Remove all elements smaller than the new element from the queue. Because + // the new element will become the maximum element before them, and since they + // come b1efore the new element, they will have been popped before the new + // element, so they will never become the maximum element. + while (rm->np) { + int p_tail = IDX(rm->p_head + rm->np - 1); + if (rm->p[p_tail] > val) { + break; + } + // rm->p.pop_back() + rm->np--; + } + // Add the new element to the end of the queue. + // rm->p.push_back(rm->start_index + rm->nelem - 1) + assert(rm->np < rm->capacity); + rm->p[IDX(rm->p_head + rm->np)] = val; + rm->np++; +} +#undef IDX + +int rolling_max_get_max(struct rolling_max *rm) { + if (rm->np == 0) { + return INT_MIN; + } + return rm->p[rm->p_head]; +} + +TEST_CASE(rolling_max_test) { +#define NELEM 15 + struct rolling_window queue; + rolling_window_init(&queue, 3); + auto rm = rolling_max_new(3); + const int data[NELEM] = {1, 2, 3, 1, 4, 5, 2, 3, 6, 5, 4, 3, 2, 0, 0}; + const int expected_max[NELEM] = {1, 2, 3, 3, 4, 5, 5, 5, 6, 6, 6, 5, 4, 3, 2}; + int max[NELEM] = {0}; + for (int i = 0; i < NELEM; i++) { + int front; + bool full = rolling_window_push_back(&queue, data[i], &front); + if (full) { + rolling_max_pop_front(rm, front); + } + rolling_max_push_back(rm, data[i]); + max[i] = rolling_max_get_max(rm); + } + rolling_window_destroy(&queue); + rolling_max_destroy(rm); + TEST_TRUE(memcmp(max, expected_max, sizeof(max)) == 0); +#undef NELEM +} + +// Find the k-th smallest element in an array. +int quickselect(int *elems, int nelem, int k) { + int l = 0, r = nelem; // [l, r) is the range of candidates + while (l != r) { + int pivot = elems[l]; + int i = l, j = r; + while (i < j) { + while (i < j && elems[--j] >= pivot) { + } + elems[i] = elems[j]; + while (i < j && elems[++i] <= pivot) { + } + elems[j] = elems[i]; + } + elems[i] = pivot; + + if (i == k) { + break; + } + + if (i < k) { + l = i + 1; + } else { + r = i; + } + } + return elems[k]; +} + +void rolling_quantile_init(struct rolling_quantile *rq, int capacity, int mink, int maxk) { + *rq = (struct rolling_quantile){0}; + rq->tmp_buffer = malloc(sizeof(int) * (size_t)capacity); + rq->capacity = capacity; + rq->min_target_rank = mink; + rq->max_target_rank = maxk; +} + +void rolling_quantile_init_with_tolerance(struct rolling_quantile *rq, int window_size, + double target, double tolerance) { + rolling_quantile_init(rq, window_size, (int)((target - tolerance) * window_size), + (int)((target + tolerance) * window_size)); +} + +void rolling_quantile_reset(struct rolling_quantile *rq) { + rq->current_rank = 0; + rq->estimate = 0; +} + +void rolling_quantile_destroy(struct rolling_quantile *rq) { + free(rq->tmp_buffer); +} + +int rolling_quantile_estimate(struct rolling_quantile *rq, struct rolling_window *elements) { + if (rq->current_rank < rq->min_target_rank || rq->current_rank > rq->max_target_rank) { + if (elements->nelem != elements->window_size) { + return INT_MIN; + } + // Re-estimate the quantile. + assert(elements->nelem <= rq->capacity); + rolling_window_copy_to_array(elements, rq->tmp_buffer); + const int target_rank = + rq->min_target_rank + (rq->max_target_rank - rq->min_target_rank) / 2; + rq->estimate = quickselect(rq->tmp_buffer, elements->nelem, target_rank); + rq->current_rank = target_rank; + } + return rq->estimate; +} + +void rolling_quantile_push_back(struct rolling_quantile *rq, int x) { + if (x <= rq->estimate) { + rq->current_rank++; + } +} + +void rolling_quantile_pop_front(struct rolling_quantile *rq, int x) { + if (x <= rq->estimate) { + rq->current_rank--; + } +} + // vim: set noet sw=8 ts=8 : diff --git a/src/utils.h b/src/utils.h index a35bfa84b3..446fba8be7 100644 --- a/src/utils.h +++ b/src/utils.h @@ -17,6 +17,7 @@ #include #include "compiler.h" +#include "log.h" #include "types.h" #define ARR_SIZE(arr) (sizeof(arr) / sizeof(arr[0])) @@ -124,14 +125,22 @@ safe_isnan(double a) { * @param max maximum value * @return normalized value */ -static inline int attr_const normalize_i_range(int i, int min, int max) { - if (i > max) +static inline int attr_const attr_unused normalize_i_range(int i, int min, int max) { + if (i > max) { return max; - if (i < min) + } + if (i < min) { return min; + } return i; } +/// Generic integer abs() +#define iabs(val) \ + ({ \ + __auto_type __tmp = (val); \ + __tmp > 0 ? __tmp : -__tmp; \ + }) #define min2(a, b) ((a) > (b) ? (b) : (a)) #define max2(a, b) ((a) > (b) ? (a) : (b)) #define min3(a, b, c) min2(a, min2(b, c)) @@ -148,10 +157,12 @@ static inline int attr_const normalize_i_range(int i, int min, int max) { * @return normalized value */ static inline double attr_const normalize_d_range(double d, double min, double max) { - if (d > max) + if (d > max) { return max; - if (d < min) + } + if (d < min) { return min; + } return d; } @@ -161,7 +172,7 @@ static inline double attr_const normalize_d_range(double d, double min, double m * @param d double value to normalize * @return normalized value */ -static inline double attr_const normalize_d(double d) { +static inline double attr_const attr_unused normalize_d(double d) { return normalize_d_range(d, 0.0, 1.0); } @@ -289,6 +300,98 @@ static inline void free_charpp(char **str) { /// int next_power_of_two(int n); +struct rolling_window { + int *elem; + int elem_head, nelem; + int window_size; +}; + +void rolling_window_destroy(struct rolling_window *rw); +void rolling_window_reset(struct rolling_window *rw); +void rolling_window_init(struct rolling_window *rw, int size); +int rolling_window_pop_front(struct rolling_window *rw); +bool rolling_window_push_back(struct rolling_window *rw, int val, int *front); + +/// Copy the contents of the rolling window to an array. The array is assumed to +/// have enough space to hold the contents of the rolling window. +static inline void attr_unused rolling_window_copy_to_array(struct rolling_window *rw, + int *arr) { + // The length from head to the end of the array + auto head_len = (size_t)(rw->window_size - rw->elem_head); + if (head_len >= (size_t)rw->nelem) { + memcpy(arr, rw->elem + rw->elem_head, sizeof(int) * (size_t)rw->nelem); + } else { + auto tail_len = (size_t)((size_t)rw->nelem - head_len); + memcpy(arr, rw->elem + rw->elem_head, sizeof(int) * head_len); + memcpy(arr + head_len, rw->elem, sizeof(int) * tail_len); + } +} + +struct rolling_max; + +struct rolling_max *rolling_max_new(int capacity); +void rolling_max_destroy(struct rolling_max *rm); +void rolling_max_reset(struct rolling_max *rm); +void rolling_max_pop_front(struct rolling_max *rm, int front); +void rolling_max_push_back(struct rolling_max *rm, int val); +int rolling_max_get_max(struct rolling_max *rm); + +/// Estimate the mean and variance of random variable X using Welford's online +/// algorithm. +struct cumulative_mean_and_var { + double mean; + double m2; + unsigned int n; +}; + +static inline attr_unused void +cumulative_mean_and_var_init(struct cumulative_mean_and_var *cmv) { + *cmv = (struct cumulative_mean_and_var){0}; +} + +static inline attr_unused void +cumulative_mean_and_var_update(struct cumulative_mean_and_var *cmv, double x) { + if (cmv->n == UINT_MAX) { + // We have too many elements, let's keep the mean and variance. + return; + } + cmv->n++; + double delta = x - cmv->mean; + cmv->mean += delta / (double)cmv->n; + cmv->m2 += delta * (x - cmv->mean); +} + +static inline attr_unused double +cumulative_mean_and_var_get_var(struct cumulative_mean_and_var *cmv) { + if (cmv->n < 2) { + return 0; + } + return cmv->m2 / (double)(cmv->n - 1); +} + +// Find the k-th smallest element in an array. +int quickselect(int *elems, int nelem, int k); + +/// A naive quantile estimator. +/// +/// Estimates the N-th percentile of a random variable X in a sliding window. +struct rolling_quantile { + int current_rank; + int min_target_rank, max_target_rank; + int estimate; + int capacity; + int *tmp_buffer; +}; + +void rolling_quantile_init(struct rolling_quantile *rq, int capacity, int mink, int maxk); +void rolling_quantile_init_with_tolerance(struct rolling_quantile *rq, int window_size, + double target, double tolerance); +void rolling_quantile_reset(struct rolling_quantile *rq); +void rolling_quantile_destroy(struct rolling_quantile *rq); +int rolling_quantile_estimate(struct rolling_quantile *rq, struct rolling_window *elements); +void rolling_quantile_push_back(struct rolling_quantile *rq, int x); +void rolling_quantile_pop_front(struct rolling_quantile *rq, int x); + // Some versions of the Android libc do not have timespec_get(), use // clock_gettime() instead. #ifdef __ANDROID__ diff --git a/src/vblank.c b/src/vblank.c new file mode 100644 index 0000000000..ff83a9a76e --- /dev/null +++ b/src/vblank.c @@ -0,0 +1,541 @@ +#include + +#include +#include +#include +#include +#include +#include +#include +#include "config.h" + +#ifdef CONFIG_OPENGL +// Enable sgi_video_sync_vblank_scheduler +#include +#include +#include +#include +#include +#include + +#include "backend/gl/glx.h" +#endif + +#include "compiler.h" +#include "list.h" // for container_of +#include "log.h" +#include "vblank.h" +#include "x.h" + +struct vblank_closure { + vblank_callback_t fn; + void *user_data; +}; + +#define VBLANK_WIND_DOWN 4 + +struct vblank_scheduler { + struct x_connection *c; + size_t callback_capacity, callback_count; + struct vblank_closure *callbacks; + struct ev_loop *loop; + /// Request extra vblank events even when no callbacks are scheduled. + /// This is because when callbacks are scheduled too close to a vblank, + /// we might send PresentNotifyMsc request too late and miss the vblank event. + /// So we request extra vblank events right after the last vblank event + /// to make sure this doesn't happen. + unsigned int wind_down; + xcb_window_t target_window; + enum vblank_scheduler_type type; + bool vblank_event_requested; +}; + +struct present_vblank_scheduler { + struct vblank_scheduler base; + + uint64_t last_msc; + /// The timestamp for the end of last vblank. + uint64_t last_ust; + ev_timer callback_timer; + xcb_present_event_t event_id; + xcb_special_event_t *event; +}; + +struct vblank_scheduler_ops { + size_t size; + void (*init)(struct vblank_scheduler *self); + void (*deinit)(struct vblank_scheduler *self); + void (*schedule)(struct vblank_scheduler *self); + bool (*handle_x_events)(struct vblank_scheduler *self); +}; + +static void +vblank_scheduler_invoke_callbacks(struct vblank_scheduler *self, struct vblank_event *event); + +#ifdef CONFIG_OPENGL +struct sgi_video_sync_vblank_scheduler { + struct vblank_scheduler base; + + // Since glXWaitVideoSyncSGI blocks, we need to run it in a separate thread. + // ... and all the thread shenanigans that come with it. + _Atomic unsigned int last_msc; + _Atomic uint64_t last_ust; + ev_async notify; + pthread_t sync_thread; + bool running, error; + + /// Protects `running`, `error` and `base.vblank_event_requested` + pthread_mutex_t vblank_requested_mtx; + pthread_cond_t vblank_requested_cnd; +}; + +struct sgi_video_sync_thread_args { + struct sgi_video_sync_vblank_scheduler *self; + int start_status; + pthread_mutex_t start_mtx; + pthread_cond_t start_cnd; +}; + +static bool check_sgi_video_sync_extension(Display *dpy, int screen) { + const char *glx_ext = glXQueryExtensionsString(dpy, screen); + const char *needle = "GLX_SGI_video_sync"; + char *found = strstr(glx_ext, needle); + if (!found) { + return false; + } + if (found != glx_ext && found[-1] != ' ') { + return false; + } + if (found[strlen(needle)] != ' ' && found[strlen(needle)] != '\0') { + return false; + } + + glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)(void *)glXGetProcAddress( + (const GLubyte *)"glXWaitVideoSyncSGI"); + if (!glXWaitVideoSyncSGI) { + return false; + } + return true; +} + +static void *sgi_video_sync_thread(void *data) { + auto args = (struct sgi_video_sync_thread_args *)data; + auto self = args->self; + Display *dpy = XOpenDisplay(NULL); + int error_code = 0; + if (!dpy) { + error_code = 1; + goto start_failed; + } + Window root = DefaultRootWindow(dpy), dummy = None; + int screen = DefaultScreen(dpy); + int ncfg = 0; + GLXFBConfig *cfg_ = glXChooseFBConfig( + dpy, screen, + (int[]){GLX_RENDER_TYPE, GLX_RGBA_BIT, GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, 0}, + &ncfg); + GLXContext ctx = NULL; + GLXDrawable drawable = None; + + if (!cfg_) { + error_code = 2; + goto start_failed; + } + GLXFBConfig cfg = cfg_[0]; + XFree(cfg_); + + XVisualInfo *vi = glXGetVisualFromFBConfig(dpy, cfg); + if (!vi) { + error_code = 3; + goto start_failed; + } + + Visual *visual = vi->visual; + const int depth = vi->depth; + XFree(vi); + + Colormap colormap = XCreateColormap(dpy, root, visual, AllocNone); + XSetWindowAttributes attributes; + attributes.colormap = colormap; + + dummy = XCreateWindow(dpy, root, 0, 0, 1, 1, 0, depth, InputOutput, visual, + CWColormap, &attributes); + XFreeColormap(dpy, colormap); + if (dummy == None) { + error_code = 4; + goto start_failed; + } + + drawable = glXCreateWindow(dpy, cfg, dummy, NULL); + if (drawable == None) { + error_code = 5; + goto start_failed; + } + + ctx = glXCreateNewContext(dpy, cfg, GLX_RGBA_TYPE, 0, true); + if (ctx == NULL) { + error_code = 6; + goto start_failed; + } + + if (!glXMakeContextCurrent(dpy, drawable, drawable, ctx)) { + error_code = 7; + goto start_failed; + } + + if (!check_sgi_video_sync_extension(dpy, screen)) { + error_code = 8; + goto start_failed; + } + + pthread_mutex_lock(&args->start_mtx); + args->start_status = 0; + pthread_cond_signal(&args->start_cnd); + pthread_mutex_unlock(&args->start_mtx); + + pthread_mutex_lock(&self->vblank_requested_mtx); + while (self->running) { + if (!self->base.vblank_event_requested) { + pthread_cond_wait(&self->vblank_requested_cnd, + &self->vblank_requested_mtx); + continue; + } + pthread_mutex_unlock(&self->vblank_requested_mtx); + + unsigned int last_msc; + glXWaitVideoSyncSGI(1, 0, &last_msc); + + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + atomic_store(&self->last_msc, last_msc); + atomic_store(&self->last_ust, + (uint64_t)(now.tv_sec * 1000000 + now.tv_nsec / 1000)); + ev_async_send(self->base.loop, &self->notify); + pthread_mutex_lock(&self->vblank_requested_mtx); + } + pthread_mutex_unlock(&self->vblank_requested_mtx); + goto cleanup; + +start_failed: + pthread_mutex_lock(&args->start_mtx); + args->start_status = error_code; + pthread_cond_signal(&args->start_cnd); + pthread_mutex_unlock(&args->start_mtx); + +cleanup: + if (dpy) { + glXMakeCurrent(dpy, None, NULL); + if (ctx) { + glXDestroyContext(dpy, ctx); + } + if (drawable) { + glXDestroyWindow(dpy, drawable); + } + if (dummy) { + XDestroyWindow(dpy, dummy); + } + XCloseDisplay(dpy); + } + return NULL; +} + +static void sgi_video_sync_scheduler_schedule(struct vblank_scheduler *base) { + auto self = (struct sgi_video_sync_vblank_scheduler *)base; + log_verbose("Requesting vblank event for msc %d", self->last_msc + 1); + pthread_mutex_lock(&self->vblank_requested_mtx); + assert(!base->vblank_event_requested); + base->vblank_event_requested = true; + pthread_cond_signal(&self->vblank_requested_cnd); + pthread_mutex_unlock(&self->vblank_requested_mtx); +} + +static void +sgi_video_sync_scheduler_callback(EV_P attr_unused, ev_async *w, int attr_unused revents) { + auto sched = container_of(w, struct sgi_video_sync_vblank_scheduler, notify); + auto event = (struct vblank_event){ + .msc = atomic_load(&sched->last_msc), + .ust = atomic_load(&sched->last_ust), + }; + sched->base.vblank_event_requested = false; + log_verbose("Received vblank event for msc %lu", event.msc); + vblank_scheduler_invoke_callbacks(&sched->base, &event); +} + +static void sgi_video_sync_scheduler_init(struct vblank_scheduler *base) { + auto self = (struct sgi_video_sync_vblank_scheduler *)base; + auto args = (struct sgi_video_sync_thread_args){ + .self = self, + .start_status = -1, + }; + pthread_mutex_init(&args.start_mtx, NULL); + pthread_cond_init(&args.start_cnd, NULL); + + base->type = VBLANK_SCHEDULER_SGI_VIDEO_SYNC; + ev_async_init(&self->notify, sgi_video_sync_scheduler_callback); + ev_async_start(base->loop, &self->notify); + pthread_mutex_init(&self->vblank_requested_mtx, NULL); + pthread_cond_init(&self->vblank_requested_cnd, NULL); + + self->running = true; + pthread_create(&self->sync_thread, NULL, sgi_video_sync_thread, &args); + + pthread_mutex_lock(&args.start_mtx); + while (args.start_status == -1) { + pthread_cond_wait(&args.start_cnd, &args.start_mtx); + } + if (args.start_status != 0) { + log_fatal("Failed to start sgi_video_sync_thread, error code: %d", + args.start_status); + abort(); + } + pthread_mutex_destroy(&args.start_mtx); + pthread_cond_destroy(&args.start_cnd); + log_info("Started sgi_video_sync_thread"); +} + +static void sgi_video_sync_scheduler_deinit(struct vblank_scheduler *base) { + auto self = (struct sgi_video_sync_vblank_scheduler *)base; + ev_async_stop(base->loop, &self->notify); + pthread_mutex_lock(&self->vblank_requested_mtx); + self->running = false; + pthread_cond_signal(&self->vblank_requested_cnd); + pthread_mutex_unlock(&self->vblank_requested_mtx); + + pthread_join(self->sync_thread, NULL); + + pthread_mutex_destroy(&self->vblank_requested_mtx); + pthread_cond_destroy(&self->vblank_requested_cnd); +} +#endif + +static void present_vblank_scheduler_schedule(struct vblank_scheduler *base) { + auto self = (struct present_vblank_scheduler *)base; + log_verbose("Requesting vblank event for window 0x%08x, msc %" PRIu64, + base->target_window, self->last_msc + 1); + assert(!base->vblank_event_requested); + x_request_vblank_event(base->c, base->target_window, self->last_msc + 1); + base->vblank_event_requested = true; +} + +static void present_vblank_callback(EV_P attr_unused, ev_timer *w, int attr_unused revents) { + auto sched = container_of(w, struct present_vblank_scheduler, callback_timer); + auto event = (struct vblank_event){ + .msc = sched->last_msc, + .ust = sched->last_ust, + }; + sched->base.vblank_event_requested = false; + vblank_scheduler_invoke_callbacks(&sched->base, &event); +} + +static void present_vblank_scheduler_init(struct vblank_scheduler *base) { + auto self = (struct present_vblank_scheduler *)base; + base->type = VBLANK_SCHEDULER_PRESENT; + ev_timer_init(&self->callback_timer, present_vblank_callback, 0, 0); + + self->event_id = x_new_id(base->c); + auto select_input = + xcb_present_select_input(base->c->c, self->event_id, base->target_window, + XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY); + set_cant_fail_cookie(base->c, select_input); + self->event = + xcb_register_for_special_xge(base->c->c, &xcb_present_id, self->event_id, NULL); +} + +static void present_vblank_scheduler_deinit(struct vblank_scheduler *base) { + auto self = (struct present_vblank_scheduler *)base; + ev_timer_stop(base->loop, &self->callback_timer); + auto select_input = + xcb_present_select_input(base->c->c, self->event_id, base->target_window, 0); + set_cant_fail_cookie(base->c, select_input); + xcb_unregister_for_special_event(base->c->c, self->event); +} + +/// Handle PresentCompleteNotify events +/// +/// Schedule the registered callback to be called when the current vblank ends. +static void handle_present_complete_notify(struct present_vblank_scheduler *self, + xcb_present_complete_notify_event_t *cne) { + assert(self->base.type == VBLANK_SCHEDULER_PRESENT); + + if (cne->kind != XCB_PRESENT_COMPLETE_KIND_NOTIFY_MSC) { + return; + } + + assert(self->base.vblank_event_requested); + + // X sometimes sends duplicate/bogus MSC events, when screen has just been turned + // off. Don't use the msc value in these events. We treat this as not receiving a + // vblank event at all, and try to get a new one. + // + // See: + // https://gitlab.freedesktop.org/xorg/xserver/-/issues/1418 + bool event_is_invalid = cne->msc <= self->last_msc || cne->ust == 0; + if (event_is_invalid) { + log_debug("Invalid PresentCompleteNotify event, %" PRIu64 " %" PRIu64, + cne->msc, cne->ust); + x_request_vblank_event(self->base.c, cne->window, self->last_msc + 1); + return; + } + + self->last_ust = cne->ust; + self->last_msc = cne->msc; + + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + auto now_us = (unsigned long)(now.tv_sec * 1000000L + now.tv_nsec / 1000); + double delay_sec = 0.0; + if (now_us < cne->ust) { + log_trace("The end of this vblank is %lu us into the " + "future", + cne->ust - now_us); + delay_sec = (double)(cne->ust - now_us) / 1000000.0; + } + // Wait until the end of the current vblank to invoke callbacks. If we + // call it too early, it can mistakenly think the render missed the + // vblank, and doesn't schedule render for the next vblank, causing frame + // drops. + assert(!ev_is_active(&self->callback_timer)); + ev_timer_set(&self->callback_timer, delay_sec, 0); + ev_timer_start(self->base.loop, &self->callback_timer); +} + +static bool handle_present_events(struct vblank_scheduler *base) { + auto self = (struct present_vblank_scheduler *)base; + xcb_present_generic_event_t *ev; + while ((ev = (void *)xcb_poll_for_special_event(base->c->c, self->event))) { + if (ev->event != self->event_id) { + // This event doesn't have the right event context, it's not meant + // for us. + goto next; + } + + // We only subscribed to the complete notify event. + assert(ev->evtype == XCB_PRESENT_EVENT_COMPLETE_NOTIFY); + handle_present_complete_notify(self, (void *)ev); + next: + free(ev); + } + return true; +} + +static const struct vblank_scheduler_ops vblank_scheduler_ops[LAST_VBLANK_SCHEDULER] = { + [VBLANK_SCHEDULER_PRESENT] = + { + .size = sizeof(struct present_vblank_scheduler), + .init = present_vblank_scheduler_init, + .deinit = present_vblank_scheduler_deinit, + .schedule = present_vblank_scheduler_schedule, + .handle_x_events = handle_present_events, + }, +#ifdef CONFIG_OPENGL + [VBLANK_SCHEDULER_SGI_VIDEO_SYNC] = + { + .size = sizeof(struct sgi_video_sync_vblank_scheduler), + .init = sgi_video_sync_scheduler_init, + .deinit = sgi_video_sync_scheduler_deinit, + .schedule = sgi_video_sync_scheduler_schedule, + .handle_x_events = NULL, + }, +#endif +}; + +static void vblank_scheduler_schedule_internal(struct vblank_scheduler *self) { + assert(self->type < LAST_VBLANK_SCHEDULER); + auto fn = vblank_scheduler_ops[self->type].schedule; + assert(fn != NULL); + fn(self); +} + +bool vblank_scheduler_schedule(struct vblank_scheduler *self, + vblank_callback_t vblank_callback, void *user_data) { + if (self->callback_count == 0 && self->wind_down == 0) { + vblank_scheduler_schedule_internal(self); + } + if (self->callback_count == self->callback_capacity) { + size_t new_capacity = + self->callback_capacity ? self->callback_capacity * 2 : 1; + void *new_buffer = + realloc(self->callbacks, new_capacity * sizeof(*self->callbacks)); + if (!new_buffer) { + return false; + } + self->callbacks = new_buffer; + self->callback_capacity = new_capacity; + } + self->callbacks[self->callback_count++] = (struct vblank_closure){ + .fn = vblank_callback, + .user_data = user_data, + }; + return true; +} + +static void +vblank_scheduler_invoke_callbacks(struct vblank_scheduler *self, struct vblank_event *event) { + // callbacks might be added during callback invocation, so we need to + // copy the callback_count. + size_t count = self->callback_count, write_head = 0; + if (count == 0) { + self->wind_down--; + } else { + self->wind_down = VBLANK_WIND_DOWN; + } + for (size_t i = 0; i < count; i++) { + auto action = self->callbacks[i].fn(event, self->callbacks[i].user_data); + switch (action) { + case VBLANK_CALLBACK_AGAIN: + if (i != write_head) { + self->callbacks[write_head] = self->callbacks[i]; + } + write_head++; + case VBLANK_CALLBACK_DONE: + default: // nothing to do + break; + } + } + memset(self->callbacks + write_head, 0, + (count - write_head) * sizeof(*self->callbacks)); + assert(count == self->callback_count && "callbacks should not be added when " + "callbacks are being invoked."); + self->callback_count = write_head; + if (self->callback_count || self->wind_down) { + vblank_scheduler_schedule_internal(self); + } +} + +void vblank_scheduler_free(struct vblank_scheduler *self) { + assert(self->type < LAST_VBLANK_SCHEDULER); + auto fn = vblank_scheduler_ops[self->type].deinit; + if (fn != NULL) { + fn(self); + } + free(self->callbacks); + free(self); +} + +struct vblank_scheduler * +vblank_scheduler_new(struct ev_loop *loop, struct x_connection *c, + xcb_window_t target_window, enum vblank_scheduler_type type) { + size_t object_size = vblank_scheduler_ops[type].size; + auto init_fn = vblank_scheduler_ops[type].init; + if (!object_size || !init_fn) { + log_error("Unsupported or invalid vblank scheduler type: %d", type); + return NULL; + } + + assert(object_size >= sizeof(struct vblank_scheduler)); + struct vblank_scheduler *self = calloc(1, object_size); + self->target_window = target_window; + self->c = c; + self->loop = loop; + init_fn(self); + return self; +} + +bool vblank_handle_x_events(struct vblank_scheduler *self) { + assert(self->type < LAST_VBLANK_SCHEDULER); + auto fn = vblank_scheduler_ops[self->type].handle_x_events; + if (fn != NULL) { + return fn(self); + } + return true; +} \ No newline at end of file diff --git a/src/vblank.h b/src/vblank.h new file mode 100644 index 0000000000..8050f4878d --- /dev/null +++ b/src/vblank.h @@ -0,0 +1,47 @@ +#pragma once + +#include +#include +#include +#include + +#include +#include + +#include "config.h" +#include "x.h" + +/// An object that schedule vblank events. +struct vblank_scheduler; + +struct vblank_event { + uint64_t msc; + uint64_t ust; +}; + +enum vblank_callback_action { + /// The callback should be called again in the next vblank. + VBLANK_CALLBACK_AGAIN, + /// The callback is done and should not be called again. + VBLANK_CALLBACK_DONE, +}; + +typedef enum vblank_callback_action (*vblank_callback_t)(struct vblank_event *event, + void *user_data); + +/// Schedule a vblank event. +/// +/// Schedule for `cb` to be called when the current vblank ends. If this is called +/// from a callback function for the current vblank, the newly scheduled callback +/// will be called in the next vblank. +/// +/// Returns whether the scheduling is successful. Scheduling can fail if there +/// is not enough memory. +bool vblank_scheduler_schedule(struct vblank_scheduler *self, vblank_callback_t cb, + void *user_data); +struct vblank_scheduler * +vblank_scheduler_new(struct ev_loop *loop, struct x_connection *c, + xcb_window_t target_window, enum vblank_scheduler_type type); +void vblank_scheduler_free(struct vblank_scheduler *); + +bool vblank_handle_x_events(struct vblank_scheduler *self); diff --git a/src/vsync.c b/src/vsync.c index 5980155837..57fbb595ef 100644 --- a/src/vsync.c +++ b/src/vsync.c @@ -77,31 +77,35 @@ static bool vsync_drm_init(session_t *ps) { * @return true for success, false otherwise */ static bool vsync_opengl_init(session_t *ps) { - if (!ensure_glx_context(ps)) + if (!ensure_glx_context(ps)) { return false; + } return glxext.has_GLX_SGI_video_sync; } static bool vsync_opengl_oml_init(session_t *ps) { - if (!ensure_glx_context(ps)) + if (!ensure_glx_context(ps)) { return false; + } return glxext.has_GLX_OML_sync_control; } static inline bool vsync_opengl_swc_swap_interval(session_t *ps, int interval) { - if (glxext.has_GLX_MESA_swap_control) + if (glxext.has_GLX_MESA_swap_control) { return glXSwapIntervalMESA((uint)interval) == 0; - else if (glxext.has_GLX_SGI_swap_control) + } + if (glxext.has_GLX_SGI_swap_control) { return glXSwapIntervalSGI(interval) == 0; - else if (glxext.has_GLX_EXT_swap_control) { + } + if (glxext.has_GLX_EXT_swap_control) { GLXDrawable d = glXGetCurrentDrawable(); if (d == None) { // We don't have a context?? return false; } - glXSwapIntervalEXT(ps->dpy, glXGetCurrentDrawable(), interval); + glXSwapIntervalEXT(ps->c.dpy, glXGetCurrentDrawable(), interval); return true; } return false; @@ -140,8 +144,8 @@ static int vsync_opengl_wait(session_t *ps attr_unused) { static int vsync_opengl_oml_wait(session_t *ps) { int64_t ust = 0, msc = 0, sbc = 0; - glXGetSyncValuesOML(ps->dpy, ps->reg_win, &ust, &msc, &sbc); - glXWaitForMscOML(ps->dpy, ps->reg_win, 0, 2, (msc + 1) % 2, &ust, &msc, &sbc); + glXGetSyncValuesOML(ps->c.dpy, ps->reg_win, &ust, &msc, &sbc); + glXWaitForMscOML(ps->c.dpy, ps->reg_win, 0, 2, (msc + 1) % 2, &ust, &msc, &sbc); return 0; } #endif diff --git a/src/win.c b/src/win.c index 370fbfd3d7..901b646cae 100644 --- a/src/win.c +++ b/src/win.c @@ -14,7 +14,6 @@ #include #include #include -#include #include "atom.h" #include "backend/backend.h" @@ -325,7 +324,7 @@ static inline bool win_bind_pixmap(struct backend_base *b, struct managed_win *w assert(!w->win_image); auto pixmap = x_new_id(b->c); auto e = xcb_request_check( - b->c, xcb_composite_name_window_pixmap_checked(b->c, w->base.id, pixmap)); + b->c->c, xcb_composite_name_window_pixmap_checked(b->c->c, w->base.id, pixmap)); if (e) { log_error("Failed to get named pixmap for window %#010x(%s)", w->base.id, w->name); @@ -346,10 +345,11 @@ static inline bool win_bind_pixmap(struct backend_base *b, struct managed_win *w } bool win_bind_mask(struct backend_base *b, struct managed_win *w) { + assert(!w->mask_image); auto reg_bound_local = win_get_bounding_shape_global_by_val(w); pixman_region32_translate(®_bound_local, -w->g.x, -w->g.y); w->mask_image = b->ops->make_mask( - b, (geometry_t){.width = w->g.width, .height = w->g.height}, ®_bound_local); + b, (geometry_t){.width = w->widthb, .height = w->heightb}, ®_bound_local); pixman_region32_fini(®_bound_local); if (!w->mask_image) { @@ -368,7 +368,11 @@ bool win_bind_shadow(struct backend_base *b, struct managed_win *w, struct color b->ops->shadow_from_mask == NULL) { w->shadow_image = b->ops->render_shadow(b, w->widthb, w->heightb, sctx, c); } else { - win_bind_mask(b, w); + if (!w->mask_image) { + // It's possible we already allocated a mask because of background + // blur + win_bind_mask(b, w); + } w->shadow_image = b->ops->shadow_from_mask(b, w->mask_image, sctx, c); } if (!w->shadow_image) { @@ -516,7 +520,7 @@ void win_process_update_flags(session_t *ps, struct managed_win *w) { win_clear_flags(w, WIN_FLAGS_POSITION_STALE); } - win_update_screen(ps->xinerama_nscrs, ps->xinerama_scr_regs, w); + win_update_monitor(&ps->monitors, w); } if (win_check_flags_all(w, WIN_FLAGS_PROPERTY_STALE)) { @@ -699,7 +703,7 @@ static inline bool win_bounding_shaped(const session_t *ps, xcb_window_t wid) { Bool bounding_shaped; reply = xcb_shape_query_extents_reply( - ps->c, xcb_shape_query_extents(ps->c, wid), NULL); + ps->c.c, xcb_shape_query_extents(ps->c.c, wid), NULL); bounding_shaped = reply && reply->bounding_shaped; free(reply); @@ -711,7 +715,7 @@ static inline bool win_bounding_shaped(const session_t *ps, xcb_window_t wid) { static wintype_t wid_get_prop_wintype(session_t *ps, xcb_window_t wid) { winprop_t prop = - x_get_prop(ps->c, wid, ps->atoms->a_NET_WM_WINDOW_TYPE, 32L, XCB_ATOM_ATOM, 32); + x_get_prop(&ps->c, wid, ps->atoms->a_NET_WM_WINDOW_TYPE, 32L, XCB_ATOM_ATOM, 32); for (unsigned i = 0; i < prop.nitems; ++i) { for (wintype_t j = 1; j < NUM_WINTYPES; ++j) { @@ -732,7 +736,7 @@ wid_get_opacity_prop(session_t *ps, xcb_window_t wid, opacity_t def, opacity_t * bool ret = false; *out = def; - winprop_t prop = x_get_prop(ps->c, wid, ps->atoms->a_NET_WM_WINDOW_OPACITY, 1L, + winprop_t prop = x_get_prop(&ps->c, wid, ps->atoms->a_NET_WM_WINDOW_OPACITY, 1L, XCB_ATOM_CARDINAL, 32); if (prop.nitems) { @@ -824,11 +828,12 @@ double win_calc_opacity_target(session_t *ps, const struct managed_win *w) { } else { // Respect active_opacity only when the window is physically // focused - if (win_is_focused_raw(ps, w)) + if (win_is_focused_raw(ps, w)) { opacity = ps->o.active_opacity; - else if (!w->focused) + } else if (!w->focused) { // Respect inactive_opacity in some cases opacity = ps->o.inactive_opacity; + } } // respect inactive override @@ -850,9 +855,8 @@ bool win_should_dim(session_t *ps, const struct managed_win *w) { if (ps->o.inactive_dim > 0 && !(w->focused)) { return true; - } else { - return false; } + return false; } /** @@ -884,7 +888,7 @@ bool win_should_fade(session_t *ps, const struct managed_win *w) { * The property must be set on the outermost window, usually the WM frame. */ void win_update_prop_shadow_raw(session_t *ps, struct managed_win *w) { - winprop_t prop = x_get_prop(ps->c, w->base.id, ps->atoms->a_COMPTON_SHADOW, 1, + winprop_t prop = x_get_prop(&ps->c, w->base.id, ps->atoms->a_COMPTON_SHADOW, 1, XCB_ATOM_CARDINAL, 32); if (!prop.nitems) { @@ -1082,8 +1086,9 @@ void win_set_shadow_force(session_t *ps, struct managed_win *w, switch_t val) { static void win_set_blur_background(session_t *ps, struct managed_win *w, bool blur_background_new) { - if (w->blur_background == blur_background_new) + if (w->blur_background == blur_background_new) { return; + } w->blur_background = blur_background_new; @@ -1139,13 +1144,24 @@ static void win_determine_rounded_corners(session_t *ps, struct managed_win *w) return; } - // Don't round full screen windows & excluded windows - if ((w && win_is_fullscreen(ps, w)) || - c2_match(ps, w, ps->o.rounded_corners_blacklist, NULL)) { + void *radius_override = NULL; + if (c2_match(ps, w, ps->o.corner_radius_rules, &radius_override)) { + log_debug("Matched corner rule! %d", w->corner_radius); + } + + // Don't round full screen windows & excluded windows, + // unless we find a corner override in corner_radius_rules + if (!radius_override && ((w && win_is_fullscreen(ps, w)) || + c2_match(ps, w, ps->o.rounded_corners_blacklist, NULL))) { w->corner_radius = 0; log_debug("Not rounding corners for window %#010x", w->base.id); } else { - w->corner_radius = ps->o.corner_radius; + if (radius_override) { + w->corner_radius = (int)(long)radius_override; + } else { + w->corner_radius = ps->o.corner_radius; + } + log_debug("Rounding corners for window %#010x", w->base.id); // Initialize the border color to an invalid value w->border_col[0] = w->border_col[1] = w->border_col[2] = @@ -1270,10 +1286,11 @@ void win_update_wintype(session_t *ps, struct managed_win *w) { // _NET_WM_WINDOW_TYPE_NORMAL, otherwise as _NET_WM_WINDOW_TYPE_DIALOG. if (WINTYPE_UNKNOWN == w->window_type) { if (w->a.override_redirect || - !wid_has_prop(ps, w->client_win, ps->atoms->aWM_TRANSIENT_FOR)) + !wid_has_prop(ps, w->client_win, ps->atoms->aWM_TRANSIENT_FOR)) { w->window_type = WINTYPE_NORMAL; - else + } else { w->window_type = WINTYPE_DIALOG; + } } if (w->window_type != wtype_old) { @@ -1298,9 +1315,9 @@ void win_mark_client(session_t *ps, struct managed_win *w, xcb_window_t client) } auto e = xcb_request_check( - ps->c, xcb_change_window_attributes( - ps->c, client, XCB_CW_EVENT_MASK, - (const uint32_t[]){determine_evmask(ps, client, WIN_EVMODE_CLIENT)})); + ps->c.c, xcb_change_window_attributes_checked( + ps->c.c, client, XCB_CW_EVENT_MASK, + (const uint32_t[]){determine_evmask(ps, client, WIN_EVMODE_CLIENT)})); if (e) { log_error("Failed to change event mask of window %#010x", client); free(e); @@ -1325,13 +1342,13 @@ void win_mark_client(session_t *ps, struct managed_win *w, xcb_window_t client) win_on_factor_change(ps, w); auto r = xcb_get_window_attributes_reply( - ps->c, xcb_get_window_attributes(ps->c, w->client_win), &e); + ps->c.c, xcb_get_window_attributes(ps->c.c, w->client_win), &e); if (!r) { log_error_x_error(e, "Failed to get client window attributes"); return; } - w->client_pictfmt = x_get_pictform_for_visual(ps->c, r->visual); + w->client_pictfmt = x_get_pictform_for_visual(&ps->c, r->visual); free(r); } @@ -1350,7 +1367,7 @@ void win_unmark_client(session_t *ps, struct managed_win *w) { // Recheck event mask xcb_change_window_attributes( - ps->c, client, XCB_CW_EVENT_MASK, + ps->c.c, client, XCB_CW_EVENT_MASK, (const uint32_t[]){determine_evmask(ps, client, WIN_EVMODE_UNKNOWN)}); } @@ -1363,7 +1380,7 @@ static xcb_window_t find_client_win(session_t *ps, xcb_window_t w) { } xcb_query_tree_reply_t *reply = - xcb_query_tree_reply(ps->c, xcb_query_tree(ps->c, w), NULL); + xcb_query_tree_reply(ps->c.c, xcb_query_tree(ps->c.c, w), NULL); if (!reply) { return 0; } @@ -1437,7 +1454,7 @@ void free_win_res(session_t *ps, struct managed_win *w) { pixman_region32_fini(&w->bounding_shape); // BadDamage may be thrown if the window is destroyed - set_ignore_cookie(ps, xcb_damage_destroy(ps->c, w->damage)); + set_ignore_cookie(&ps->c, xcb_damage_destroy(ps->c.c, w->damage)); rc_region_unref(&w->reg_ignore); free(w->name); free(w->class_instance); @@ -1486,12 +1503,11 @@ struct win *add_win_above(session_t *ps, xcb_window_t id, xcb_window_t below) { return NULL; } return add_win_top(ps, id); - } else { - // we found something from the hash table, so if the stack is - // empty, we are in an inconsistent state. - assert(!list_is_empty(&ps->window_stack)); - return add_win(ps, id, w->stack_neighbour.prev); } + // we found something from the hash table, so if the stack is + // empty, we are in an inconsistent state. + assert(!list_is_empty(&ps->window_stack)); + return add_win(ps, id, w->stack_neighbour.prev); } /// Query the Xorg for information about window `win` @@ -1549,7 +1565,7 @@ struct win *fill_win(session_t *ps, struct win *w) { .shadow = false, .clip_shadow_above = false, .fg_shader = NULL, - .xinerama_scr = -1, + .randr_monitor = -1, .mode = WMODE_TRANS, .ever_damaged = false, .client_win = XCB_NONE, @@ -1605,9 +1621,10 @@ struct win *fill_win(session_t *ps, struct win *w) { } log_debug("Managing window %#010x", w->id); - xcb_get_window_attributes_cookie_t acookie = xcb_get_window_attributes(ps->c, w->id); + xcb_get_window_attributes_cookie_t acookie = + xcb_get_window_attributes(ps->c.c, w->id); xcb_get_window_attributes_reply_t *a = - xcb_get_window_attributes_reply(ps->c, acookie, NULL); + xcb_get_window_attributes_reply(ps->c.c, acookie, NULL); if (!a || a->map_state == XCB_MAP_STATE_UNVIEWABLE) { // Failed to get window attributes or geometry probably means // the window is gone already. Unviewable means the window is @@ -1642,7 +1659,7 @@ struct win *fill_win(session_t *ps, struct win *w) { free(a); xcb_generic_error_t *e; - auto g = xcb_get_geometry_reply(ps->c, xcb_get_geometry(ps->c, w->id), &e); + auto g = xcb_get_geometry_reply(ps->c.c, xcb_get_geometry(ps->c.c, w->id), &e); if (!g) { log_error_x_error(e, "Failed to get geometry of window %#010x", w->id); free(e); @@ -1660,10 +1677,10 @@ struct win *fill_win(session_t *ps, struct win *w) { free(g); // Create Damage for window (if not Input Only) - new->damage = x_new_id(ps->c); + new->damage = x_new_id(&ps->c); e = xcb_request_check( - ps->c, xcb_damage_create_checked(ps->c, new->damage, w->id, - XCB_DAMAGE_REPORT_LEVEL_NON_EMPTY)); + ps->c.c, xcb_damage_create_checked(ps->c.c, new->damage, w->id, + XCB_DAMAGE_REPORT_LEVEL_NON_EMPTY)); if (e) { log_error_x_error(e, "Failed to create damage"); free(e); @@ -1673,15 +1690,15 @@ struct win *fill_win(session_t *ps, struct win *w) { // Set window event mask xcb_change_window_attributes( - ps->c, new->base.id, XCB_CW_EVENT_MASK, + ps->c.c, new->base.id, XCB_CW_EVENT_MASK, (const uint32_t[]){determine_evmask(ps, new->base.id, WIN_EVMODE_FRAME)}); // Get notification when the shape of a window changes if (ps->shape_exists) { - xcb_shape_select_input(ps->c, new->base.id, 1); + xcb_shape_select_input(ps->c.c, new->base.id, 1); } - new->pictfmt = x_get_pictform_for_visual(ps->c, new->a.visual); + new->pictfmt = x_get_pictform_for_visual(&ps->c, new->a.visual); new->client_pictfmt = NULL; list_replace(&w->stack_neighbour, &new->base.stack_neighbour); @@ -1751,12 +1768,12 @@ void win_update_leader(session_t *ps, struct managed_win *w) { // Read the leader properties if (ps->o.detect_transient && !leader) { leader = - wid_get_prop_window(ps->c, w->client_win, ps->atoms->aWM_TRANSIENT_FOR); + wid_get_prop_window(&ps->c, w->client_win, ps->atoms->aWM_TRANSIENT_FOR); } if (ps->o.detect_client_leader && !leader) { leader = - wid_get_prop_window(ps->c, w->client_win, ps->atoms->aWM_CLIENT_LEADER); + wid_get_prop_window(&ps->c, w->client_win, ps->atoms->aWM_CLIENT_LEADER); } win_set_leader(ps, w, leader); @@ -1772,8 +1789,9 @@ static xcb_window_t win_get_leader_raw(session_t *ps, struct managed_win *w, int // Rebuild the cache if needed if (!w->cache_leader && (w->client_win || w->leader)) { // Leader defaults to client window - if (!(w->cache_leader = w->leader)) + if (!(w->cache_leader = w->leader)) { w->cache_leader = w->client_win; + } // If the leader of this window isn't itself, look for its // ancestors @@ -1781,8 +1799,9 @@ static xcb_window_t win_get_leader_raw(session_t *ps, struct managed_win *w, int auto wp = find_toplevel(ps, w->cache_leader); if (wp) { // Dead loop? - if (recursions > WIN_GET_LEADER_MAX_RECURSION) + if (recursions > WIN_GET_LEADER_MAX_RECURSION) { return XCB_NONE; + } w->cache_leader = win_get_leader_raw(ps, wp, recursions + 1); } @@ -1801,8 +1820,9 @@ bool win_update_class(session_t *ps, struct managed_win *w) { int nstr = 0; // Can't do anything if there's no client window - if (!w->client_win) + if (!w->client_win) { return false; + } // Free and reset old strings free(w->class_instance); @@ -1942,8 +1962,9 @@ void win_update_bounding_shape(session_t *ps, struct managed_win *w) { */ xcb_shape_get_rectangles_reply_t *r = xcb_shape_get_rectangles_reply( - ps->c, - xcb_shape_get_rectangles(ps->c, w->base.id, XCB_SHAPE_SK_BOUNDING), NULL); + ps->c.c, + xcb_shape_get_rectangles(ps->c.c, w->base.id, XCB_SHAPE_SK_BOUNDING), + NULL); if (!r) { break; @@ -2016,7 +2037,7 @@ void win_update_opacity_prop(session_t *ps, struct managed_win *w) { * Retrieve frame extents from a window. */ void win_update_frame_extents(session_t *ps, struct managed_win *w, xcb_window_t client) { - winprop_t prop = x_get_prop(ps->c, client, ps->atoms->a_NET_FRAME_EXTENTS, 4L, + winprop_t prop = x_get_prop(&ps->c, client, ps->atoms->a_NET_FRAME_EXTENTS, 4L, XCB_ATOM_CARDINAL, 32); if (prop.nitems == 4) { @@ -2071,7 +2092,7 @@ bool win_is_region_ignore_valid(session_t *ps, const struct managed_win *w) { * Stop listening for events on a particular window. */ void win_ev_stop(session_t *ps, const struct win *w) { - xcb_change_window_attributes(ps->c, w->id, XCB_CW_EVENT_MASK, (const uint32_t[]){0}); + xcb_change_window_attributes(ps->c.c, w->id, XCB_CW_EVENT_MASK, (const uint32_t[]){0}); if (!w->managed) { return; @@ -2079,12 +2100,12 @@ void win_ev_stop(session_t *ps, const struct win *w) { auto mw = (struct managed_win *)w; if (mw->client_win) { - xcb_change_window_attributes(ps->c, mw->client_win, XCB_CW_EVENT_MASK, + xcb_change_window_attributes(ps->c.c, mw->client_win, XCB_CW_EVENT_MASK, (const uint32_t[]){0}); } if (ps->shape_exists) { - xcb_shape_select_input(ps->c, w->id, 0); + xcb_shape_select_input(ps->c.c, w->id, 0); } } @@ -2139,6 +2160,7 @@ static void destroy_win_finish(session_t *ps, struct win *w) { assert(mw->shadow_image != NULL); win_release_shadow(ps->backend_data, mw); } + win_release_mask(ps->backend_data, mw); // Invalidate reg_ignore of windows below this one // TODO(yshui) what if next_w is not mapped?? @@ -2411,7 +2433,7 @@ bool win_check_fade_finished(session_t *ps, struct managed_win *w) { case WSTATE_DESTROYING: destroy_win_finish(ps, &w->base); return true; case WSTATE_MAPPING: map_win_finish(w); return false; case WSTATE_FADING: w->state = WSTATE_MAPPED; break; - default: unreachable; + default: unreachable(); } } @@ -2432,33 +2454,24 @@ bool win_skip_fading(session_t *ps, struct managed_win *w) { return win_check_fade_finished(ps, w); } -/** - * Get the Xinerama screen a window is on. - * - * Return an index >= 0, or -1 if not found. - * - * TODO(yshui) move to x.c - * TODO(yshui) use xrandr - */ -void win_update_screen(int nscreens, region_t *screens, struct managed_win *w) { - w->xinerama_scr = -1; - - for (int i = 0; i < nscreens; i++) { - auto e = pixman_region32_extents(&screens[i]); - if (e->x1 <= w->g.x && e->y1 <= w->g.y && e->x2 >= w->g.x + w->widthb && - e->y2 >= w->g.y + w->heightb) { - w->xinerama_scr = i; - log_debug("Window %#010x (%s), %dx%d+%dx%d, is on screen " - "%d " - "(%dx%d+%dx%d)", - w->base.id, w->name, w->g.x, w->g.y, w->widthb, w->heightb, - i, e->x1, e->y1, e->x2 - e->x1, e->y2 - e->y1); +// TODO(absolutelynothelix): rename to x_update_win_(randr_?)monitor and move to +// the x.c. +void win_update_monitor(struct x_monitors *monitors, struct managed_win *mw) { + mw->randr_monitor = -1; + for (int i = 0; i < monitors->count; i++) { + auto e = pixman_region32_extents(&monitors->regions[i]); + if (e->x1 <= mw->g.x && e->y1 <= mw->g.y && + e->x2 >= mw->g.x + mw->widthb && e->y2 >= mw->g.y + mw->heightb) { + mw->randr_monitor = i; + log_debug("Window %#010x (%s), %dx%d+%dx%d, is entirely on the " + "monitor %d (%dx%d+%dx%d)", + mw->base.id, mw->name, mw->g.x, mw->g.y, mw->widthb, + mw->heightb, i, e->x1, e->y1, e->x2 - e->x1, e->y2 - e->y1); return; } } - log_debug("Window %#010x (%s), %dx%d+%dx%d, is not contained by any " - "screen", - w->base.id, w->name, w->g.x, w->g.y, w->g.width, w->g.height); + log_debug("Window %#010x (%s), %dx%d+%dx%d, is not entirely on any monitor", + mw->base.id, mw->name, mw->g.x, mw->g.y, mw->widthb, mw->heightb); } /// Map an already registered window @@ -2664,11 +2677,12 @@ struct managed_win *find_managed_window_or_parent(session_t *ps, xcb_window_t wi // We traverse through its ancestors to find out the frame // Using find_win here because if we found a unmanaged window we know // about, we can stop early. - while (wid && wid != ps->root && !(w = find_win(ps, wid))) { + while (wid && wid != ps->c.screen_info->root && !(w = find_win(ps, wid))) { // xcb_query_tree probably fails if you run picom when X is // somehow initializing (like add it in .xinitrc). In this case // just leave it alone. - auto reply = xcb_query_tree_reply(ps->c, xcb_query_tree(ps->c, wid), NULL); + auto reply = + xcb_query_tree_reply(ps->c.c, xcb_query_tree(ps->c.c, wid), NULL); if (reply == NULL) { break; } @@ -2744,7 +2758,7 @@ void win_clear_flags(struct managed_win *w, uint64_t flags) { } void win_set_properties_stale(struct managed_win *w, const xcb_atom_t *props, int nprops) { - const auto bits_per_element = sizeof(*w->stale_props) * 8; + auto const bits_per_element = sizeof(*w->stale_props) * 8; size_t new_capacity = w->stale_props_capacity; // Calculate the new capacity of the properties array @@ -2779,12 +2793,12 @@ static void win_clear_all_properties_stale(struct managed_win *w) { } static bool win_fetch_and_unset_property_stale(struct managed_win *w, xcb_atom_t prop) { - const auto bits_per_element = sizeof(*w->stale_props) * 8; + auto const bits_per_element = sizeof(*w->stale_props) * 8; if (prop >= w->stale_props_capacity * bits_per_element) { return false; } - const auto mask = 1UL << (prop % bits_per_element); + auto const mask = 1UL << (prop % bits_per_element); bool ret = w->stale_props[prop / bits_per_element] & mask; w->stale_props[prop / bits_per_element] &= ~mask; return ret; @@ -2805,7 +2819,7 @@ bool win_check_flags_all(struct managed_win *w, uint64_t flags) { */ bool win_is_fullscreen(const session_t *ps, const struct managed_win *w) { if (!ps->o.no_ewmh_fullscreen && - win_is_fullscreen_xcb(ps->c, ps->atoms, w->client_win)) { + win_is_fullscreen_xcb(ps->c.c, ps->atoms, w->client_win)) { return true; } return rect_is_fullscreen(ps, w->g.x, w->g.y, w->widthb, w->heightb) && @@ -2820,7 +2834,7 @@ bool win_is_fullscreen(const session_t *ps, const struct managed_win *w) { bool win_is_bypassing_compositor(const session_t *ps, const struct managed_win *w) { bool ret = false; - auto prop = x_get_prop(ps->c, w->client_win, ps->atoms->a_NET_WM_BYPASS_COMPOSITOR, + auto prop = x_get_prop(&ps->c, w->client_win, ps->atoms->a_NET_WM_BYPASS_COMPOSITOR, 1L, XCB_ATOM_CARDINAL, 32); if (prop.nitems && *prop.c32 == 1) { @@ -2841,13 +2855,13 @@ bool win_is_focused_raw(const session_t *ps, const struct managed_win *w) { // Find the managed window immediately below `i` in the window stack struct managed_win * -win_stack_find_next_managed(const session_t *ps, const struct list_node *i) { - while (!list_node_is_last(&ps->window_stack, i)) { - auto next = list_entry(i->next, struct win, stack_neighbour); +win_stack_find_next_managed(const session_t *ps, const struct list_node *w) { + while (!list_node_is_last(&ps->window_stack, w)) { + auto next = list_entry(w->next, struct win, stack_neighbour); if (next->managed) { return (struct managed_win *)next; } - i = &next->stack_neighbour; + w = &next->stack_neighbour; } return NULL; } diff --git a/src/win.h b/src/win.h index abc03d9701..51e7f9d32c 100644 --- a/src/win.h +++ b/src/win.h @@ -11,11 +11,6 @@ #include "uthash_extra.h" -// FIXME shouldn't need this -#ifdef CONFIG_OPENGL -#include -#endif - #include "c2.h" #include "compiler.h" #include "list.h" @@ -31,11 +26,12 @@ typedef struct session session_t; typedef struct _glx_texture glx_texture_t; #define win_stack_foreach_managed(w, win_stack) \ - list_foreach(struct managed_win, w, win_stack, base.stack_neighbour) if (w->base.managed) + list_foreach(struct managed_win, w, win_stack, \ + base.stack_neighbour) if ((w)->base.managed) #define win_stack_foreach_managed_safe(w, win_stack) \ list_foreach_safe(struct managed_win, w, win_stack, \ - base.stack_neighbour) if (w->base.managed) + base.stack_neighbour) if ((w)->base.managed) #ifdef CONFIG_OPENGL // FIXME this type should be in opengl.h @@ -123,8 +119,8 @@ struct managed_win { struct win_geometry g; /// Updated geometry received in events struct win_geometry pending_g; - /// Xinerama screen this window is on. - int xinerama_scr; + /// X RandR monitor this window is on. + int randr_monitor; /// Window visual pict format const xcb_render_pictforminfo_t *pictfmt; /// Client window visual pict format @@ -345,7 +341,9 @@ void win_recheck_client(session_t *ps, struct managed_win *w); */ double attr_pure win_calc_opacity_target(session_t *ps, const struct managed_win *w); bool attr_pure win_should_dim(session_t *ps, const struct managed_win *w); -void win_update_screen(int nscreens, region_t *screens, struct managed_win *w); + +void win_update_monitor(struct x_monitors *monitors, struct managed_win *mw); + /** * Retrieve the bounding shape of a window. */ diff --git a/src/x.c b/src/x.c index 795211dbcc..06c8b939d6 100644 --- a/src/x.c +++ b/src/x.c @@ -4,11 +4,15 @@ #include #include +#include #include #include #include #include +#include #include +#include +#include #include #include #include @@ -27,6 +31,72 @@ #include "utils.h" #include "x.h" +// === Error handling === + +/** + * Xlib error handler function. + */ +static int xerror(Display attr_unused *dpy, XErrorEvent *ev) { + if (!ps_g) { + // Do not ignore errors until the session has been initialized + return 0; + } + + // Fake a xcb error, fill in just enough information + xcb_generic_error_t xcb_err; + xcb_err.full_sequence = (uint32_t)ev->serial; + xcb_err.major_code = ev->request_code; + xcb_err.minor_code = ev->minor_code; + xcb_err.error_code = ev->error_code; + x_handle_error(&ps_g->c, &xcb_err); + return 0; +} + +void x_discard_pending(struct x_connection *c, uint32_t sequence) { + while (c->pending_reply_head && sequence > c->pending_reply_head->sequence) { + auto next = c->pending_reply_head->next; + free(c->pending_reply_head); + c->pending_reply_head = next; + } + if (!c->pending_reply_head) { + c->pending_reply_tail = &c->pending_reply_head; + } +} + +void x_handle_error(struct x_connection *c, xcb_generic_error_t *ev) { + x_discard_pending(c, ev->full_sequence); + if (c->pending_reply_head && c->pending_reply_head->sequence == ev->full_sequence) { + if (c->pending_reply_head->action != PENDING_REPLY_ACTION_IGNORE) { + x_log_error(LOG_LEVEL_ERROR, ev->full_sequence, ev->major_code, + ev->minor_code, ev->error_code); + } + switch (c->pending_reply_head->action) { + case PENDING_REPLY_ACTION_ABORT: + log_fatal("An unrecoverable X error occurred, aborting..."); + abort(); + case PENDING_REPLY_ACTION_DEBUG_ABORT: assert(false); break; + case PENDING_REPLY_ACTION_IGNORE: break; + } + return; + } + x_log_error(LOG_LEVEL_WARN, ev->full_sequence, ev->major_code, ev->minor_code, + ev->error_code); +} + +/// Initialize x_connection struct from an Xlib Display. +/// +/// Note this function doesn't take ownership of the Display, the caller is still +/// responsible for closing it after `free_x_connection` is called. +void x_connection_init(struct x_connection *c, Display *dpy) { + c->dpy = dpy; + c->c = XGetXCBConnection(dpy); + c->pending_reply_tail = &c->pending_reply_head; + c->previous_xerror_handler = XSetErrorHandler(xerror); + + c->screen = DefaultScreen(dpy); + c->screen_info = x_screen_of_display(c, c->screen); +} + /** * Get a specific attribute of a window. * @@ -42,11 +112,11 @@ * @return a winprop_t structure containing the attribute * and number of items. A blank one on failure. */ -winprop_t x_get_prop_with_offset(xcb_connection_t *c, xcb_window_t w, xcb_atom_t atom, +winprop_t x_get_prop_with_offset(const struct x_connection *c, xcb_window_t w, xcb_atom_t atom, int offset, int length, xcb_atom_t rtype, int rformat) { xcb_get_property_reply_t *r = xcb_get_property_reply( - c, - xcb_get_property(c, 0, w, atom, rtype, to_u32_checked(offset), + c->c, + xcb_get_property(c->c, 0, w, atom, rtype, to_u32_checked(offset), to_u32_checked(length)), NULL); @@ -70,10 +140,10 @@ winprop_t x_get_prop_with_offset(xcb_connection_t *c, xcb_window_t w, xcb_atom_t } /// Get the type, format and size in bytes of a window's specific attribute. -winprop_info_t x_get_prop_info(xcb_connection_t *c, xcb_window_t w, xcb_atom_t atom) { +winprop_info_t x_get_prop_info(const struct x_connection *c, xcb_window_t w, xcb_atom_t atom) { xcb_generic_error_t *e = NULL; auto r = xcb_get_property_reply( - c, xcb_get_property(c, 0, w, atom, XCB_ATOM_ANY, 0, 0), &e); + c->c, xcb_get_property(c->c, 0, w, atom, XCB_ATOM_ANY, 0, 0), &e); if (!r) { log_debug_x_error(e, "Failed to get property info for window %#010x", w); free(e); @@ -93,7 +163,7 @@ winprop_info_t x_get_prop_info(xcb_connection_t *c, xcb_window_t w, xcb_atom_t a * * @return the value if successful, 0 otherwise */ -xcb_window_t wid_get_prop_window(xcb_connection_t *c, xcb_window_t wid, xcb_atom_t aprop) { +xcb_window_t wid_get_prop_window(struct x_connection *c, xcb_window_t wid, xcb_atom_t aprop) { // Get the attribute xcb_window_t p = XCB_NONE; winprop_t prop = x_get_prop(c, wid, aprop, 1L, XCB_ATOM_WINDOW, 32); @@ -114,7 +184,7 @@ xcb_window_t wid_get_prop_window(xcb_connection_t *c, xcb_window_t wid, xcb_atom bool wid_get_text_prop(session_t *ps, xcb_window_t wid, xcb_atom_t prop, char ***pstrlst, int *pnstr) { assert(ps->server_grabbed); - auto prop_info = x_get_prop_info(ps->c, wid, prop); + auto prop_info = x_get_prop_info(&ps->c, wid, prop); auto type = prop_info.type; auto format = prop_info.format; auto length = prop_info.length; @@ -139,7 +209,7 @@ bool wid_get_text_prop(session_t *ps, xcb_window_t wid, xcb_atom_t prop, char ** xcb_generic_error_t *e = NULL; auto word_count = (length + 4 - 1) / 4; auto r = xcb_get_property_reply( - ps->c, xcb_get_property(ps->c, 0, wid, prop, type, 0, word_count), &e); + ps->c.c, xcb_get_property(ps->c.c, 0, wid, prop, type, 0, word_count), &e); if (!r) { log_debug_x_error(e, "Failed to get window property for %#010x", wid); free(e); @@ -197,14 +267,14 @@ bool wid_get_text_prop(session_t *ps, xcb_window_t wid, xcb_atom_t prop, char ** // of this program static thread_local xcb_render_query_pict_formats_reply_t *g_pictfmts = NULL; -static inline void x_get_server_pictfmts(xcb_connection_t *c) { +static inline void x_get_server_pictfmts(struct x_connection *c) { if (g_pictfmts) { return; } xcb_generic_error_t *e = NULL; // Get window picture format - g_pictfmts = - xcb_render_query_pict_formats_reply(c, xcb_render_query_pict_formats(c), &e); + g_pictfmts = xcb_render_query_pict_formats_reply( + c->c, xcb_render_query_pict_formats(c->c), &e); if (e || !g_pictfmts) { log_fatal("failed to get pict formats\n"); abort(); @@ -212,7 +282,7 @@ static inline void x_get_server_pictfmts(xcb_connection_t *c) { } const xcb_render_pictforminfo_t * -x_get_pictform_for_visual(xcb_connection_t *c, xcb_visualid_t visual) { +x_get_pictform_for_visual(struct x_connection *c, xcb_visualid_t visual) { x_get_server_pictfmts(c); xcb_render_pictvisual_t *pv = xcb_render_util_find_visual_format(g_pictfmts, visual); @@ -243,7 +313,7 @@ static xcb_visualid_t attr_pure x_get_visual_for_pictfmt(xcb_render_query_pict_f return XCB_NONE; } -xcb_visualid_t x_get_visual_for_standard(xcb_connection_t *c, xcb_pict_standard_t std) { +xcb_visualid_t x_get_visual_for_standard(struct x_connection *c, xcb_pict_standard_t std) { x_get_server_pictfmts(c); auto pictfmt = xcb_render_util_find_standard_format(g_pictfmts, std); @@ -252,7 +322,7 @@ xcb_visualid_t x_get_visual_for_standard(xcb_connection_t *c, xcb_pict_standard_ } xcb_render_pictformat_t -x_get_pictfmt_for_standard(xcb_connection_t *c, xcb_pict_standard_t std) { +x_get_pictfmt_for_standard(struct x_connection *c, xcb_pict_standard_t std) { x_get_server_pictfmts(c); auto pictfmt = xcb_render_util_find_standard_format(g_pictfmts, std); @@ -260,8 +330,8 @@ x_get_pictfmt_for_standard(xcb_connection_t *c, xcb_pict_standard_t std) { return pictfmt->id; } -int x_get_visual_depth(xcb_connection_t *c, xcb_visualid_t visual) { - auto setup = xcb_get_setup(c); +int x_get_visual_depth(struct x_connection *c, xcb_visualid_t visual) { + auto setup = xcb_get_setup(c->c); for (auto screen = xcb_setup_roots_iterator(setup); screen.rem; xcb_screen_next(&screen)) { for (auto depth = xcb_screen_allowed_depths_iterator(screen.data); @@ -279,7 +349,7 @@ int x_get_visual_depth(xcb_connection_t *c, xcb_visualid_t visual) { } xcb_render_picture_t -x_create_picture_with_pictfmt_and_pixmap(xcb_connection_t *c, +x_create_picture_with_pictfmt_and_pixmap(struct x_connection *c, const xcb_render_pictforminfo_t *pictfmt, xcb_pixmap_t pixmap, uint32_t valuemask, const xcb_render_create_picture_value_list_t *attr) { @@ -293,19 +363,20 @@ x_create_picture_with_pictfmt_and_pixmap(xcb_connection_t *c, } xcb_render_picture_t tmp_picture = x_new_id(c); - xcb_generic_error_t *e = - xcb_request_check(c, xcb_render_create_picture_checked( - c, tmp_picture, pixmap, pictfmt->id, valuemask, buf)); + xcb_generic_error_t *e = xcb_request_check( + c->c, xcb_render_create_picture_checked(c->c, tmp_picture, pixmap, + pictfmt->id, valuemask, buf)); free(buf); if (e) { log_error_x_error(e, "failed to create picture"); + free(e); return XCB_NONE; } return tmp_picture; } xcb_render_picture_t -x_create_picture_with_visual_and_pixmap(xcb_connection_t *c, xcb_visualid_t visual, +x_create_picture_with_visual_and_pixmap(struct x_connection *c, xcb_visualid_t visual, xcb_pixmap_t pixmap, uint32_t valuemask, const xcb_render_create_picture_value_list_t *attr) { const xcb_render_pictforminfo_t *pictfmt = x_get_pictform_for_visual(c, visual); @@ -313,7 +384,7 @@ x_create_picture_with_visual_and_pixmap(xcb_connection_t *c, xcb_visualid_t visu } xcb_render_picture_t -x_create_picture_with_standard_and_pixmap(xcb_connection_t *c, xcb_pict_standard_t standard, +x_create_picture_with_standard_and_pixmap(struct x_connection *c, xcb_pict_standard_t standard, xcb_pixmap_t pixmap, uint32_t valuemask, const xcb_render_create_picture_value_list_t *attr) { x_get_server_pictfmts(c); @@ -324,26 +395,26 @@ x_create_picture_with_standard_and_pixmap(xcb_connection_t *c, xcb_pict_standard } xcb_render_picture_t -x_create_picture_with_standard(xcb_connection_t *c, xcb_drawable_t d, int w, int h, +x_create_picture_with_standard(struct x_connection *c, int w, int h, xcb_pict_standard_t standard, uint32_t valuemask, const xcb_render_create_picture_value_list_t *attr) { x_get_server_pictfmts(c); auto pictfmt = xcb_render_util_find_standard_format(g_pictfmts, standard); assert(pictfmt); - return x_create_picture_with_pictfmt(c, d, w, h, pictfmt, valuemask, attr); + return x_create_picture_with_pictfmt(c, w, h, pictfmt, valuemask, attr); } /** * Create an picture. */ xcb_render_picture_t -x_create_picture_with_pictfmt(xcb_connection_t *c, xcb_drawable_t d, int w, int h, +x_create_picture_with_pictfmt(struct x_connection *c, int w, int h, const xcb_render_pictforminfo_t *pictfmt, uint32_t valuemask, const xcb_render_create_picture_value_list_t *attr) { uint8_t depth = pictfmt->depth; - xcb_pixmap_t tmp_pixmap = x_create_pixmap(c, depth, d, w, h); + xcb_pixmap_t tmp_pixmap = x_create_pixmap(c, depth, w, h); if (!tmp_pixmap) { return XCB_NONE; } @@ -351,23 +422,23 @@ x_create_picture_with_pictfmt(xcb_connection_t *c, xcb_drawable_t d, int w, int xcb_render_picture_t picture = x_create_picture_with_pictfmt_and_pixmap( c, pictfmt, tmp_pixmap, valuemask, attr); - xcb_free_pixmap(c, tmp_pixmap); + set_cant_fail_cookie(c, xcb_free_pixmap(c->c, tmp_pixmap)); return picture; } xcb_render_picture_t -x_create_picture_with_visual(xcb_connection_t *c, xcb_drawable_t d, int w, int h, - xcb_visualid_t visual, uint32_t valuemask, +x_create_picture_with_visual(struct x_connection *c, int w, int h, xcb_visualid_t visual, + uint32_t valuemask, const xcb_render_create_picture_value_list_t *attr) { auto pictfmt = x_get_pictform_for_visual(c, visual); - return x_create_picture_with_pictfmt(c, d, w, h, pictfmt, valuemask, attr); + return x_create_picture_with_pictfmt(c, w, h, pictfmt, valuemask, attr); } -bool x_fetch_region(xcb_connection_t *c, xcb_xfixes_region_t r, pixman_region32_t *res) { +bool x_fetch_region(struct x_connection *c, xcb_xfixes_region_t r, pixman_region32_t *res) { xcb_generic_error_t *e = NULL; xcb_xfixes_fetch_region_reply_t *xr = - xcb_xfixes_fetch_region_reply(c, xcb_xfixes_fetch_region(c, r), &e); + xcb_xfixes_fetch_region_reply(c->c, xcb_xfixes_fetch_region(c->c, r), &e); if (!xr) { log_error_x_error(e, "Failed to fetch rectangles"); return false; @@ -388,7 +459,42 @@ bool x_fetch_region(xcb_connection_t *c, xcb_xfixes_region_t r, pixman_region32_ return ret; } -void x_set_picture_clip_region(xcb_connection_t *c, xcb_render_picture_t pict, +uint32_t x_create_region(struct x_connection *c, const region_t *reg) { + if (!reg) { + return XCB_NONE; + } + + int nrects; + // In older pixman versions, pixman_region32_rectangles doesn't take const + // region_t, instead of dealing with this version difference, just suppress the + // warning. + const pixman_box32_t *rects = pixman_region32_rectangles((region_t *)reg, &nrects); + auto xrects = ccalloc(nrects, xcb_rectangle_t); + for (int i = 0; i < nrects; i++) { + xrects[i] = + (xcb_rectangle_t){.x = to_i16_checked(rects[i].x1), + .y = to_i16_checked(rects[i].y1), + .width = to_u16_checked(rects[i].x2 - rects[i].x1), + .height = to_u16_checked(rects[i].y2 - rects[i].y1)}; + } + + xcb_xfixes_region_t ret = x_new_id(c); + bool success = XCB_AWAIT_VOID(xcb_xfixes_create_region, c->c, ret, + to_u32_checked(nrects), xrects); + free(xrects); + if (!success) { + return XCB_NONE; + } + return ret; +} + +void x_destroy_region(struct x_connection *c, xcb_xfixes_region_t r) { + if (r != XCB_NONE) { + set_debug_cant_fail_cookie(c, xcb_xfixes_destroy_region(c->c, r)); + } +} + +void x_set_picture_clip_region(struct x_connection *c, xcb_render_picture_t pict, int16_t clip_x_origin, int16_t clip_y_origin, const region_t *reg) { int nrects; @@ -403,9 +509,10 @@ void x_set_picture_clip_region(xcb_connection_t *c, xcb_render_picture_t pict, }; } - xcb_generic_error_t *e = xcb_request_check( - c, xcb_render_set_picture_clip_rectangles_checked( - c, pict, clip_x_origin, clip_y_origin, to_u32_checked(nrects), xrects)); + xcb_generic_error_t *e = + xcb_request_check(c->c, xcb_render_set_picture_clip_rectangles_checked( + c->c, pict, clip_x_origin, clip_y_origin, + to_u32_checked(nrects), xrects)); if (e) { log_error_x_error(e, "Failed to set clip region"); free(e); @@ -413,16 +520,28 @@ void x_set_picture_clip_region(xcb_connection_t *c, xcb_render_picture_t pict, free(xrects); } -void x_clear_picture_clip_region(xcb_connection_t *c, xcb_render_picture_t pict) { +void x_clear_picture_clip_region(struct x_connection *c, xcb_render_picture_t pict) { + assert(pict != XCB_NONE); xcb_render_change_picture_value_list_t v = {.clipmask = XCB_NONE}; xcb_generic_error_t *e = xcb_request_check( - c, xcb_render_change_picture(c, pict, XCB_RENDER_CP_CLIP_MASK, &v)); + c->c, xcb_render_change_picture_checked(c->c, pict, XCB_RENDER_CP_CLIP_MASK, &v)); if (e) { log_error_x_error(e, "failed to clear clip region"); free(e); } } +/** + * Destroy a Picture. + * + * Picture must be valid. + */ +void x_free_picture(struct x_connection *c, xcb_render_picture_t p) { + assert(p != XCB_NONE); + auto cookie = xcb_render_free_picture(c->c, p); + set_debug_cant_fail_cookie(c, cookie); +} + enum { XSyncBadCounter = 0, XSyncBadAlarm = 1, @@ -527,8 +646,16 @@ _x_strerror(unsigned long serial, uint8_t major, uint16_t minor, uint8_t error_c /** * Log a X11 error */ +void x_log_error(enum log_level level, unsigned long serial, uint8_t major, + uint16_t minor, uint8_t error_code) { + if (unlikely(level >= log_get_level_tls())) { + log_printf(tls_logger, level, __func__, "%s", + _x_strerror(serial, major, minor, error_code)); + } +} + void x_print_error(unsigned long serial, uint8_t major, uint16_t minor, uint8_t error_code) { - log_debug("%s", _x_strerror(serial, major, minor, error_code)); + x_log_error(LOG_LEVEL_DEBUG, serial, major, minor, error_code); } /* @@ -547,12 +674,12 @@ const char *x_strerror(xcb_generic_error_t *e) { /** * Create a pixmap and check that creation succeeded. */ -xcb_pixmap_t x_create_pixmap(xcb_connection_t *c, uint8_t depth, xcb_drawable_t drawable, - int width, int height) { +xcb_pixmap_t x_create_pixmap(struct x_connection *c, uint8_t depth, int width, int height) { xcb_pixmap_t pix = x_new_id(c); - xcb_void_cookie_t cookie = xcb_create_pixmap_checked( - c, depth, pix, drawable, to_u16_checked(width), to_u16_checked(height)); - xcb_generic_error_t *err = xcb_request_check(c, cookie); + xcb_void_cookie_t cookie = + xcb_create_pixmap_checked(c->c, depth, pix, c->screen_info->root, + to_u16_checked(width), to_u16_checked(height)); + xcb_generic_error_t *err = xcb_request_check(c->c, cookie); if (err == NULL) { return pix; } @@ -568,12 +695,12 @@ xcb_pixmap_t x_create_pixmap(xcb_connection_t *c, uint8_t depth, xcb_drawable_t * Detect whether the pixmap is valid with XGetGeometry. Well, maybe there * are better ways. */ -bool x_validate_pixmap(xcb_connection_t *c, xcb_pixmap_t pixmap) { +bool x_validate_pixmap(struct x_connection *c, xcb_pixmap_t pixmap) { if (pixmap == XCB_NONE) { return false; } - auto r = xcb_get_geometry_reply(c, xcb_get_geometry(c, pixmap), NULL); + auto r = xcb_get_geometry_reply(c->c, xcb_get_geometry(c->c, pixmap), NULL); if (!r) { return false; } @@ -582,22 +709,27 @@ bool x_validate_pixmap(xcb_connection_t *c, xcb_pixmap_t pixmap) { free(r); return ret; } -/// Names of root window properties that could point to a pixmap of -/// background. -static const char *background_props_str[] = { - "_XROOTPMAP_ID", - "_XSETROOT_ID", - 0, -}; -xcb_pixmap_t -x_get_root_back_pixmap(xcb_connection_t *c, xcb_window_t root, struct atom *atoms) { +/// We don't use the _XSETROOT_ID root window property as a source of the background +/// pixmap because it most likely points to a dummy pixmap used to keep the colormap +/// associated with the background pixmap alive but we listen for it's changes and update +/// the background pixmap accordingly. +/// +/// For details on the _XSETROOT_ID root window property and it's usage see: +/// https://metacpan.org/pod/X11::Protocol::XSetRoot#_XSETROOT_ID +/// https://gitlab.freedesktop.org/xorg/app/xsetroot/-/blob/435d35409768de7cbc2c47a6322192dd4b480545/xsetroot.c#L318-352 +/// https://github.com/ImageMagick/ImageMagick/blob/d04a47227637dbb3af9231b0107ccf9677bf985e/MagickCore/xwindow.c#L9203-L9260 +/// https://github.com/ImageMagick/ImageMagick/blob/d04a47227637dbb3af9231b0107ccf9677bf985e/MagickCore/xwindow.c#L1853-L1922 +/// https://www.fvwm.org/Archive/Manpages/fvwm-root.html + +xcb_pixmap_t x_get_root_back_pixmap(struct x_connection *c, struct atom *atoms) { xcb_pixmap_t pixmap = XCB_NONE; - // Get the values of background attributes - for (int p = 0; background_props_str[p]; p++) { - xcb_atom_t prop_atom = get_atom(atoms, background_props_str[p]); - winprop_t prop = x_get_prop(c, root, prop_atom, 1, XCB_ATOM_PIXMAP, 32); + xcb_atom_t root_back_pixmap_atoms[] = {atoms->a_XROOTPMAP_ID, atoms->aESETROOT_PMAP_ID}; + for (size_t i = 0; i < ARR_SIZE(root_back_pixmap_atoms); i++) { + winprop_t prop = + x_get_prop(c, c->screen_info->root, root_back_pixmap_atoms[i], 1, + XCB_ATOM_PIXMAP, 32); if (prop.nitems) { pixmap = (xcb_pixmap_t)*prop.p32; free_winprop(&prop); @@ -610,37 +742,32 @@ x_get_root_back_pixmap(xcb_connection_t *c, xcb_window_t root, struct atom *atom } bool x_is_root_back_pixmap_atom(struct atom *atoms, xcb_atom_t atom) { - for (int p = 0; background_props_str[p]; p++) { - xcb_atom_t prop_atom = get_atom(atoms, background_props_str[p]); - if (prop_atom == atom) { - return true; - } - } - return false; + return atom == atoms->a_XROOTPMAP_ID || atom == atoms->aESETROOT_PMAP_ID || + atom == atoms->a_XSETROOT_ID; } /** * Synchronizes a X Render drawable to ensure all pending painting requests * are completed. */ -bool x_fence_sync(xcb_connection_t *c, xcb_sync_fence_t f) { +bool x_fence_sync(struct x_connection *c, xcb_sync_fence_t f) { // TODO(richardgv): If everybody just follows the rules stated in X Sync // prototype, we need only one fence per screen, but let's stay a bit // cautious right now - auto e = xcb_request_check(c, xcb_sync_trigger_fence_checked(c, f)); + auto e = xcb_request_check(c->c, xcb_sync_trigger_fence_checked(c->c, f)); if (e) { log_error_x_error(e, "Failed to trigger the fence"); goto err; } - e = xcb_request_check(c, xcb_sync_await_fence_checked(c, 1, &f)); + e = xcb_request_check(c->c, xcb_sync_await_fence_checked(c->c, 1, &f)); if (e) { log_error_x_error(e, "Failed to await on a fence"); goto err; } - e = xcb_request_check(c, xcb_sync_reset_fence_checked(c, f)); + e = xcb_request_check(c->c, xcb_sync_reset_fence_checked(c->c, f)); if (e) { log_error_x_error(e, "Failed to reset the fence"); goto err; @@ -652,6 +779,31 @@ bool x_fence_sync(xcb_connection_t *c, xcb_sync_fence_t f) { return false; } +void x_request_vblank_event(struct x_connection *c, xcb_window_t window, uint64_t msc) { + auto cookie = xcb_present_notify_msc(c->c, window, 0, msc, 1, 0); + set_cant_fail_cookie(c, cookie); +} + +static inline bool dpms_screen_is_off(xcb_dpms_info_reply_t *info) { + // state is a bool indicating whether dpms is enabled + return info->state && (info->power_level != XCB_DPMS_DPMS_MODE_ON); +} + +bool x_check_dpms_status(struct x_connection *c, bool *screen_is_off) { + auto r = xcb_dpms_info_reply(c->c, xcb_dpms_info(c->c), NULL); + if (!r) { + log_error("Failed to query DPMS status."); + return false; + } + auto now_screen_is_off = dpms_screen_is_off(r); + if (*screen_is_off != now_screen_is_off) { + log_debug("Screen is now %s", now_screen_is_off ? "off" : "on"); + *screen_is_off = now_screen_is_off; + } + free(r); + return true; +} + /** * Convert a struct conv to a X picture convolution filter, normalizing the kernel * in the process. Allow the caller to specify the element at the center of the kernel, @@ -702,7 +854,7 @@ void x_create_convolution_kernel(const conv *kernel, double center, /// Generate a search criteria for fbconfig from a X visual. /// Returns {-1, -1, -1, -1, -1, 0} on failure -struct xvisual_info x_get_visual_info(xcb_connection_t *c, xcb_visualid_t visual) { +struct xvisual_info x_get_visual_info(struct x_connection *c, xcb_visualid_t visual) { auto pictfmt = x_get_pictform_for_visual(c, visual); auto depth = x_get_visual_depth(c, visual); if (!pictfmt || depth == -1) { @@ -730,10 +882,10 @@ struct xvisual_info x_get_visual_info(xcb_connection_t *c, xcb_visualid_t visual }; } -xcb_screen_t *x_screen_of_display(xcb_connection_t *c, int screen) { +xcb_screen_t *x_screen_of_display(struct x_connection *c, int screen) { xcb_screen_iterator_t iter; - iter = xcb_setup_roots_iterator(xcb_get_setup(c)); + iter = xcb_setup_roots_iterator(xcb_get_setup(c->c)); for (; iter.rem; --screen, xcb_screen_next(&iter)) { if (screen == 0) { return iter.data; @@ -742,3 +894,35 @@ xcb_screen_t *x_screen_of_display(xcb_connection_t *c, int screen) { return NULL; } + +void x_update_monitors(struct x_connection *c, struct x_monitors *m) { + x_free_monitor_info(m); + + xcb_randr_get_monitors_reply_t *r = xcb_randr_get_monitors_reply( + c->c, xcb_randr_get_monitors(c->c, c->screen_info->root, true), NULL); + if (!r) { + return; + } + + m->count = xcb_randr_get_monitors_monitors_length(r); + m->regions = ccalloc(m->count, region_t); + xcb_randr_monitor_info_iterator_t monitor_info_it = + xcb_randr_get_monitors_monitors_iterator(r); + for (int i = 0; monitor_info_it.rem; xcb_randr_monitor_info_next(&monitor_info_it)) { + xcb_randr_monitor_info_t *mi = monitor_info_it.data; + pixman_region32_init_rect(&m->regions[i++], mi->x, mi->y, mi->width, mi->height); + } + + free(r); +} + +void x_free_monitor_info(struct x_monitors *m) { + if (m->regions) { + for (int i = 0; i < m->count; i++) { + pixman_region32_fini(&m->regions[i]); + } + free(m->regions); + m->regions = NULL; + } + m->count = 0; +} diff --git a/src/x.h b/src/x.h index 3b8787c7c5..df45b5cca7 100644 --- a/src/x.h +++ b/src/x.h @@ -1,6 +1,7 @@ // SPDX-License-Identifier: MPL-2.0 // Copyright (c) 2018 Yuxuan Shui #pragma once +#include #include #include #include @@ -55,6 +56,42 @@ struct xvisual_info { xcb_visualid_t visual; }; +enum pending_reply_action { + PENDING_REPLY_ACTION_IGNORE, + PENDING_REPLY_ACTION_ABORT, + PENDING_REPLY_ACTION_DEBUG_ABORT, +}; + +typedef struct pending_reply { + struct pending_reply *next; + unsigned long sequence; + enum pending_reply_action action; +} pending_reply_t; + +struct x_connection { + /// XCB connection. + xcb_connection_t *c; + /// Display in use. + Display *dpy; + /// Head pointer of the error ignore linked list. + pending_reply_t *pending_reply_head; + /// Pointer to the next member of tail element of the error + /// ignore linked list. + pending_reply_t **pending_reply_tail; + /// Previous handler of X errors + XErrorHandler previous_xerror_handler; + /// Default screen + int screen; + /// Information about the default screen + xcb_screen_t *screen_info; +}; + +/// Monitor info +struct x_monitors { + int count; + region_t *regions; +}; + #define XCB_AWAIT_VOID(func, c, ...) \ ({ \ bool __success = true; \ @@ -92,8 +129,8 @@ struct xvisual_info { #define DOUBLE_TO_XFIXED(value) ((xcb_render_fixed_t)(((double)(value)) * 65536)) /// Wraps x_new_id. abort the program if x_new_id returns error -static inline uint32_t x_new_id(xcb_connection_t *c) { - auto ret = xcb_generate_id(c); +static inline uint32_t x_new_id(struct x_connection *c) { + auto ret = xcb_generate_id(c->c); if (ret == (uint32_t)-1) { log_fatal("We seems to have run of XIDs. This is either a bug in the X " "server, or a resource leakage in the compositor. Please open " @@ -103,6 +140,73 @@ static inline uint32_t x_new_id(xcb_connection_t *c) { return ret; } +static void set_reply_action(struct x_connection *c, uint32_t sequence, + enum pending_reply_action action) { + auto i = cmalloc(pending_reply_t); + + i->sequence = sequence; + i->next = 0; + i->action = action; + *c->pending_reply_tail = i; + c->pending_reply_tail = &i->next; +} + +/** + * Ignore X errors caused by given X request. + */ +static inline void attr_unused set_ignore_cookie(struct x_connection *c, + xcb_void_cookie_t cookie) { + set_reply_action(c, cookie.sequence, PENDING_REPLY_ACTION_IGNORE); +} + +static inline void attr_unused set_cant_fail_cookie(struct x_connection *c, + xcb_void_cookie_t cookie) { + set_reply_action(c, cookie.sequence, PENDING_REPLY_ACTION_ABORT); +} + +static inline void attr_unused set_debug_cant_fail_cookie(struct x_connection *c, + xcb_void_cookie_t cookie) { +#ifndef NDEBUG + set_reply_action(c, cookie.sequence, PENDING_REPLY_ACTION_DEBUG_ABORT); +#else + (void)c; + (void)cookie; +#endif +} + +static inline void attr_unused free_x_connection(struct x_connection *c) { + pending_reply_t *next = NULL; + for (auto ign = c->pending_reply_head; ign; ign = next) { + next = ign->next; + + free(ign); + } + + // Reset head and tail + c->pending_reply_head = NULL; + c->pending_reply_tail = &c->pending_reply_head; + + XSetErrorHandler(c->previous_xerror_handler); +} + +/// Initialize x_connection struct from an Xlib Display. +/// +/// Note this function doesn't take ownership of the Display, the caller is still +/// responsible for closing it after `free_x_connection` is called. +void x_connection_init(struct x_connection *c, Display *dpy); + +/// Discard queued pending replies. +/// +/// We have received reply with sequence number `sequence`, which means all pending +/// replies with sequence number less than `sequence` will never be received. So discard +/// them. +void x_discard_pending(struct x_connection *c, uint32_t sequence); + +/// Handle X errors. +/// +/// This function logs X errors, or aborts the program based on severity of the error. +void x_handle_error(struct x_connection *c, xcb_generic_error_t *ev); + /** * Send a request to X server and get the reply to make sure all previous * requests are processed, and their replies received @@ -110,8 +214,8 @@ static inline uint32_t x_new_id(xcb_connection_t *c) { * xcb_get_input_focus is used here because it is the same request used by * libX11 */ -static inline void x_sync(xcb_connection_t *c) { - free(xcb_get_input_focus_reply(c, xcb_get_input_focus(c), NULL)); +static inline void x_sync(struct x_connection *c) { + free(xcb_get_input_focus_reply(c->c, xcb_get_input_focus(c->c), NULL)); } /** @@ -129,25 +233,26 @@ static inline void x_sync(xcb_connection_t *c) { * @return a winprop_t structure containing the attribute * and number of items. A blank one on failure. */ -winprop_t x_get_prop_with_offset(xcb_connection_t *c, xcb_window_t w, xcb_atom_t atom, +winprop_t x_get_prop_with_offset(const struct x_connection *c, xcb_window_t w, xcb_atom_t atom, int offset, int length, xcb_atom_t rtype, int rformat); /** * Wrapper of wid_get_prop_adv(). */ -static inline winprop_t x_get_prop(xcb_connection_t *c, xcb_window_t wid, xcb_atom_t atom, - int length, xcb_atom_t rtype, int rformat) { +static inline winprop_t +x_get_prop(const struct x_connection *c, xcb_window_t wid, xcb_atom_t atom, int length, + xcb_atom_t rtype, int rformat) { return x_get_prop_with_offset(c, wid, atom, 0L, length, rtype, rformat); } /// Get the type, format and size in bytes of a window's specific attribute. -winprop_info_t x_get_prop_info(xcb_connection_t *c, xcb_window_t w, xcb_atom_t atom); +winprop_info_t x_get_prop_info(const struct x_connection *c, xcb_window_t w, xcb_atom_t atom); /// Discard all X events in queue or in flight. Should only be used when the server is /// grabbed -static inline void x_discard_events(xcb_connection_t *c) { +static inline void x_discard_events(struct x_connection *c) { xcb_generic_event_t *e; - while ((e = xcb_poll_for_event(c))) { + while ((e = xcb_poll_for_event(c->c))) { free(e); } } @@ -157,7 +262,7 @@ static inline void x_discard_events(xcb_connection_t *c) { * * @return the value if successful, 0 otherwise */ -xcb_window_t wid_get_prop_window(xcb_connection_t *c, xcb_window_t wid, xcb_atom_t aprop); +xcb_window_t wid_get_prop_window(struct x_connection *c, xcb_window_t wid, xcb_atom_t aprop); /** * Get the value of a text property of a window. @@ -170,30 +275,30 @@ bool wid_get_text_prop(session_t *ps, xcb_window_t wid, xcb_atom_t prop, char ** int *pnstr); const xcb_render_pictforminfo_t * -x_get_pictform_for_visual(xcb_connection_t *, xcb_visualid_t); -int x_get_visual_depth(xcb_connection_t *, xcb_visualid_t); +x_get_pictform_for_visual(struct x_connection *, xcb_visualid_t); +int x_get_visual_depth(struct x_connection *, xcb_visualid_t); xcb_render_picture_t -x_create_picture_with_pictfmt_and_pixmap(xcb_connection_t *, +x_create_picture_with_pictfmt_and_pixmap(struct x_connection *, const xcb_render_pictforminfo_t *pictfmt, xcb_pixmap_t pixmap, uint32_t valuemask, const xcb_render_create_picture_value_list_t *attr) attr_nonnull(1, 2); xcb_render_picture_t -x_create_picture_with_visual_and_pixmap(xcb_connection_t *, xcb_visualid_t visual, +x_create_picture_with_visual_and_pixmap(struct x_connection *, xcb_visualid_t visual, xcb_pixmap_t pixmap, uint32_t valuemask, const xcb_render_create_picture_value_list_t *attr) attr_nonnull(1); xcb_render_picture_t -x_create_picture_with_standard_and_pixmap(xcb_connection_t *, xcb_pict_standard_t standard, +x_create_picture_with_standard_and_pixmap(struct x_connection *, xcb_pict_standard_t standard, xcb_pixmap_t pixmap, uint32_t valuemask, const xcb_render_create_picture_value_list_t *attr) attr_nonnull(1); xcb_render_picture_t -x_create_picture_with_standard(xcb_connection_t *c, xcb_drawable_t d, int w, int h, +x_create_picture_with_standard(struct x_connection *c, int w, int h, xcb_pict_standard_t standard, uint32_t valuemask, const xcb_render_create_picture_value_list_t *attr) attr_nonnull(1); @@ -202,29 +307,44 @@ x_create_picture_with_standard(xcb_connection_t *c, xcb_drawable_t d, int w, int * Create an picture. */ xcb_render_picture_t -x_create_picture_with_pictfmt(xcb_connection_t *, xcb_drawable_t, int w, int h, +x_create_picture_with_pictfmt(struct x_connection *, int w, int h, const xcb_render_pictforminfo_t *pictfmt, uint32_t valuemask, const xcb_render_create_picture_value_list_t *attr) - attr_nonnull(1, 5); + attr_nonnull(1, 4); xcb_render_picture_t -x_create_picture_with_visual(xcb_connection_t *, xcb_drawable_t, int w, int h, - xcb_visualid_t visual, uint32_t valuemask, +x_create_picture_with_visual(struct x_connection *, int w, int h, xcb_visualid_t visual, + uint32_t valuemask, const xcb_render_create_picture_value_list_t *attr) attr_nonnull(1); /// Fetch a X region and store it in a pixman region -bool x_fetch_region(xcb_connection_t *, xcb_xfixes_region_t r, region_t *res); +bool x_fetch_region(struct x_connection *, xcb_xfixes_region_t r, region_t *res); + +/// Create a X region from a pixman region +uint32_t x_create_region(struct x_connection *c, const region_t *reg); -void x_set_picture_clip_region(xcb_connection_t *, xcb_render_picture_t, int16_t clip_x_origin, - int16_t clip_y_origin, const region_t *); +/// Destroy a X region +void x_destroy_region(struct x_connection *c, uint32_t region); -void x_clear_picture_clip_region(xcb_connection_t *, xcb_render_picture_t pict); +void x_set_picture_clip_region(struct x_connection *, xcb_render_picture_t, + int16_t clip_x_origin, int16_t clip_y_origin, const region_t *); + +void x_clear_picture_clip_region(struct x_connection *, xcb_render_picture_t pict); + +/** + * Destroy a Picture. + * + * Picture must be valid. + */ +void x_free_picture(struct x_connection *c, xcb_render_picture_t p); /** * Log a X11 error */ void x_print_error(unsigned long serial, uint8_t major, uint16_t minor, uint8_t error_code); +void x_log_error(enum log_level level, unsigned long serial, uint8_t major, + uint16_t minor, uint8_t error_code); /* * Convert a xcb_generic_error_t to a string that describes the error @@ -234,10 +354,9 @@ void x_print_error(unsigned long serial, uint8_t major, uint16_t minor, uint8_t */ const char *x_strerror(xcb_generic_error_t *e); -xcb_pixmap_t x_create_pixmap(xcb_connection_t *, uint8_t depth, xcb_drawable_t drawable, - int width, int height); +xcb_pixmap_t x_create_pixmap(struct x_connection *, uint8_t depth, int width, int height); -bool x_validate_pixmap(xcb_connection_t *, xcb_pixmap_t pxmap); +bool x_validate_pixmap(struct x_connection *, xcb_pixmap_t pxmap); /** * Free a winprop_t. @@ -246,22 +365,22 @@ bool x_validate_pixmap(xcb_connection_t *, xcb_pixmap_t pxmap); */ static inline void free_winprop(winprop_t *pprop) { // Empty the whole structure to avoid possible issues - if (pprop->r) + if (pprop->r) { free(pprop->r); + } pprop->ptr = NULL; pprop->r = NULL; pprop->nitems = 0; } /// Get the back pixmap of the root window -xcb_pixmap_t -x_get_root_back_pixmap(xcb_connection_t *c, xcb_window_t root, struct atom *atoms); +xcb_pixmap_t x_get_root_back_pixmap(struct x_connection *c, struct atom *atoms); /// Return true if the atom refers to a property name that is used for the /// root window background pixmap bool x_is_root_back_pixmap_atom(struct atom *atoms, xcb_atom_t atom); -bool x_fence_sync(xcb_connection_t *, xcb_sync_fence_t); +bool x_fence_sync(struct x_connection *, xcb_sync_fence_t); struct x_convolution_kernel { int size; @@ -285,13 +404,26 @@ void attr_nonnull(1, 3) x_create_convolution_kernel(const conv *kernel, double c /// Generate a search criteria for fbconfig from a X visual. /// Returns {-1, -1, -1, -1, -1, -1} on failure -struct xvisual_info x_get_visual_info(xcb_connection_t *c, xcb_visualid_t visual); +struct xvisual_info x_get_visual_info(struct x_connection *c, xcb_visualid_t visual); -xcb_visualid_t x_get_visual_for_standard(xcb_connection_t *c, xcb_pict_standard_t std); +xcb_visualid_t x_get_visual_for_standard(struct x_connection *c, xcb_pict_standard_t std); xcb_render_pictformat_t -x_get_pictfmt_for_standard(xcb_connection_t *c, xcb_pict_standard_t std); +x_get_pictfmt_for_standard(struct x_connection *c, xcb_pict_standard_t std); + +xcb_screen_t *x_screen_of_display(struct x_connection *c, int screen); -xcb_screen_t *x_screen_of_display(xcb_connection_t *c, int screen); +/// Populates a `struct x_monitors` with the current monitor configuration. +void x_update_monitors(struct x_connection *, struct x_monitors *); +/// Free memory allocated for a `struct x_monitors`. +void x_free_monitor_info(struct x_monitors *); uint32_t attr_deprecated xcb_generate_id(xcb_connection_t *c); + +/// Ask X server to send us a notification for the next end of vblank. +void x_request_vblank_event(struct x_connection *c, xcb_window_t window, uint64_t msc); + +/// Update screen_is_off to reflect the current DPMS state. +/// +/// Returns true if the DPMS state was successfully queried, false otherwise. +bool x_check_dpms_status(struct x_connection *c, bool *screen_is_off); diff --git a/tests/configs/parsing_test.conf b/tests/configs/parsing_test.conf index 5269e6e842..7b6acd310a 100644 --- a/tests/configs/parsing_test.conf +++ b/tests/configs/parsing_test.conf @@ -64,8 +64,9 @@ shadow-exclude = [ # # shadow-exclude-reg = "" -# Crop shadow of a window fully on a particular Xinerama screen to the screen. -# xinerama-shadow-crop = false +# Crop shadow of a window fully on a particular monitor to that monitor. This is +# currently implemented using the X RandR extension. +# crop-shadow-to-monitor = false ################################# @@ -154,6 +155,11 @@ rounded-corners-exclude = [ "window_type = 'desktop'" ]; +corner-radius-rules = [ + "10:window_type = 'dock'", + "0x32:window_type = 'desktop'" +]; + ################################# # Background-Blurring # @@ -311,7 +317,7 @@ detect-transient = true; # glx-no-rebind-pixmap = false # Disable the use of damage information. -# This cause the whole screen to be redrawn everytime, instead of the part of the screen +# This cause the whole screen to be redrawn every time, instead of the part of the screen # has actually changed. Potentially degrades the performance, but might fix some artifacts. # The opposing option is use-damage # @@ -400,7 +406,7 @@ log-level = "warn"; # transparent, and you want shadows in those areas. # # clip-shadow-above::: -# Controls wether shadows that would have been drawn above the window should +# Controls whether shadows that would have been drawn above the window should # be clipped. Useful for dock windows that should have no shadow painted on top. # # redir-ignore:::