drm_assign_planes() is called to separate views out and decide what will be taken out for plane composition and what will be left for the renderer to compose. It calls drm_output_propose_state() in order to find a good configuration, which itself has a number of helpers that it calls. Break these out into a separate file. Signed-off-by: Daniel Stone <daniels@collabora.com>dev
Daniel Stone
6 years ago
parent
6b466f25af
commit
e404b72fd5
@ -0,0 +1,804 @@ |
||||
/*
|
||||
* 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 "linux-dmabuf.h" |
||||
#include "presentation-time-server-protocol.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 struct drm_plane_state * |
||||
drm_output_prepare_overlay_view(struct drm_output_state *output_state, |
||||
struct weston_view *ev, |
||||
enum drm_output_propose_state_mode mode) |
||||
{ |
||||
struct drm_output *output = output_state->output; |
||||
struct weston_compositor *ec = output->base.compositor; |
||||
struct drm_backend *b = to_drm_backend(ec); |
||||
struct drm_plane *p; |
||||
struct drm_plane_state *state = NULL; |
||||
struct drm_fb *fb; |
||||
unsigned int i; |
||||
int ret; |
||||
enum { |
||||
NO_PLANES, |
||||
NO_PLANES_WITH_FORMAT, |
||||
NO_PLANES_ACCEPTED, |
||||
PLACED_ON_PLANE, |
||||
} availability = NO_PLANES; |
||||
|
||||
assert(!b->sprites_are_broken); |
||||
assert(b->atomic_modeset); |
||||
|
||||
fb = drm_fb_get_from_view(output_state, ev); |
||||
if (!fb) { |
||||
drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay: " |
||||
" couldn't get fb\n", ev); |
||||
return NULL; |
||||
} |
||||
|
||||
wl_list_for_each(p, &b->plane_list, link) { |
||||
if (p->type != WDRM_PLANE_TYPE_OVERLAY) |
||||
continue; |
||||
|
||||
if (!drm_plane_is_available(p, output)) |
||||
continue; |
||||
|
||||
state = drm_output_state_get_plane(output_state, p); |
||||
if (state->fb) { |
||||
state = NULL; |
||||
continue; |
||||
} |
||||
|
||||
if (availability == NO_PLANES) |
||||
availability = NO_PLANES_WITH_FORMAT; |
||||
|
||||
/* Check whether the format is supported */ |
||||
for (i = 0; i < p->count_formats; i++) { |
||||
unsigned int j; |
||||
|
||||
if (p->formats[i].format != fb->format->format) |
||||
continue; |
||||
|
||||
if (fb->modifier == DRM_FORMAT_MOD_INVALID) |
||||
break; |
||||
|
||||
for (j = 0; j < p->formats[i].count_modifiers; j++) { |
||||
if (p->formats[i].modifiers[j] == fb->modifier) |
||||
break; |
||||
} |
||||
if (j != p->formats[i].count_modifiers) |
||||
break; |
||||
} |
||||
if (i == p->count_formats) { |
||||
drm_plane_state_put_back(state); |
||||
state = NULL; |
||||
continue; |
||||
} |
||||
|
||||
if (availability == NO_PLANES_WITH_FORMAT) |
||||
availability = NO_PLANES_ACCEPTED; |
||||
|
||||
state->ev = ev; |
||||
state->output = output; |
||||
if (!drm_plane_state_coords_for_view(state, ev)) { |
||||
drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay: " |
||||
"unsuitable transform\n", ev); |
||||
drm_plane_state_put_back(state); |
||||
state = NULL; |
||||
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 && |
||||
p->props[WDRM_PLANE_IN_FENCE_FD].prop_id == 0) { |
||||
drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay: " |
||||
"no in-fence support\n", ev); |
||||
drm_plane_state_put_back(state); |
||||
state = NULL; |
||||
continue; |
||||
} |
||||
|
||||
/* We hold one reference for the lifetime of this function;
|
||||
* from calling drm_fb_get_from_view, to the out label where |
||||
* we unconditionally drop the reference. So, we take another |
||||
* reference here to live within the state. */ |
||||
state->fb = drm_fb_ref(fb); |
||||
|
||||
state->in_fence_fd = ev->surface->acquire_fence_fd; |
||||
|
||||
/* 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_debug(b, "\t\t\t\t[overlay] provisionally placing " |
||||
"view %p on overlay %lu in planes-only mode\n", |
||||
ev, (unsigned long) p->plane_id); |
||||
availability = PLACED_ON_PLANE; |
||||
goto out; |
||||
} |
||||
|
||||
ret = drm_pending_state_test(output_state->pending_state); |
||||
if (ret == 0) { |
||||
drm_debug(b, "\t\t\t\t[overlay] provisionally placing " |
||||
"view %p on overlay %d in mixed mode\n", |
||||
ev, p->plane_id); |
||||
availability = PLACED_ON_PLANE; |
||||
goto out; |
||||
} |
||||
|
||||
drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay %lu " |
||||
"in mixed mode: kernel test failed\n", |
||||
ev, (unsigned long) p->plane_id); |
||||
|
||||
drm_plane_state_put_back(state); |
||||
state = NULL; |
||||
} |
||||
|
||||
switch (availability) { |
||||
case NO_PLANES: |
||||
drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay: " |
||||
"no free overlay planes\n", ev); |
||||
break; |
||||
case NO_PLANES_WITH_FORMAT: |
||||
drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay: " |
||||
"no free overlay planes matching format %s (0x%lx) " |
||||
"modifier 0x%llx\n", |
||||
ev, fb->format->drm_format_name, |
||||
(unsigned long) fb->format, |
||||
(unsigned long long) fb->modifier); |
||||
break; |
||||
case NO_PLANES_ACCEPTED: |
||||
case PLACED_ON_PLANE: |
||||
break; |
||||
} |
||||
|
||||
out: |
||||
drm_fb_unref(fb); |
||||
return state; |
||||
} |
||||
|
||||
/**
|
||||
* Update the image for the current cursor surface |
||||
* |
||||
* @param plane_state DRM cursor plane state |
||||
* @param ev Source view for cursor |
||||
*/ |
||||
static void |
||||
cursor_bo_update(struct drm_plane_state *plane_state, struct weston_view *ev) |
||||
{ |
||||
struct drm_backend *b = plane_state->plane->backend; |
||||
struct gbm_bo *bo = plane_state->fb->bo; |
||||
struct weston_buffer *buffer = ev->surface->buffer_ref.buffer; |
||||
uint32_t buf[b->cursor_width * b->cursor_height]; |
||||
int32_t stride; |
||||
uint8_t *s; |
||||
int i; |
||||
|
||||
assert(buffer && buffer->shm_buffer); |
||||
assert(buffer->shm_buffer == wl_shm_buffer_get(buffer->resource)); |
||||
assert(buffer->width <= b->cursor_width); |
||||
assert(buffer->height <= b->cursor_height); |
||||
|
||||
memset(buf, 0, sizeof buf); |
||||
stride = wl_shm_buffer_get_stride(buffer->shm_buffer); |
||||
s = wl_shm_buffer_get_data(buffer->shm_buffer); |
||||
|
||||
wl_shm_buffer_begin_access(buffer->shm_buffer); |
||||
for (i = 0; i < buffer->height; i++) |
||||
memcpy(buf + i * b->cursor_width, |
||||
s + i * stride, |
||||
buffer->width * 4); |
||||
wl_shm_buffer_end_access(buffer->shm_buffer); |
||||
|
||||
if (gbm_bo_write(bo, buf, sizeof buf) < 0) |
||||
weston_log("failed update cursor: %s\n", strerror(errno)); |
||||
} |
||||
|
||||
static struct drm_plane_state * |
||||
drm_output_prepare_cursor_view(struct drm_output_state *output_state, |
||||
struct weston_view *ev) |
||||
{ |
||||
struct drm_output *output = output_state->output; |
||||
struct drm_backend *b = to_drm_backend(output->base.compositor); |
||||
struct drm_plane *plane = output->cursor_plane; |
||||
struct drm_plane_state *plane_state; |
||||
struct wl_shm_buffer *shmbuf; |
||||
bool needs_update = false; |
||||
|
||||
assert(!b->cursors_are_broken); |
||||
|
||||
if (!plane) |
||||
return NULL; |
||||
|
||||
if (!plane->state_cur->complete) |
||||
return NULL; |
||||
|
||||
if (plane->state_cur->output && plane->state_cur->output != output) |
||||
return NULL; |
||||
|
||||
/* We use GBM to import SHM buffers. */ |
||||
if (b->gbm == NULL) |
||||
return NULL; |
||||
|
||||
if (ev->surface->buffer_ref.buffer == NULL) { |
||||
drm_debug(b, "\t\t\t\t[cursor] not assigning view %p to cursor plane " |
||||
"(no buffer available)\n", ev); |
||||
return NULL; |
||||
} |
||||
shmbuf = wl_shm_buffer_get(ev->surface->buffer_ref.buffer->resource); |
||||
if (!shmbuf) { |
||||
drm_debug(b, "\t\t\t\t[cursor] not assigning view %p to cursor plane " |
||||
"(buffer isn't SHM)\n", ev); |
||||
return NULL; |
||||
} |
||||
if (wl_shm_buffer_get_format(shmbuf) != WL_SHM_FORMAT_ARGB8888) { |
||||
drm_debug(b, "\t\t\t\t[cursor] not assigning view %p to cursor plane " |
||||
"(format 0x%lx unsuitable)\n", |
||||
ev, (unsigned long) wl_shm_buffer_get_format(shmbuf)); |
||||
return NULL; |
||||
} |
||||
|
||||
plane_state = |
||||
drm_output_state_get_plane(output_state, output->cursor_plane); |
||||
|
||||
if (plane_state && plane_state->fb) |
||||
return NULL; |
||||
|
||||
/* 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_view(plane_state, ev)) |
||||
goto err; |
||||
|
||||
if (plane_state->src_x != 0 || plane_state->src_y != 0 || |
||||
plane_state->src_w > (unsigned) b->cursor_width << 16 || |
||||
plane_state->src_h > (unsigned) b->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[cursor] not assigning view %p to cursor plane " |
||||
"(positioning requires cropping or scaling)\n", ev); |
||||
goto err; |
||||
} |
||||
|
||||
/* Since we're setting plane state up front, we need to work out
|
||||
* whether or not we need to upload a new cursor. We can't use the |
||||
* plane damage, since the planes haven't actually been calculated |
||||
* yet: instead try to figure it out directly. KMS cursor planes are |
||||
* pretty unique here, in that they lie partway between a Weston plane |
||||
* (direct scanout) and a renderer. */ |
||||
if (ev != output->cursor_view || |
||||
pixman_region32_not_empty(&ev->surface->damage)) { |
||||
output->current_cursor++; |
||||
output->current_cursor = |
||||
output->current_cursor % |
||||
ARRAY_LENGTH(output->gbm_cursor_fb); |
||||
needs_update = true; |
||||
} |
||||
|
||||
output->cursor_view = ev; |
||||
plane_state->ev = ev; |
||||
|
||||
plane_state->fb = |
||||
drm_fb_ref(output->gbm_cursor_fb[output->current_cursor]); |
||||
|
||||
if (needs_update) { |
||||
drm_debug(b, "\t\t\t\t[cursor] copying new content to cursor BO\n"); |
||||
cursor_bo_update(plane_state, ev); |
||||
} |
||||
|
||||
/* 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 = b->cursor_width << 16; |
||||
plane_state->src_h = b->cursor_height << 16; |
||||
plane_state->dest_w = b->cursor_width; |
||||
plane_state->dest_h = b->cursor_height; |
||||
|
||||
drm_debug(b, "\t\t\t\t[cursor] provisionally assigned view %p to cursor\n", |
||||
ev); |
||||
|
||||
return plane_state; |
||||
|
||||
err: |
||||
drm_plane_state_put_back(plane_state); |
||||
return NULL; |
||||
} |
||||
|
||||
static struct drm_plane_state * |
||||
drm_output_prepare_scanout_view(struct drm_output_state *output_state, |
||||
struct weston_view *ev, |
||||
enum drm_output_propose_state_mode mode) |
||||
{ |
||||
struct drm_output *output = output_state->output; |
||||
struct drm_backend *b = to_drm_backend(output->base.compositor); |
||||
struct drm_plane *scanout_plane = output->scanout_plane; |
||||
struct drm_plane_state *state; |
||||
struct drm_fb *fb; |
||||
pixman_box32_t *extents; |
||||
|
||||
assert(!b->sprites_are_broken); |
||||
assert(b->atomic_modeset); |
||||
assert(mode == DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY); |
||||
|
||||
/* Check the view spans exactly the output size, calculated in the
|
||||
* logical co-ordinate space. */ |
||||
extents = pixman_region32_extents(&ev->transform.boundingbox); |
||||
if (extents->x1 != output->base.x || |
||||
extents->y1 != output->base.y || |
||||
extents->x2 != output->base.x + output->base.width || |
||||
extents->y2 != output->base.y + output->base.height) |
||||
return NULL; |
||||
|
||||
/* 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 && |
||||
scanout_plane->props[WDRM_PLANE_IN_FENCE_FD].prop_id == 0) |
||||
return NULL; |
||||
|
||||
fb = drm_fb_get_from_view(output_state, ev); |
||||
if (!fb) { |
||||
drm_debug(b, "\t\t\t\t[scanout] not placing view %p on scanout: " |
||||
" couldn't get fb\n", ev); |
||||
return NULL; |
||||
} |
||||
|
||||
state = drm_output_state_get_plane(output_state, scanout_plane); |
||||
|
||||
/* The only way we can already have a buffer in the scanout plane is
|
||||
* if we are in mixed mode, or if a client buffer has already been |
||||
* placed into scanout. The former case will never call into here, |
||||
* and in the latter case, the view must have been marked as occluded, |
||||
* meaning we should never have ended up here. */ |
||||
assert(!state->fb); |
||||
state->fb = fb; |
||||
state->ev = ev; |
||||
state->output = output; |
||||
if (!drm_plane_state_coords_for_view(state, ev)) |
||||
goto err; |
||||
|
||||
if (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) |
||||
goto err; |
||||
|
||||
state->in_fence_fd = ev->surface->acquire_fence_fd; |
||||
|
||||
/* In plane-only mode, we don't need to test the state now, as we
|
||||
* will only test it once at the end. */ |
||||
return state; |
||||
|
||||
err: |
||||
drm_plane_state_put_back(state); |
||||
return NULL; |
||||
} |
||||
|
||||
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_backend *b = to_drm_backend(output->base.compositor); |
||||
struct drm_output_state *state; |
||||
struct drm_plane_state *scanout_state = NULL; |
||||
struct weston_view *ev; |
||||
pixman_region32_t surface_overlap, renderer_region, occluded_region; |
||||
bool planes_ok = (mode != DRM_OUTPUT_PROPOSE_STATE_RENDERER_ONLY); |
||||
bool renderer_ok = (mode != DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY); |
||||
int ret; |
||||
|
||||
assert(!output->state_last); |
||||
state = drm_output_state_duplicate(output->state_cur, |
||||
pending_state, |
||||
DRM_OUTPUT_STATE_CLEAR_PLANES); |
||||
|
||||
/* 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); |
||||
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); |
||||
} |
||||
|
||||
/*
|
||||
* Find a surface for each sprite in the output using some heuristics: |
||||
* 1) size |
||||
* 2) frequency of update |
||||
* 3) opacity (though some hw might support alpha blending) |
||||
* 4) clipping (this can be fixed with color keys) |
||||
* |
||||
* The idea is to save on blitting since this should save power. |
||||
* If we can get a large video surface on the sprite for example, |
||||
* the main display surface may not need to update at all, and |
||||
* the client buffer can be used directly for the sprite surface |
||||
* as we do for flipping full screen surfaces. |
||||
*/ |
||||
pixman_region32_init(&renderer_region); |
||||
pixman_region32_init(&occluded_region); |
||||
|
||||
wl_list_for_each(ev, &output_base->compositor->view_list, link) { |
||||
struct drm_plane_state *ps = NULL; |
||||
bool force_renderer = false; |
||||
pixman_region32_t clipped_view; |
||||
bool totally_occluded = false; |
||||
bool overlay_occluded = 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); |
||||
|
||||
/* If this view doesn't touch our output at all, there's no
|
||||
* reason to do anything with it. */ |
||||
if (!(ev->output_mask & (1u << output->base.id))) { |
||||
drm_debug(b, "\t\t\t\t[view] ignoring view %p " |
||||
"(not on our output)\n", ev); |
||||
continue; |
||||
} |
||||
|
||||
/* We only assign planes to views which are exclusively present
|
||||
* on our output. */ |
||||
if (ev->output_mask != (1u << output->base.id)) { |
||||
drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane " |
||||
"(on multiple outputs)\n", ev); |
||||
force_renderer = true; |
||||
} |
||||
|
||||
if (!ev->surface->buffer_ref.buffer) { |
||||
drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane " |
||||
"(no buffer available)\n", ev); |
||||
force_renderer = true; |
||||
} |
||||
|
||||
/* 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); |
||||
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; |
||||
} |
||||
|
||||
/* 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 a plane. */ |
||||
pixman_region32_intersect(&surface_overlap, &renderer_region, |
||||
&clipped_view); |
||||
if (pixman_region32_not_empty(&surface_overlap)) { |
||||
drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane " |
||||
"(occluded by renderer views)\n", ev); |
||||
force_renderer = true; |
||||
} |
||||
|
||||
/* We do not control the stacking order of overlay planes;
|
||||
* the scanout plane is strictly stacked bottom and the cursor |
||||
* plane top, but the ordering of overlay planes with respect |
||||
* to each other is undefined. Make sure we do not have two |
||||
* planes overlapping each other. */ |
||||
pixman_region32_intersect(&surface_overlap, &occluded_region, |
||||
&clipped_view); |
||||
if (pixman_region32_not_empty(&surface_overlap)) { |
||||
drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane " |
||||
"(occluded by other overlay planes)\n", ev); |
||||
overlay_occluded = true; |
||||
} |
||||
pixman_region32_fini(&surface_overlap); |
||||
|
||||
/* The cursor plane is 'special' in the sense that we can still
|
||||
* place it in the legacy API, and we gate that with a separate |
||||
* cursors_are_broken flag. */ |
||||
if (!force_renderer && !overlay_occluded && !b->cursors_are_broken) |
||||
ps = drm_output_prepare_cursor_view(state, ev); |
||||
|
||||
/* If sprites are disabled or the view is not fully opaque, we
|
||||
* must put the view into the renderer - unless it has already |
||||
* been placed in the cursor plane, which can handle alpha. */ |
||||
if (!ps && !planes_ok) { |
||||
drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane " |
||||
"(precluded by mode)\n", ev); |
||||
force_renderer = true; |
||||
} |
||||
if (!ps && !weston_view_is_opaque(ev, &clipped_view)) { |
||||
drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane " |
||||
"(view not fully opaque)\n", ev); |
||||
force_renderer = true; |
||||
} |
||||
|
||||
/* Only try to place scanout surfaces in planes-only mode; in
|
||||
* mixed mode, we have already failed to place a view on the |
||||
* scanout surface, forcing usage of the renderer on the |
||||
* scanout plane. */ |
||||
if (!ps && !force_renderer && !renderer_ok) |
||||
ps = drm_output_prepare_scanout_view(state, ev, mode); |
||||
|
||||
if (!ps && !overlay_occluded && !force_renderer) |
||||
ps = drm_output_prepare_overlay_view(state, ev, mode); |
||||
|
||||
if (ps) { |
||||
/* If we have been assigned to an overlay or scanout
|
||||
* plane, add this area to the occluded region, so |
||||
* other views are known to be behind it. The cursor |
||||
* plane, however, is special, in that it blends with |
||||
* the content underneath it: the area should neither |
||||
* be added to the renderer region nor the occluded |
||||
* region. */ |
||||
if (ps->plane->type != WDRM_PLANE_TYPE_CURSOR) { |
||||
pixman_region32_union(&occluded_region, |
||||
&occluded_region, |
||||
&clipped_view); |
||||
pixman_region32_fini(&clipped_view); |
||||
} |
||||
continue; |
||||
} |
||||
|
||||
/* We have been assigned to the primary (renderer) plane:
|
||||
* check if this is OK, and add ourselves to the renderer |
||||
* region if so. */ |
||||
if (!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; |
||||
} |
||||
|
||||
pixman_region32_union(&renderer_region, |
||||
&renderer_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 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, void *repaint_data) |
||||
{ |
||||
struct drm_backend *b = to_drm_backend(output_base->compositor); |
||||
struct drm_pending_state *pending_state = repaint_data; |
||||
struct drm_output *output = to_drm_output(output_base); |
||||
struct drm_output_state *state = NULL; |
||||
struct drm_plane_state *plane_state; |
||||
struct weston_view *ev; |
||||
struct weston_plane *primary = &output_base->compositor->primary_plane; |
||||
enum drm_output_propose_state_mode mode = DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY; |
||||
|
||||
drm_debug(b, "\t[repaint] preparing state for output %s (%lu)\n", |
||||
output_base->name, (unsigned long) output_base->id); |
||||
|
||||
if (!b->sprites_are_broken && !output->virtual) { |
||||
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); |
||||
} |
||||
if (!state) { |
||||
drm_debug(b, "\t[repaint] could not build mixed-mode " |
||||
"state, trying renderer-only\n"); |
||||
} |
||||
} else { |
||||
drm_debug(b, "\t[state] no overlay plane support\n"); |
||||
} |
||||
|
||||
if (!state) { |
||||
mode = DRM_OUTPUT_PROPOSE_STATE_RENDERER_ONLY; |
||||
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(ev, &output_base->compositor->view_list, link) { |
||||
struct drm_plane *target_plane = NULL; |
||||
|
||||
/* If this view doesn't touch our output at all, there's no
|
||||
* reason to do anything with it. */ |
||||
if (!(ev->output_mask & (1u << output->base.id))) |
||||
continue; |
||||
|
||||
/* Test whether this buffer can ever go into a plane:
|
||||
* non-shm, or small enough to be a cursor. |
||||
* |
||||
* Also, keep a reference when using the pixman renderer. |
||||
* That makes it possible to do a seamless switch to the GL |
||||
* renderer and since the pixman renderer keeps a reference |
||||
* to the buffer anyway, there is no side effects. |
||||
*/ |
||||
if (b->use_pixman || |
||||
(ev->surface->buffer_ref.buffer && |
||||
(!wl_shm_buffer_get(ev->surface->buffer_ref.buffer->resource) || |
||||
(ev->surface->width <= b->cursor_width && |
||||
ev->surface->height <= b->cursor_height)))) |
||||
ev->surface->keep_buffer = true; |
||||
else |
||||
ev->surface->keep_buffer = false; |
||||
|
||||
/* 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, plane_type_enums[target_plane->type].name, |
||||
(unsigned long) target_plane->plane_id); |
||||
weston_view_move_to_plane(ev, &target_plane->base); |
||||
} else { |
||||
drm_debug(b, "\t[repaint] view %p using renderer " |
||||
"composition\n", ev); |
||||
weston_view_move_to_plane(ev, primary); |
||||
} |
||||
|
||||
if (!target_plane || |
||||
target_plane->type == WDRM_PLANE_TYPE_CURSOR) { |
||||
/* cursor plane & renderer involve a copy */ |
||||
ev->psf_flags = 0; |
||||
} else { |
||||
/* All other planes are a direct scanout of a
|
||||
* single client buffer. |
||||
*/ |
||||
ev->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_view. 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) |
||||
output->cursor_view = NULL; |
||||
} |
||||
} |
||||
Loading…
Reference in new issue