f95d81e88b
The window buffer mechanism would free the pixmap and its corresponding
Wayland buffer as soon as window buffers are disposed.
Typically when the X11 window is unrealized, the current window buffer
is still used by the Wayland compositor and yet Xwayland will destroy
the buffer.
As a matter of fact, Xwayland should not destroy the Wayland buffer
before the wl_buffer.release event is received.
Add a reference counter to the window buffer similar to the to pixmap
reference counter to keep the buffer around until the release callback
is received.
Increase that reference counter on the buffer which will be attached to
the surface, and drop that reference when receiving the release callback
notification.
v2: Use a specific reference counter on the buffer rather than relying
on the pixmap refcnt (Michel Dänzer <mdaenzer@redhat.com>)
Signed-off-by: Olivier Fourdan <ofourdan@redhat.com>
Reviewed-by: Michel Dänzer <mdaenzer@redhat.com>
Acked-by: Martin Peres <martin.peres@mupuf.org>
368 lines
13 KiB
C
368 lines
13 KiB
C
/*
|
|
* Copyright © 2019 Red Hat, Inc.
|
|
*
|
|
* 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.
|
|
*
|
|
* Authors:
|
|
* Olivier Fourdan <ofourdan@redhat.com>
|
|
*/
|
|
|
|
#include <xwayland-config.h>
|
|
|
|
#include "gcstruct.h"
|
|
|
|
#include "xwayland-window.h"
|
|
#include "xwayland-pixmap.h"
|
|
#include "xwayland-screen.h"
|
|
#include "xwayland-window-buffers.h"
|
|
|
|
#define BUFFER_TIMEOUT 1 * 1000 /* ms */
|
|
|
|
struct xwl_window_buffer {
|
|
struct xwl_window *xwl_window;
|
|
PixmapPtr pixmap;
|
|
RegionPtr damage_region;
|
|
Bool recycle_on_release;
|
|
int refcnt;
|
|
uint32_t time;
|
|
struct xorg_list link_buffer;
|
|
};
|
|
|
|
static Bool
|
|
copy_pixmap_area(PixmapPtr src_pixmap, PixmapPtr dst_pixmap,
|
|
int x, int y, int width, int height)
|
|
{
|
|
GCPtr pGC;
|
|
pGC = GetScratchGC(dst_pixmap->drawable.depth,
|
|
dst_pixmap->drawable.pScreen);
|
|
if (pGC) {
|
|
ValidateGC(&dst_pixmap->drawable, pGC);
|
|
(void) (*pGC->ops->CopyArea) (&src_pixmap->drawable,
|
|
&dst_pixmap->drawable,
|
|
pGC,
|
|
x, y,
|
|
width, height,
|
|
x, y);
|
|
FreeScratchGC(pGC);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static struct xwl_window_buffer *
|
|
xwl_window_buffer_new(struct xwl_window *xwl_window)
|
|
{
|
|
struct xwl_window_buffer *xwl_window_buffer;
|
|
|
|
xwl_window_buffer = calloc (1, sizeof(struct xwl_window_buffer));
|
|
if (!xwl_window_buffer)
|
|
return NULL;
|
|
|
|
xwl_window_buffer->xwl_window = xwl_window;
|
|
xwl_window_buffer->damage_region = RegionCreate(NullBox, 1);
|
|
xwl_window_buffer->pixmap = NullPixmap;
|
|
xwl_window_buffer->refcnt = 1;
|
|
|
|
xorg_list_append(&xwl_window_buffer->link_buffer,
|
|
&xwl_window->window_buffers_available);
|
|
|
|
return xwl_window_buffer;
|
|
}
|
|
|
|
static void
|
|
xwl_window_buffer_destroy_pixmap(struct xwl_window_buffer *xwl_window_buffer)
|
|
{
|
|
ScreenPtr pScreen = xwl_window_buffer->pixmap->drawable.pScreen;
|
|
|
|
xwl_pixmap_del_buffer_release_cb(xwl_window_buffer->pixmap);
|
|
(*pScreen->DestroyPixmap) (xwl_window_buffer->pixmap);
|
|
xwl_window_buffer->pixmap = NullPixmap;
|
|
}
|
|
|
|
static Bool
|
|
xwl_window_buffer_dispose(struct xwl_window_buffer *xwl_window_buffer)
|
|
{
|
|
assert(xwl_window_buffer->refcnt > 0);
|
|
|
|
if (--xwl_window_buffer->refcnt)
|
|
return FALSE;
|
|
|
|
RegionDestroy(xwl_window_buffer->damage_region);
|
|
|
|
if (xwl_window_buffer->pixmap)
|
|
xwl_window_buffer_destroy_pixmap (xwl_window_buffer);
|
|
|
|
xorg_list_del(&xwl_window_buffer->link_buffer);
|
|
free(xwl_window_buffer);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
xwl_window_buffer_recycle(struct xwl_window_buffer *xwl_window_buffer)
|
|
{
|
|
RegionEmpty(xwl_window_buffer->damage_region);
|
|
xwl_window_buffer->recycle_on_release = FALSE;
|
|
|
|
if (xwl_window_buffer->pixmap)
|
|
xwl_window_buffer_destroy_pixmap (xwl_window_buffer);
|
|
}
|
|
|
|
static void
|
|
xwl_window_buffer_add_damage_region(struct xwl_window *xwl_window,
|
|
RegionPtr damage_region)
|
|
{
|
|
struct xwl_window_buffer *xwl_window_buffer;
|
|
|
|
/* Add damage region to all buffers */
|
|
xorg_list_for_each_entry(xwl_window_buffer,
|
|
&xwl_window->window_buffers_available,
|
|
link_buffer) {
|
|
RegionUnion(xwl_window_buffer->damage_region,
|
|
xwl_window_buffer->damage_region,
|
|
damage_region);
|
|
}
|
|
xorg_list_for_each_entry(xwl_window_buffer,
|
|
&xwl_window->window_buffers_unavailable,
|
|
link_buffer) {
|
|
RegionUnion(xwl_window_buffer->damage_region,
|
|
xwl_window_buffer->damage_region,
|
|
damage_region);
|
|
}
|
|
}
|
|
|
|
static struct xwl_window_buffer *
|
|
xwl_window_buffer_get_available(struct xwl_window *xwl_window)
|
|
{
|
|
if (xorg_list_is_empty(&xwl_window->window_buffers_available))
|
|
return xwl_window_buffer_new(xwl_window);
|
|
|
|
return xorg_list_last_entry(&xwl_window->window_buffers_available,
|
|
struct xwl_window_buffer,
|
|
link_buffer);
|
|
}
|
|
|
|
static CARD32
|
|
xwl_window_buffer_timer_callback(OsTimerPtr timer, CARD32 time, void *arg)
|
|
{
|
|
struct xwl_window *xwl_window = arg;
|
|
struct xwl_window_buffer *xwl_window_buffer, *tmp;
|
|
|
|
/* Dispose older available buffers */
|
|
xorg_list_for_each_entry_safe(xwl_window_buffer, tmp,
|
|
&xwl_window->window_buffers_available,
|
|
link_buffer) {
|
|
if ((int64_t)(time - xwl_window_buffer->time) >= BUFFER_TIMEOUT)
|
|
xwl_window_buffer_dispose(xwl_window_buffer);
|
|
}
|
|
|
|
/* If there are still available buffers, re-arm the timer */
|
|
if (!xorg_list_is_empty(&xwl_window->window_buffers_available)) {
|
|
struct xwl_window_buffer *oldest_available_buffer =
|
|
xorg_list_first_entry(&xwl_window->window_buffers_available,
|
|
struct xwl_window_buffer,
|
|
link_buffer);
|
|
|
|
return oldest_available_buffer->time + BUFFER_TIMEOUT - time;
|
|
}
|
|
|
|
/* Don't re-arm the timer */
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
xwl_window_buffer_release_callback(void *data)
|
|
{
|
|
struct xwl_window_buffer *xwl_window_buffer = data;
|
|
struct xwl_window *xwl_window = xwl_window_buffer->xwl_window;
|
|
struct xwl_window_buffer *oldest_available_buffer;
|
|
|
|
/* Drop the reference on the buffer we took in get_pixmap. If that
|
|
* frees the window buffer, we're done.
|
|
*/
|
|
if (xwl_window_buffer_dispose(xwl_window_buffer))
|
|
return;
|
|
|
|
if (xwl_window_buffer->recycle_on_release)
|
|
xwl_window_buffer_recycle(xwl_window_buffer);
|
|
|
|
/* We append the buffers to the end of the list, as we pick the last
|
|
* entry again when looking for new available buffers, that means the
|
|
* least used buffers will remain at the beginning of the list so that
|
|
* they can be garbage collected automatically after some time unused.
|
|
*/
|
|
|
|
xorg_list_del(&xwl_window_buffer->link_buffer);
|
|
xorg_list_append(&xwl_window_buffer->link_buffer,
|
|
&xwl_window->window_buffers_available);
|
|
xwl_window_buffer->time = (uint32_t) GetTimeInMillis();
|
|
|
|
oldest_available_buffer =
|
|
xorg_list_first_entry(&xwl_window->window_buffers_available,
|
|
struct xwl_window_buffer,
|
|
link_buffer);
|
|
|
|
/* Schedule next timer based on time of the oldest buffer */
|
|
xwl_window->window_buffers_timer =
|
|
TimerSet(xwl_window->window_buffers_timer,
|
|
TimerAbsolute,
|
|
oldest_available_buffer->time + BUFFER_TIMEOUT,
|
|
&xwl_window_buffer_timer_callback,
|
|
xwl_window);
|
|
}
|
|
|
|
void
|
|
xwl_window_buffers_init(struct xwl_window *xwl_window)
|
|
{
|
|
xorg_list_init(&xwl_window->window_buffers_available);
|
|
xorg_list_init(&xwl_window->window_buffers_unavailable);
|
|
}
|
|
|
|
void
|
|
xwl_window_buffers_recycle(struct xwl_window *xwl_window)
|
|
{
|
|
struct xwl_window_buffer *xwl_window_buffer, *tmp;
|
|
|
|
/* Dispose available buffers */
|
|
xorg_list_for_each_entry_safe(xwl_window_buffer, tmp,
|
|
&xwl_window->window_buffers_available,
|
|
link_buffer) {
|
|
xwl_window_buffer_dispose(xwl_window_buffer);
|
|
}
|
|
|
|
if (xwl_window->window_buffers_timer)
|
|
TimerCancel(xwl_window->window_buffers_timer);
|
|
|
|
/* Mark the others for recycle on release */
|
|
xorg_list_for_each_entry(xwl_window_buffer,
|
|
&xwl_window->window_buffers_unavailable,
|
|
link_buffer) {
|
|
xwl_window_buffer->recycle_on_release = TRUE;
|
|
}
|
|
}
|
|
|
|
void
|
|
xwl_window_buffers_dispose(struct xwl_window *xwl_window)
|
|
{
|
|
struct xwl_window_buffer *xwl_window_buffer, *tmp;
|
|
|
|
/* This is called prior to free the xwl_window, make sure to untie
|
|
* the buffers from the xwl_window so that we don't point at freed
|
|
* memory if we get a release buffer later.
|
|
*/
|
|
xorg_list_for_each_entry_safe(xwl_window_buffer, tmp,
|
|
&xwl_window->window_buffers_available,
|
|
link_buffer) {
|
|
xorg_list_del(&xwl_window_buffer->link_buffer);
|
|
xwl_window_buffer_dispose(xwl_window_buffer);
|
|
}
|
|
|
|
xorg_list_for_each_entry_safe(xwl_window_buffer, tmp,
|
|
&xwl_window->window_buffers_unavailable,
|
|
link_buffer) {
|
|
xorg_list_del(&xwl_window_buffer->link_buffer);
|
|
xwl_window_buffer_dispose(xwl_window_buffer);
|
|
}
|
|
|
|
if (xwl_window->window_buffers_timer) {
|
|
TimerFree(xwl_window->window_buffers_timer);
|
|
xwl_window->window_buffers_timer = 0;
|
|
}
|
|
}
|
|
|
|
PixmapPtr
|
|
xwl_window_buffers_get_pixmap(struct xwl_window *xwl_window,
|
|
RegionPtr damage_region)
|
|
{
|
|
struct xwl_screen *xwl_screen = xwl_window->xwl_screen;
|
|
struct xwl_window_buffer *xwl_window_buffer;
|
|
PixmapPtr window_pixmap;
|
|
RegionPtr full_damage;
|
|
|
|
window_pixmap = (*xwl_screen->screen->GetWindowPixmap) (xwl_window->window);
|
|
|
|
#ifdef XWL_HAS_GLAMOR
|
|
if (!xwl_glamor_needs_n_buffering(xwl_screen))
|
|
return window_pixmap;
|
|
#endif /* XWL_HAS_GLAMOR */
|
|
|
|
xwl_window_buffer = xwl_window_buffer_get_available(xwl_window);
|
|
if (!xwl_window_buffer)
|
|
return window_pixmap;
|
|
|
|
xwl_window_buffer_add_damage_region(xwl_window, damage_region);
|
|
|
|
full_damage = xwl_window_buffer->damage_region;
|
|
|
|
if (xwl_window_buffer->pixmap) {
|
|
BoxPtr pBox = RegionRects(full_damage);
|
|
int nBox = RegionNumRects(full_damage);
|
|
while (nBox--) {
|
|
if (!copy_pixmap_area(window_pixmap,
|
|
xwl_window_buffer->pixmap,
|
|
pBox->x1 + xwl_window->window->borderWidth,
|
|
pBox->y1 + xwl_window->window->borderWidth,
|
|
pBox->x2 - pBox->x1,
|
|
pBox->y2 - pBox->y1))
|
|
return window_pixmap;
|
|
|
|
pBox++;
|
|
}
|
|
} else {
|
|
xwl_window_buffer->pixmap =
|
|
(*xwl_screen->screen->CreatePixmap) (window_pixmap->drawable.pScreen,
|
|
window_pixmap->drawable.width,
|
|
window_pixmap->drawable.height,
|
|
window_pixmap->drawable.depth,
|
|
CREATE_PIXMAP_USAGE_BACKING_PIXMAP);
|
|
|
|
if (!xwl_window_buffer->pixmap)
|
|
return window_pixmap;
|
|
|
|
if (!copy_pixmap_area(window_pixmap,
|
|
xwl_window_buffer->pixmap,
|
|
0, 0,
|
|
window_pixmap->drawable.width,
|
|
window_pixmap->drawable.height)) {
|
|
xwl_window_buffer_recycle(xwl_window_buffer);
|
|
return window_pixmap;
|
|
}
|
|
}
|
|
|
|
RegionEmpty(xwl_window_buffer->damage_region);
|
|
|
|
/* Hold a reference on the buffer until it's released by the compositor */
|
|
xwl_window_buffer->refcnt++;
|
|
xwl_pixmap_set_buffer_release_cb(xwl_window_buffer->pixmap,
|
|
xwl_window_buffer_release_callback,
|
|
xwl_window_buffer);
|
|
|
|
xorg_list_del(&xwl_window_buffer->link_buffer);
|
|
xorg_list_append(&xwl_window_buffer->link_buffer,
|
|
&xwl_window->window_buffers_unavailable);
|
|
|
|
if (xorg_list_is_empty(&xwl_window->window_buffers_available))
|
|
TimerCancel(xwl_window->window_buffers_timer);
|
|
|
|
return xwl_window_buffer->pixmap;
|
|
}
|