hyprwm/wlroots-hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/wlroots-hyprland.git synced 2024-11-02 11:55:59 +01:00
Code Issues Projects Releases Packages Wiki Activity
wlroots-hyprland/include/backend/drm/renderer.h

58 lines
1.5 KiB
C
Raw Normal View History

Split DRM rendering to its own file
2017-09-30 09:52:58 +02:00
#ifndef BACKEND_DRM_RENDERER_H
#define BACKEND_DRM_RENDERER_H
Reformat all #include directives
2018-02-12 21:29:23 +01:00
#include <stdbool.h>
#include <stdint.h>
backends: implement custom EGL and renderer initialization Compositors now have more control over how the backend creates its renderer. Currently all backends create an EGL/GLES2 renderer, so the necessary attributes for creating the context are passed to a user-provided callback function. It is responsible for initializing provided wlr_egl and to return a renderer. On fail, return 0. Fixes #987
2018-05-25 12:14:35 +02:00
#include <wlr/backend.h>
render: split render.h into wlr_renderer.h and wlr_texture.h
2018-03-19 23:16:29 +01:00
#include <wlr/render/wlr_renderer.h>
Multi-GPU DRM
2017-10-01 08:22:47 +02:00
Minor fixes
2017-10-01 11:44:24 +02:00
struct wlr_drm_backend;
Multi-GPU DRM
2017-10-01 08:22:47 +02:00
struct wlr_drm_plane;
backend/drm: introduce wlr_drm_fb This is a type which manages gbm_surfaces and imported dmabufs in the same place, and makes the lifetime management between the two shared. It should lead to easier to understand code, and fewer special cases. This also contains a fair bit of refactoring to start using this new type. Co-authored-by: Simon Ser <contact@emersion.fr>
2020-02-08 07:02:31 +01:00
struct wlr_buffer;
Multi-GPU DRM
2017-10-01 08:22:47 +02:00
Split DRM rendering to its own file
2017-09-30 09:52:58 +02:00
struct wlr_drm_renderer {
backend/drm: remove drm_fb_acquire Instead, import the buffer into GBM and KMS in drm_fb_import. Also move the multi-GPU copy there if necessary.
2020-12-15 12:21:40 +01:00
struct wlr_drm_backend *backend;
Multi-GPU DRM
2017-10-01 08:22:47 +02:00
struct wlr_renderer *wlr_rend;
render/gbm_allocator: make wlr_gbm_allocator_create return a wlr_allocator
2021-04-15 20:32:13 +02:00
struct wlr_allocator *allocator;
Split DRM rendering to its own file
2017-09-30 09:52:58 +02:00
};
struct wlr_drm_surface {
Add renderer pointer inside drm_surface
2017-10-01 04:55:25 +02:00
struct wlr_drm_renderer *renderer;
backend/drm: use wlr_swapchain
2020-06-01 19:49:51 +02:00
struct wlr_swapchain *swapchain;
backend/drm: introduce wlr_drm_fb This is a type which manages gbm_surfaces and imported dmabufs in the same place, and makes the lifetime management between the two shared. It should lead to easier to understand code, and fewer special cases. This also contains a fair bit of refactoring to start using this new type. Co-authored-by: Simon Ser <contact@emersion.fr>
2020-02-08 07:02:31 +01:00
};
struct wlr_drm_fb {
backend/drm: only keep track of local buffer Stop keeping track of buffers on the parent GPU when multi-GPU is used. This removes support for export_dmabuf on secondary GPUs, but renderer v6 will bring this back by managing the swapchains in wlr_output instead of the backends.
2020-12-22 18:23:28 +01:00
struct wlr_buffer *wlr_buf;
backend/drm: use addon for wlr_drm_fb
2021-08-17 09:34:49 +02:00
struct wlr_addon addon;
backend/drm: introduce wlr_drm_bo_handle_table Using GBM to import DRM dumb buffers tends to not work well. By using GBM we're calling some driver-specific functions in Mesa. These functions check whether Mesa can work with the buffer. Sometimes Mesa has requirements which differ from DRM dumb buffers and the GBM import will fail (e.g. on amdgpu). Instead, drop GBM and use drmPrimeFDToHandle directly. But there's a twist: BO handles are not ref'counted by the kernel and need to be ref'counted in user-space [1]. libdrm usually performs this bookkeeping and is used under-the-hood by Mesa. We can't re-use libdrm for this task without using driver-specific APIs. So let's just re-implement the ref'counting logic in wlroots. The wlroots implementation is inspired from amdgpu's in libdrm [2]. Closes: https://github.com/swaywm/wlroots/issues/2916 [1]: https://gitlab.freedesktop.org/mesa/drm/-/merge_requests/110 [2]: https://gitlab.freedesktop.org/mesa/drm/-/blob/1a4c0ec9aea13211997f982715fe5ffcf19dd067/amdgpu/handle_table.c
2021-08-23 17:41:08 +02:00
struct wlr_drm_backend *backend;
backend/drm: re-use FBs Instead of importing buffers to GBM and KMS at each frame, cache them and re-use them while the wlr_buffer is alive. This is the same as [1] and [2] but for the DRM backend. [1]: https://github.com/swaywm/wlroots/pull/2538 [2]: https://github.com/swaywm/wlroots/pull/2539
2020-12-22 18:42:59 +01:00
struct wl_list link; // wlr_drm_backend.fbs
backend/drm: make drm_fb_acquire return a FB ID
2020-12-15 09:53:15 +01:00
uint32_t id;
Split DRM rendering to its own file
2017-09-30 09:52:58 +02:00
};
Make sure we don't use others' prefixes
2018-04-26 00:24:58 +02:00
bool init_drm_renderer(struct wlr_drm_backend *drm,
Remove wlr_create_renderer_func_t This callback allowed compositors to customize the EGL config used by the renderer. However with renderer v6 EGL configs aren't used anymore. Instead, buffers are allocated via GBM and GL FBOs are rendered to. So customizing the EGL config is a no-op.
2020-12-19 11:34:28 +01:00
struct wlr_drm_renderer *renderer);
Make sure we don't use others' prefixes
2018-04-26 00:24:58 +02:00
void finish_drm_renderer(struct wlr_drm_renderer *renderer);
Split DRM rendering to its own file
2017-09-30 09:52:58 +02:00
output: take a wlr_buffer in set_cursor Instead of passing a wlr_texture to the backend, directly pass a wlr_buffer. Use get_cursor_size and get_cursor_formats to create a wlr_buffer that can be used as a cursor. We don't want to pass a wlr_texture because we want to remove as many rendering bits from the backend as possible.
2020-12-04 16:41:16 +01:00
bool init_drm_surface(struct wlr_drm_surface *surf,
backend/drm: remove wlr_drm_surface.{width,height} This information is stored in wlr_swapchain, no need to duplicate it.
2022-05-25 15:55:41 +02:00
struct wlr_drm_renderer *renderer, int width, int height,
output: take a wlr_buffer in set_cursor Instead of passing a wlr_texture to the backend, directly pass a wlr_buffer. Use get_cursor_size and get_cursor_formats to create a wlr_buffer that can be used as a cursor. We don't want to pass a wlr_texture because we want to remove as many rendering bits from the backend as possible.
2020-12-04 16:41:16 +01:00
const struct wlr_drm_format *drm_format);
Split DRM rendering to its own file
2017-09-30 09:52:58 +02:00
backend/drm: make wlr_drm_plane.{pending,queued,current}_fb pointers This will be useful once we start re-using wlr_drm_fb.
2020-12-22 17:07:29 +01:00
bool drm_fb_import(struct wlr_drm_fb **fb, struct wlr_drm_backend *drm,
backend/drm: don't blit in drm_fb_import Instead blit in drm_plane_lock_surface. This makes drm_fb_import simpler and better fits its name.
2021-01-24 18:33:56 +01:00
struct wlr_buffer *buf, const struct wlr_drm_format_set *formats);
backend/drm: re-use FBs Instead of importing buffers to GBM and KMS at each frame, cache them and re-use them while the wlr_buffer is alive. This is the same as [1] and [2] but for the DRM backend. [1]: https://github.com/swaywm/wlroots/pull/2538 [2]: https://github.com/swaywm/wlroots/pull/2539
2020-12-22 18:42:59 +01:00
void drm_fb_destroy(struct wlr_drm_fb *fb);
backend/drm: introduce wlr_drm_fb This is a type which manages gbm_surfaces and imported dmabufs in the same place, and makes the lifetime management between the two shared. It should lead to easier to understand code, and fewer special cases. This also contains a fair bit of refactoring to start using this new type. Co-authored-by: Simon Ser <contact@emersion.fr>
2020-02-08 07:02:31 +01:00
backend/drm: make wlr_drm_plane.{pending,queued,current}_fb pointers This will be useful once we start re-using wlr_drm_fb.
2020-12-22 17:07:29 +01:00
void drm_fb_clear(struct wlr_drm_fb **fb);
void drm_fb_move(struct wlr_drm_fb **new, struct wlr_drm_fb **old);
backend/drm: store pending FB in state Instead of having a pending_fb field on the struct wlr_drm_plane, move it to struct wlr_drm_connector_state. That way, there's no risk having a stale pending FB around: the state doesn't survive across tests and commits. The cursor is a special case because it's disconnected from the atomic state: the wlr_backend_impl.set_cursor hook sets the cursor for the next commit. Move the field to wlr_drm_connector.cursor_pending_fb.
2022-12-06 17:39:23 +01:00
struct wlr_drm_fb *drm_fb_lock(struct wlr_drm_fb *fb);
backend/drm: introduce wlr_drm_fb This is a type which manages gbm_surfaces and imported dmabufs in the same place, and makes the lifetime management between the two shared. It should lead to easier to understand code, and fewer special cases. This also contains a fair bit of refactoring to start using this new type. Co-authored-by: Simon Ser <contact@emersion.fr>
2020-02-08 07:02:31 +01:00
output: take a wlr_buffer in set_cursor Instead of passing a wlr_texture to the backend, directly pass a wlr_buffer. Use get_cursor_size and get_cursor_formats to create a wlr_buffer that can be used as a cursor. We don't want to pass a wlr_texture because we want to remove as many rendering bits from the backend as possible.
2020-12-04 16:41:16 +01:00
struct wlr_buffer *drm_surface_blit(struct wlr_drm_surface *surf,
struct wlr_buffer *buffer);
backend/drm: introduce wlr_drm_fb This is a type which manages gbm_surfaces and imported dmabufs in the same place, and makes the lifetime management between the two shared. It should lead to easier to understand code, and fewer special cases. This also contains a fair bit of refactoring to start using this new type. Co-authored-by: Simon Ser <contact@emersion.fr>
2020-02-08 07:02:31 +01:00
wlr_drm_format: Rework wlr_drm_format_intersect Now it takes a reference to a destination format
2023-05-05 01:24:44 +02:00
bool drm_plane_pick_render_format(struct wlr_drm_plane *plane,
struct wlr_drm_format *fmt, struct wlr_drm_renderer *renderer);
backend/drm: introduce wlr_drm_fb This is a type which manages gbm_surfaces and imported dmabufs in the same place, and makes the lifetime management between the two shared. It should lead to easier to understand code, and fewer special cases. This also contains a fair bit of refactoring to start using this new type. Co-authored-by: Simon Ser <contact@emersion.fr>
2020-02-08 07:02:31 +01:00
void drm_plane_finish_surface(struct wlr_drm_plane *plane);
Split DRM rendering to its own file
2017-09-30 09:52:58 +02:00
#endif
Reference in a new issue Copy permalink