sungmg/mutter-performance-source
1
0
Fork 0
Code Activity
mutter-performance-source/src/backends/native/meta-cursor-renderer-native.c

1999 lines
68 KiB
C
Raw Normal View History

backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright (C) 2014 Red Hat
cursor-renderer/native: Handle GPU hotplug Listen for GPU hotplug events to initialize their cursor support. This fixes one reason for why DisplayLink devices may not be using a hardware cursor. Particularly, when a DisplayLink device is hotplugged for the first time such that EVDI creates a new DRM device node after gnome-shell has already started, we used to forget to initialize the cursor support. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1097
2020-02-24 13:36:24 +00:00
* Copyright 2020 DisplayLink (UK) Ltd.
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
* Written by:
* Jasper St. Pierre <jstpierre@mecheye.net>
*/
#include "config.h"
Clean up include macros mess The order and way include macros were structured was chaotic, with no real common thread between files. Try to tidy up the mess with some common scheme, to make things look less messy.
2018-07-10 08:36:24 +00:00
#include "backends/native/meta-cursor-renderer-native.h"
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
#include <string.h>
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
#include <gbm.h>
Support for hardware cursor sizes other than 64x64 on wayland Use the new DRM capabilities to figure out the correct cursor size, and make sure that matches instead of hardcoding 64x64. This fixes incorrect rendering on some newer AMD cards that support 256x256 cursors. Based heavily on a patch by: Alvaro Fernando García <alvarofernandogarcia@gmail.com>
2014-09-24 21:40:09 +00:00
#include <xf86drm.h>
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
#include <errno.h>
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
Move cogl KMS winsys into the native backend Move the KMS interaction from cogl into mutter, where most of the other KMS interaction already takes place. This also removes dead code which were only excercised when non-mutter callers used the cogl KMS backend. The cogl KMS API was updated to pass via MetaRendererNative instead of via the different cogl objects. https://bugzilla.gnome.org/show_bug.cgi?id=768976
2016-05-09 11:51:29 +00:00
#include "backends/meta-backend-private.h"
cursor-renderer: Centralize hw cursor realization paths Use a common entry point into the cursor renderer implementations HW cursor realization paths for all cursor sprite types. This is in preparation for realizing at more strategic times. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 12:34:02 +00:00
#include "backends/meta-cursor-sprite-xcursor.h"
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
#include "backends/meta-logical-monitor.h"
#include "backends/meta-monitor.h"
Move cogl KMS winsys into the native backend Move the KMS interaction from cogl into mutter, where most of the other KMS interaction already takes place. This also removes dead code which were only excercised when non-mutter callers used the cogl KMS backend. The cogl KMS API was updated to pass via MetaRendererNative instead of via the different cogl objects. https://bugzilla.gnome.org/show_bug.cgi?id=768976
2016-05-09 11:51:29 +00:00
#include "backends/meta-monitor-manager-private.h"
Make MetaOutput a GObject Turn MetaOutput into a GObject and move it to a separate file. This changes the storage format, resulting in changing the API for accessing MetaOutputs from using an array, to using a GList. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-03-24 09:35:51 +00:00
#include "backends/meta-output.h"
drm-buffer: Create from MetaDeviceFile instead of MetaKmsDevice The DRM buffers aren't really tied to mode setting, so they shouldn't need to have an associated mode setting device. Now that we have a device file level object that can fill this role, port over MetaDrmBuffer and friends away from MetaKmsDevice to MetaDeviceFile. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1828>
2021-04-12 14:13:29 +00:00
#include "backends/native/meta-backend-native-private.h"
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
#include "backends/native/meta-crtc-kms.h"
drm-buffer: Create from MetaDeviceFile instead of MetaKmsDevice The DRM buffers aren't really tied to mode setting, so they shouldn't need to have an associated mode setting device. Now that we have a device file level object that can fill this role, port over MetaDrmBuffer and friends away from MetaKmsDevice to MetaDeviceFile. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1828>
2021-04-12 14:13:29 +00:00
#include "backends/native/meta-device-pool.h"
cursor-renderer/native: Support allocating dumb buffers This makes it possible to allocate HW cursor without a gbm_device, e.g. when using EGLStream/EGLDevice. Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/1980 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:38:37 +00:00
#include "backends/native/meta-drm-buffer-dumb.h"
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
#include "backends/native/meta-drm-buffer-gbm.h"
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
#include "backends/native/meta-kms-device.h"
cursor-renderer/native: Postpone cursor update if modeset is pending If a modeset is pending, it's likely that the cursor update will not work; thus, wait with updating the cursor so that it's applied together with the mode set update. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-02 14:43:45 +00:00
#include "backends/native/meta-kms-plane.h"
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
#include "backends/native/meta-kms-update.h"
#include "backends/native/meta-kms.h"
Move cogl KMS winsys into the native backend Move the KMS interaction from cogl into mutter, where most of the other KMS interaction already takes place. This also removes dead code which were only excercised when non-mutter callers used the cogl KMS backend. The cogl KMS API was updated to pass via MetaRendererNative instead of via the different cogl objects. https://bugzilla.gnome.org/show_bug.cgi?id=768976
2016-05-09 11:51:29 +00:00
#include "backends/native/meta-renderer-native.h"
cursor-renderer: Track cursor position using floats To be able to render the pointer cursor sprite at sub-(logical)-pixel positions, track the pointer position using floats instead of ints. This also requires users of the cursor sprite rect to deal with floating points, when e.g. finding the logical monitor etc. https://bugzilla.gnome.org/show_bug.cgi?id=765011
2017-06-08 14:13:16 +00:00
#include "core/boxes-private.h"
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
#include "meta/boxes.h"
Clean up include macros mess The order and way include macros were structured was chaotic, with no real common thread between files. Try to tidy up the mess with some common scheme, to make things look less messy.
2018-07-10 08:36:24 +00:00
#include "meta/meta-backend.h"
#include "meta/util.h"
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
cursor-renderer/native: Fetch instead of pass wl_buffer when realizing This is the next step in centralizing the cursor sprite hw sprite realization paths. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 10:27:02 +00:00
#ifdef HAVE_WAYLAND
#include "wayland/meta-cursor-sprite-wayland.h"
#include "wayland/meta-wayland-buffer.h"
#endif
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
/* When animating a cursor, we usually call drmModeSetCursor2 once per frame.
* Though, testing shows that we need to triple buffer the cursor buffer in
* order to avoid glitches when animating the cursor, at least when running on
* Intel. The reason for this might be (but is not confirmed to be) due to
* the user space gbm_bo cache, making us reuse and overwrite the kernel side
* buffer content before it was scanned out. To avoid this, we keep a user space
* reference to each buffer we set until at least one frame after it was drawn.
* In effect, this means we three active cursor gbm_bo's: one that that just has
* been set, one that was previously set and may or may not have been scanned
* out, and one pending that will be replaced if the cursor sprite changes.
*/
#define HW_CURSOR_BUFFER_COUNT 3
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
static GQuark quark_cursor_sprite = 0;
cursor-renderer/native: Store struct in CRTC private In this struct, for now only the buffer is stored, but it'll be used for more state in later commits. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 21:57:03 +00:00
typedef struct _CrtcCursorData
{
MetaDrmBuffer *buffer;
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
gboolean needs_sync_position;
gboolean hw_state_invalidated;
cursor-renderer/native: Store struct in CRTC private In this struct, for now only the buffer is stored, but it'll be used for more state in later commits. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 21:57:03 +00:00
} CrtcCursorData;
cursor-renderer-native: Cleanup type declaration Use G_DECLARE_FINAL_TYPE instead of the old macros. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-07 08:06:22 +00:00
struct _MetaCursorRendererNative
{
MetaCursorRenderer parent;
};
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
struct _MetaCursorRendererNativePrivate
{
backend: Move GPU ownership from the monitor manager to the backend Lets work towards making MetaMonitorManager about managing monitors, and not about managing GPUs. This changes other units to keep a pointer to the backend instead of a monitor manager, in case their ownership changed, or their main usage of the monitor manager was to look up GPUs. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-11 14:35:42 +00:00
MetaBackend *backend;
native/cursor-renderer: Cleanup construction Pass the backend to a new factory function, and keep a pointer to the monitor manager, which is accessed elsewhere in the same file instead of fetching the singleton. The HW cursor initialization part is also made more obvious, without depending on seemingly irrelevant clutter features. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-07 08:12:07 +00:00
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
gboolean has_hw_cursor;
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 03:23:00 +00:00
MetaCursorSprite *last_cursor;
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
guint animation_timeout_id;
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
};
typedef struct _MetaCursorRendererNativePrivate MetaCursorRendererNativePrivate;
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
typedef struct _MetaCursorRendererNativeGpuData
{
gboolean hw_cursor_broken;
Support for hardware cursor sizes other than 64x64 on wayland Use the new DRM capabilities to figure out the correct cursor size, and make sure that matches instead of hardcoding 64x64. This fixes incorrect rendering on some newer AMD cards that support 256x256 cursors. Based heavily on a patch by: Alvaro Fernando García <alvarofernandogarcia@gmail.com>
2014-09-24 21:40:09 +00:00
uint64_t cursor_width;
uint64_t cursor_height;
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
} MetaCursorRendererNativeGpuData;
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
typedef enum _MetaCursorBufferState
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
{
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
META_CURSOR_BUFFER_STATE_NONE,
META_CURSOR_BUFFER_STATE_SET,
META_CURSOR_BUFFER_STATE_INVALIDATED,
} MetaCursorBufferState;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
typedef struct _MetaCursorNativeGpuState
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
{
cursor-renderer/native: Clear active CRTC gbm_bo when destroyed When we freed the cursor GPU state including the gbm_bo objects attached to it, we didn't unset the cursor renderer private of the CRTCs of the associated GPU. This means that HW cursor invalidation could potentially break if a new gbm_bo happened to be allocated at the same memory address as the previous one. To avoid this, iterate through the CRTCs of the GPU of which the cursor data is freed, and unset the cursor renderer private if it was the one destroyed. https://gitlab.gnome.org/GNOME/mutter/issues/199
2019-02-08 18:33:09 +00:00
MetaGpu *gpu;
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
unsigned int active_buffer_idx;
MetaCursorBufferState pending_buffer_state;
MetaDrmBuffer *buffers[HW_CURSOR_BUFFER_COUNT];
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
} MetaCursorNativeGpuState;
typedef struct _MetaCursorNativePrivate
{
GHashTable *gpu_states;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
struct {
gboolean can_preprocess;
float current_relative_scale;
MetaMonitorTransform current_relative_transform;
} preprocess_state;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
} MetaCursorNativePrivate;
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
static GQuark quark_cursor_renderer_native_gpu_data = 0;
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
G_DEFINE_TYPE_WITH_PRIVATE (MetaCursorRendererNative, meta_cursor_renderer_native, META_TYPE_CURSOR_RENDERER);
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
static void
on_kms_update_result (const MetaKmsFeedback *kms_feedback,
gpointer user_data);
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
static void
realize_cursor_sprite (MetaCursorRenderer *renderer,
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
MetaCursorSprite *cursor_sprite,
GList *gpus);
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
static MetaCursorNativeGpuState *
get_cursor_gpu_state (MetaCursorNativePrivate *cursor_priv,
MetaGpuKms *gpu_kms);
static MetaCursorNativeGpuState *
ensure_cursor_gpu_state (MetaCursorNativePrivate *cursor_priv,
MetaGpuKms *gpu_kms);
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
static void
invalidate_cursor_gpu_state (MetaCursorSprite *cursor_sprite);
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
static MetaCursorNativePrivate *
ensure_cursor_priv (MetaCursorSprite *cursor_sprite);
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
static MetaCursorNativePrivate *
get_cursor_priv (MetaCursorSprite *cursor_sprite);
backends/native: Update cursor also when scaled or transformed MetaCursorRendererNative only updates the cursor state when the underlying texture changes. The cursor scale and transform do not trigger updates. This results in wrong cursor orientations on rotated displays. Use both texture changes and scale and transformation changes to figure out when to update the cursor state. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2363>
2022-04-13 14:32:35 +00:00
static gboolean
is_cursor_scale_and_transform_valid (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite);
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
static MetaCursorRendererNativeGpuData *
meta_cursor_renderer_native_gpu_data_from_gpu (MetaGpuKms *gpu_kms)
{
return g_object_get_qdata (G_OBJECT (gpu_kms),
quark_cursor_renderer_native_gpu_data);
}
static MetaCursorRendererNativeGpuData *
meta_create_cursor_renderer_native_gpu_data (MetaGpuKms *gpu_kms)
{
MetaCursorRendererNativeGpuData *cursor_renderer_gpu_data;
cursor_renderer_gpu_data = g_new0 (MetaCursorRendererNativeGpuData, 1);
g_object_set_qdata_full (G_OBJECT (gpu_kms),
quark_cursor_renderer_native_gpu_data,
cursor_renderer_gpu_data,
g_free);
return cursor_renderer_gpu_data;
}
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
static void
meta_cursor_renderer_native_finalize (GObject *object)
{
MetaCursorRendererNative *renderer = META_CURSOR_RENDERER_NATIVE (object);
cursor-renderer/native: Various whitespace fixes https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 12:31:44 +00:00
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (renderer);
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
cleanup: Use g_clear_handle_id() for g_source_remove() It makes sure we do not forget to zero the id and lets us avoid zero checks before. We use it for all new code, lets clean up the existing code base. https://gitlab.gnome.org/GNOME/mutter/merge_requests/947
2019-11-21 23:25:30 +00:00
g_clear_handle_id (&priv->animation_timeout_id, g_source_remove);
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
G_OBJECT_CLASS (meta_cursor_renderer_native_parent_class)->finalize (object);
}
cursor-renderer/native: Change guint to unsigned int No need to use GLib types. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:21:19 +00:00
static unsigned int
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
get_pending_cursor_sprite_buffer_index (MetaCursorNativeGpuState *cursor_gpu_state)
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
{
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
return (cursor_gpu_state->active_buffer_idx + 1) % HW_CURSOR_BUFFER_COUNT;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
}
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
static MetaDrmBuffer *
get_pending_cursor_sprite_buffer (MetaCursorNativeGpuState *cursor_gpu_state)
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
{
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
unsigned int pending_buffer_idx;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
pending_buffer_idx =
get_pending_cursor_sprite_buffer_index (cursor_gpu_state);
return cursor_gpu_state->buffers[pending_buffer_idx];
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
}
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
static MetaDrmBuffer *
get_active_cursor_sprite_buffer (MetaCursorNativeGpuState *cursor_gpu_state)
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
{
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
return cursor_gpu_state->buffers[cursor_gpu_state->active_buffer_idx];
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
}
static void
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
set_pending_cursor_sprite_buffer (MetaCursorSprite *cursor_sprite,
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
MetaGpuKms *gpu_kms,
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
MetaDrmBuffer *buffer)
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
{
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
MetaCursorNativePrivate *cursor_priv;
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
MetaCursorNativeGpuState *cursor_gpu_state;
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
unsigned int pending_buffer_idx;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor_priv = ensure_cursor_priv (cursor_sprite);
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_gpu_state = ensure_cursor_gpu_state (cursor_priv, gpu_kms);
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
pending_buffer_idx =
get_pending_cursor_sprite_buffer_index (cursor_gpu_state);
cursor_gpu_state->buffers[pending_buffer_idx] = buffer;
cursor_gpu_state->pending_buffer_state = META_CURSOR_BUFFER_STATE_SET;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
}
cursor-renderer-native: Set cursor hotspot metadata on plane assignment This triggers the paths in the legacy KMS backend to use drmModeSetCursor2(), making virtual machines using "seamless mouse mode" behave correctly again. Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/1094 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1136
2020-03-19 08:06:09 +00:00
static void
calculate_crtc_cursor_hotspot (MetaCursorSprite *cursor_sprite,
int *cursor_hotspot_x,
int *cursor_hotspot_y)
{
MetaCursorNativePrivate *cursor_priv = get_cursor_priv (cursor_sprite);
int hot_x, hot_y;
int width, height;
float scale;
MetaMonitorTransform transform;
scale = cursor_priv->preprocess_state.current_relative_scale;
transform = cursor_priv->preprocess_state.current_relative_transform;
meta_cursor_sprite_get_hotspot (cursor_sprite, &hot_x, &hot_y);
width = meta_cursor_sprite_get_width (cursor_sprite);
height = meta_cursor_sprite_get_height (cursor_sprite);
meta_monitor_transform_transform_point (transform,
width, height,
hot_x, hot_y,
&hot_x, &hot_y);
*cursor_hotspot_x = (int) roundf (hot_x * scale);
*cursor_hotspot_y = (int) roundf (hot_y * scale);
}
cursor-renderer/native: Store struct in CRTC private In this struct, for now only the buffer is stored, but it'll be used for more state in later commits. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 21:57:03 +00:00
static CrtcCursorData *
ensure_crtc_cursor_data (MetaCrtcKms *crtc_kms)
{
CrtcCursorData *crtc_cursor_data;
crtc_cursor_data = meta_crtc_kms_get_cursor_renderer_private (crtc_kms);
if (!crtc_cursor_data)
{
crtc_cursor_data = g_new0 (CrtcCursorData, 1);
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
crtc_cursor_data->hw_state_invalidated = TRUE;
cursor-renderer/native: Store struct in CRTC private In this struct, for now only the buffer is stored, but it'll be used for more state in later commits. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 21:57:03 +00:00
meta_crtc_kms_set_cursor_renderer_private (crtc_kms,
crtc_cursor_data,
g_free);
}
return crtc_cursor_data;
}
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
static void
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
assign_cursor_plane (MetaCursorRendererNative *native,
MetaCrtcKms *crtc_kms,
int x,
int y,
MetaCursorSprite *cursor_sprite)
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
{
crtc: Make implementations inherit MetaCrtc Just as with MetaOutput, instead of the home baked "inheritance" system, using a gpointer and a GDestroyNotify function to keep the what effectively is sub type details, make MetaCrtc an abstract derivable type, and make the implementations inherit it. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1287
2020-02-26 18:47:44 +00:00
MetaCrtc *crtc = META_CRTC (crtc_kms);
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
MetaCursorNativePrivate *cursor_priv = get_cursor_priv (cursor_sprite);
MetaGpuKms *gpu_kms = META_GPU_KMS (meta_crtc_get_gpu (crtc));
MetaCursorRendererNativeGpuData *cursor_renderer_gpu_data =
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
meta_cursor_renderer_native_gpu_data_from_gpu (gpu_kms);
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
MetaCursorNativeGpuState *cursor_gpu_state =
get_cursor_gpu_state (cursor_priv, gpu_kms);
MetaKmsCrtc *kms_crtc;
MetaKmsDevice *kms_device;
MetaKmsPlane *cursor_plane;
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
MetaDrmBuffer *buffer;
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
int cursor_width, cursor_height;
MetaFixed16Rectangle src_rect;
kms/update: Make dst_rect a int rectangle It's never used as a 16.16 fixed point rectangle so no reason it should be passed around as one. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 16:00:36 +00:00
MetaRectangle dst_rect;
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
MetaDrmBuffer *crtc_buffer;
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
MetaKmsAssignPlaneFlag flags;
cursor-renderer/native: Store struct in CRTC private In this struct, for now only the buffer is stored, but it'll be used for more state in later commits. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 21:57:03 +00:00
CrtcCursorData *crtc_cursor_data;
cursor-renderer-native: Set cursor hotspot metadata on plane assignment This triggers the paths in the legacy KMS backend to use drmModeSetCursor2(), making virtual machines using "seamless mouse mode" behave correctly again. Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/1094 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1136
2020-03-19 08:06:09 +00:00
int cursor_hotspot_x;
int cursor_hotspot_y;
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
MetaKmsUpdate *kms_update;
cursor-renderer-native: Set cursor hotspot metadata on plane assignment This triggers the paths in the legacy KMS backend to use drmModeSetCursor2(), making virtual machines using "seamless mouse mode" behave correctly again. Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/1094 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1136
2020-03-19 08:06:09 +00:00
MetaKmsPlaneAssignment *plane_assignment;
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
if (cursor_gpu_state->pending_buffer_state == META_CURSOR_BUFFER_STATE_SET)
buffer = get_pending_cursor_sprite_buffer (cursor_gpu_state);
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
else
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
buffer = get_active_cursor_sprite_buffer (cursor_gpu_state);
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
crtc: Make implementations inherit MetaCrtc Just as with MetaOutput, instead of the home baked "inheritance" system, using a gpointer and a GDestroyNotify function to keep the what effectively is sub type details, make MetaCrtc an abstract derivable type, and make the implementations inherit it. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1287
2020-02-26 18:47:44 +00:00
kms_crtc = meta_crtc_kms_get_kms_crtc (crtc_kms);
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
kms_device = meta_kms_crtc_get_device (kms_crtc);
cursor_plane = meta_kms_device_get_cursor_plane_for (kms_device, kms_crtc);
g_return_if_fail (cursor_plane);
cursor_width = cursor_renderer_gpu_data->cursor_width;
cursor_height = cursor_renderer_gpu_data->cursor_height;
src_rect = (MetaFixed16Rectangle) {
.x = meta_fixed_16_from_int (0),
.y = meta_fixed_16_from_int (0),
.width = meta_fixed_16_from_int (cursor_width),
.height = meta_fixed_16_from_int (cursor_height),
};
kms/update: Make dst_rect a int rectangle It's never used as a 16.16 fixed point rectangle so no reason it should be passed around as one. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 16:00:36 +00:00
dst_rect = (MetaRectangle) {
.x = x,
.y = y,
.width = cursor_width,
.height = cursor_height,
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
};
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
kms: Allow update passing with failed plane assignments This will later make it possible to pass cursor plane assignments, together with a complete update including the primary plane, but not failing the whole update if just processing the cursor plane failed. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-02 13:45:28 +00:00
flags = META_KMS_ASSIGN_PLANE_FLAG_ALLOW_FAIL;
cursor-renderer/native: Store struct in CRTC private In this struct, for now only the buffer is stored, but it'll be used for more state in later commits. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 21:57:03 +00:00
crtc_cursor_data = ensure_crtc_cursor_data (crtc_kms);
crtc_buffer = crtc_cursor_data->buffer;
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
if (!crtc_cursor_data->hw_state_invalidated && buffer == crtc_buffer)
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
flags |= META_KMS_ASSIGN_PLANE_FLAG_FB_UNCHANGED;
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
kms_update =
meta_kms_ensure_pending_update (meta_kms_device_get_kms (kms_device),
meta_kms_crtc_get_device (kms_crtc));
cursor-renderer-native: Set cursor hotspot metadata on plane assignment This triggers the paths in the legacy KMS backend to use drmModeSetCursor2(), making virtual machines using "seamless mouse mode" behave correctly again. Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/1094 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1136
2020-03-19 08:06:09 +00:00
plane_assignment = meta_kms_update_assign_plane (kms_update,
kms_crtc,
cursor_plane,
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
buffer,
cursor-renderer-native: Set cursor hotspot metadata on plane assignment This triggers the paths in the legacy KMS backend to use drmModeSetCursor2(), making virtual machines using "seamless mouse mode" behave correctly again. Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/1094 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1136
2020-03-19 08:06:09 +00:00
src_rect,
dst_rect,
flags);
calculate_crtc_cursor_hotspot (cursor_sprite,
&cursor_hotspot_x,
&cursor_hotspot_y);
meta_kms_plane_assignment_set_cursor_hotspot (plane_assignment,
cursor_hotspot_x,
cursor_hotspot_y);
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
meta_kms_update_add_result_listener (kms_update,
on_kms_update_result,
native);
cursor-renderer/native: Store struct in CRTC private In this struct, for now only the buffer is stored, but it'll be used for more state in later commits. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 21:57:03 +00:00
crtc_cursor_data->buffer = buffer;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
if (cursor_gpu_state->pending_buffer_state == META_CURSOR_BUFFER_STATE_SET)
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
{
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
cursor_gpu_state->active_buffer_idx =
(cursor_gpu_state->active_buffer_idx + 1) % HW_CURSOR_BUFFER_COUNT;
cursor_gpu_state->pending_buffer_state = META_CURSOR_BUFFER_STATE_NONE;
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
}
}
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
static float
calculate_cursor_crtc_sprite_scale (MetaCursorSprite *cursor_sprite,
MetaLogicalMonitor *logical_monitor)
{
if (meta_is_stage_views_scaled ())
{
return (meta_logical_monitor_get_scale (logical_monitor) *
meta_cursor_sprite_get_texture_scale (cursor_sprite));
}
else
{
return 1.0;
}
}
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
static void
set_crtc_cursor (MetaCursorRendererNative *cursor_renderer_native,
MetaRendererView *view,
MetaCrtc *crtc,
MetaCursorSprite *cursor_sprite)
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
{
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
MetaCursorRenderer *cursor_renderer =
META_CURSOR_RENDERER (cursor_renderer_native);
MetaOutput *output = meta_crtc_get_outputs (crtc)->data;
MetaMonitor *monitor = meta_output_get_monitor (output);
MetaLogicalMonitor *logical_monitor =
meta_monitor_get_logical_monitor (monitor);
const MetaCrtcConfig *crtc_config = meta_crtc_get_config (crtc);
graphene_rect_t rect;
graphene_rect_t local_crtc_rect;
graphene_rect_t local_cursor_rect;
float view_scale;
float crtc_cursor_x, crtc_cursor_y;
CoglTexture *texture;
int tex_width, tex_height;
float cursor_crtc_scale;
MetaRectangle cursor_rect;
cursor-renderer-native: take rotation into account Rotating an output would show duplicate cursors when the pointer is located over an area which would be within the output if not rotated. Make sure to swap the width/height of the output when rotated. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/85
2018-03-26 13:56:04 +00:00
MetaMonitorTransform transform;
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
MetaMonitorMode *monitor_mode;
MetaMonitorCrtcMode *monitor_crtc_mode;
crtc-mode: Move away fields from public MetaCrtcMode struct The ID and name are just moved into the instance private, while the rest is moved to a `MetaCrtcModeInfo` struct which is used during construction and retrieved via a getter. Opens up the possibility to add actual sub types. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1287
2020-02-26 23:08:58 +00:00
const MetaCrtcModeInfo *crtc_mode_info;
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
view_scale = clutter_stage_view_get_scale (CLUTTER_STAGE_VIEW (view));
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
rect = meta_cursor_renderer_calculate_rect (cursor_renderer, cursor_sprite);
local_cursor_rect =
GRAPHENE_RECT_INIT (rect.origin.x - logical_monitor->rect.x,
rect.origin.y - logical_monitor->rect.y,
rect.size.width,
rect.size.height);
cursor-renderer-native: Take CRTC transform into account The CRTC level transform (not necessarily the hw transform) must be taken into account when calculating the position of the CRTC in the stage coordinate space, when placing the hw cursor, otherwise we'll place the cursor as if the monitor was not rotated. This wasn't a problem in the past, as with rotation, we always used the OpenGL cursor, so the issue newer showed. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1199
2020-04-14 19:14:24 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
local_crtc_rect = crtc_config->layout;
graphene_rect_offset (&local_crtc_rect,
-logical_monitor->rect.x,
-logical_monitor->rect.y);
crtc-mode: Move away fields from public MetaCrtcMode struct The ID and name are just moved into the instance private, while the rest is moved to a `MetaCrtcModeInfo` struct which is used during construction and retrieved via a getter. Opens up the possibility to add actual sub types. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1287
2020-02-26 23:08:58 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
crtc_cursor_x = (local_cursor_rect.origin.x -
local_crtc_rect.origin.x) * view_scale;
crtc_cursor_y = (local_cursor_rect.origin.y -
local_crtc_rect.origin.y) * view_scale;
cursor-renderer-native: take rotation into account Rotating an output would show duplicate cursors when the pointer is located over an area which would be within the output if not rotated. Make sure to swap the width/height of the output when rotated. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/85
2018-03-26 13:56:04 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
texture = meta_cursor_sprite_get_cogl_texture (cursor_sprite);
tex_width = cogl_texture_get_width (texture);
tex_height = cogl_texture_get_height (texture);
cursor_crtc_scale =
calculate_cursor_crtc_sprite_scale (cursor_sprite,
logical_monitor);
cursor_rect = (MetaRectangle) {
.x = floorf (crtc_cursor_x),
.y = floorf (crtc_cursor_y),
.width = roundf (tex_width * cursor_crtc_scale),
.height = roundf (tex_height * cursor_crtc_scale)
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
};
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
transform = meta_logical_monitor_get_transform (logical_monitor);
transform = meta_monitor_logical_to_crtc_transform (monitor, transform);
backends: Move MetaOutput::crtc field into private struct No functional changes. This is only done so that changes to reference counting can done more reliably. https://bugzilla.gnome.org/show_bug.cgi?id=786929
2017-11-03 10:25:30 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
monitor_mode = meta_monitor_get_current_mode (monitor);
monitor_crtc_mode = meta_monitor_get_crtc_mode_for_output (monitor,
monitor_mode,
output);
crtc_mode_info = meta_crtc_mode_get_info (monitor_crtc_mode->crtc_mode);
meta_rectangle_transform (&cursor_rect,
cursor-renderer/native: Various fixes for rotated cursors - Drop bogus `meta_monitor_transform_invert()`. It papered over wrong `meta_rectangle_transform()` behaviour for non-flipped output transforms. - Update `scale_and_transform_cursor_sprite_cpu` to match the GL pipeline matrix in `MetaShapedTexture`, fixing several of the flipped cases. Note: the rotation applied is the one a client would need to apply to the buffer for a given monitor transform. - While on it, drop a redundant `return`. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2459>
2022-06-14 16:47:10 +00:00
transform,
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
crtc_mode_info->width,
crtc_mode_info->height,
&cursor_rect);
assign_cursor_plane (cursor_renderer_native,
crtc: Make implementations inherit MetaCrtc Just as with MetaOutput, instead of the home baked "inheritance" system, using a gpointer and a GDestroyNotify function to keep the what effectively is sub type details, make MetaCrtc an abstract derivable type, and make the implementations inherit it. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1287
2020-02-26 18:47:44 +00:00
META_CRTC_KMS (crtc),
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
cursor_rect.x,
cursor_rect.y,
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
cursor_sprite);
}
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
static void
unset_crtc_cursor (MetaCursorRendererNative *native,
MetaCrtc *crtc)
{
MetaCrtcKms *crtc_kms = META_CRTC_KMS (crtc);
CrtcCursorData *crtc_cursor_data;
MetaKmsCrtc *kms_crtc;
MetaKmsDevice *kms_device;
MetaKmsPlane *cursor_plane;
MetaDrmBuffer *crtc_buffer;
crtc_cursor_data = ensure_crtc_cursor_data (crtc_kms);
crtc_buffer = crtc_cursor_data->buffer;
if (!crtc_cursor_data->hw_state_invalidated && !crtc_buffer)
return;
kms_crtc = meta_crtc_kms_get_kms_crtc (crtc_kms);
kms_device = meta_kms_crtc_get_device (kms_crtc);
cursor_plane = meta_kms_device_get_cursor_plane_for (kms_device, kms_crtc);
if (cursor_plane)
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
{
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
MetaKms *kms = meta_kms_device_get_kms (kms_device);
MetaKmsUpdate *kms_update;
kms_update = meta_kms_ensure_pending_update (kms, kms_device);
meta_kms_update_unassign_plane (kms_update, kms_crtc, cursor_plane);
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
}
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
crtc_cursor_data->buffer = NULL;
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
}
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
static void
cursor-renderer-native: Don't retry forever after GBM cursor functions fail This avoids flooding the log with every cursor change: ``` (gnome-shell:19923): libmutter-WARNING **: 10:15:23.404: Realizing HW cursor failed: Failed to allocate gbm_bo: Invalid argument (gnome-shell:19923): libmutter-WARNING **: 10:15:23.450: Realizing HW cursor failed: Failed to allocate gbm_bo: Invalid argument (gnome-shell:19923): libmutter-WARNING **: 10:15:23.451: Realizing HW cursor failed: Failed to allocate gbm_bo: Invalid argument ``` Related: https://gitlab.gnome.org/GNOME/mutter/-/issues/2354 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2520>
2022-07-20 10:10:21 +00:00
disable_hw_cursor_for_gpu (MetaGpuKms *gpu_kms,
const GError *error)
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
{
MetaCursorRendererNativeGpuData *cursor_renderer_gpu_data =
meta_cursor_renderer_native_gpu_data_from_gpu (gpu_kms);
g_warning ("Failed to set hardware cursor (%s), "
"using OpenGL from now on",
error->message);
cursor_renderer_gpu_data->hw_cursor_broken = TRUE;
}
cursor-renderer-native: Don't retry forever after GBM cursor functions fail This avoids flooding the log with every cursor change: ``` (gnome-shell:19923): libmutter-WARNING **: 10:15:23.404: Realizing HW cursor failed: Failed to allocate gbm_bo: Invalid argument (gnome-shell:19923): libmutter-WARNING **: 10:15:23.450: Realizing HW cursor failed: Failed to allocate gbm_bo: Invalid argument (gnome-shell:19923): libmutter-WARNING **: 10:15:23.451: Realizing HW cursor failed: Failed to allocate gbm_bo: Invalid argument ``` Related: https://gitlab.gnome.org/GNOME/mutter/-/issues/2354 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2520>
2022-07-20 10:10:21 +00:00
static void
disable_hw_cursor_for_crtc (MetaKmsCrtc *kms_crtc,
const GError *error)
{
MetaCrtcKms *crtc_kms = meta_crtc_kms_from_kms_crtc (kms_crtc);
MetaCrtc *crtc = META_CRTC (crtc_kms);
MetaGpuKms *gpu_kms = META_GPU_KMS (meta_crtc_get_gpu (crtc));
disable_hw_cursor_for_gpu (gpu_kms, error);
}
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
void
meta_cursor_renderer_native_prepare_frame (MetaCursorRendererNative *cursor_renderer_native,
MetaRendererView *view)
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
{
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
MetaCursorRenderer *cursor_renderer =
META_CURSOR_RENDERER (cursor_renderer_native);
cursor-renderer/native: Various whitespace fixes https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 12:31:44 +00:00
MetaCursorRendererNativePrivate *priv =
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
meta_cursor_renderer_native_get_instance_private (cursor_renderer_native);
backend: Move GPU ownership from the monitor manager to the backend Lets work towards making MetaMonitorManager about managing monitors, and not about managing GPUs. This changes other units to keep a pointer to the backend instead of a monitor manager, in case their ownership changed, or their main usage of the monitor manager was to look up GPUs. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-11 14:35:42 +00:00
MetaBackend *backend = priv->backend;
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
MetaCrtc *crtc = meta_renderer_view_get_crtc (view);
MetaCursorSprite *cursor_sprite;
graphene_rect_t cursor_rect;
cairo_rectangle_int_t view_layout;
graphene_rect_t view_rect;
CrtcCursorData *crtc_cursor_data;
cursor-renderer-native: Port to transactional KMS api Turns the cursor setting and movement into cursor plane assignment primitives. In the current simple implementation, this in turn translates into legacy drmModeSetCursor() and drmModeMoveCursor() calls. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-08 23:19:51 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
if (meta_monitor_manager_get_power_save_mode (monitor_manager) !=
META_POWER_SAVE_ON)
return;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
Introduce virtual monitors Virtual monitors are monitors that isn't backed by any monitor like hardware. It would typically be backed by e.g. a remote desktop service, or a network display. It is currently only supported by the native backend, and whether the X11 backend will ever see virtual monitors is an open question. This rest of this commit message describes how it works under the native backend. Each virutal monitor consists of virtualized mode setting components: * A virtual CRTC mode (MetaCrtcModeVirtual) * A virtual CRTC (MetaCrtcVirtual) * A virtual connector (MetaOutputVirtual) In difference to the corresponding mode setting objects that represents KMS objects, the virtual ones isn't directly tied to a MetaGpu, other than the CoglFramebuffer being part of the GPU context of the primary GPU, which is the case for all monitors no matter what GPU they are connected to. Part of the reason for this is that a MetaGpu in practice represents a mode setting device, and its CRTCs and outputs, are all backed by real mode setting objects, while a virtual monitor is only backed by a framebuffer that is tied to the primary GPU. Maybe this will be reevaluated in the future, but since a virtual monitor is not tied to any GPU currently, so is the case for the virtual mode setting objects. The native rendering backend, including the cursor renderer, is adapted to handle the situation where a CRTC does not have a GPU associated with it; this in practice means that it e.g. will not try to upload HW cursor buffers when the cursor is only on a virtual monitor. The same applies to the native renderer, which is made to avoid creating MetaOnscreenNative for views that are backed by virtual CRTCs, as well as to avoid trying to mode set on such views. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1698>
2021-01-26 15:49:28 +00:00
if (!meta_crtc_get_gpu (crtc))
return;
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
crtc_cursor_data = ensure_crtc_cursor_data (META_CRTC_KMS (crtc));
if (!crtc_cursor_data->hw_state_invalidated &&
!crtc_cursor_data->needs_sync_position)
return;
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
cursor_sprite = meta_cursor_renderer_get_cursor (cursor_renderer);
if (!cursor_sprite)
goto unset_cursor;
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
if (!priv->has_hw_cursor)
goto unset_cursor;
cursor_rect = meta_cursor_renderer_calculate_rect (cursor_renderer,
cursor_sprite);
clutter_stage_view_get_layout (CLUTTER_STAGE_VIEW (view), &view_layout);
view_rect = GRAPHENE_RECT_INIT (view_layout.x, view_layout.y,
view_layout.width, view_layout.height);
if (!graphene_rect_intersection (&cursor_rect, &view_rect, NULL))
goto unset_cursor;
cursor-renderer: Add a cursor painted signal This signal allows interested parties to be notified of a new cursor frame being painted regardless of whether it's being painted by the backend directly or if it's a software rendered cursor frame handled by clutter. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-01-10 16:28:54 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
set_crtc_cursor (cursor_renderer_native, view, crtc, cursor_sprite);
MetaCursorRendererNative: Always force set hw cursor the first time The initial state of the hardware cursor is not known, so always force update it the first time we update the cursor. Do this by changing the 'force' flag of update_hw_cursor() to an 'invalidated' hw cursor state. https://bugzilla.gnome.org/show_bug.cgi?id=771056
2017-01-10 08:01:46 +00:00
backend: Pass stage view to cursor-painted signal Will be used for presentation-time handling. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1484>
2021-02-02 13:49:56 +00:00
meta_cursor_renderer_emit_painted (cursor_renderer,
cursor_sprite,
CLUTTER_STAGE_VIEW (view));
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
crtc_cursor_data->needs_sync_position = FALSE;
crtc_cursor_data->hw_state_invalidated = FALSE;
return;
unset_cursor:
unset_crtc_cursor (cursor_renderer_native, crtc);
crtc_cursor_data = ensure_crtc_cursor_data (META_CRTC_KMS (crtc));
crtc_cursor_data->hw_state_invalidated = FALSE;
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
}
static gboolean
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
has_valid_cursor_sprite_buffer (MetaCursorSprite *cursor_sprite,
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
MetaGpuKms *gpu_kms)
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
{
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
MetaCursorNativePrivate *cursor_priv;
MetaCursorNativeGpuState *cursor_gpu_state;
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_priv = get_cursor_priv (cursor_sprite);
cursor-renderer-native: Avoid a crash if we fail to allocate a gbm bo https://bugzilla.gnome.org/show_bug.cgi?id=758613
2016-01-08 15:09:10 +00:00
if (!cursor_priv)
return FALSE;
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_gpu_state = get_cursor_gpu_state (cursor_priv, gpu_kms);
if (!cursor_gpu_state)
return FALSE;
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
switch (cursor_gpu_state->pending_buffer_state)
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
{
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
case META_CURSOR_BUFFER_STATE_NONE:
return get_active_cursor_sprite_buffer (cursor_gpu_state) != NULL;
case META_CURSOR_BUFFER_STATE_SET:
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
return TRUE;
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
case META_CURSOR_BUFFER_STATE_INVALIDATED:
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
return FALSE;
}
g_assert_not_reached ();
return FALSE;
}
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
static void
set_can_preprocess (MetaCursorSprite *cursor_sprite,
float scale,
MetaMonitorTransform transform)
{
MetaCursorNativePrivate *cursor_priv = get_cursor_priv (cursor_sprite);
cursor_priv->preprocess_state.current_relative_scale = scale;
cursor_priv->preprocess_state.current_relative_transform = transform;
cursor_priv->preprocess_state.can_preprocess = TRUE;
invalidate_cursor_gpu_state (cursor_sprite);
}
static void
unset_can_preprocess (MetaCursorSprite *cursor_sprite)
{
MetaCursorNativePrivate *cursor_priv = get_cursor_priv (cursor_sprite);
memset (&cursor_priv->preprocess_state,
0,
sizeof (cursor_priv->preprocess_state));
cursor_priv->preprocess_state.can_preprocess = FALSE;
invalidate_cursor_gpu_state (cursor_sprite);
}
native: Implement DRM-based crtc rotation We can know the rotation modes supported by the driver, so export these as our supported modes, and ensure these modes are honored on the CRTC primary plane upon apply_configuration(). It is worth noting however that not all hardware will be capable of supporting all rotation modes (in fact, most of them won't). A driver independent solution should be in place to back up the rotation modes unsupported by the drivers, so this is still a partial solution. The cursor renderer has also been changed to default to software-based rendering anytime the cursor enters a rotated CRTC. Another solution would be actually rotating the DRM cursor planes, but then it requires applying rotation on these per-CRTC, and actually transforming the pointer position by the output matrix. This brings marginal gains, so we use the "sw" rendered cursor, which will be transformed together with the primary plane. https://bugzilla.gnome.org/show_bug.cgi?id=745079
2015-12-18 11:16:59 +00:00
static gboolean
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
get_can_preprocess (MetaCursorSprite *cursor_sprite)
{
MetaCursorNativePrivate *cursor_priv = get_cursor_priv (cursor_sprite);
return cursor_priv->preprocess_state.can_preprocess;
}
static float
get_current_relative_scale (MetaCursorSprite *cursor_sprite)
{
MetaCursorNativePrivate *cursor_priv = get_cursor_priv (cursor_sprite);
return cursor_priv->preprocess_state.current_relative_scale;
}
static MetaMonitorTransform
get_current_relative_transform (MetaCursorSprite *cursor_sprite)
{
MetaCursorNativePrivate *cursor_priv = get_cursor_priv (cursor_sprite);
return cursor_priv->preprocess_state.current_relative_transform;
}
cursor-renderer-native: Handle lack of cursor planes gracefully While we will always have cursor planes, as we'll currently create fake ones when real ones are missing (See #1058), eventually we will run into situations where we can't create fake ones, for example for atomic KMS drivers that don't advertise any cursor planes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1079
2020-02-21 11:08:34 +00:00
static void
cursor-renderer/native: Use MetaCrtcNative API to check capabilities The cursor renderer shouldn't assume all the CRTCs of a logical are KMS CRTC's, as we'll end up checking hardware capabilities for CRTC's of virtual monitors as well, when they were created to not embed the cursor image directly in the framebuffer. Instead, use the newly introduced API for checking CRTC cursor capabilities. This fixes a crash with the following backtrace: 0) get_plane_with_type_for at ../src/backends/native/meta-kms-device.c:150 1) meta_kms_device_get_cursor_plane_for at ../src/backends/native/meta-kms-device.c:173 2) has_cursor_plane at ../src/backends/native/meta-cursor-renderer-native.c:678 3) foreach_crtc at ../src/backends/meta-logical-monitor.c:247 4) meta_monitor_mode_foreach_crtc at ../src/backends/meta-monitor.c:1920 5) meta_logical_monitor_foreach_crtc at ../src/backends/meta-logical-monitor.c:274 6) crtcs_has_cursor_planes at ../src/backends/native/meta-cursor-renderer-native.c:718 7) should_have_hw_cursor at ../src/backends/native/meta-cursor-renderer-native.c:881 8) meta_cursor_renderer_native_update_cursor at ../src/backends/native/meta-cursor-renderer-native.c:1085 9) meta_cursor_renderer_update_cursor at ../src/backends/meta-cursor-renderer.c:411 Related: https://bugzilla.redhat.com/show_bug.cgi?id=2000183 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1991>
2021-09-06 08:42:32 +00:00
crtc_supports_hw_cursor (MetaLogicalMonitor *logical_monitor,
MetaMonitor *monitor,
MetaOutput *output,
MetaCrtc *crtc,
gpointer user_data)
cursor-renderer-native: Handle lack of cursor planes gracefully While we will always have cursor planes, as we'll currently create fake ones when real ones are missing (See #1058), eventually we will run into situations where we can't create fake ones, for example for atomic KMS drivers that don't advertise any cursor planes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1079
2020-02-21 11:08:34 +00:00
{
cursor-renderer/native: Use MetaCrtcNative API to check capabilities The cursor renderer shouldn't assume all the CRTCs of a logical are KMS CRTC's, as we'll end up checking hardware capabilities for CRTC's of virtual monitors as well, when they were created to not embed the cursor image directly in the framebuffer. Instead, use the newly introduced API for checking CRTC cursor capabilities. This fixes a crash with the following backtrace: 0) get_plane_with_type_for at ../src/backends/native/meta-kms-device.c:150 1) meta_kms_device_get_cursor_plane_for at ../src/backends/native/meta-kms-device.c:173 2) has_cursor_plane at ../src/backends/native/meta-cursor-renderer-native.c:678 3) foreach_crtc at ../src/backends/meta-logical-monitor.c:247 4) meta_monitor_mode_foreach_crtc at ../src/backends/meta-monitor.c:1920 5) meta_logical_monitor_foreach_crtc at ../src/backends/meta-logical-monitor.c:274 6) crtcs_has_cursor_planes at ../src/backends/native/meta-cursor-renderer-native.c:718 7) should_have_hw_cursor at ../src/backends/native/meta-cursor-renderer-native.c:881 8) meta_cursor_renderer_native_update_cursor at ../src/backends/native/meta-cursor-renderer-native.c:1085 9) meta_cursor_renderer_update_cursor at ../src/backends/meta-cursor-renderer.c:411 Related: https://bugzilla.redhat.com/show_bug.cgi?id=2000183 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1991>
2021-09-06 08:42:32 +00:00
gboolean *supports_hw_cursor = user_data;
MetaCrtcNative *crtc_native = META_CRTC_NATIVE (crtc);
cursor-renderer-native: Handle lack of cursor planes gracefully While we will always have cursor planes, as we'll currently create fake ones when real ones are missing (See #1058), eventually we will run into situations where we can't create fake ones, for example for atomic KMS drivers that don't advertise any cursor planes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1079
2020-02-21 11:08:34 +00:00
cursor-renderer/native: Use MetaCrtcNative API to check capabilities The cursor renderer shouldn't assume all the CRTCs of a logical are KMS CRTC's, as we'll end up checking hardware capabilities for CRTC's of virtual monitors as well, when they were created to not embed the cursor image directly in the framebuffer. Instead, use the newly introduced API for checking CRTC cursor capabilities. This fixes a crash with the following backtrace: 0) get_plane_with_type_for at ../src/backends/native/meta-kms-device.c:150 1) meta_kms_device_get_cursor_plane_for at ../src/backends/native/meta-kms-device.c:173 2) has_cursor_plane at ../src/backends/native/meta-cursor-renderer-native.c:678 3) foreach_crtc at ../src/backends/meta-logical-monitor.c:247 4) meta_monitor_mode_foreach_crtc at ../src/backends/meta-monitor.c:1920 5) meta_logical_monitor_foreach_crtc at ../src/backends/meta-logical-monitor.c:274 6) crtcs_has_cursor_planes at ../src/backends/native/meta-cursor-renderer-native.c:718 7) should_have_hw_cursor at ../src/backends/native/meta-cursor-renderer-native.c:881 8) meta_cursor_renderer_native_update_cursor at ../src/backends/native/meta-cursor-renderer-native.c:1085 9) meta_cursor_renderer_update_cursor at ../src/backends/meta-cursor-renderer.c:411 Related: https://bugzilla.redhat.com/show_bug.cgi?id=2000183 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1991>
2021-09-06 08:42:32 +00:00
*supports_hw_cursor &= meta_crtc_native_is_hw_cursor_supported (crtc_native);
cursor-renderer-native: Handle lack of cursor planes gracefully While we will always have cursor planes, as we'll currently create fake ones when real ones are missing (See #1058), eventually we will run into situations where we can't create fake ones, for example for atomic KMS drivers that don't advertise any cursor planes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1079
2020-02-21 11:08:34 +00:00
}
static gboolean
cursor-renderer/native: Use MetaCrtcNative API to check capabilities The cursor renderer shouldn't assume all the CRTCs of a logical are KMS CRTC's, as we'll end up checking hardware capabilities for CRTC's of virtual monitors as well, when they were created to not embed the cursor image directly in the framebuffer. Instead, use the newly introduced API for checking CRTC cursor capabilities. This fixes a crash with the following backtrace: 0) get_plane_with_type_for at ../src/backends/native/meta-kms-device.c:150 1) meta_kms_device_get_cursor_plane_for at ../src/backends/native/meta-kms-device.c:173 2) has_cursor_plane at ../src/backends/native/meta-cursor-renderer-native.c:678 3) foreach_crtc at ../src/backends/meta-logical-monitor.c:247 4) meta_monitor_mode_foreach_crtc at ../src/backends/meta-monitor.c:1920 5) meta_logical_monitor_foreach_crtc at ../src/backends/meta-logical-monitor.c:274 6) crtcs_has_cursor_planes at ../src/backends/native/meta-cursor-renderer-native.c:718 7) should_have_hw_cursor at ../src/backends/native/meta-cursor-renderer-native.c:881 8) meta_cursor_renderer_native_update_cursor at ../src/backends/native/meta-cursor-renderer-native.c:1085 9) meta_cursor_renderer_update_cursor at ../src/backends/meta-cursor-renderer.c:411 Related: https://bugzilla.redhat.com/show_bug.cgi?id=2000183 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1991>
2021-09-06 08:42:32 +00:00
crtcs_supports_hw_cursor (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite)
cursor-renderer-native: Handle lack of cursor planes gracefully While we will always have cursor planes, as we'll currently create fake ones when real ones are missing (See #1058), eventually we will run into situations where we can't create fake ones, for example for atomic KMS drivers that don't advertise any cursor planes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1079
2020-02-21 11:08:34 +00:00
{
MetaCursorRendererNative *cursor_renderer_native =
META_CURSOR_RENDERER_NATIVE (renderer);
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (cursor_renderer_native);
MetaBackend *backend = priv->backend;
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
GList *logical_monitors;
GList *l;
graphene_rect_t cursor_rect;
cursor_rect = meta_cursor_renderer_calculate_rect (renderer, cursor_sprite);
logical_monitors =
meta_monitor_manager_get_logical_monitors (monitor_manager);
for (l = logical_monitors; l; l = l->next)
{
MetaLogicalMonitor *logical_monitor = l->data;
MetaRectangle logical_monitor_layout;
graphene_rect_t logical_monitor_rect;
cursor-renderer/native: Use MetaCrtcNative API to check capabilities The cursor renderer shouldn't assume all the CRTCs of a logical are KMS CRTC's, as we'll end up checking hardware capabilities for CRTC's of virtual monitors as well, when they were created to not embed the cursor image directly in the framebuffer. Instead, use the newly introduced API for checking CRTC cursor capabilities. This fixes a crash with the following backtrace: 0) get_plane_with_type_for at ../src/backends/native/meta-kms-device.c:150 1) meta_kms_device_get_cursor_plane_for at ../src/backends/native/meta-kms-device.c:173 2) has_cursor_plane at ../src/backends/native/meta-cursor-renderer-native.c:678 3) foreach_crtc at ../src/backends/meta-logical-monitor.c:247 4) meta_monitor_mode_foreach_crtc at ../src/backends/meta-monitor.c:1920 5) meta_logical_monitor_foreach_crtc at ../src/backends/meta-logical-monitor.c:274 6) crtcs_has_cursor_planes at ../src/backends/native/meta-cursor-renderer-native.c:718 7) should_have_hw_cursor at ../src/backends/native/meta-cursor-renderer-native.c:881 8) meta_cursor_renderer_native_update_cursor at ../src/backends/native/meta-cursor-renderer-native.c:1085 9) meta_cursor_renderer_update_cursor at ../src/backends/meta-cursor-renderer.c:411 Related: https://bugzilla.redhat.com/show_bug.cgi?id=2000183 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1991>
2021-09-06 08:42:32 +00:00
gboolean supports_hw_cursor;
cursor-renderer-native: Handle lack of cursor planes gracefully While we will always have cursor planes, as we'll currently create fake ones when real ones are missing (See #1058), eventually we will run into situations where we can't create fake ones, for example for atomic KMS drivers that don't advertise any cursor planes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1079
2020-02-21 11:08:34 +00:00
logical_monitor_layout =
meta_logical_monitor_get_layout (logical_monitor);
logical_monitor_rect =
meta_rectangle_to_graphene_rect (&logical_monitor_layout);
if (!graphene_rect_intersection (&cursor_rect, &logical_monitor_rect,
NULL))
continue;
cursor-renderer/native: Use MetaCrtcNative API to check capabilities The cursor renderer shouldn't assume all the CRTCs of a logical are KMS CRTC's, as we'll end up checking hardware capabilities for CRTC's of virtual monitors as well, when they were created to not embed the cursor image directly in the framebuffer. Instead, use the newly introduced API for checking CRTC cursor capabilities. This fixes a crash with the following backtrace: 0) get_plane_with_type_for at ../src/backends/native/meta-kms-device.c:150 1) meta_kms_device_get_cursor_plane_for at ../src/backends/native/meta-kms-device.c:173 2) has_cursor_plane at ../src/backends/native/meta-cursor-renderer-native.c:678 3) foreach_crtc at ../src/backends/meta-logical-monitor.c:247 4) meta_monitor_mode_foreach_crtc at ../src/backends/meta-monitor.c:1920 5) meta_logical_monitor_foreach_crtc at ../src/backends/meta-logical-monitor.c:274 6) crtcs_has_cursor_planes at ../src/backends/native/meta-cursor-renderer-native.c:718 7) should_have_hw_cursor at ../src/backends/native/meta-cursor-renderer-native.c:881 8) meta_cursor_renderer_native_update_cursor at ../src/backends/native/meta-cursor-renderer-native.c:1085 9) meta_cursor_renderer_update_cursor at ../src/backends/meta-cursor-renderer.c:411 Related: https://bugzilla.redhat.com/show_bug.cgi?id=2000183 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1991>
2021-09-06 08:42:32 +00:00
supports_hw_cursor = TRUE;
cursor-renderer-native: Handle lack of cursor planes gracefully While we will always have cursor planes, as we'll currently create fake ones when real ones are missing (See #1058), eventually we will run into situations where we can't create fake ones, for example for atomic KMS drivers that don't advertise any cursor planes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1079
2020-02-21 11:08:34 +00:00
meta_logical_monitor_foreach_crtc (logical_monitor,
cursor-renderer/native: Use MetaCrtcNative API to check capabilities The cursor renderer shouldn't assume all the CRTCs of a logical are KMS CRTC's, as we'll end up checking hardware capabilities for CRTC's of virtual monitors as well, when they were created to not embed the cursor image directly in the framebuffer. Instead, use the newly introduced API for checking CRTC cursor capabilities. This fixes a crash with the following backtrace: 0) get_plane_with_type_for at ../src/backends/native/meta-kms-device.c:150 1) meta_kms_device_get_cursor_plane_for at ../src/backends/native/meta-kms-device.c:173 2) has_cursor_plane at ../src/backends/native/meta-cursor-renderer-native.c:678 3) foreach_crtc at ../src/backends/meta-logical-monitor.c:247 4) meta_monitor_mode_foreach_crtc at ../src/backends/meta-monitor.c:1920 5) meta_logical_monitor_foreach_crtc at ../src/backends/meta-logical-monitor.c:274 6) crtcs_has_cursor_planes at ../src/backends/native/meta-cursor-renderer-native.c:718 7) should_have_hw_cursor at ../src/backends/native/meta-cursor-renderer-native.c:881 8) meta_cursor_renderer_native_update_cursor at ../src/backends/native/meta-cursor-renderer-native.c:1085 9) meta_cursor_renderer_update_cursor at ../src/backends/meta-cursor-renderer.c:411 Related: https://bugzilla.redhat.com/show_bug.cgi?id=2000183 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1991>
2021-09-06 08:42:32 +00:00
crtc_supports_hw_cursor,
&supports_hw_cursor);
if (!supports_hw_cursor)
cursor-renderer-native: Handle lack of cursor planes gracefully While we will always have cursor planes, as we'll currently create fake ones when real ones are missing (See #1058), eventually we will run into situations where we can't create fake ones, for example for atomic KMS drivers that don't advertise any cursor planes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1079
2020-02-21 11:08:34 +00:00
return FALSE;
}
return TRUE;
}
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
static gboolean
get_common_crtc_sprite_scale_for_logical_monitors (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite,
float *out_scale)
native: Implement DRM-based crtc rotation We can know the rotation modes supported by the driver, so export these as our supported modes, and ensure these modes are honored on the CRTC primary plane upon apply_configuration(). It is worth noting however that not all hardware will be capable of supporting all rotation modes (in fact, most of them won't). A driver independent solution should be in place to back up the rotation modes unsupported by the drivers, so this is still a partial solution. The cursor renderer has also been changed to default to software-based rendering anytime the cursor enters a rotated CRTC. Another solution would be actually rotating the DRM cursor planes, but then it requires applying rotation on these per-CRTC, and actually transforming the pointer position by the output matrix. This brings marginal gains, so we use the "sw" rendered cursor, which will be transformed together with the primary plane. https://bugzilla.gnome.org/show_bug.cgi?id=745079
2015-12-18 11:16:59 +00:00
{
native/cursor-renderer: Cleanup construction Pass the backend to a new factory function, and keep a pointer to the monitor manager, which is accessed elsewhere in the same file instead of fetching the singleton. The HW cursor initialization part is also made more obvious, without depending on seemingly irrelevant clutter features. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-07 08:12:07 +00:00
MetaCursorRendererNative *cursor_renderer_native =
META_CURSOR_RENDERER_NATIVE (renderer);
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (cursor_renderer_native);
backend: Move GPU ownership from the monitor manager to the backend Lets work towards making MetaMonitorManager about managing monitors, and not about managing GPUs. This changes other units to keep a pointer to the backend instead of a monitor manager, in case their ownership changed, or their main usage of the monitor manager was to look up GPUs. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-11 14:35:42 +00:00
MetaBackend *backend = priv->backend;
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
graphene_rect_t cursor_rect;
float scale = 1.0;
gboolean has_visible_crtc_sprite = FALSE;
cursor-renderer-native: Don't use HW cursor on transformed logical monitor The HW cursor plane can't do any transformations, and as we still don't pre-transform any buffer before uploading to the cursor plane, we must disable the HW cursor when a logical monitor is transformed. This worked previously because the transform of a MetaCrtc did not correspond to the transform of a CRTC, but the transform of the logical monitor the CRTC was assigned to. https://bugzilla.gnome.org/show_bug.cgi?id=786023
2017-08-11 07:02:43 +00:00
GList *logical_monitors;
GList *l;
native: Implement DRM-based crtc rotation We can know the rotation modes supported by the driver, so export these as our supported modes, and ensure these modes are honored on the CRTC primary plane upon apply_configuration(). It is worth noting however that not all hardware will be capable of supporting all rotation modes (in fact, most of them won't). A driver independent solution should be in place to back up the rotation modes unsupported by the drivers, so this is still a partial solution. The cursor renderer has also been changed to default to software-based rendering anytime the cursor enters a rotated CRTC. Another solution would be actually rotating the DRM cursor planes, but then it requires applying rotation on these per-CRTC, and actually transforming the pointer position by the output matrix. This brings marginal gains, so we use the "sw" rendered cursor, which will be transformed together with the primary plane. https://bugzilla.gnome.org/show_bug.cgi?id=745079
2015-12-18 11:16:59 +00:00
cursor-renderer-native: Don't use HW cursor on transformed logical monitor The HW cursor plane can't do any transformations, and as we still don't pre-transform any buffer before uploading to the cursor plane, we must disable the HW cursor when a logical monitor is transformed. This worked previously because the transform of a MetaCrtc did not correspond to the transform of a CRTC, but the transform of the logical monitor the CRTC was assigned to. https://bugzilla.gnome.org/show_bug.cgi?id=786023
2017-08-11 07:02:43 +00:00
cursor_rect = meta_cursor_renderer_calculate_rect (renderer, cursor_sprite);
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor-renderer-native: Don't use HW cursor on transformed logical monitor The HW cursor plane can't do any transformations, and as we still don't pre-transform any buffer before uploading to the cursor plane, we must disable the HW cursor when a logical monitor is transformed. This worked previously because the transform of a MetaCrtc did not correspond to the transform of a CRTC, but the transform of the logical monitor the CRTC was assigned to. https://bugzilla.gnome.org/show_bug.cgi?id=786023
2017-08-11 07:02:43 +00:00
logical_monitors =
meta_monitor_manager_get_logical_monitors (monitor_manager);
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
cursor-renderer-native: Don't use HW cursor on transformed logical monitor The HW cursor plane can't do any transformations, and as we still don't pre-transform any buffer before uploading to the cursor plane, we must disable the HW cursor when a logical monitor is transformed. This worked previously because the transform of a MetaCrtc did not correspond to the transform of a CRTC, but the transform of the logical monitor the CRTC was assigned to. https://bugzilla.gnome.org/show_bug.cgi?id=786023
2017-08-11 07:02:43 +00:00
for (l = logical_monitors; l; l = l->next)
native: Implement DRM-based crtc rotation We can know the rotation modes supported by the driver, so export these as our supported modes, and ensure these modes are honored on the CRTC primary plane upon apply_configuration(). It is worth noting however that not all hardware will be capable of supporting all rotation modes (in fact, most of them won't). A driver independent solution should be in place to back up the rotation modes unsupported by the drivers, so this is still a partial solution. The cursor renderer has also been changed to default to software-based rendering anytime the cursor enters a rotated CRTC. Another solution would be actually rotating the DRM cursor planes, but then it requires applying rotation on these per-CRTC, and actually transforming the pointer position by the output matrix. This brings marginal gains, so we use the "sw" rendered cursor, which will be transformed together with the primary plane. https://bugzilla.gnome.org/show_bug.cgi?id=745079
2015-12-18 11:16:59 +00:00
{
cursor-renderer-native: Don't use HW cursor on transformed logical monitor The HW cursor plane can't do any transformations, and as we still don't pre-transform any buffer before uploading to the cursor plane, we must disable the HW cursor when a logical monitor is transformed. This worked previously because the transform of a MetaCrtc did not correspond to the transform of a CRTC, but the transform of the logical monitor the CRTC was assigned to. https://bugzilla.gnome.org/show_bug.cgi?id=786023
2017-08-11 07:02:43 +00:00
MetaLogicalMonitor *logical_monitor = l->data;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
graphene_rect_t logical_monitor_rect =
meta_rectangle_to_graphene_rect (&logical_monitor->rect);
float tmp_scale;
cursor-renderer: Track cursor position using floats To be able to render the pointer cursor sprite at sub-(logical)-pixel positions, track the pointer position using floats instead of ints. This also requires users of the cursor sprite rect to deal with floating points, when e.g. finding the logical monitor etc. https://bugzilla.gnome.org/show_bug.cgi?id=765011
2017-06-08 14:13:16 +00:00
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
if (!graphene_rect_intersection (&cursor_rect,
&logical_monitor_rect,
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
NULL))
native: Implement DRM-based crtc rotation We can know the rotation modes supported by the driver, so export these as our supported modes, and ensure these modes are honored on the CRTC primary plane upon apply_configuration(). It is worth noting however that not all hardware will be capable of supporting all rotation modes (in fact, most of them won't). A driver independent solution should be in place to back up the rotation modes unsupported by the drivers, so this is still a partial solution. The cursor renderer has also been changed to default to software-based rendering anytime the cursor enters a rotated CRTC. Another solution would be actually rotating the DRM cursor planes, but then it requires applying rotation on these per-CRTC, and actually transforming the pointer position by the output matrix. This brings marginal gains, so we use the "sw" rendered cursor, which will be transformed together with the primary plane. https://bugzilla.gnome.org/show_bug.cgi?id=745079
2015-12-18 11:16:59 +00:00
continue;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
tmp_scale =
calculate_cursor_crtc_sprite_scale (cursor_sprite, logical_monitor);
cursor-renderer-native: Take panel-orientation into account Even if the logical_monitor config does not have an active transform, we might still be doing a transform under the hood to compensate for panel-orientation. Check for this and fall back to the sw cursor if this is the case. https://bugzilla.gnome.org/show_bug.cgi?id=782294
2017-10-06 12:48:32 +00:00
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
if (has_visible_crtc_sprite && scale != tmp_scale)
return FALSE;
has_visible_crtc_sprite = TRUE;
scale = tmp_scale;
native: Implement DRM-based crtc rotation We can know the rotation modes supported by the driver, so export these as our supported modes, and ensure these modes are honored on the CRTC primary plane upon apply_configuration(). It is worth noting however that not all hardware will be capable of supporting all rotation modes (in fact, most of them won't). A driver independent solution should be in place to back up the rotation modes unsupported by the drivers, so this is still a partial solution. The cursor renderer has also been changed to default to software-based rendering anytime the cursor enters a rotated CRTC. Another solution would be actually rotating the DRM cursor planes, but then it requires applying rotation on these per-CRTC, and actually transforming the pointer position by the output matrix. This brings marginal gains, so we use the "sw" rendered cursor, which will be transformed together with the primary plane. https://bugzilla.gnome.org/show_bug.cgi?id=745079
2015-12-18 11:16:59 +00:00
}
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
if (!has_visible_crtc_sprite)
return FALSE;
native: Implement DRM-based crtc rotation We can know the rotation modes supported by the driver, so export these as our supported modes, and ensure these modes are honored on the CRTC primary plane upon apply_configuration(). It is worth noting however that not all hardware will be capable of supporting all rotation modes (in fact, most of them won't). A driver independent solution should be in place to back up the rotation modes unsupported by the drivers, so this is still a partial solution. The cursor renderer has also been changed to default to software-based rendering anytime the cursor enters a rotated CRTC. Another solution would be actually rotating the DRM cursor planes, but then it requires applying rotation on these per-CRTC, and actually transforming the pointer position by the output matrix. This brings marginal gains, so we use the "sw" rendered cursor, which will be transformed together with the primary plane. https://bugzilla.gnome.org/show_bug.cgi?id=745079
2015-12-18 11:16:59 +00:00
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
*out_scale = scale;
return TRUE;
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
}
static gboolean
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
get_common_crtc_sprite_transform_for_logical_monitors (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite,
MetaMonitorTransform *out_transform)
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
{
native/cursor-renderer: Cleanup construction Pass the backend to a new factory function, and keep a pointer to the monitor manager, which is accessed elsewhere in the same file instead of fetching the singleton. The HW cursor initialization part is also made more obvious, without depending on seemingly irrelevant clutter features. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-07 08:12:07 +00:00
MetaCursorRendererNative *cursor_renderer_native =
META_CURSOR_RENDERER_NATIVE (renderer);
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (cursor_renderer_native);
backend: Move GPU ownership from the monitor manager to the backend Lets work towards making MetaMonitorManager about managing monitors, and not about managing GPUs. This changes other units to keep a pointer to the backend instead of a monitor manager, in case their ownership changed, or their main usage of the monitor manager was to look up GPUs. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-11 14:35:42 +00:00
MetaBackend *backend = priv->backend;
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
graphene_rect_t cursor_rect;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
MetaMonitorTransform transform = META_MONITOR_TRANSFORM_NORMAL;
gboolean has_visible_crtc_sprite = FALSE;
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
GList *logical_monitors;
GList *l;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
cursor_rect = meta_cursor_renderer_calculate_rect (renderer, cursor_sprite);
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
logical_monitors =
meta_monitor_manager_get_logical_monitors (monitor_manager);
for (l = logical_monitors; l; l = l->next)
{
MetaLogicalMonitor *logical_monitor = l->data;
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
graphene_rect_t logical_monitor_rect =
meta_rectangle_to_graphene_rect (&logical_monitor->rect);
cursor-renderer-native: Take panel-orientation into account for sprite transform When calculating the transform we should apply to the cursor sprite before uploading it to the cursor plane, we must also take into account non upright mounted LCD panels. Otherwise the cursor ends up 90 degrees rotated on devices where the LCD panel is mounted 90 degrees rotated in its enclosure. This commit fixes this by calling meta_monitor_logical_to_crtc_transform in get_common_crtc_sprite_transform_for_logical_monitors to adjust the transform for each Monitor in the LogicalMonitor. Fixes: https://gitlab.gnome.org/GNOME/mutter/-/issues/1123 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1153
2020-03-27 13:57:27 +00:00
MetaMonitorTransform logical_transform, tmp_transform;
GList *monitors, *l_mon;
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
if (!graphene_rect_intersection (&cursor_rect,
&logical_monitor_rect,
NULL))
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
continue;
cursor-renderer-native: Take panel-orientation into account for sprite transform When calculating the transform we should apply to the cursor sprite before uploading it to the cursor plane, we must also take into account non upright mounted LCD panels. Otherwise the cursor ends up 90 degrees rotated on devices where the LCD panel is mounted 90 degrees rotated in its enclosure. This commit fixes this by calling meta_monitor_logical_to_crtc_transform in get_common_crtc_sprite_transform_for_logical_monitors to adjust the transform for each Monitor in the LogicalMonitor. Fixes: https://gitlab.gnome.org/GNOME/mutter/-/issues/1123 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1153
2020-03-27 13:57:27 +00:00
logical_transform = meta_logical_monitor_get_transform (logical_monitor);
monitors = meta_logical_monitor_get_monitors (logical_monitor);
for (l_mon = monitors; l_mon; l_mon = l_mon->next)
{
MetaMonitor *monitor = l_mon->data;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
monitor-transform: Fix transform() and drop relative_transform() The following implicit definition for `transform()` did not correctly apply: ``` a * b = c c * invert(b) = a ``` Crucially the following did not apply for `FLIPPED-90` and `FLIPPED-270`: ``` a * invert(a) = identity ``` Fix this by applying the operations, first the flip, then the rotation, in this order and add tests to ensure correct results for the requirement above. Also drop `relative_transform()` as it only had a single user and can be replaced by `transform()`: ``` invert(a) * b = c a * c = b ``` As this is not very intuitive, ensure in tests as well. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2459>
2022-07-01 14:03:20 +00:00
tmp_transform = meta_monitor_transform_transform (
meta_monitor_transform_invert (
meta_cursor_sprite_get_texture_transform (cursor_sprite)),
cursor-renderer-native: Take panel-orientation into account for sprite transform When calculating the transform we should apply to the cursor sprite before uploading it to the cursor plane, we must also take into account non upright mounted LCD panels. Otherwise the cursor ends up 90 degrees rotated on devices where the LCD panel is mounted 90 degrees rotated in its enclosure. This commit fixes this by calling meta_monitor_logical_to_crtc_transform in get_common_crtc_sprite_transform_for_logical_monitors to adjust the transform for each Monitor in the LogicalMonitor. Fixes: https://gitlab.gnome.org/GNOME/mutter/-/issues/1123 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1153
2020-03-27 13:57:27 +00:00
meta_monitor_logical_to_crtc_transform (monitor, logical_transform));
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
cursor-renderer-native: Take panel-orientation into account for sprite transform When calculating the transform we should apply to the cursor sprite before uploading it to the cursor plane, we must also take into account non upright mounted LCD panels. Otherwise the cursor ends up 90 degrees rotated on devices where the LCD panel is mounted 90 degrees rotated in its enclosure. This commit fixes this by calling meta_monitor_logical_to_crtc_transform in get_common_crtc_sprite_transform_for_logical_monitors to adjust the transform for each Monitor in the LogicalMonitor. Fixes: https://gitlab.gnome.org/GNOME/mutter/-/issues/1123 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1153
2020-03-27 13:57:27 +00:00
if (has_visible_crtc_sprite && transform != tmp_transform)
return FALSE;
has_visible_crtc_sprite = TRUE;
transform = tmp_transform;
}
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
}
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
if (!has_visible_crtc_sprite)
return FALSE;
*out_transform = transform;
return TRUE;
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 10:10:52 +00:00
}
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
static gboolean
should_have_hw_cursor (MetaCursorRenderer *renderer,
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
MetaCursorSprite *cursor_sprite,
GList *gpus)
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
{
backends: Move HW cursor inhibitors to MetaBackend We are aiming for a split of HW and SW cursor rendering management. Given the HW plane is a limited resource and the amount of cursor renderers may be >1 (due to tablets, even though we currently use an always-software cursor renderer there), it would ideally be able to switch between renderers. Being MetaCursorRenderer not really a singleton, having cursor inhibitor accounting here doesn't pan out. Make it MetaBackend API so all cursor renderers get the same picture. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1403>
2020-07-13 15:45:41 +00:00
MetaCursorRendererNative *cursor_renderer_native =
META_CURSOR_RENDERER_NATIVE (renderer);
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (cursor_renderer_native);
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
CoglTexture *texture;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
MetaMonitorTransform transform;
float scale;
GList *l;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
Introduce virtual monitors Virtual monitors are monitors that isn't backed by any monitor like hardware. It would typically be backed by e.g. a remote desktop service, or a network display. It is currently only supported by the native backend, and whether the X11 backend will ever see virtual monitors is an open question. This rest of this commit message describes how it works under the native backend. Each virutal monitor consists of virtualized mode setting components: * A virtual CRTC mode (MetaCrtcModeVirtual) * A virtual CRTC (MetaCrtcVirtual) * A virtual connector (MetaOutputVirtual) In difference to the corresponding mode setting objects that represents KMS objects, the virtual ones isn't directly tied to a MetaGpu, other than the CoglFramebuffer being part of the GPU context of the primary GPU, which is the case for all monitors no matter what GPU they are connected to. Part of the reason for this is that a MetaGpu in practice represents a mode setting device, and its CRTCs and outputs, are all backed by real mode setting objects, while a virtual monitor is only backed by a framebuffer that is tied to the primary GPU. Maybe this will be reevaluated in the future, but since a virtual monitor is not tied to any GPU currently, so is the case for the virtual mode setting objects. The native rendering backend, including the cursor renderer, is adapted to handle the situation where a CRTC does not have a GPU associated with it; this in practice means that it e.g. will not try to upload HW cursor buffers when the cursor is only on a virtual monitor. The same applies to the native renderer, which is made to avoid creating MetaOnscreenNative for views that are backed by virtual CRTCs, as well as to avoid trying to mode set on such views. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1698>
2021-01-26 15:49:28 +00:00
if (!gpus)
return FALSE;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
if (!cursor_sprite)
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
return FALSE;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
backends: Move HW cursor inhibitors to MetaBackend We are aiming for a split of HW and SW cursor rendering management. Given the HW plane is a limited resource and the amount of cursor renderers may be >1 (due to tablets, even though we currently use an always-software cursor renderer there), it would ideally be able to switch between renderers. Being MetaCursorRenderer not really a singleton, having cursor inhibitor accounting here doesn't pan out. Make it MetaBackend API so all cursor renderers get the same picture. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1403>
2020-07-13 15:45:41 +00:00
if (meta_backend_is_hw_cursors_inhibited (priv->backend))
cursor-renderer: Add API to allow inhibiting HW cursor There may be reasons to temporarly inhibit the HW cursor under certain circumstances. Allow adding such inhibitations by adding API to the cursor renderer to allow API users to add generic inhibitors with whatever logic is deemed necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/357
2018-09-13 09:28:51 +00:00
return FALSE;
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
for (l = gpus; l; l = l->next)
{
MetaGpuKms *gpu_kms = l->data;
MetaCursorRendererNativeGpuData *cursor_renderer_gpu_data;
cursor_renderer_gpu_data =
meta_cursor_renderer_native_gpu_data_from_gpu (gpu_kms);
if (!cursor_renderer_gpu_data)
return FALSE;
if (cursor_renderer_gpu_data->hw_cursor_broken)
return FALSE;
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
if (!has_valid_cursor_sprite_buffer (cursor_sprite, gpu_kms))
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
return FALSE;
}
backends: Split out CRTC/output management to MetaGpu In order to eventually support multilpe GPUs with their own connectors, split out related meta data management (i.e. outputs, CRTCs and CRTC modes) into a new MetaGpu GObject. The Xrandr backend always assumes there is always only a single "GPU" as the GPU is abstracted by the X server; only the native backend (aside from the test backend) will eventually see more than one GPU. The Xrandr backend still moves some management to MetaGpuXrandr, in order to behave more similarly to the KMS counterparts. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-10 10:19:32 +00:00
cursor-renderer/native: Use MetaCrtcNative API to check capabilities The cursor renderer shouldn't assume all the CRTCs of a logical are KMS CRTC's, as we'll end up checking hardware capabilities for CRTC's of virtual monitors as well, when they were created to not embed the cursor image directly in the framebuffer. Instead, use the newly introduced API for checking CRTC cursor capabilities. This fixes a crash with the following backtrace: 0) get_plane_with_type_for at ../src/backends/native/meta-kms-device.c:150 1) meta_kms_device_get_cursor_plane_for at ../src/backends/native/meta-kms-device.c:173 2) has_cursor_plane at ../src/backends/native/meta-cursor-renderer-native.c:678 3) foreach_crtc at ../src/backends/meta-logical-monitor.c:247 4) meta_monitor_mode_foreach_crtc at ../src/backends/meta-monitor.c:1920 5) meta_logical_monitor_foreach_crtc at ../src/backends/meta-logical-monitor.c:274 6) crtcs_has_cursor_planes at ../src/backends/native/meta-cursor-renderer-native.c:718 7) should_have_hw_cursor at ../src/backends/native/meta-cursor-renderer-native.c:881 8) meta_cursor_renderer_native_update_cursor at ../src/backends/native/meta-cursor-renderer-native.c:1085 9) meta_cursor_renderer_update_cursor at ../src/backends/meta-cursor-renderer.c:411 Related: https://bugzilla.redhat.com/show_bug.cgi?id=2000183 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1991>
2021-09-06 08:42:32 +00:00
if (!crtcs_supports_hw_cursor (renderer, cursor_sprite))
cursor-renderer-native: Handle lack of cursor planes gracefully While we will always have cursor planes, as we'll currently create fake ones when real ones are missing (See #1058), eventually we will run into situations where we can't create fake ones, for example for atomic KMS drivers that don't advertise any cursor planes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1079
2020-02-21 11:08:34 +00:00
return FALSE;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
texture = meta_cursor_sprite_get_cogl_texture (cursor_sprite);
if (!texture)
return FALSE;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
if (!get_common_crtc_sprite_scale_for_logical_monitors (renderer,
cursor_sprite,
&scale))
return FALSE;
if (!get_common_crtc_sprite_transform_for_logical_monitors (renderer,
cursor_sprite,
&transform))
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
return FALSE;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
if (G_APPROX_VALUE (scale, 1.f, FLT_EPSILON) &&
transform == META_MONITOR_TRANSFORM_NORMAL)
return TRUE;
else
return get_can_preprocess (cursor_sprite);
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
}
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
static gboolean
meta_cursor_renderer_native_update_animation (MetaCursorRendererNative *native)
{
cursor-renderer/native: Various whitespace fixes https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 12:31:44 +00:00
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (native);
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
MetaCursorRenderer *renderer = META_CURSOR_RENDERER (native);
MetaCursorSprite *cursor_sprite = meta_cursor_renderer_get_cursor (renderer);
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
priv->animation_timeout_id = 0;
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 03:23:00 +00:00
meta_cursor_sprite_tick_frame (cursor_sprite);
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
meta_cursor_renderer_force_update (renderer);
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
return G_SOURCE_REMOVE;
}
static void
cursor-renderer/native: Rename frame scheduling helper function The function conditionally schedules a cursor animation frame, so rename it to make that clearer. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:43:30 +00:00
maybe_schedule_cursor_sprite_animation_frame (MetaCursorRendererNative *native,
MetaCursorSprite *cursor_sprite)
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
{
cursor-renderer/native: Various whitespace fixes https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 12:31:44 +00:00
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (native);
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
gboolean cursor_change;
guint delay;
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 03:23:00 +00:00
cursor_change = cursor_sprite != priv->last_cursor;
priv->last_cursor = cursor_sprite;
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
if (!cursor_change && priv->animation_timeout_id)
return;
cleanup: Use g_clear_handle_id() for g_source_remove() It makes sure we do not forget to zero the id and lets us avoid zero checks before. We use it for all new code, lets clean up the existing code base. https://gitlab.gnome.org/GNOME/mutter/merge_requests/947
2019-11-21 23:25:30 +00:00
g_clear_handle_id (&priv->animation_timeout_id, g_source_remove);
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 03:23:00 +00:00
if (cursor_sprite && meta_cursor_sprite_is_animated (cursor_sprite))
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
{
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 03:23:00 +00:00
delay = meta_cursor_sprite_get_current_frame_time (cursor_sprite);
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
if (delay == 0)
return;
priv->animation_timeout_id =
g_timeout_add (delay,
(GSourceFunc) meta_cursor_renderer_native_update_animation,
native);
g_source_set_name_by_id (priv->animation_timeout_id,
"[mutter] meta_cursor_renderer_native_update_animation");
}
}
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
static GList *
calculate_cursor_sprite_gpus (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite)
{
MetaCursorRendererNative *native = META_CURSOR_RENDERER_NATIVE (renderer);
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (native);
backend: Move GPU ownership from the monitor manager to the backend Lets work towards making MetaMonitorManager about managing monitors, and not about managing GPUs. This changes other units to keep a pointer to the backend instead of a monitor manager, in case their ownership changed, or their main usage of the monitor manager was to look up GPUs. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-11 14:35:42 +00:00
MetaBackend *backend = priv->backend;
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
GList *gpus = NULL;
GList *logical_monitors;
GList *l;
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
graphene_rect_t cursor_rect;
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
cursor_rect = meta_cursor_renderer_calculate_rect (renderer, cursor_sprite);
logical_monitors =
meta_monitor_manager_get_logical_monitors (monitor_manager);
for (l = logical_monitors; l; l = l->next)
{
MetaLogicalMonitor *logical_monitor = l->data;
MetaRectangle logical_monitor_layout;
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
graphene_rect_t logical_monitor_rect;
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
GList *monitors, *l_mon;
logical_monitor_layout =
meta_logical_monitor_get_layout (logical_monitor);
logical_monitor_rect =
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
meta_rectangle_to_graphene_rect (&logical_monitor_layout);
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
if (!graphene_rect_intersection (&cursor_rect, &logical_monitor_rect,
NULL))
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
continue;
monitors = meta_logical_monitor_get_monitors (logical_monitor);
for (l_mon = monitors; l_mon; l_mon = l_mon->next)
{
MetaMonitor *monitor = l_mon->data;
monitor: Attach to backend instead of GPU Prepare for the future when a monitor isn't necessarily attached to a mode setting device, which is practically what MetaGpu represents. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1698>
2021-01-26 13:49:25 +00:00
MetaOutput *output = meta_monitor_get_main_output (monitor);
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
MetaGpu *gpu;
monitor: Attach to backend instead of GPU Prepare for the future when a monitor isn't necessarily attached to a mode setting device, which is practically what MetaGpu represents. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1698>
2021-01-26 13:49:25 +00:00
gpu = meta_output_get_gpu (output);
Introduce virtual monitors Virtual monitors are monitors that isn't backed by any monitor like hardware. It would typically be backed by e.g. a remote desktop service, or a network display. It is currently only supported by the native backend, and whether the X11 backend will ever see virtual monitors is an open question. This rest of this commit message describes how it works under the native backend. Each virutal monitor consists of virtualized mode setting components: * A virtual CRTC mode (MetaCrtcModeVirtual) * A virtual CRTC (MetaCrtcVirtual) * A virtual connector (MetaOutputVirtual) In difference to the corresponding mode setting objects that represents KMS objects, the virtual ones isn't directly tied to a MetaGpu, other than the CoglFramebuffer being part of the GPU context of the primary GPU, which is the case for all monitors no matter what GPU they are connected to. Part of the reason for this is that a MetaGpu in practice represents a mode setting device, and its CRTCs and outputs, are all backed by real mode setting objects, while a virtual monitor is only backed by a framebuffer that is tied to the primary GPU. Maybe this will be reevaluated in the future, but since a virtual monitor is not tied to any GPU currently, so is the case for the virtual mode setting objects. The native rendering backend, including the cursor renderer, is adapted to handle the situation where a CRTC does not have a GPU associated with it; this in practice means that it e.g. will not try to upload HW cursor buffers when the cursor is only on a virtual monitor. The same applies to the native renderer, which is made to avoid creating MetaOnscreenNative for views that are backed by virtual CRTCs, as well as to avoid trying to mode set on such views. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1698>
2021-01-26 15:49:28 +00:00
if (gpu && !g_list_find (gpus, gpu))
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
gpus = g_list_prepend (gpus, gpu);
}
}
return gpus;
}
cursor-renderer/native: Postpone cursor update if modeset is pending If a modeset is pending, it's likely that the cursor update will not work; thus, wait with updating the cursor so that it's applied together with the mode set update. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-02 14:43:45 +00:00
static void
on_kms_update_result (const MetaKmsFeedback *kms_feedback,
gpointer user_data)
{
MetaCursorRendererNative *cursor_renderer_native = user_data;
MetaCursorRenderer *cursor_renderer =
META_CURSOR_RENDERER (cursor_renderer_native);
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (cursor_renderer_native);
gboolean has_hw_cursor_failure = FALSE;
GList *l;
for (l = meta_kms_feedback_get_failed_planes (kms_feedback); l; l = l->next)
{
MetaKmsPlaneFeedback *plane_feedback = l->data;
switch (meta_kms_plane_get_plane_type (plane_feedback->plane))
{
case META_KMS_PLANE_TYPE_CURSOR:
break;
case META_KMS_PLANE_TYPE_PRIMARY:
case META_KMS_PLANE_TYPE_OVERLAY:
continue;
}
disable_hw_cursor_for_crtc (plane_feedback->crtc,
plane_feedback->error);
has_hw_cursor_failure = TRUE;
}
if (has_hw_cursor_failure)
{
priv->has_hw_cursor = FALSE;
meta_cursor_renderer_force_update (cursor_renderer);
}
}
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
static void
schedule_sync_position (MetaCursorRendererNative *cursor_renderer_native)
{
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (cursor_renderer_native);
GList *l;
for (l = meta_backend_get_gpus (priv->backend); l; l = l->next)
{
MetaGpu *gpu = l->data;
GList *l_crtc;
for (l_crtc = meta_gpu_get_crtcs (gpu); l_crtc; l_crtc = l_crtc->next)
{
MetaCrtcKms *crtc_kms = META_CRTC_KMS (l_crtc->data);
CrtcCursorData *crtc_cursor_data;
crtc_cursor_data = ensure_crtc_cursor_data (crtc_kms);
crtc_cursor_data->needs_sync_position = TRUE;
}
}
}
cursor: Correct switching between fallback and backend cursors When switching from the stage cursor to the native cursor, we forgot to repaint the stage to get rid of the old cursor. Fix this by having the abstract cursor renderer class track whether we're using the backend, rather than doing chain-up shenanigans.
2014-05-17 15:22:05 +00:00
static gboolean
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
meta_cursor_renderer_native_update_cursor (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite)
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
{
MetaCursorRendererNative *native = META_CURSOR_RENDERER_NATIVE (renderer);
cursor-renderer/native: Various whitespace fixes https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 12:31:44 +00:00
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (native);
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
ClutterStage *stage = CLUTTER_STAGE (meta_backend_get_stage (priv->backend));
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
g_autoptr (GList) gpus = NULL;
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
if (cursor_sprite)
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
{
backends: Only reload sprite cursor on changes Let the meta_cursor_sprite_realize() function return a boolean value telling whether there was an actual change in the sprite cursor. E.g. the surface/icon for it changed in between. This is used in the native backend to avoid converting/uploading again the cursor surface. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1915>
2021-07-05 13:47:58 +00:00
gboolean realized;
backends/native: Update cursor also when scaled or transformed MetaCursorRendererNative only updates the cursor state when the underlying texture changes. The cursor scale and transform do not trigger updates. This results in wrong cursor orientations on rotated displays. Use both texture changes and scale and transformation changes to figure out when to update the cursor state. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2363>
2022-04-13 14:32:35 +00:00
ensure_cursor_priv (cursor_sprite);
backends: Only reload sprite cursor on changes Let the meta_cursor_sprite_realize() function return a boolean value telling whether there was an actual change in the sprite cursor. E.g. the surface/icon for it changed in between. This is used in the native backend to avoid converting/uploading again the cursor surface. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1915>
2021-07-05 13:47:58 +00:00
realized = meta_cursor_sprite_realize_texture (cursor_sprite);
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
gpus = calculate_cursor_sprite_gpus (renderer, cursor_sprite);
backends: Only reload sprite cursor on changes Let the meta_cursor_sprite_realize() function return a boolean value telling whether there was an actual change in the sprite cursor. E.g. the surface/icon for it changed in between. This is used in the native backend to avoid converting/uploading again the cursor surface. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1915>
2021-07-05 13:47:58 +00:00
backends/native: Update cursor also when scaled or transformed MetaCursorRendererNative only updates the cursor state when the underlying texture changes. The cursor scale and transform do not trigger updates. This results in wrong cursor orientations on rotated displays. Use both texture changes and scale and transformation changes to figure out when to update the cursor state. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2363>
2022-04-13 14:32:35 +00:00
if (realized ||
!is_cursor_scale_and_transform_valid (renderer, cursor_sprite))
backends: Only reload sprite cursor on changes Let the meta_cursor_sprite_realize() function return a boolean value telling whether there was an actual change in the sprite cursor. E.g. the surface/icon for it changed in between. This is used in the native backend to avoid converting/uploading again the cursor surface. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1915>
2021-07-05 13:47:58 +00:00
realize_cursor_sprite (renderer, cursor_sprite, gpus);
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
}
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor-renderer/native: Rename frame scheduling helper function The function conditionally schedules a cursor animation frame, so rename it to make that clearer. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:43:30 +00:00
maybe_schedule_cursor_sprite_animation_frame (native, cursor_sprite);
backends: Trigger animated cursor animations on the native backend We will need to update the timeout on either cursor changes, or right when ticking to the next cursor frame. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 18:38:08 +00:00
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
priv->has_hw_cursor = should_have_hw_cursor (renderer, cursor_sprite, gpus);
cursor-renderer/native: Postpone cursor update if modeset is pending If a modeset is pending, it's likely that the cursor update will not work; thus, wait with updating the cursor so that it's applied together with the mode set update. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-02 14:43:45 +00:00
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
schedule_sync_position (native);
clutter_stage_schedule_update (stage);
cursor-renderer/native: Postpone cursor update if modeset is pending If a modeset is pending, it's likely that the cursor update will not work; thus, wait with updating the cursor so that it's applied together with the mode set update. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-02 14:43:45 +00:00
cursor-renderer/native: Don't trigger redraw when cursor hidden When a cursor is hidden, the native backend will properly hide the HW cursor sprite as well, but it would communicate this as if the cursor was not handled by the backend, while in fact it still was. This caused the generic cursor rendering layer to queue a redraw. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-11 11:23:39 +00:00
return (priv->has_hw_cursor ||
!cursor_sprite ||
!meta_cursor_sprite_get_cogl_texture (cursor_sprite));
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
}
cursor-renderer/native: Clear active CRTC gbm_bo when destroyed When we freed the cursor GPU state including the gbm_bo objects attached to it, we didn't unset the cursor renderer private of the CRTCs of the associated GPU. This means that HW cursor invalidation could potentially break if a new gbm_bo happened to be allocated at the same memory address as the previous one. To avoid this, iterate through the CRTCs of the GPU of which the cursor data is freed, and unset the cursor renderer private if it was the one destroyed. https://gitlab.gnome.org/GNOME/mutter/issues/199
2019-02-08 18:33:09 +00:00
static void
unset_crtc_cursor_renderer_privates (MetaGpu *gpu,
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
MetaDrmBuffer *buffer)
cursor-renderer/native: Clear active CRTC gbm_bo when destroyed When we freed the cursor GPU state including the gbm_bo objects attached to it, we didn't unset the cursor renderer private of the CRTCs of the associated GPU. This means that HW cursor invalidation could potentially break if a new gbm_bo happened to be allocated at the same memory address as the previous one. To avoid this, iterate through the CRTCs of the GPU of which the cursor data is freed, and unset the cursor renderer private if it was the one destroyed. https://gitlab.gnome.org/GNOME/mutter/issues/199
2019-02-08 18:33:09 +00:00
{
GList *l;
for (l = meta_gpu_get_crtcs (gpu); l; l = l->next)
{
crtc: Make implementations inherit MetaCrtc Just as with MetaOutput, instead of the home baked "inheritance" system, using a gpointer and a GDestroyNotify function to keep the what effectively is sub type details, make MetaCrtc an abstract derivable type, and make the implementations inherit it. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1287
2020-02-26 18:47:44 +00:00
MetaCrtcKms *crtc_kms = META_CRTC_KMS (l->data);
cursor-renderer/native: Fix type in unset_crtc_cursor_renderer_privates Since the commit below, meta_crtc_kms_get_cursor_renderer_private has returned a CrtcCursorData pointer, but this code was still treating it as a MetaDrmBuffer pointer. Fixes: fea8ebcca9e1 ("cursor-renderer/native: Store struct in CRTC private") Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2524>
2022-07-12 15:09:01 +00:00
CrtcCursorData *crtc_cursor_data;
cursor-renderer/native: Clear active CRTC gbm_bo when destroyed When we freed the cursor GPU state including the gbm_bo objects attached to it, we didn't unset the cursor renderer private of the CRTCs of the associated GPU. This means that HW cursor invalidation could potentially break if a new gbm_bo happened to be allocated at the same memory address as the previous one. To avoid this, iterate through the CRTCs of the GPU of which the cursor data is freed, and unset the cursor renderer private if it was the one destroyed. https://gitlab.gnome.org/GNOME/mutter/issues/199
2019-02-08 18:33:09 +00:00
cursor-renderer/native: Fix type in unset_crtc_cursor_renderer_privates Since the commit below, meta_crtc_kms_get_cursor_renderer_private has returned a CrtcCursorData pointer, but this code was still treating it as a MetaDrmBuffer pointer. Fixes: fea8ebcca9e1 ("cursor-renderer/native: Store struct in CRTC private") Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2524>
2022-07-12 15:09:01 +00:00
crtc_cursor_data = meta_crtc_kms_get_cursor_renderer_private (crtc_kms);
if (crtc_cursor_data && buffer == crtc_cursor_data->buffer)
crtc_cursor_data->buffer = NULL;
cursor-renderer/native: Clear active CRTC gbm_bo when destroyed When we freed the cursor GPU state including the gbm_bo objects attached to it, we didn't unset the cursor renderer private of the CRTCs of the associated GPU. This means that HW cursor invalidation could potentially break if a new gbm_bo happened to be allocated at the same memory address as the previous one. To avoid this, iterate through the CRTCs of the GPU of which the cursor data is freed, and unset the cursor renderer private if it was the one destroyed. https://gitlab.gnome.org/GNOME/mutter/issues/199
2019-02-08 18:33:09 +00:00
}
}
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
static void
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_gpu_state_free (MetaCursorNativeGpuState *cursor_gpu_state)
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
{
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
int i;
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
MetaDrmBuffer *active_buffer;
cursor-renderer/native: Clear active CRTC gbm_bo when destroyed When we freed the cursor GPU state including the gbm_bo objects attached to it, we didn't unset the cursor renderer private of the CRTCs of the associated GPU. This means that HW cursor invalidation could potentially break if a new gbm_bo happened to be allocated at the same memory address as the previous one. To avoid this, iterate through the CRTCs of the GPU of which the cursor data is freed, and unset the cursor renderer private if it was the one destroyed. https://gitlab.gnome.org/GNOME/mutter/issues/199
2019-02-08 18:33:09 +00:00
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
active_buffer = get_active_cursor_sprite_buffer (cursor_gpu_state);
if (active_buffer)
unset_crtc_cursor_renderer_privates (cursor_gpu_state->gpu,
active_buffer);
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
for (i = 0; i < HW_CURSOR_BUFFER_COUNT; i++)
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
g_clear_object (&cursor_gpu_state->buffers[i]);
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
g_free (cursor_gpu_state);
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
}
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
static MetaCursorNativeGpuState *
get_cursor_gpu_state (MetaCursorNativePrivate *cursor_priv,
MetaGpuKms *gpu_kms)
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
{
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
return g_hash_table_lookup (cursor_priv->gpu_states, gpu_kms);
}
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
static MetaCursorNativeGpuState *
ensure_cursor_gpu_state (MetaCursorNativePrivate *cursor_priv,
MetaGpuKms *gpu_kms)
{
MetaCursorNativeGpuState *cursor_gpu_state;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_gpu_state = get_cursor_gpu_state (cursor_priv, gpu_kms);
if (cursor_gpu_state)
return cursor_gpu_state;
cursor_gpu_state = g_new0 (MetaCursorNativeGpuState, 1);
cursor-renderer/native: Clear active CRTC gbm_bo when destroyed When we freed the cursor GPU state including the gbm_bo objects attached to it, we didn't unset the cursor renderer private of the CRTCs of the associated GPU. This means that HW cursor invalidation could potentially break if a new gbm_bo happened to be allocated at the same memory address as the previous one. To avoid this, iterate through the CRTCs of the GPU of which the cursor data is freed, and unset the cursor renderer private if it was the one destroyed. https://gitlab.gnome.org/GNOME/mutter/issues/199
2019-02-08 18:33:09 +00:00
cursor_gpu_state->gpu = META_GPU (gpu_kms);
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
g_hash_table_insert (cursor_priv->gpu_states, gpu_kms, cursor_gpu_state);
return cursor_gpu_state;
}
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
static void
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
invalidate_cursor_gpu_state (MetaCursorSprite *cursor_sprite)
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
{
MetaCursorNativePrivate *cursor_priv = get_cursor_priv (cursor_sprite);
GHashTableIter iter;
MetaCursorNativeGpuState *cursor_gpu_state;
g_hash_table_iter_init (&iter, cursor_priv->gpu_states);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &cursor_gpu_state))
{
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
unsigned int pending_buffer_idx;
pending_buffer_idx = get_pending_cursor_sprite_buffer_index (cursor_gpu_state);
g_clear_object (&cursor_gpu_state->buffers[pending_buffer_idx]);
cursor_gpu_state->pending_buffer_state =
META_CURSOR_BUFFER_STATE_INVALIDATED;
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
}
}
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
static void
on_cursor_sprite_texture_changed (MetaCursorSprite *cursor_sprite)
{
invalidate_cursor_gpu_state (cursor_sprite);
}
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
static void
cursor_priv_free (MetaCursorNativePrivate *cursor_priv)
{
g_hash_table_destroy (cursor_priv->gpu_states);
cursor-renderer-native: Free MetaCursorNativePrivate struct Fix a small leak in native renderer. https://gitlab.gnome.org/GNOME/mutter/merge_requests/581
2019-05-17 19:46:33 +00:00
g_free (cursor_priv);
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
}
static MetaCursorNativePrivate *
get_cursor_priv (MetaCursorSprite *cursor_sprite)
{
return g_object_get_qdata (G_OBJECT (cursor_sprite), quark_cursor_sprite);
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
}
static MetaCursorNativePrivate *
ensure_cursor_priv (MetaCursorSprite *cursor_sprite)
{
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
MetaCursorNativePrivate *cursor_priv;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_priv = get_cursor_priv (cursor_sprite);
if (cursor_priv)
return cursor_priv;
cursor_priv = g_new0 (MetaCursorNativePrivate, 1);
cursor_priv->gpu_states =
g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
(GDestroyNotify) cursor_gpu_state_free);
g_object_set_qdata_full (G_OBJECT (cursor_sprite),
quark_cursor_sprite,
cursor_priv,
(GDestroyNotify) cursor_priv_free);
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
g_signal_connect (cursor_sprite, "texture-changed",
G_CALLBACK (on_cursor_sprite_texture_changed), NULL);
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
unset_can_preprocess (cursor_sprite);
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
return cursor_priv;
}
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
static MetaDrmBuffer *
cursor-renderer/native: Support allocating dumb buffers This makes it possible to allocate HW cursor without a gbm_device, e.g. when using EGLStream/EGLDevice. Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/1980 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:38:37 +00:00
create_cursor_drm_buffer_gbm (MetaGpuKms *gpu_kms,
MetaDeviceFile *device_file,
struct gbm_device *gbm_device,
uint8_t *pixels,
int width,
int height,
int stride,
int cursor_width,
int cursor_height,
uint32_t format,
GError **error)
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
{
struct gbm_bo *bo;
uint8_t buf[4 * cursor_width * cursor_height];
int i;
MetaDrmBufferFlags flags;
MetaDrmBufferGbm *buffer_gbm;
if (!gbm_device_is_format_supported (gbm_device, format,
GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
"Buffer format not supported");
return NULL;
}
bo = gbm_bo_create (gbm_device, cursor_width, cursor_height,
format, GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE);
if (!bo)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
"Failed to allocate gbm_bo: %s", g_strerror (errno));
return NULL;
}
memset (buf, 0, sizeof (buf));
for (i = 0; i < height; i++)
memcpy (buf + i * 4 * cursor_width, pixels + i * stride, width * 4);
if (gbm_bo_write (bo, buf, cursor_width * cursor_height * 4) != 0)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
"Failed write to gbm_bo: %s", g_strerror (errno));
gbm_bo_destroy (bo);
return NULL;
}
flags = META_DRM_BUFFER_FLAG_DISABLE_MODIFIERS;
buffer_gbm = meta_drm_buffer_gbm_new_take (device_file, bo, flags, error);
if (!buffer_gbm)
{
gbm_bo_destroy (bo);
return NULL;
}
return META_DRM_BUFFER (buffer_gbm);
}
cursor-renderer/native: Support allocating dumb buffers This makes it possible to allocate HW cursor without a gbm_device, e.g. when using EGLStream/EGLDevice. Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/1980 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:38:37 +00:00
static MetaDrmBuffer *
create_cursor_drm_buffer_dumb (MetaGpuKms *gpu_kms,
MetaDeviceFile *device_file,
uint8_t *pixels,
int width,
int height,
int stride,
int cursor_width,
int cursor_height,
uint32_t format,
GError **error)
{
MetaDrmBufferDumb *buffer_dumb;
int i;
uint8_t *data;
buffer_dumb = meta_drm_buffer_dumb_new (device_file,
cursor_width, cursor_height,
format,
error);
if (!buffer_dumb)
return NULL;
data = meta_drm_buffer_dumb_get_data (buffer_dumb);
memset (data, 0, cursor_width * cursor_height * 4);
for (i = 0; i < height; i++)
memcpy (data + i * 4 * cursor_width, pixels + i * stride, width * 4);
return META_DRM_BUFFER (buffer_dumb);
}
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
static MetaDrmBuffer *
create_cursor_drm_buffer (MetaGpuKms *gpu_kms,
MetaDeviceFile *device_file,
uint8_t *pixels,
int width,
int height,
int stride,
int cursor_width,
int cursor_height,
uint32_t format,
GError **error)
{
cursor-renderer/native: Support allocating dumb buffers This makes it possible to allocate HW cursor without a gbm_device, e.g. when using EGLStream/EGLDevice. Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/1980 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:38:37 +00:00
struct gbm_device *gbm_device;
gbm_device = meta_gbm_device_from_gpu (gpu_kms);
if (gbm_device)
{
return create_cursor_drm_buffer_gbm (gpu_kms, device_file, gbm_device,
pixels,
width, height, stride,
cursor_width, cursor_height,
format,
error);
}
else
{
return create_cursor_drm_buffer_dumb (gpu_kms, device_file,
pixels,
width, height, stride,
cursor_width, cursor_height,
format,
error);
}
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
}
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
static void
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
load_cursor_sprite_gbm_buffer_for_gpu (MetaCursorRendererNative *native,
MetaGpuKms *gpu_kms,
MetaCursorSprite *cursor_sprite,
uint8_t *pixels,
uint width,
uint height,
int rowstride,
uint32_t gbm_format)
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
{
drm-buffer: Create from MetaDeviceFile instead of MetaKmsDevice The DRM buffers aren't really tied to mode setting, so they shouldn't need to have an associated mode setting device. Now that we have a device file level object that can fill this role, port over MetaDrmBuffer and friends away from MetaKmsDevice to MetaDeviceFile. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1828>
2021-04-12 14:13:29 +00:00
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (native);
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
MetaBackendNative *backend_native = META_BACKEND_NATIVE (priv->backend);
MetaDevicePool *device_pool =
meta_backend_native_get_device_pool (backend_native);
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
uint64_t cursor_width, cursor_height;
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
MetaDrmBuffer *buffer;
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
MetaCursorRendererNativeGpuData *cursor_renderer_gpu_data;
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
g_autoptr (MetaDeviceFile) device_file = NULL;
g_autoptr (GError) error = NULL;
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_renderer_gpu_data =
meta_cursor_renderer_native_gpu_data_from_gpu (gpu_kms);
if (!cursor_renderer_gpu_data)
return;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_width = (uint64_t) cursor_renderer_gpu_data->cursor_width;
cursor_height = (uint64_t) cursor_renderer_gpu_data->cursor_height;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
if (width > cursor_width || height > cursor_height)
{
Make meta_* logging utilities not require line break Unlike g_* logging utilities, the meta_* counterparts behave like odd printf() functions. Lets change that so they fit better into how logging is done everywhere else. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1466
2020-10-02 15:47:22 +00:00
meta_warning ("Invalid theme cursor size (must be at most %ux%u)",
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
(unsigned int)cursor_width, (unsigned int)cursor_height);
return;
}
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
device_file = meta_device_pool_open (device_pool,
meta_gpu_kms_get_file_path (gpu_kms),
META_DEVICE_FILE_FLAG_TAKE_CONTROL,
&error);
if (!device_file)
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
{
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
g_warning ("Failed to open '%s' for updating the cursor: %s",
meta_gpu_kms_get_file_path (gpu_kms),
error->message);
cursor-renderer-native: Don't retry forever after GBM cursor functions fail This avoids flooding the log with every cursor change: ``` (gnome-shell:19923): libmutter-WARNING **: 10:15:23.404: Realizing HW cursor failed: Failed to allocate gbm_bo: Invalid argument (gnome-shell:19923): libmutter-WARNING **: 10:15:23.450: Realizing HW cursor failed: Failed to allocate gbm_bo: Invalid argument (gnome-shell:19923): libmutter-WARNING **: 10:15:23.451: Realizing HW cursor failed: Failed to allocate gbm_bo: Invalid argument ``` Related: https://gitlab.gnome.org/GNOME/mutter/-/issues/2354 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2520>
2022-07-20 10:10:21 +00:00
disable_hw_cursor_for_gpu (gpu_kms, error);
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
return;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
}
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
buffer = create_cursor_drm_buffer (gpu_kms, device_file,
pixels,
width, height, rowstride,
cursor_width,
cursor_height,
gbm_format,
&error);
if (!buffer)
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
{
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
g_warning ("Realizing HW cursor failed: %s", error->message);
cursor-renderer-native: Don't retry forever after GBM cursor functions fail This avoids flooding the log with every cursor change: ``` (gnome-shell:19923): libmutter-WARNING **: 10:15:23.404: Realizing HW cursor failed: Failed to allocate gbm_bo: Invalid argument (gnome-shell:19923): libmutter-WARNING **: 10:15:23.450: Realizing HW cursor failed: Failed to allocate gbm_bo: Invalid argument (gnome-shell:19923): libmutter-WARNING **: 10:15:23.451: Realizing HW cursor failed: Failed to allocate gbm_bo: Invalid argument ``` Related: https://gitlab.gnome.org/GNOME/mutter/-/issues/2354 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2520>
2022-07-20 10:10:21 +00:00
disable_hw_cursor_for_gpu (gpu_kms, error);
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
return;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
}
cursor-renderer/native: Move buffer creation to helper Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:05:32 +00:00
set_pending_cursor_sprite_buffer (cursor_sprite, gpu_kms, buffer);
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
}
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
static gboolean
is_cursor_hw_state_valid (MetaCursorSprite *cursor_sprite,
MetaGpuKms *gpu_kms)
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
{
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
MetaCursorNativePrivate *cursor_priv;
MetaCursorNativeGpuState *cursor_gpu_state;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_priv = get_cursor_priv (cursor_sprite);
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
if (!cursor_priv)
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
return FALSE;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_gpu_state = get_cursor_gpu_state (cursor_priv, gpu_kms);
if (!cursor_gpu_state)
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
return FALSE;
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
switch (cursor_gpu_state->pending_buffer_state)
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
{
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
case META_CURSOR_BUFFER_STATE_SET:
case META_CURSOR_BUFFER_STATE_NONE:
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
return TRUE;
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
case META_CURSOR_BUFFER_STATE_INVALIDATED:
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
return FALSE;
}
g_assert_not_reached ();
Fix builds with G_DISABLE_ASSERT Commit 25f416c13db added additional compilation warnings, including -Werror=return-type. There are several places where this results in build failures if `g_assert_not_reached()` is disabled at compile time and the compiler misses a return value. https://gitlab.gnome.org/GNOME/mutter/issues/447
2019-01-24 23:47:44 +00:00
return FALSE;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
}
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
static gboolean
is_cursor_scale_and_transform_valid (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite)
{
MetaMonitorTransform transform;
float scale;
if (!get_common_crtc_sprite_scale_for_logical_monitors (renderer,
cursor_sprite,
&scale))
return FALSE;
if (!get_common_crtc_sprite_transform_for_logical_monitors (renderer,
cursor_sprite,
&transform))
return FALSE;
return (scale == get_current_relative_scale (cursor_sprite) &&
transform == get_current_relative_transform (cursor_sprite));
}
static cairo_surface_t *
scale_and_transform_cursor_sprite_cpu (uint8_t *pixels,
int width,
int height,
int rowstride,
float scale,
MetaMonitorTransform transform)
{
cairo_t *cr;
cairo_surface_t *source_surface;
cairo_surface_t *target_surface;
int image_width;
int image_height;
image_width = ceilf (width * scale);
image_height = ceilf (height * scale);
target_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
image_width,
image_height);
cr = cairo_create (target_surface);
if (transform != META_MONITOR_TRANSFORM_NORMAL)
{
cairo_translate (cr, 0.5 * image_width, 0.5 * image_height);
switch (transform)
{
case META_MONITOR_TRANSFORM_90:
cairo_rotate (cr, M_PI * 1.5);
break;
case META_MONITOR_TRANSFORM_180:
cairo_rotate (cr, M_PI);
break;
case META_MONITOR_TRANSFORM_270:
cairo_rotate (cr, M_PI * 0.5);
break;
case META_MONITOR_TRANSFORM_FLIPPED:
cursor-renderer/native: Various fixes for rotated cursors - Drop bogus `meta_monitor_transform_invert()`. It papered over wrong `meta_rectangle_transform()` behaviour for non-flipped output transforms. - Update `scale_and_transform_cursor_sprite_cpu` to match the GL pipeline matrix in `MetaShapedTexture`, fixing several of the flipped cases. Note: the rotation applied is the one a client would need to apply to the buffer for a given monitor transform. - While on it, drop a redundant `return`. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2459>
2022-06-14 16:47:10 +00:00
cairo_scale (cr, -1, 1);
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
break;
case META_MONITOR_TRANSFORM_FLIPPED_90:
cairo_scale (cr, -1, 1);
cursor-renderer/native: Various fixes for rotated cursors - Drop bogus `meta_monitor_transform_invert()`. It papered over wrong `meta_rectangle_transform()` behaviour for non-flipped output transforms. - Update `scale_and_transform_cursor_sprite_cpu` to match the GL pipeline matrix in `MetaShapedTexture`, fixing several of the flipped cases. Note: the rotation applied is the one a client would need to apply to the buffer for a given monitor transform. - While on it, drop a redundant `return`. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2459>
2022-06-14 16:47:10 +00:00
cairo_rotate (cr, M_PI * 0.5);
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
break;
case META_MONITOR_TRANSFORM_FLIPPED_180:
cursor-renderer/native: Various fixes for rotated cursors - Drop bogus `meta_monitor_transform_invert()`. It papered over wrong `meta_rectangle_transform()` behaviour for non-flipped output transforms. - Update `scale_and_transform_cursor_sprite_cpu` to match the GL pipeline matrix in `MetaShapedTexture`, fixing several of the flipped cases. Note: the rotation applied is the one a client would need to apply to the buffer for a given monitor transform. - While on it, drop a redundant `return`. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2459>
2022-06-14 16:47:10 +00:00
cairo_scale (cr, -1, 1);
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
cairo_rotate (cr, M_PI);
break;
case META_MONITOR_TRANSFORM_FLIPPED_270:
cairo_scale (cr, -1, 1);
cursor-renderer/native: Various fixes for rotated cursors - Drop bogus `meta_monitor_transform_invert()`. It papered over wrong `meta_rectangle_transform()` behaviour for non-flipped output transforms. - Update `scale_and_transform_cursor_sprite_cpu` to match the GL pipeline matrix in `MetaShapedTexture`, fixing several of the flipped cases. Note: the rotation applied is the one a client would need to apply to the buffer for a given monitor transform. - While on it, drop a redundant `return`. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2459>
2022-06-14 16:47:10 +00:00
cairo_rotate (cr, M_PI * 1.5);
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
break;
case META_MONITOR_TRANSFORM_NORMAL:
g_assert_not_reached ();
}
cairo_translate (cr, -0.5 * image_width, -0.5 * image_height);
}
cairo_scale (cr, scale, scale);
source_surface = cairo_image_surface_create_for_data (pixels,
CAIRO_FORMAT_ARGB32,
width,
height,
rowstride);
cairo_set_source_surface (cr, source_surface, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
cairo_surface_destroy (source_surface);
return target_surface;
}
static void
load_scaled_and_transformed_cursor_sprite (MetaCursorRendererNative *native,
MetaGpuKms *gpu_kms,
MetaCursorSprite *cursor_sprite,
float relative_scale,
MetaMonitorTransform relative_transform,
uint8_t *data,
int width,
int height,
int rowstride,
uint32_t gbm_format)
{
if (!G_APPROX_VALUE (relative_scale, 1.f, FLT_EPSILON) ||
relative_transform != META_MONITOR_TRANSFORM_NORMAL)
{
cairo_surface_t *surface;
surface = scale_and_transform_cursor_sprite_cpu (data,
width,
height,
rowstride,
relative_scale,
relative_transform);
load_cursor_sprite_gbm_buffer_for_gpu (native,
gpu_kms,
cursor_sprite,
cairo_image_surface_get_data (surface),
cairo_image_surface_get_width (surface),
cairo_image_surface_get_width (surface),
cairo_image_surface_get_stride (surface),
gbm_format);
cairo_surface_destroy (surface);
}
else
{
load_cursor_sprite_gbm_buffer_for_gpu (native,
gpu_kms,
cursor_sprite,
data,
width,
height,
rowstride,
gbm_format);
}
}
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
#ifdef HAVE_WAYLAND
static void
cursor-renderer/native: Fetch instead of pass wl_buffer when realizing This is the next step in centralizing the cursor sprite hw sprite realization paths. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 10:27:02 +00:00
realize_cursor_sprite_from_wl_buffer_for_gpu (MetaCursorRenderer *renderer,
MetaGpuKms *gpu_kms,
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
MetaCursorSpriteWayland *sprite_wayland)
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
{
MetaCursorRendererNative *native = META_CURSOR_RENDERER_NATIVE (renderer);
drm-buffer: Create from MetaDeviceFile instead of MetaKmsDevice The DRM buffers aren't really tied to mode setting, so they shouldn't need to have an associated mode setting device. Now that we have a device file level object that can fill this role, port over MetaDrmBuffer and friends away from MetaKmsDevice to MetaDeviceFile. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1828>
2021-04-12 14:13:29 +00:00
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (native);
cursor-renderer/native: Fetch instead of pass wl_buffer when realizing This is the next step in centralizing the cursor sprite hw sprite realization paths. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 10:27:02 +00:00
MetaCursorSprite *cursor_sprite = META_CURSOR_SPRITE (sprite_wayland);
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
MetaCursorRendererNativeGpuData *cursor_renderer_gpu_data;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
uint64_t cursor_width, cursor_height;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
CoglTexture *texture;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
uint width, height;
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
MetaWaylandBuffer *buffer;
struct wl_resource *buffer_resource;
struct wl_shm_buffer *shm_buffer;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_renderer_gpu_data =
meta_cursor_renderer_native_gpu_data_from_gpu (gpu_kms);
if (!cursor_renderer_gpu_data || cursor_renderer_gpu_data->hw_cursor_broken)
MetaCursorRendererNative: Fall back to texture when there is no gbm For when there is no gbm available, for example when using EGLDevice/EGLStream's, just fall back to the OpenGL texture based cursor rendering path. https://bugzilla.gnome.org/show_bug.cgi?id=773629
2016-09-27 05:39:45 +00:00
return;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
if (is_cursor_hw_state_valid (cursor_sprite, gpu_kms) &&
is_cursor_scale_and_transform_valid (renderer, cursor_sprite))
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
return;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
buffer = meta_cursor_sprite_wayland_get_buffer (sprite_wayland);
if (!buffer)
return;
buffer_resource = meta_wayland_buffer_get_resource (buffer);
if (!buffer_resource)
return;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
ensure_cursor_priv (cursor_sprite);
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
shm_buffer = wl_shm_buffer_get (buffer_resource);
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
if (shm_buffer)
{
int rowstride = wl_shm_buffer_get_stride (shm_buffer);
uint8_t *buffer_data;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
float relative_scale;
MetaMonitorTransform relative_transform;
uint32_t gbm_format;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
cursor-renderer/native: Skip hw cursor upload if we can't use it If the CRTCs the cursor is visible on do not share a common scale and transform, we can't use the cursor hardware plane as we only have one. We therefore fall back to software / gl cursor. The check for that currently happens after we tried to upload the cursor image to the hardware plane though. This is made worse by the fact that in the scaling step, where we scale the cursor image to the desired size, until now we expected a valid common scale - otherwise scaling the image by an uninitialized float. Make sure we bail out early during the scale/upload step if we don't have common scales and transforms - to avoid that bug and save some unnecessary work. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1125
2020-03-14 14:52:38 +00:00
if (!get_common_crtc_sprite_scale_for_logical_monitors (renderer,
cursor_sprite,
&relative_scale))
{
unset_can_preprocess (cursor_sprite);
return;
}
if (!get_common_crtc_sprite_transform_for_logical_monitors (renderer,
cursor_sprite,
&relative_transform))
{
unset_can_preprocess (cursor_sprite);
return;
}
set_can_preprocess (cursor_sprite,
relative_scale,
relative_transform);
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
wl_shm_buffer_begin_access (shm_buffer);
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
buffer_data = wl_shm_buffer_get_data (shm_buffer);
width = wl_shm_buffer_get_width (shm_buffer);
cursor-renderer-native: Fix hw cursor for non-square sprites wl_shm_buffer_get_width() was used where wl_shm_buffer_get_height() should have used, resulting in only square cursors working. Make rectangular cursors work again. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1099
2020-02-28 21:21:13 +00:00
height = wl_shm_buffer_get_height (shm_buffer);
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
switch (wl_shm_buffer_get_format (shm_buffer))
{
case WL_SHM_FORMAT_ARGB8888:
gbm_format = GBM_FORMAT_ARGB8888;
break;
case WL_SHM_FORMAT_XRGB8888:
gbm_format = GBM_FORMAT_XRGB8888;
break;
default:
g_warn_if_reached ();
gbm_format = GBM_FORMAT_ARGB8888;
}
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
load_scaled_and_transformed_cursor_sprite (native,
gpu_kms,
cursor_sprite,
relative_scale,
relative_transform,
buffer_data,
width,
height,
rowstride,
gbm_format);
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
wl_shm_buffer_end_access (shm_buffer);
}
else
{
drm-buffer: Create from MetaDeviceFile instead of MetaKmsDevice The DRM buffers aren't really tied to mode setting, so they shouldn't need to have an associated mode setting device. Now that we have a device file level object that can fill this role, port over MetaDrmBuffer and friends away from MetaKmsDevice to MetaDeviceFile. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1828>
2021-04-12 14:13:29 +00:00
MetaBackendNative *backend_native = META_BACKEND_NATIVE (priv->backend);
MetaDevicePool *device_pool =
meta_backend_native_get_device_pool (backend_native);
g_autoptr (MetaDeviceFile) device_file = NULL;
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
struct gbm_device *gbm_device;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
struct gbm_bo *bo;
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
g_autoptr (GError) error = NULL;
drm-buffer: Replace 'use-modifier' boolean with flags This lets us add more customization to the buffer instance without adding more boolean arguments. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1854>
2021-05-05 08:15:18 +00:00
MetaDrmBufferFlags flags;
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
MetaDrmBufferGbm *buffer_gbm;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
drm-buffer: Create from MetaDeviceFile instead of MetaKmsDevice The DRM buffers aren't really tied to mode setting, so they shouldn't need to have an associated mode setting device. Now that we have a device file level object that can fill this role, port over MetaDrmBuffer and friends away from MetaKmsDevice to MetaDeviceFile. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1828>
2021-04-12 14:13:29 +00:00
device_file = meta_device_pool_open (device_pool,
meta_gpu_kms_get_file_path (gpu_kms),
META_DEVICE_FILE_FLAG_TAKE_CONTROL,
&error);
if (!device_file)
{
g_warning ("Failed to open '%s' for updating the cursor: %s",
meta_gpu_kms_get_file_path (gpu_kms),
error->message);
return;
}
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
/* HW cursors have a predefined size (at least 64x64), which usually is
* bigger than cursor theme size, so themed cursors must be padded with
* transparent pixels to fill the overlay. This is trivial if we have CPU
* access to the data, but it's not possible if the buffer is in GPU
* memory (and possibly tiled too), so if we don't get the right size, we
* fallback to GL. */
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_width = (uint64_t) cursor_renderer_gpu_data->cursor_width;
cursor_height = (uint64_t) cursor_renderer_gpu_data->cursor_height;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
texture = meta_cursor_sprite_get_cogl_texture (cursor_sprite);
width = cogl_texture_get_width (texture);
height = cogl_texture_get_height (texture);
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
if (width != cursor_width || height != cursor_height)
{
Make meta_* logging utilities not require line break Unlike g_* logging utilities, the meta_* counterparts behave like odd printf() functions. Lets change that so they fit better into how logging is done everywhere else. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1466
2020-10-02 15:47:22 +00:00
meta_warning ("Invalid cursor size (must be 64x64), falling back to software (GL) cursors");
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
return;
}
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
gbm_device = meta_gbm_device_from_gpu (gpu_kms);
cursor-renderer/native: Support allocating dumb buffers This makes it possible to allocate HW cursor without a gbm_device, e.g. when using EGLStream/EGLDevice. Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/1980 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2275>
2022-02-08 14:38:37 +00:00
if (!gbm_device)
return;
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
bo = gbm_bo_import (gbm_device,
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
GBM_BO_IMPORT_WL_BUFFER,
buffer,
GBM_BO_USE_CURSOR);
if (!bo)
{
Make meta_* logging utilities not require line break Unlike g_* logging utilities, the meta_* counterparts behave like odd printf() functions. Lets change that so they fit better into how logging is done everywhere else. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1466
2020-10-02 15:47:22 +00:00
meta_warning ("Importing HW cursor from wl_buffer failed");
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
return;
}
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
unset_can_preprocess (cursor_sprite);
drm-buffer: Replace 'use-modifier' boolean with flags This lets us add more customization to the buffer instance without adding more boolean arguments. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1854>
2021-05-05 08:15:18 +00:00
flags = META_DRM_BUFFER_FLAG_DISABLE_MODIFIERS;
buffer_gbm = meta_drm_buffer_gbm_new_take (device_file, bo, flags,
&error);
kms/update: Assign planes with MetaDrmBuffer instead of fb ids This will eventually allow better lifetime control. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-09-21 17:32:46 +00:00
if (!buffer_gbm)
{
meta_warning ("Failed to create DRM buffer wrapper: %s",
error->message);
gbm_bo_destroy (bo);
return;
}
set_pending_cursor_sprite_buffer (cursor_sprite, gpu_kms,
META_DRM_BUFFER (buffer_gbm));
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
}
}
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
#endif
static void
cursor-renderer/native: Shorten some helper function names Purely a cosmetic change, making a couple of unnecessarily long function name shorter. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 10:23:49 +00:00
realize_cursor_sprite_from_xcursor_for_gpu (MetaCursorRenderer *renderer,
MetaGpuKms *gpu_kms,
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
MetaCursorSpriteXcursor *sprite_xcursor)
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
{
MetaCursorRendererNative *native = META_CURSOR_RENDERER_NATIVE (renderer);
MetaCursorRendererNativeGpuData *cursor_renderer_gpu_data;
cursor-renderer: Fetch instead of pass Xcursor image when realizing The end goal here is to being able to realize at any point in time through a single API, so start by moving state into the cursor sprite implementation. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-30 10:55:08 +00:00
MetaCursorSprite *cursor_sprite = META_CURSOR_SPRITE (sprite_xcursor);
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
XcursorImage *xc_image;
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
float relative_scale;
MetaMonitorTransform relative_transform;
ensure_cursor_priv (cursor_sprite);
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
cursor_renderer_gpu_data =
meta_cursor_renderer_native_gpu_data_from_gpu (gpu_kms);
if (!cursor_renderer_gpu_data || cursor_renderer_gpu_data->hw_cursor_broken)
MetaCursorRendererNative: Fall back to texture when there is no gbm For when there is no gbm available, for example when using EGLDevice/EGLStream's, just fall back to the OpenGL texture based cursor rendering path. https://bugzilla.gnome.org/show_bug.cgi?id=773629
2016-09-27 05:39:45 +00:00
return;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
if (is_cursor_hw_state_valid (cursor_sprite, gpu_kms) &&
is_cursor_scale_and_transform_valid (renderer, cursor_sprite))
cursor-renderer/native: Let the backend realize cursor sprite itself It knows better when it's needed. For now, just do it just as before, before drawing. Eventually, we can conditionalize where to realize depending on the cursor sprite position. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 14:56:53 +00:00
return;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor-renderer/native: Skip hw cursor upload if we can't use it If the CRTCs the cursor is visible on do not share a common scale and transform, we can't use the cursor hardware plane as we only have one. We therefore fall back to software / gl cursor. The check for that currently happens after we tried to upload the cursor image to the hardware plane though. This is made worse by the fact that in the scaling step, where we scale the cursor image to the desired size, until now we expected a valid common scale - otherwise scaling the image by an uninitialized float. Make sure we bail out early during the scale/upload step if we don't have common scales and transforms - to avoid that bug and save some unnecessary work. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1125
2020-03-14 14:52:38 +00:00
if (!get_common_crtc_sprite_scale_for_logical_monitors (renderer,
cursor_sprite,
&relative_scale))
{
unset_can_preprocess (cursor_sprite);
return;
}
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
cursor-renderer/native: Skip hw cursor upload if we can't use it If the CRTCs the cursor is visible on do not share a common scale and transform, we can't use the cursor hardware plane as we only have one. We therefore fall back to software / gl cursor. The check for that currently happens after we tried to upload the cursor image to the hardware plane though. This is made worse by the fact that in the scaling step, where we scale the cursor image to the desired size, until now we expected a valid common scale - otherwise scaling the image by an uninitialized float. Make sure we bail out early during the scale/upload step if we don't have common scales and transforms - to avoid that bug and save some unnecessary work. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1125
2020-03-14 14:52:38 +00:00
if (!get_common_crtc_sprite_transform_for_logical_monitors (renderer,
cursor_sprite,
&relative_transform))
{
unset_can_preprocess (cursor_sprite);
return;
}
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
set_can_preprocess (cursor_sprite,
relative_scale,
relative_transform);
cursor-renderer/native: Skip hw cursor upload if we can't use it If the CRTCs the cursor is visible on do not share a common scale and transform, we can't use the cursor hardware plane as we only have one. We therefore fall back to software / gl cursor. The check for that currently happens after we tried to upload the cursor image to the hardware plane though. This is made worse by the fact that in the scaling step, where we scale the cursor image to the desired size, until now we expected a valid common scale - otherwise scaling the image by an uninitialized float. Make sure we bail out early during the scale/upload step if we don't have common scales and transforms - to avoid that bug and save some unnecessary work. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1125
2020-03-14 14:52:38 +00:00
xc_image = meta_cursor_sprite_xcursor_get_current_image (sprite_xcursor);
cursor-renderer/native: Implement scaled/transformed hardware cursors If the cursor sprite does not match the scale factor or transformation of the monintor, we currently fall back to a software cursor, causing redraws of the shell. This commit implements scaling and transforming of the cursor sprite, so we can use it with hardware planes, too. This commit does the following steps: 1. Make sure we reupload the cursor image if the cursor is over a logical monitor not matching the scale or transform from the previous update. 2. Before upload to the hardware plane, scale and transform the cursor image if possible and necessary. 3. Make sure we always use the hardware cursor if possible (only fall back to software/OGL cursor if it is visible on multiple logical monitors with differet scales/transforms). 4. Transform or scale the cursor coordinates if necessary. https://gitlab.gnome.org/GNOME/mutter/merge_requests/526
2019-05-13 08:21:40 +00:00
load_scaled_and_transformed_cursor_sprite (native,
gpu_kms,
cursor_sprite,
relative_scale,
relative_transform,
(uint8_t *) xc_image->pixels,
xc_image->width,
xc_image->height,
xc_image->width * 4,
GBM_FORMAT_ARGB8888);
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
}
static void
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
realize_cursor_sprite_for_gpu (MetaCursorRenderer *renderer,
MetaGpuKms *gpu_kms,
MetaCursorSprite *cursor_sprite)
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
{
cursor-renderer: Centralize hw cursor realization paths Use a common entry point into the cursor renderer implementations HW cursor realization paths for all cursor sprite types. This is in preparation for realizing at more strategic times. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 12:34:02 +00:00
if (META_IS_CURSOR_SPRITE_XCURSOR (cursor_sprite))
{
MetaCursorSpriteXcursor *sprite_xcursor =
META_CURSOR_SPRITE_XCURSOR (cursor_sprite);
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
realize_cursor_sprite_from_xcursor_for_gpu (renderer,
gpu_kms,
sprite_xcursor);
cursor-renderer: Centralize hw cursor realization paths Use a common entry point into the cursor renderer implementations HW cursor realization paths for all cursor sprite types. This is in preparation for realizing at more strategic times. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 12:34:02 +00:00
}
#ifdef HAVE_WAYLAND
else if (META_IS_CURSOR_SPRITE_WAYLAND (cursor_sprite))
{
MetaCursorSpriteWayland *sprite_wayland =
META_CURSOR_SPRITE_WAYLAND (cursor_sprite);
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
realize_cursor_sprite_from_wl_buffer_for_gpu (renderer,
gpu_kms,
sprite_wayland);
cursor-renderer: Centralize hw cursor realization paths Use a common entry point into the cursor renderer implementations HW cursor realization paths for all cursor sprite types. This is in preparation for realizing at more strategic times. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 12:34:02 +00:00
}
#endif
}
cursor-render/native: Realize hw cursor lazilly Where to realize a hardware cursor depends on where on the screen it will be displayed. For example it only needs buffers for the cursor plane on a certain GPU if it overlaps with a monitor that is connected said GPU. Previously, we were too eager with uploading the cursor plane buffers, which in effect resulted in the secondary GPU always being woken up when changing the cursor, even though the cursor plane would actually never be set unless the pointer cursor was moved to a monitor connected to the secondary GPU. These wake-ups caused noticable stuttering; thus by uploading the buffers more lazilly, the stuttering is avoided. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 18:32:43 +00:00
static void
realize_cursor_sprite (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite,
GList *gpus)
{
GList *l;
for (l = gpus; l; l = l->next)
{
MetaGpuKms *gpu_kms = l->data;
realize_cursor_sprite_for_gpu (renderer, gpu_kms, cursor_sprite);
}
}
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
static void
meta_cursor_renderer_native_class_init (MetaCursorRendererNativeClass *klass)
{
MetaCursorRendererClass *renderer_class = META_CURSOR_RENDERER_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = meta_cursor_renderer_native_finalize;
renderer_class->update_cursor = meta_cursor_renderer_native_update_cursor;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-11 03:16:58 +00:00
quark_cursor_sprite = g_quark_from_static_string ("-meta-cursor-native");
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
quark_cursor_renderer_native_gpu_data =
g_quark_from_static_string ("-meta-cursor-renderer-native-gpu-data");
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
}
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
static void
force_update_hw_cursor (MetaCursorRendererNative *native)
{
MetaCursorRenderer *renderer = META_CURSOR_RENDERER (native);
MetaCursorRendererNative: Always force set hw cursor the first time The initial state of the hardware cursor is not known, so always force update it the first time we update the cursor. Do this by changing the 'force' flag of update_hw_cursor() to an 'invalidated' hw cursor state. https://bugzilla.gnome.org/show_bug.cgi?id=771056
2017-01-10 08:01:46 +00:00
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (native);
cursor-renderer/native: Update HW state during frames Before each frame is maybe redrawn, push any new cursor KMS state to the pending update. It'll then either be posted during the next page flip, or when the same frame finishes, in case nothing was redrawn. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1488>
2020-10-09 23:02:28 +00:00
GList *l;
for (l = meta_backend_get_gpus (priv->backend); l; l = l->next)
{
MetaGpu *gpu = l->data;
GList *l_crtc;
for (l_crtc = meta_gpu_get_crtcs (gpu); l_crtc; l_crtc = l_crtc->next)
{
MetaCrtcKms *crtc_kms = META_CRTC_KMS (l_crtc->data);
CrtcCursorData *crtc_cursor_data;
crtc_cursor_data = ensure_crtc_cursor_data (crtc_kms);
crtc_cursor_data->hw_state_invalidated = TRUE;
}
}
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
cursor-renderer/native: Update hw state via generic update path When force-updating the HW state we might end up with a situation where the HW cursor is no longer usable. If this would happen, we'd before this commit not trigger the fallback paths using a GL texture. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-09 16:50:37 +00:00
meta_cursor_renderer_force_update (renderer);
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
}
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
static void
on_monitors_changed (MetaMonitorManager *monitors,
MetaCursorRendererNative *native)
{
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 15:16:39 +00:00
force_update_hw_cursor (native);
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
}
cursor-renderer/native: Refactor init to per-gpu Extract the code to initialize a single GPU cursor support into its own function. The new function will be used by GPU hotplug in the future. This is a pure refactoring without any behavioral changes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1097
2020-02-24 13:13:42 +00:00
static void
init_hw_cursor_support_for_gpu (MetaGpuKms *gpu_kms)
{
MetaKmsDevice *kms_device = meta_gpu_kms_get_kms_device (gpu_kms);
MetaCursorRendererNativeGpuData *cursor_renderer_gpu_data;
uint64_t width, height;
cursor_renderer_gpu_data =
meta_create_cursor_renderer_native_gpu_data (gpu_kms);
if (!meta_kms_device_get_cursor_size (kms_device, &width, &height))
{
width = 64;
height = 64;
}
cursor_renderer_gpu_data->cursor_width = width;
cursor_renderer_gpu_data->cursor_height = height;
}
cursor-renderer/native: Handle GPU hotplug Listen for GPU hotplug events to initialize their cursor support. This fixes one reason for why DisplayLink devices may not be using a hardware cursor. Particularly, when a DisplayLink device is hotplugged for the first time such that EVDI creates a new DRM device node after gnome-shell has already started, we used to forget to initialize the cursor support. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1097
2020-02-24 13:36:24 +00:00
static void
on_gpu_added_for_cursor (MetaBackend *backend,
MetaGpuKms *gpu_kms)
{
init_hw_cursor_support_for_gpu (gpu_kms);
}
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
static void
backends: Split out CRTC/output management to MetaGpu In order to eventually support multilpe GPUs with their own connectors, split out related meta data management (i.e. outputs, CRTCs and CRTC modes) into a new MetaGpu GObject. The Xrandr backend always assumes there is always only a single "GPU" as the GPU is abstracted by the X server; only the native backend (aside from the test backend) will eventually see more than one GPU. The Xrandr backend still moves some management to MetaGpuXrandr, in order to behave more similarly to the KMS counterparts. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-10 10:19:32 +00:00
init_hw_cursor_support (MetaCursorRendererNative *cursor_renderer_native)
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
{
native/cursor-renderer: Cleanup construction Pass the backend to a new factory function, and keep a pointer to the monitor manager, which is accessed elsewhere in the same file instead of fetching the singleton. The HW cursor initialization part is also made more obvious, without depending on seemingly irrelevant clutter features. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-07 08:12:07 +00:00
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (cursor_renderer_native);
backends: Split out CRTC/output management to MetaGpu In order to eventually support multilpe GPUs with their own connectors, split out related meta data management (i.e. outputs, CRTCs and CRTC modes) into a new MetaGpu GObject. The Xrandr backend always assumes there is always only a single "GPU" as the GPU is abstracted by the X server; only the native backend (aside from the test backend) will eventually see more than one GPU. The Xrandr backend still moves some management to MetaGpuXrandr, in order to behave more similarly to the KMS counterparts. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-10 10:19:32 +00:00
GList *gpus;
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
GList *l;
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
backend: Move GPU ownership from the monitor manager to the backend Lets work towards making MetaMonitorManager about managing monitors, and not about managing GPUs. This changes other units to keep a pointer to the backend instead of a monitor manager, in case their ownership changed, or their main usage of the monitor manager was to look up GPUs. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-11 14:35:42 +00:00
gpus = meta_backend_get_gpus (priv->backend);
cursor-renderer-native: Support HW cursors on multiple GPUs On hybrid GPU systems, hardware cursors needs to be realized on all the GPUs, as scanout cursor planes cannot be shared. Do this by moving gbm buffer and drm buffer ID management to a per GPU struct, realizing a cursor on each GPU when previously only realized on the primary GPU. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-25 02:31:25 +00:00
for (l = gpus; l; l = l->next)
{
MetaGpuKms *gpu_kms = l->data;
cursor-renderer-native: Get cursor size from MetaKmsDevice It now provides this information, so don't get it ourself. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-11-09 10:47:34 +00:00
cursor-renderer/native: Refactor init to per-gpu Extract the code to initialize a single GPU cursor support into its own function. The new function will be used by GPU hotplug in the future. This is a pure refactoring without any behavioral changes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1097
2020-02-24 13:13:42 +00:00
init_hw_cursor_support_for_gpu (gpu_kms);
native/cursor-renderer: Cleanup construction Pass the backend to a new factory function, and keep a pointer to the monitor manager, which is accessed elsewhere in the same file instead of fetching the singleton. The HW cursor initialization part is also made more obvious, without depending on seemingly irrelevant clutter features. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-07 08:12:07 +00:00
}
}
MetaCursorRendererNative *
backends: Add ::device property to MetaCursorRenderer A cursor renderer is made to invariably follow a pointer device, make it a construct-time property, and update all creators of cursor renderers to specify it. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1403>
2020-07-13 11:32:48 +00:00
meta_cursor_renderer_native_new (MetaBackend *backend,
ClutterInputDevice *device)
native/cursor-renderer: Cleanup construction Pass the backend to a new factory function, and keep a pointer to the monitor manager, which is accessed elsewhere in the same file instead of fetching the singleton. The HW cursor initialization part is also made more obvious, without depending on seemingly irrelevant clutter features. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-07 08:12:07 +00:00
{
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
MetaCursorRendererNative *cursor_renderer_native;
MetaCursorRendererNativePrivate *priv;
cursor-renderer: Pass backend to constructor Then use the backend passed instead of the global singleton. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1289
2020-05-27 07:29:04 +00:00
cursor_renderer_native = g_object_new (META_TYPE_CURSOR_RENDERER_NATIVE,
"backend", backend,
backends: Add ::device property to MetaCursorRenderer A cursor renderer is made to invariably follow a pointer device, make it a construct-time property, and update all creators of cursor renderers to specify it. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1403>
2020-07-13 11:32:48 +00:00
"device", device,
cursor-renderer: Pass backend to constructor Then use the backend passed instead of the global singleton. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1289
2020-05-27 07:29:04 +00:00
NULL);
native/cursor-renderer: Cleanup construction Pass the backend to a new factory function, and keep a pointer to the monitor manager, which is accessed elsewhere in the same file instead of fetching the singleton. The HW cursor initialization part is also made more obvious, without depending on seemingly irrelevant clutter features. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-07 08:12:07 +00:00
priv =
meta_cursor_renderer_native_get_instance_private (cursor_renderer_native);
backends: add 'monitors-updated-internal' signal to only update internal state Adding an internal signal and use it to update the internal state before emitting "monitors-changed" which will be repeated by the screen to the world. https://bugzilla.gnome.org/show_bug.cgi?id=788860
2017-10-13 00:14:40 +00:00
g_signal_connect_object (monitor_manager, "monitors-changed-internal",
native/cursor-renderer: Cleanup construction Pass the backend to a new factory function, and keep a pointer to the monitor manager, which is accessed elsewhere in the same file instead of fetching the singleton. The HW cursor initialization part is also made more obvious, without depending on seemingly irrelevant clutter features. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-07 08:12:07 +00:00
G_CALLBACK (on_monitors_changed),
cursor_renderer_native, 0);
cursor-renderer/native: Handle GPU hotplug Listen for GPU hotplug events to initialize their cursor support. This fixes one reason for why DisplayLink devices may not be using a hardware cursor. Particularly, when a DisplayLink device is hotplugged for the first time such that EVDI creates a new DRM device node after gnome-shell has already started, we used to forget to initialize the cursor support. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1097
2020-02-24 13:36:24 +00:00
g_signal_connect (backend, "gpu-added",
G_CALLBACK (on_gpu_added_for_cursor), NULL);
native/cursor-renderer: Cleanup construction Pass the backend to a new factory function, and keep a pointer to the monitor manager, which is accessed elsewhere in the same file instead of fetching the singleton. The HW cursor initialization part is also made more obvious, without depending on seemingly irrelevant clutter features. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-07 08:12:07 +00:00
backend: Move GPU ownership from the monitor manager to the backend Lets work towards making MetaMonitorManager about managing monitors, and not about managing GPUs. This changes other units to keep a pointer to the backend instead of a monitor manager, in case their ownership changed, or their main usage of the monitor manager was to look up GPUs. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-11 14:35:42 +00:00
priv->backend = backend;
native/cursor-renderer: Cleanup construction Pass the backend to a new factory function, and keep a pointer to the monitor manager, which is accessed elsewhere in the same file instead of fetching the singleton. The HW cursor initialization part is also made more obvious, without depending on seemingly irrelevant clutter features. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-07 08:12:07 +00:00
cursor-renderer/native: Add a means to disable HW cursors When dealing with a faulty hardware or bugs in the driver, it might be interesting to force the use of software cursors for debugging purposes. Add a debug environment variable MUTTER_DEBUG_DISABLE_HW_CURSORS to disable hardware cursors and force using software cursors. Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/2046 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2150>
2021-12-10 09:57:29 +00:00
if (g_strcmp0 (getenv ("MUTTER_DEBUG_DISABLE_HW_CURSORS"), "1"))
init_hw_cursor_support (cursor_renderer_native);
else
g_message ("Disabling hardware cursors because MUTTER_DEBUG_DISABLE_HW_CURSORS is set");
native/cursor-renderer: Cleanup construction Pass the backend to a new factory function, and keep a pointer to the monitor manager, which is accessed elsewhere in the same file instead of fetching the singleton. The HW cursor initialization part is also made more obvious, without depending on seemingly irrelevant clutter features. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-07 08:12:07 +00:00
return cursor_renderer_native;
}
static void
meta_cursor_renderer_native_init (MetaCursorRendererNative *native)
{
backends: Add a native cursor renderer
2014-04-22 19:15:11 +00:00
}
cursor-renderer/native: Clear GPU state before closing device This ensures we don't have any left over cursor GPU buffers (via gbm_bo's) after destroying the corresponding gbm_device (owned by MetaRenderDevice). Fixes crashes with backtraces such as 1) meta_drm_buffer_gbm_finalize at ../src/backends/native/meta-drm-buffer-gbm.c:450 4) invalidate_cursor_gpu_state at ../src/backends/native/meta-cursor-renderer-native.c:1167 9) update_cursor_sprite_texture at ../src/wayland/meta-wayland-cursor-surface.c:70 10) meta_wayland_surface_role_apply_state at ../src/wayland/meta-wayland-surface.c:1869 11) meta_wayland_surface_apply_state at ../src/wayland/meta-wayland-surface.c:832 12) meta_wayland_surface_commit at ../src/wayland/meta-wayland-surface.c:993 13) wl_surface_commit at ../src/wayland/meta-wayland-surface.c:1158 14) ffi_call_unix64 at ../src/x86/unix64.S:76 15) ffi_call at ../src/x86/ffi64.c:525 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2147>
2021-11-15 13:27:54 +00:00
void
meta_cursor_renderer_native_invalidate_gpu_state (MetaCursorRendererNative *native,
MetaCursorSprite *cursor_sprite,
MetaGpuKms *gpu_kms)
{
MetaCursorNativePrivate *cursor_priv;
cursor_priv = get_cursor_priv (cursor_sprite);
if (!cursor_priv)
return;
g_hash_table_remove (cursor_priv->gpu_states, gpu_kms);
}
Copy permalink