fdo-mirrors/weston
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wayland/weston.git synced 2025-12-20 04:40:07 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
weston/libweston/backend-drm/state-propose.c
Loïc Molinari 9373e76655 shared: Rename NULL and not NULL pointer assertions 
Make the NULL assertions more explicit.

weston_assert_ptr_is_null() -> weston_assert_ptr_null()
weston_assert_ptr()         -> weston_assert_ptr_not_null()

Signed-off-by: Loïc Molinari <loic.molinari@collabora.com>
2025-02-26 23:50:45 +01:00

1241 lines
44 KiB
C
Raw Blame History

/*
* Copyright © 2008-2011 Kristian Høgsberg
* Copyright © 2011 Intel Corporation
* Copyright © 2017, 2018 Collabora, Ltd.
* Copyright © 2017, 2018 General Electric Company
* Copyright (c) 2018 DisplayLink (UK) Ltd.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include "config.h"
#include <xf86drm.h>
#include <xf86drmMode.h>
#include <libweston/libweston.h>
#include <libweston/backend-drm.h>
#include <libweston/pixel-formats.h>
#include "drm-internal.h"
#include "color.h"
#include "linux-dmabuf.h"
#include "presentation-time-server-protocol.h"
#include "linux-dmabuf-unstable-v1-server-protocol.h"
#include "shared/string-helpers.h"
#include "shared/weston-assert.h"
enum drm_output_propose_state_mode {
DRM_OUTPUT_PROPOSE_STATE_MIXED, /**< mix renderer & planes */
DRM_OUTPUT_PROPOSE_STATE_RENDERER_ONLY, /**< only assign to renderer & cursor */
DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY, /**< no renderer use, only planes */
};
static const char *const drm_output_propose_state_mode_as_string[] = {
[DRM_OUTPUT_PROPOSE_STATE_MIXED] = "mixed state",
[DRM_OUTPUT_PROPOSE_STATE_RENDERER_ONLY] = "render-only state",
[DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY] = "plane-only state"
};
static const char *
drm_propose_state_mode_to_string(enum drm_output_propose_state_mode mode)
{
if (mode < 0 || mode >= ARRAY_LENGTH(drm_output_propose_state_mode_as_string))
return " unknown compositing mode";
return drm_output_propose_state_mode_as_string[mode];
}
static bool
drm_mixed_mode_check_underlay(enum drm_output_propose_state_mode mode,
struct drm_plane_state *scanout_state,
uint64_t zpos)
{
if (mode == DRM_OUTPUT_PROPOSE_STATE_MIXED) {
assert(scanout_state != NULL);
if (scanout_state->zpos >= zpos)
return true;
}
return false;
}
static bool
drm_output_check_plane_has_view_assigned(struct drm_plane *plane,
struct drm_output_state *output_state)
{
struct drm_plane_state *ps;
wl_list_for_each(ps, &output_state->plane_list, link) {
if (ps->plane == plane && ps->fb)
return true;
}
return false;
}
static struct drm_plane_state *
drm_output_try_paint_node_on_plane(struct drm_plane *plane,
struct drm_output_state *output_state,
struct weston_paint_node *node,
enum drm_output_propose_state_mode mode,
struct drm_fb *fb, uint64_t zpos)
{
struct drm_output *output = output_state->output;
struct weston_view *ev = node->view;
struct weston_surface *surface = ev->surface;
struct drm_device *device = output->device;
struct drm_backend *b = device->backend;
struct drm_plane_state *state = NULL;
assert(!device->sprites_are_broken);
assert(device->atomic_modeset);
assert(fb);
assert(mode == DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY ||
(mode == DRM_OUTPUT_PROPOSE_STATE_MIXED &&
plane->type == WDRM_PLANE_TYPE_OVERLAY));
state = drm_output_state_get_plane(output_state, plane);
/* we can't have a 'pending' framebuffer as never set one before reaching here */
assert(!state->fb);
state->output = output;
if (!drm_plane_state_coords_for_paint_node(state, node, zpos)) {
drm_debug(b, "\t\t\t\t[view] not placing view %p on plane: "
"unsuitable transform\n", ev);
goto out;
}
/* Should've been ensured by weston_view_matches_entire_output. */
if (plane->type == WDRM_PLANE_TYPE_PRIMARY) {
assert(state->dest_x == 0 && state->dest_y == 0 &&
state->dest_w == (unsigned) output->base.current_mode->width &&
state->dest_h == (unsigned) output->base.current_mode->height);
}
/* We hold one reference for the lifetime of this function; from
* calling drm_fb_get_from_paint_node() in
* drm_output_prepare_plane_view(), so, we take another reference
* here to live within the state. */
state->ev = ev;
state->fb = drm_fb_ref(fb);
state->in_fence_fd = ev->surface->acquire_fence_fd;
if (fb->format && fb->format->color_model == COLOR_MODEL_YUV) {
enum wdrm_plane_color_encoding color_encoding;
enum wdrm_plane_color_range color_range;
/* These values will become dynamic once we implement the
* color-representation protocol. */
color_encoding = WDRM_PLANE_COLOR_ENCODING_DEFAULT;
color_range = WDRM_PLANE_COLOR_RANGE_DEFAULT;
if (plane->props[WDRM_PLANE_COLOR_ENCODING].prop_id == 0) {
if (color_encoding != WDRM_PLANE_COLOR_ENCODING_DEFAULT) {
drm_debug(b, "\t\t\t[view] not placing view %p on plane %lu: "
"non-default color encoding not supported\n",
ev, (unsigned long) plane->plane_id);
goto out;
}
} else if (!drm_plane_supports_color_encoding(plane,
color_encoding)) {
drm_debug(b, "\t\t\t[view] not placing view %p on plane %lu: "
"color encoding not supported\n", ev,
(unsigned long) plane->plane_id);
goto out;
}
if (plane->props[WDRM_PLANE_COLOR_RANGE].prop_id == 0) {
if (color_range != WDRM_PLANE_COLOR_RANGE_DEFAULT) {
drm_debug(b, "\t\t\t[view] not placing view %p on plane %lu: "
"non-default color range not supported\n",
ev, (unsigned long) plane->plane_id);
goto out;
}
} else if (!drm_plane_supports_color_range(plane,
color_range)) {
drm_debug(b, "\t\t\t[view] not placing view %p on plane %lu: "
"color range not supported\n", ev,
(unsigned long) plane->plane_id);
goto out;
}
state->color_encoding = color_encoding;
state->color_range = color_range;
}
/* In planes-only mode, we don't have an incremental state to
* test against, so we just hope it'll work. */
if (mode != DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY &&
drm_pending_state_test(output_state->pending_state) != 0) {
drm_debug(b, "\t\t\t[view] not placing view %p on plane %lu: "
"atomic test failed\n",
ev, (unsigned long) plane->plane_id);
goto out;
}
drm_debug(b, "\t\t\t[view] provisionally placing view %p on plane %lu\n",
ev, (unsigned long) plane->plane_id);
/* Take a reference on the buffer so that we don't release it
* back to the client until we're done with it; cursor buffers
* don't require a reference since we copy them. */
assert(state->fb_ref.buffer.buffer == NULL);
assert(state->fb_ref.release.buffer_release == NULL);
weston_buffer_reference(&state->fb_ref.buffer,
surface->buffer_ref.buffer,
BUFFER_MAY_BE_ACCESSED);
weston_buffer_release_reference(&state->fb_ref.release,
surface->buffer_release_ref.buffer_release);
return state;
out:
drm_plane_state_put_back(state);
return NULL;
}
#ifdef BUILD_DRM_GBM
static struct drm_plane_state *
drm_output_prepare_cursor_paint_node(struct drm_output_state *output_state,
struct weston_paint_node *node,
uint64_t zpos)
{
struct drm_output *output = output_state->output;
struct drm_device *device = output->device;
struct drm_backend *b = device->backend;
struct drm_plane *plane = output->cursor_plane;
struct weston_view *ev = node->view;
struct drm_plane_state *plane_state;
const char *p_name = drm_output_get_plane_type_name(plane);
assert(!device->cursors_are_broken);
assert(plane);
assert(plane->state_cur->complete);
assert(!plane->state_cur->output || plane->state_cur->output == output);
/* We use GBM to import SHM buffers. */
assert(b->gbm);
plane_state = drm_output_state_get_plane(output_state, plane);
assert(!plane_state->fb);
/* We can't scale with the legacy API, and we don't try to account for
* simple cropping/translation in cursor_bo_update. */
plane_state->output = output;
if (!drm_plane_state_coords_for_paint_node(plane_state, node, zpos)) {
drm_debug(b, "\t\t\t\t[%s] not placing view %p on %s: "
"unsuitable transform\n", p_name, ev, p_name);
goto err;
}
if (plane_state->src_x != 0 || plane_state->src_y != 0 ||
plane_state->src_w > (unsigned) device->cursor_width << 16 ||
plane_state->src_h > (unsigned) device->cursor_height << 16 ||
plane_state->src_w != plane_state->dest_w << 16 ||
plane_state->src_h != plane_state->dest_h << 16) {
drm_debug(b, "\t\t\t\t[%s] not assigning view %p to %s plane "
"(positioning requires cropping or scaling)\n",
p_name, ev, p_name);
goto err;
}
drm_output_set_cursor_view(output, ev);
plane_state->ev = ev;
/* We always test with cursor fb 0. There are two potential fbs, and
* they are identically allocated for cursor use specifically, so if
* one works the other almost certainly should as well.
*
* Later when we determine if the cursor needs an update, we'll
* select the correct fb to use.
*/
plane_state->fb = drm_fb_ref(output->gbm_cursor_fb[0]);
/* The cursor API is somewhat special: in cursor_bo_update(), we upload
* a buffer which is always cursor_width x cursor_height, even if the
* surface we want to promote is actually smaller than this. Manually
* mangle the plane state to deal with this. */
plane_state->src_w = device->cursor_width << 16;
plane_state->src_h = device->cursor_height << 16;
plane_state->dest_w = device->cursor_width;
plane_state->dest_h = device->cursor_height;
drm_debug(b, "\t\t\t\t[%s] provisionally assigned view %p to cursor\n",
p_name, ev);
return plane_state;
err:
drm_plane_state_put_back(plane_state);
return NULL;
}
#else
static struct drm_plane_state *
drm_output_prepare_cursor_paint_node(struct drm_output_state *output_state,
struct weston_paint_node *node,
uint64_t zpos)
{
return NULL;
}
#endif
static void
drm_output_check_zpos_plane_states(struct drm_output_state *state)
{
struct drm_plane_state *ps;
wl_list_for_each(ps, &state->plane_list, link) {
struct wl_list *next_node = ps->link.next;
bool found_dup = false;
/* skip any plane that is not enabled */
if (!ps->fb)
continue;
assert(ps->zpos != DRM_PLANE_ZPOS_INVALID_PLANE);
/* find another plane with the same zpos value */
if (next_node == &state->plane_list)
break;
while (next_node && next_node != &state->plane_list) {
struct drm_plane_state *ps_next;
ps_next = container_of(next_node,
struct drm_plane_state,
link);
if (ps->zpos == ps_next->zpos) {
found_dup = true;
break;
}
next_node = next_node->next;
}
/* this should never happen so exit hard in case
* we screwed up that bad */
assert(!found_dup);
}
}
static const char *
action_needed_to_str(enum actions_needed_dmabuf_feedback action_needed)
{
switch(action_needed) {
case ACTION_NEEDED_ADD_SCANOUT_TRANCHE:
return "add scanout tranche";
case ACTION_NEEDED_REMOVE_SCANOUT_TRANCHE:
return "remove scanout tranche";
case ACTION_NEEDED_NONE:
return "no action needed";
default:
assert(0);
}
}
static void
dmabuf_feedback_maybe_update(struct drm_device *device, struct weston_view *ev,
uint32_t try_view_on_plane_failure_reasons)
{
struct weston_dmabuf_feedback *dmabuf_feedback = ev->surface->dmabuf_feedback;
struct weston_dmabuf_feedback_tranche *scanout_tranche;
struct drm_backend *b = device->backend;
dev_t scanout_dev = device->drm.devnum;
uint32_t scanout_flags = ZWP_LINUX_DMABUF_FEEDBACK_V1_TRANCHE_FLAGS_SCANOUT;
enum actions_needed_dmabuf_feedback action_needed = ACTION_NEEDED_NONE;
struct timespec current_time, delta_time;
const time_t MAX_TIME_SECONDS = 2;
/* Look for scanout tranche. If not found, add it but in disabled mode
* (we still don't know if we'll have to send it to clients). This
* simplifies the code. */
scanout_tranche =
weston_dmabuf_feedback_find_tranche(dmabuf_feedback, scanout_dev,
scanout_flags, SCANOUT_PREF);
if (!scanout_tranche) {
scanout_tranche =
weston_dmabuf_feedback_tranche_create(dmabuf_feedback,
b->compositor->dmabuf_feedback_format_table,
scanout_dev, scanout_flags, SCANOUT_PREF);
scanout_tranche->active = false;
}
/* Direct scanout won't happen even if client re-allocates using
* params from the scanout tranche, so keep only the renderer tranche. */
if (try_view_on_plane_failure_reasons & (FAILURE_REASONS_FORCE_RENDERER |
FAILURE_REASONS_NO_PLANES_AVAILABLE |
FAILURE_REASONS_INADEQUATE_CONTENT_PROTECTION)) {
action_needed = ACTION_NEEDED_REMOVE_SCANOUT_TRANCHE;
/* Direct scanout may be possible if client re-allocates using the
* params from the scanout tranche. */
} else if (try_view_on_plane_failure_reasons & (FAILURE_REASONS_ADD_FB_FAILED |
FAILURE_REASONS_FB_FORMAT_INCOMPATIBLE |
FAILURE_REASONS_DMABUF_MODIFIER_INVALID |
FAILURE_REASONS_GBM_BO_IMPORT_FAILED |
FAILURE_REASONS_GBM_BO_GET_HANDLE_FAILED)) {
action_needed = ACTION_NEEDED_ADD_SCANOUT_TRANCHE;
/* Direct scanout is already possible, so include the scanout tranche. */
} else if (try_view_on_plane_failure_reasons == FAILURE_REASONS_NONE) {
action_needed = ACTION_NEEDED_ADD_SCANOUT_TRANCHE;
}
/* No actions needed, so disarm timer and return */
if (action_needed == ACTION_NEEDED_NONE ||
(action_needed == ACTION_NEEDED_ADD_SCANOUT_TRANCHE && scanout_tranche->active) ||
(action_needed == ACTION_NEEDED_REMOVE_SCANOUT_TRANCHE && !scanout_tranche->active)) {
dmabuf_feedback->action_needed = ACTION_NEEDED_NONE;
return;
}
/* We hit this if:
*
* 1. timer is still off, or
* 2. the action needed when it was set to on does not match the most
* recent needed action we've detected.
*
* So we reset the timestamp, set the timer to on it with the most
* recent needed action, return and leave the timer running. */
if (dmabuf_feedback->action_needed == ACTION_NEEDED_NONE ||
dmabuf_feedback->action_needed != action_needed) {
clock_gettime(CLOCK_MONOTONIC, &dmabuf_feedback->timer);
dmabuf_feedback->action_needed = action_needed;
return;
/* Timer is already on and the action needed when it was set to on does
* not conflict with the most recent needed action we've detected. If
* more than MAX_TIME_SECONDS has passed, we need to resend the dma-buf
* feedback. Otherwise, return and leave the timer running. */
} else {
clock_gettime(CLOCK_MONOTONIC, &current_time);
delta_time.tv_sec = current_time.tv_sec -
dmabuf_feedback->timer.tv_sec;
if (delta_time.tv_sec < MAX_TIME_SECONDS)
return;
}
/* If we got here it means that the timer has triggered, so we have
* pending actions with the dma-buf feedback. So we update and resend
* them. */
if (action_needed == ACTION_NEEDED_ADD_SCANOUT_TRANCHE)
scanout_tranche->active = true;
else if (action_needed == ACTION_NEEDED_REMOVE_SCANOUT_TRANCHE)
scanout_tranche->active = false;
else
assert(0);
drm_debug(b, "\t[repaint] Need to update and resend the "
"dma-buf feedback for surface of view %p: %s\n",
ev, action_needed_to_str(action_needed));
weston_dmabuf_feedback_send_all(b->compositor, dmabuf_feedback,
b->compositor->dmabuf_feedback_format_table);
/* Set the timer to off */
dmabuf_feedback->action_needed = ACTION_NEEDED_NONE;
}
static const char *
failure_reasons_to_str(enum try_view_on_plane_failure_reasons failure_reasons)
{
switch(failure_reasons) {
case FAILURE_REASONS_NONE: return "none";
case FAILURE_REASONS_FORCE_RENDERER: return "force renderer";
case FAILURE_REASONS_FB_FORMAT_INCOMPATIBLE: return "fb format incompatible";
case FAILURE_REASONS_DMABUF_MODIFIER_INVALID: return "dmabuf modifier invalid";
case FAILURE_REASONS_ADD_FB_FAILED: return "add fb failed";
case FAILURE_REASONS_NO_PLANES_AVAILABLE: return "no planes available";
case FAILURE_REASONS_PLANES_REJECTED: return "planes rejected";
case FAILURE_REASONS_INADEQUATE_CONTENT_PROTECTION: return "inadequate content protection";
case FAILURE_REASONS_INCOMPATIBLE_TRANSFORM: return "incompatible transform";
case FAILURE_REASONS_NO_BUFFER: return "no buffer";
case FAILURE_REASONS_BUFFER_TOO_BIG: return "buffer too big";
case FAILURE_REASONS_BUFFER_TYPE: return "buffer type";
case FAILURE_REASONS_GLOBAL_ALPHA: return "global alpha";
case FAILURE_REASONS_NO_GBM: return "no gbm";
case FAILURE_REASONS_GBM_BO_IMPORT_FAILED: return "gbm bo import failed";
case FAILURE_REASONS_GBM_BO_GET_HANDLE_FAILED: return "gbm bo get handle failed";
}
return "???";
}
static struct drm_plane_state *
drm_output_find_plane_for_view(struct drm_output_state *state,
struct weston_paint_node *pnode,
enum drm_output_propose_state_mode mode,
struct drm_plane_state *scanout_state,
uint64_t current_lowest_zpos_overlay,
uint64_t current_lowest_zpos_underlay,
bool need_underlay)
{
struct drm_output *output = state->output;
struct drm_device *device = output->device;
struct drm_backend *b = device->backend;
struct drm_plane_state *ps = NULL;
struct drm_plane *plane;
struct weston_view *ev = pnode->view;
struct weston_buffer *buffer;
struct drm_fb *fb = NULL;
uint64_t current_lowest_zpos = need_underlay ?
current_lowest_zpos_underlay :
current_lowest_zpos_overlay;
bool view_matches_entire_output, scanout_has_view_assigned;
uint32_t possible_plane_mask = 0;
uint32_t fb_failure_reasons = 0;
bool any_candidate_picked = false;
pnode->try_view_on_plane_failure_reasons = FAILURE_REASONS_NONE;
/* filter out non-cursor views in renderer-only mode */
if (mode == DRM_OUTPUT_PROPOSE_STATE_RENDERER_ONLY &&
ev->layer_link.layer != &b->compositor->cursor_layer)
return NULL;
/* check view for valid buffer, doesn't make sense to even try */
if (!weston_view_has_valid_buffer(ev)) {
pnode->try_view_on_plane_failure_reasons |=
FAILURE_REASONS_NO_BUFFER;
return NULL;
}
buffer = ev->surface->buffer_ref.buffer;
if (buffer->type == WESTON_BUFFER_SOLID) {
pnode->try_view_on_plane_failure_reasons |=
FAILURE_REASONS_BUFFER_TYPE;
} else if (buffer->type == WESTON_BUFFER_SHM) {
if (!output->cursor_plane || device->cursors_are_broken)
pnode->try_view_on_plane_failure_reasons |=
FAILURE_REASONS_BUFFER_TYPE;
/* Even though this is a SHM buffer, pixel_format stores
* the format code as DRM FourCC */
if (buffer->pixel_format->format != DRM_FORMAT_ARGB8888) {
drm_debug(b, "\t\t\t\t[view] not placing view %p on "
"plane; SHM buffers must be ARGB8888 for "
"cursor view\n", ev);
pnode->try_view_on_plane_failure_reasons |=
FAILURE_REASONS_FB_FORMAT_INCOMPATIBLE;
}
if (buffer->width > device->cursor_width ||
buffer->height > device->cursor_height) {
drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane "
"(buffer (%dx%d) too large for cursor plane)\n",
ev, buffer->width, buffer->height);
pnode->try_view_on_plane_failure_reasons |=
FAILURE_REASONS_BUFFER_TOO_BIG;
}
if (pnode->try_view_on_plane_failure_reasons == FAILURE_REASONS_NONE)
possible_plane_mask = (1 << output->cursor_plane->plane_idx);
} else {
if (mode == DRM_OUTPUT_PROPOSE_STATE_RENDERER_ONLY) {
drm_debug(b, "\t\t\t\t[view] not assigning view %p "
"to plane: renderer-only mode\n", ev);
return NULL;
}
wl_list_for_each(plane, &device->plane_list, link) {
if (plane->type == WDRM_PLANE_TYPE_CURSOR)
continue;
if (drm_paint_node_transform_supported(pnode, plane))
possible_plane_mask |= 1 << plane->plane_idx;
}
if (!possible_plane_mask)
pnode->try_view_on_plane_failure_reasons |=
FAILURE_REASONS_INCOMPATIBLE_TRANSFORM;
fb = drm_fb_get_from_paint_node(state, pnode, &fb_failure_reasons);
if (fb) {
possible_plane_mask &= fb->plane_mask;
} else {
char *fr_str = bits_to_str(fb_failure_reasons, failure_reasons_to_str);
weston_assert_ptr_not_null(b->compositor, fr_str);
drm_debug(b, "\t\t\t[view] couldn't get FB for view: %s\n", fr_str);
free(fr_str);
pnode->try_view_on_plane_failure_reasons |= fb_failure_reasons;
}
}
view_matches_entire_output =
weston_view_matches_output_entirely(ev, &output->base);
scanout_has_view_assigned =
drm_output_check_plane_has_view_assigned(output->scanout_plane,
state);
/* assemble a list with possible candidates */
wl_list_for_each(plane, &device->plane_list, link) {
const char *p_name = drm_output_get_plane_type_name(plane);
uint64_t zpos;
bool mm_underlay_only = false;
if (possible_plane_mask == 0)
break;
if (!(possible_plane_mask & (1 << plane->plane_idx)))
continue;
possible_plane_mask &= ~(1 << plane->plane_idx);
mm_underlay_only =
drm_mixed_mode_check_underlay(mode, scanout_state, plane->zpos_max);
switch (plane->type) {
case WDRM_PLANE_TYPE_CURSOR:
assert(buffer->shm_buffer);
assert(plane == output->cursor_plane);
break;
case WDRM_PLANE_TYPE_PRIMARY:
if (plane != output->scanout_plane)
continue;
if (mode != DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY)
continue;
if (!view_matches_entire_output)
continue;
break;
case WDRM_PLANE_TYPE_OVERLAY:
assert(mode != DRM_OUTPUT_PROPOSE_STATE_RENDERER_ONLY);
/* if the view covers the whole output, put it in the
* scanout plane, not overlay */
if (view_matches_entire_output &&
weston_view_is_opaque(ev, &ev->transform.boundingbox) &&
!scanout_has_view_assigned)
continue;
/* for alpha views, avoid placing them on the HW planes that
* are below the primary plane. */
if (mm_underlay_only && !weston_view_is_opaque(ev, &ev->transform.boundingbox))
continue;
break;
default:
assert(false && "unknown plane type");
}
if (!drm_plane_is_available(plane, output))
continue;
if (drm_output_check_plane_has_view_assigned(plane, state)) {
drm_debug(b, "\t\t\t\t[plane] not trying plane %d: "
"another view already assigned\n",
plane->plane_id);
continue;
}
/* if view has alpha check if this plane supports plane alpha */
if (ev->alpha != 1.0f && plane->alpha_max == plane->alpha_min) {
drm_debug(b, "\t\t\t\t[plane] not trying plane %d:"
"plane-alpha not supported\n",
plane->plane_id);
continue;
}
/* Pre-judge whether the plane will be set as underlay plane. If so, start
* trying to find underlay plane based on 'current_lowest_zpos_underlay'. */
if (!need_underlay) {
uint64_t tmp_next_lowest_zpos;
if (current_lowest_zpos == DRM_PLANE_ZPOS_INVALID_PLANE)
tmp_next_lowest_zpos = plane->zpos_max;
else
tmp_next_lowest_zpos = current_lowest_zpos - 1;
if (drm_mixed_mode_check_underlay(mode, scanout_state, tmp_next_lowest_zpos)) {
drm_debug(b, "\t\t\t\t[plane] could not use overlay planes, "
"attempting to find underlay plane\n");
current_lowest_zpos = current_lowest_zpos_underlay;
}
}
if (plane->zpos_min >= current_lowest_zpos) {
drm_debug(b, "\t\t\t\t[plane] not trying plane %d: "
"plane's minimum zpos (%"PRIu64") above "
"current lowest zpos (%"PRIu64")\n",
plane->plane_id, plane->zpos_min,
current_lowest_zpos);
continue;
}
/* If the surface buffer has an in-fence fd, but the plane doesn't
* support fences, we can't place the buffer on this plane. */
if (ev->surface->acquire_fence_fd >= 0 &&
plane->props[WDRM_PLANE_IN_FENCE_FD].prop_id == 0) {
drm_debug(b, "\t\t\t\t[%s] not placing view %p on %s: "
"no in-fence support\n", p_name, ev, p_name);
continue;
}
if (!b->has_underlay && mm_underlay_only) {
drm_debug(b, "\t\t\t\t[plane] not adding plane %d to "
"candidate list: plane is below the primary "
"plane and backend format (%s) is opaque, "
"hole on primary plane will not work\n",
plane->plane_id, b->format->drm_format_name);
continue;
}
if (current_lowest_zpos == DRM_PLANE_ZPOS_INVALID_PLANE)
zpos = plane->zpos_max;
else
zpos = MIN(current_lowest_zpos - 1, plane->zpos_max);
any_candidate_picked = true;
drm_debug(b, "\t\t\t\t[plane] plane %d picked "
"from candidate list, type: %s\n",
plane->plane_id, p_name);
if (plane->type == WDRM_PLANE_TYPE_CURSOR) {
ps = drm_output_prepare_cursor_paint_node(state, pnode, zpos);
} else {
if (fb)
ps = drm_output_try_paint_node_on_plane(plane, state,
pnode, mode,
fb, zpos);
}
if (ps) {
/* Check if this ps is underlay plane, if so, the view
* needs through hole on primary plane. */
pnode->need_hole =
drm_mixed_mode_check_underlay(mode,
scanout_state,
ps->zpos);
drm_debug(b, "\t\t\t\t[view] view %p has been placed to "
"%s plane as an %s with computed zpos "
"%"PRIu64"\n",
ev, p_name,
pnode->need_hole ? "underlay" : "overlay",
zpos);
break;
}
pnode->try_view_on_plane_failure_reasons |=
FAILURE_REASONS_PLANES_REJECTED;
}
if (!any_candidate_picked)
pnode->try_view_on_plane_failure_reasons |=
FAILURE_REASONS_NO_PLANES_AVAILABLE;
/* if we have a plane state, it has its own ref to the fb; if not then
* we drop ours here */
drm_fb_unref(fb);
return ps;
}
static struct drm_output_state *
drm_output_propose_state(struct weston_output *output_base,
struct drm_pending_state *pending_state,
enum drm_output_propose_state_mode mode)
{
struct drm_output *output = to_drm_output(output_base);
struct drm_device *device = output->device;
struct drm_backend *b = device->backend;
struct weston_paint_node *pnode;
struct drm_output_state *state;
struct drm_plane_state *scanout_state = NULL;
pixman_region32_t renderer_region;
pixman_region32_t occluded_region;
bool renderer_ok = (mode != DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY);
int ret;
/* Record the current lowest zpos of the overlay planes */
uint64_t current_lowest_zpos_overlay = DRM_PLANE_ZPOS_INVALID_PLANE;
/* Record the current lowest zpos of the underlay plane */
uint64_t current_lowest_zpos_underlay = DRM_PLANE_ZPOS_INVALID_PLANE;
assert(!output->state_last);
state = drm_output_state_duplicate(output->state_cur,
pending_state,
DRM_OUTPUT_STATE_CLEAR_PLANES);
/* Start with the assumption that we're going to do a tearing commit,
* if the hardware supports it and we're not compositing with the
* renderer.
* As soon as anything in the scene graph wants to be presented without
* tearing, or a test fails, drop the tear flag. */
state->tear = device->tearing_supported &&
mode == DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY;
/* We implement mixed mode by progressively creating and testing
* incremental states, of scanout + overlay + cursor. Since we
* walk our views top to bottom, the scanout plane is last, however
* we always need it in our scene for the test modeset to be
* meaningful. To do this, we steal a reference to the last
* renderer framebuffer we have, if we think it's basically
* compatible. If we don't have that, then we conservatively fall
* back to only using the renderer for this repaint. */
if (mode == DRM_OUTPUT_PROPOSE_STATE_MIXED) {
struct drm_plane *plane = output->scanout_plane;
struct drm_fb *scanout_fb = plane->state_cur->fb;
if (!scanout_fb ||
(scanout_fb->type != BUFFER_GBM_SURFACE &&
scanout_fb->type != BUFFER_PIXMAN_DUMB)) {
drm_debug(b, "\t\t[state] cannot propose mixed mode: "
"for output %s (%lu): no previous renderer "
"fb\n",
output->base.name,
(unsigned long) output->base.id);
drm_output_state_free(state);
return NULL;
}
if (scanout_fb->width != output_base->current_mode->width ||
scanout_fb->height != output_base->current_mode->height) {
drm_debug(b, "\t\t[state] cannot propose mixed mode "
"for output %s (%lu): previous fb has "
"different size\n",
output->base.name,
(unsigned long) output->base.id);
drm_output_state_free(state);
return NULL;
}
scanout_state = drm_plane_state_duplicate(state,
plane->state_cur);
/* assign the primary the lowest zpos value */
scanout_state->zpos = plane->zpos_min;
/* Set the initial lowest zpos used for the underlay plane
* (asuming capable platform) to the that of the the primary
* plane, matching the lowest possible value. As we parse views
* from top to bottom we also need a start-up point for
* underlays, below this initial lowest zpos value. */
current_lowest_zpos_underlay = scanout_state->zpos;
drm_debug(b, "\t\t[state] using renderer FB ID %lu for mixed "
"mode for output %s (%lu)\n",
(unsigned long) scanout_fb->fb_id, output->base.name,
(unsigned long) output->base.id);
drm_debug(b, "\t\t[state] scanout will use for zpos %"PRIu64"\n",
scanout_state->zpos);
}
/* - renderer_region contains the total region which which will be
* covered by the renderer and underlay region.
* - occluded_region contains the total region which which will be
* covered by the renderer and hardware planes, where the view's
* visible-and-opaque region is added in both cases (the view's
* opaque region accumulates there for each view); it is being used
* to skip the view, if it is completely occluded; includes the
* situation where occluded_region covers entire output's region.
*/
pixman_region32_init(&renderer_region);
pixman_region32_init(&occluded_region);
wl_list_for_each(pnode, &output->base.paint_node_z_order_list,
z_order_link) {
struct weston_view *ev = pnode->view;
struct drm_plane_state *ps = NULL;
bool force_renderer = false;
pixman_region32_t clipped_view;
pixman_region32_t surface_overlap;
bool totally_occluded = false;
bool need_underlay = false;
drm_debug(b, "\t\t\t[view] evaluating view %p for "
"output %s (%lu)\n",
ev, output->base.name,
(unsigned long) output->base.id);
assert(ev->output_mask & (1u << output->base.id));
/* Cannot show anything without a color transform. */
if (!pnode->surf_xform_valid) {
drm_debug(b, "\t\t\t\t[view] ignoring view %p "
"(color transform failed)\n", ev);
continue;
}
/* Ignore views we know to be totally occluded. */
pixman_region32_init(&clipped_view);
pixman_region32_intersect(&clipped_view,
&ev->transform.boundingbox,
&output->base.region);
pixman_region32_init(&surface_overlap);
pixman_region32_subtract(&surface_overlap, &clipped_view,
&occluded_region);
/* if the view is completely occluded then ignore that
* view; includes the case where occluded_region covers
* the entire output */
totally_occluded = !pixman_region32_not_empty(&surface_overlap);
if (totally_occluded) {
drm_debug(b, "\t\t\t\t[view] ignoring view %p "
"(occluded on our output)\n", ev);
pixman_region32_fini(&surface_overlap);
pixman_region32_fini(&clipped_view);
continue;
}
if (!b->gbm) {
drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane "
"(GBM not available)\n", ev);
force_renderer = true;
}
if (!weston_view_has_valid_buffer(ev)) {
drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane "
"(no buffer available)\n", ev);
force_renderer = true;
}
/* We can support this with the 'CRTC background colour' property,
* if it is fullscreen (i.e. we disable the primary plane), and
* opaque (as it is only shown in the absence of any covering
* plane, not as a replacement for the primary plane per se). */
if (ev->surface->buffer_ref.buffer &&
ev->surface->buffer_ref.buffer->type == WESTON_BUFFER_SOLID) {
drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane "
"(solid-colour surface)\n", ev);
force_renderer = true;
}
if (pnode->surf_xform.transform != NULL ||
!pnode->surf_xform.identity_pipeline) {
drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane "
"(requires color transform)\n", ev);
force_renderer = true;
}
/* Since we process views from top to bottom, we know that if
* the view intersects the calculated renderer region, it must
* be part of, or occluded by, it, and cannot go on an overlay
* plane. */
pixman_region32_intersect(&surface_overlap, &renderer_region,
&clipped_view);
if (pixman_region32_not_empty(&surface_overlap)) {
if (b->has_underlay) {
need_underlay = true;
} else {
force_renderer = true;
drm_debug(b, "\t\t\t\t[view] not assigning view %p to a "
"plane (occluded by renderer views), current lowest "
"zpos change to %"PRIu64"\n", ev,
current_lowest_zpos_underlay);
}
}
pixman_region32_fini(&surface_overlap);
/* If need_underlay, but view contains alpha, then it needs to
* be rendered. Only fully-opaque views can go on an underlay.
*/
if (need_underlay &&
!weston_view_is_opaque(ev, &ev->transform.boundingbox)) {
force_renderer = true;
drm_debug(b, "\t\t\t\t[view] not assigning view %p to "
"a plane (alpha view occluded by renderer "
"views)", ev);
}
/* In case of enforced mode of content-protection do not
* assign planes for a protected surface on an unsecured output.
*/
if (ev->surface->protection_mode == WESTON_SURFACE_PROTECTION_MODE_ENFORCED &&
ev->surface->desired_protection > output_base->current_protection) {
drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane "
"(enforced protection mode on unsecured output)\n", ev);
force_renderer = true;
}
if (pnode->view->surface->tear_control)
state->tear &= pnode->view->surface->tear_control->may_tear;
else
state->tear = 0;
/* Now try to place it on a plane if we can. */
if (!force_renderer) {
drm_debug(b, "\t\t\t[plane] started with zpos %"PRIu64"\n",
need_underlay ? current_lowest_zpos_underlay :
current_lowest_zpos_overlay);
ps = drm_output_find_plane_for_view(state, pnode, mode,
scanout_state,
current_lowest_zpos_overlay,
current_lowest_zpos_underlay,
need_underlay);
} else {
/* We are forced to place the view in the renderer, set
* the failure reason accordingly. */
pnode->try_view_on_plane_failure_reasons =
FAILURE_REASONS_FORCE_RENDERER;
}
if (ps) {
if (drm_mixed_mode_check_underlay(mode, scanout_state, ps->zpos))
current_lowest_zpos_underlay = ps->zpos;
else
current_lowest_zpos_overlay = ps->zpos;
drm_debug(b, "\t\t\t[plane] next overlay zpos to use %"PRIu64","
" next underlay zpos to use %"PRIu64"\n",
current_lowest_zpos_overlay,
current_lowest_zpos_underlay);
} else if (!ps && !renderer_ok) {
drm_debug(b, "\t\t[view] failing state generation: "
"placing view %p to renderer not allowed\n",
ev);
pixman_region32_fini(&clipped_view);
goto err_region;
} else if (!ps) {
char *fr_str = bits_to_str(pnode->try_view_on_plane_failure_reasons,
failure_reasons_to_str);
weston_assert_ptr_not_null(b->compositor, fr_str);
drm_debug(b, "\t\t\t\t[view] view %p will be placed "
"on the renderer: %s\n", ev, fr_str);
free(fr_str);
}
if (!ps || drm_mixed_mode_check_underlay(mode, scanout_state, ps->zpos)) {
/* clipped_view contains the area that's going to be
* visible on screen; add this to the renderer region */
pixman_region32_union(&renderer_region,
&renderer_region,
&clipped_view);
}
/* Opaque areas of our clipped view occlude areas behind it;
* however, anything not in the opaque region (which is the
* entire clipped area if the whole view is known to be
* opaque) does not necessarily occlude what's behind it, as
* it could be alpha-blended. */
if (!weston_view_is_opaque(ev, &clipped_view))
pixman_region32_intersect(&clipped_view,
&clipped_view,
&ev->transform.opaque);
pixman_region32_union(&occluded_region,
&occluded_region,
&clipped_view);
pixman_region32_fini(&clipped_view);
}
pixman_region32_fini(&renderer_region);
pixman_region32_fini(&occluded_region);
/* In renderer-only mode, we can't test the state as we don't have a
* renderer buffer yet. */
if (mode == DRM_OUTPUT_PROPOSE_STATE_RENDERER_ONLY)
return state;
/* check if we have invalid zpos values, like duplicate(s) */
drm_output_check_zpos_plane_states(state);
/* Check to see if this state will actually work. */
ret = drm_pending_state_test(state->pending_state);
if (ret != 0) {
drm_debug(b, "\t\t[view] failing state generation: "
"atomic test not OK\n");
goto err;
}
/* Counterpart to duplicating scanout state at the top of this
* function: if we have taken a renderer framebuffer and placed it in
* the pending state in order to incrementally test overlay planes,
* remove it now. */
if (mode == DRM_OUTPUT_PROPOSE_STATE_MIXED) {
assert(scanout_state->fb->type == BUFFER_GBM_SURFACE ||
scanout_state->fb->type == BUFFER_PIXMAN_DUMB);
drm_plane_state_put_back(scanout_state);
}
return state;
err_region:
pixman_region32_fini(&renderer_region);
pixman_region32_fini(&occluded_region);
err:
drm_output_state_free(state);
return NULL;
}
void
drm_assign_planes(struct weston_output *output_base)
{
struct drm_output *output = to_drm_output(output_base);
struct drm_device *device = output->device;
struct drm_backend *b = device->backend;
struct drm_pending_state *pending_state = device->repaint_data;
struct drm_output_state *state = NULL;
struct drm_plane_state *plane_state;
struct drm_writeback_state *wb_state = output->wb_state;
struct weston_paint_node *pnode;
struct weston_plane *primary = &output_base->primary_plane;
enum drm_output_propose_state_mode mode = DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY;
assert(output);
drm_debug(b, "\t[repaint] preparing state for output %s (%lu)\n",
output_base->name, (unsigned long) output_base->id);
if (!device->sprites_are_broken && !output->is_virtual && b->gbm) {
drm_debug(b, "\t[repaint] trying planes-only build state\n");
state = drm_output_propose_state(output_base, pending_state, mode);
if (!state) {
drm_debug(b, "\t[repaint] could not build planes-only "
"state, trying mixed\n");
mode = DRM_OUTPUT_PROPOSE_STATE_MIXED;
state = drm_output_propose_state(output_base,
pending_state,
mode);
}
} else {
drm_debug(b, "\t[state] no overlay plane support\n");
}
/* We can enter this block in two situations:
* 1. If we didn't enter the last block (for some reason we can't use planes)
* 2. If we entered but both the planes-only and the mixed modes didn't work */
if (!state) {
drm_debug(b, "\t[repaint] could not build state with planes, "
"trying renderer-only\n");
mode = DRM_OUTPUT_PROPOSE_STATE_RENDERER_ONLY;
state = drm_output_propose_state(output_base, pending_state,
mode);
/* If renderer only mode failed and we are in a writeback
* screenshot, let's abort the writeback screenshot and try
* again. */
if (!state && drm_output_get_writeback_state(output) != DRM_OUTPUT_WB_SCREENSHOT_OFF) {
drm_debug(b, "\t[repaint] could not build renderer-only "
"state, trying without writeback setup\n");
drm_writeback_fail_screenshot(wb_state, "drm: failed to propose state");
state = drm_output_propose_state(output_base, pending_state,
mode);
}
}
assert(state);
drm_debug(b, "\t[repaint] Using %s composition\n",
drm_propose_state_mode_to_string(mode));
wl_list_for_each(pnode, &output->base.paint_node_z_order_list,
z_order_link) {
struct weston_view *ev = pnode->view;
struct drm_plane *target_plane = NULL;
assert(ev->output_mask & (1u << output->base.id));
/* Update dmabuf-feedback if needed */
if (ev->surface->dmabuf_feedback)
dmabuf_feedback_maybe_update(device, ev,
pnode->try_view_on_plane_failure_reasons);
pnode->try_view_on_plane_failure_reasons = FAILURE_REASONS_NONE;
/* Test whether this buffer can ever go into a plane:
* non-shm, or small enough to be a cursor. */
ev->surface->keep_buffer = false;
if (weston_view_has_valid_buffer(ev)) {
struct weston_buffer *buffer =
ev->surface->buffer_ref.buffer;
if (buffer->type == WESTON_BUFFER_DMABUF ||
buffer->type == WESTON_BUFFER_RENDERER_OPAQUE)
ev->surface->keep_buffer = true;
else if (buffer->type == WESTON_BUFFER_SHM &&
(ev->surface->width <= device->cursor_width &&
ev->surface->height <= device->cursor_height))
ev->surface->keep_buffer = true;
}
/* This is a bit unpleasant, but lacking a temporary place to
* hang a plane off the view, we have to do a nested walk.
* Our first-order iteration has to be planes rather than
* views, because otherwise we won't reset views which were
* previously on planes to being on the primary plane. */
wl_list_for_each(plane_state, &state->plane_list, link) {
if (plane_state->ev == ev) {
plane_state->ev = NULL;
target_plane = plane_state->plane;
break;
}
}
if (target_plane) {
drm_debug(b, "\t[repaint] view %p on %s plane %lu\n",
ev, drm_output_get_plane_type_name(target_plane),
(unsigned long) target_plane->plane_id);
weston_paint_node_move_to_plane(pnode, &target_plane->base);
} else {
drm_debug(b, "\t[repaint] view %p using renderer "
"composition\n", ev);
weston_paint_node_move_to_plane(pnode, primary);
pnode->need_hole = false;
}
if (!target_plane ||
target_plane->type == WDRM_PLANE_TYPE_CURSOR) {
/* cursor plane & renderer involve a copy */
pnode->psf_flags = 0;
} else {
/* All other planes are a direct scanout of a
* single client buffer.
*/
pnode->psf_flags = WP_PRESENTATION_FEEDBACK_KIND_ZERO_COPY;
}
}
/* We rely on output->cursor_view being both an accurate reflection of
* the cursor plane's state, but also being maintained across repaints
* to avoid unnecessary damage uploads, per the comment in
* drm_output_prepare_cursor_paint_node. In the event that we go from
* having a cursor view to not having a cursor view, we need to clear
* it. */
if (output->cursor_view) {
plane_state =
drm_output_state_get_existing_plane(state,
output->cursor_plane);
if (!plane_state || !plane_state->fb)
drm_output_set_cursor_view(output, NULL);
}
if (drm_output_get_writeback_state(output) == DRM_OUTPUT_WB_SCREENSHOT_PREPARE_COMMIT)
drm_writeback_reference_planes(wb_state, &state->plane_list);
}
static void
drm_output_handle_cursor_view_destroy(struct wl_listener *listener, void *data)
{
struct drm_output *output =
container_of(listener, struct drm_output,
cursor_view_destroy_listener);
drm_output_set_cursor_view(output, NULL);
}
/** Set the current cursor view used for an output.
*
* Ensure the stored value will be properly cleared if the view is destroyed.
* The stored cursor view helps avoid unnecessary uploads of cursor data to
* cursor plane buffer objects (see drm_output_prepare_cursor_paint_node).
*/
void
drm_output_set_cursor_view(struct drm_output *output, struct weston_view *ev)
{
if (output->cursor_view == ev)
return;
if (output->cursor_view)
wl_list_remove(&output->cursor_view_destroy_listener.link);
output->cursor_view = ev;
if (ev) {
output->cursor_view_destroy_listener.notify =
drm_output_handle_cursor_view_destroy;
wl_signal_add(&ev->destroy_signal,
&output->cursor_view_destroy_listener);
}
}
Reference in a new issue View git blame Copy permalink