isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-09-19 22:15:54 -04:00
Code Issues Packages Projects Releases Wiki Activity

renderer: drop wayland client support

Browse Source
This commit is contained in:
Ray Strode 2016-01-12 16:57:53 -05:00 committed by Rui Matos
parent b5648dc0cb
commit 865da1457a
13 changed files with 0 additions and 1200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
cogl/Makefile.am
View File

@ -452,14 +452,6 @@ endif
if SUPPORT_WAYLAND_EGL_SERVER
cogl_experimental_h += cogl-wayland-server.h
endif
if SUPPORT_EGL_PLATFORM_WAYLAND
cogl_experimental_h += \
cogl-wayland-renderer.h \
cogl-wayland-client.h
cogl_sources_c += \
winsys/cogl-winsys-egl-wayland.c \
winsys/cogl-winsys-egl-wayland-private.h
endif
if SUPPORT_EGL_PLATFORM_KMS
cogl_experimental_h += \
cogl-kms-renderer.h \

4
cogl/cogl-onscreen-private.h
View File

@ -65,10 +65,6 @@ struct _CoglOnscreen
void *foreign_update_mask_data;
#endif
#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT
struct wl_surface *foreign_surface;
#endif
CoglBool swap_throttled;
CoglList frame_closures;

67
cogl/cogl-onscreen.h
View File

@ -166,73 +166,6 @@ uint32_t
cogl_x11_onscreen_get_visual_xid (CoglOnscreen *onscreen);
#endif /* COGL_HAS_X11 */
#if defined (COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT)
struct wl_surface *
cogl_wayland_onscreen_get_surface (CoglOnscreen *onscreen);
struct wl_shell_surface *
cogl_wayland_onscreen_get_shell_surface (CoglOnscreen *onscreen);
/**
* cogl_wayland_onscreen_set_foreign_surface:
* @onscreen: An unallocated framebuffer.
* @surface A Wayland surface to associate with the @onscreen.
*
* Allows you to explicitly notify Cogl of an existing Wayland surface to use,
* which prevents Cogl from allocating a surface and shell surface for the
* @onscreen. An allocated surface will not be destroyed when the @onscreen is
* freed.
*
* This function must be called before @onscreen is allocated.
*
* Since: 1.16
* Stability: unstable
*/
void
cogl_wayland_onscreen_set_foreign_surface (CoglOnscreen *onscreen,
struct wl_surface *surface);
/**
* cogl_wayland_onscreen_resize:
* @onscreen: A #CoglOnscreen framebuffer
* @width: The desired width of the framebuffer
* @height: The desired height of the framebuffer
* @offset_x: A relative x offset for the new framebuffer
* @offset_y: A relative y offset for the new framebuffer
*
* Resizes the backbuffer of the given @onscreen framebuffer to the
* given size. Since a buffer is usually conceptually scaled with a
* center point the @offset_x and @offset_y arguments allow the newly
* allocated buffer to be positioned relative to the old buffer size.
*
* For example a buffer that is being resized by moving the bottom right
* corner, and the top left corner is remaining static would use x and y
* offsets of (0, 0) since the top-left of the new buffer should have the same
* position as the old buffer. If the center of the old buffer is being zoomed
* into then all the corners of the new buffer move out from the center and the x
* and y offsets would be (-half_x_size_increase, -half_y_size_increase) where
* x/y_size_increase is how many pixels bigger the buffer is on the x and y
* axis.
*
* Note that if some drawing commands have been applied to the
* framebuffer since the last swap buffers then the resize will be
* queued and will only take effect in the next swap buffers.
*
* If multiple calls to cogl_wayland_onscreen_resize() get queued
* before the next swap buffers request then the relative x and y
* offsets accumulate instead of being replaced. The @width and
* @height values superseed the old values.
*
* Since: 1.10
* Stability: unstable
*/
void
cogl_wayland_onscreen_resize (CoglOnscreen *onscreen,
int width,
int height,
int offset_x,
int offset_y);
#endif /* COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT */
/**
* cogl_onscreen_set_swap_throttled:
* @onscreen: A #CoglOnscreen framebuffer

10
cogl/cogl-renderer-private.h
View File

@ -44,11 +44,6 @@
#include <X11/Xlib.h>
#endif
#if defined (COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT)
#include <wayland-client.h>
#endif
struct _CoglRenderer
{
CoglObject _parent;
@ -80,11 +75,6 @@ struct _CoglRenderer
GModule *libgl_module;
#endif
#if defined (COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT)
struct wl_display *foreign_wayland_display;
CoglBool wayland_enable_event_dispatch;
#endif
#if defined (COGL_HAS_EGL_PLATFORM_KMS_SUPPORT)
int kms_fd;
#endif

10
cogl/cogl-renderer.c
View File

@ -54,9 +54,6 @@
#ifdef COGL_HAS_EGL_PLATFORM_XLIB_SUPPORT
#include "cogl-winsys-egl-x11-private.h"
#endif
#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT
#include "cogl-winsys-egl-wayland-private.h"
#endif
#ifdef COGL_HAS_EGL_PLATFORM_KMS_SUPPORT
#include "cogl-winsys-egl-kms-private.h"
#endif
@ -171,9 +168,6 @@ static CoglWinsysVtableGetter _cogl_winsys_vtable_getters[] =
#ifdef COGL_HAS_EGL_PLATFORM_XLIB_SUPPORT
_cogl_winsys_egl_xlib_get_vtable,
#endif
#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT
_cogl_winsys_egl_wayland_get_vtable,
#endif
#ifdef COGL_HAS_EGL_PLATFORM_KMS_SUPPORT
_cogl_winsys_egl_kms_get_vtable,
#endif
@ -252,10 +246,6 @@ cogl_renderer_new (void)
renderer->xlib_enable_event_retrieval = TRUE;
#endif
#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT
renderer->wayland_enable_event_dispatch = TRUE;
#endif
#ifdef COGL_HAS_EGL_PLATFORM_KMS_SUPPORT
renderer->kms_fd = -1;
#endif

2
cogl/cogl-renderer.h
View File

@ -161,7 +161,6 @@ cogl_renderer_new (void);
* @COGL_WINSYS_ID_STUB: Use the no-op stub backend
* @COGL_WINSYS_ID_GLX: Use the GLX window system binding API
* @COGL_WINSYS_ID_EGL_XLIB: Use EGL with the X window system via XLib
* @COGL_WINSYS_ID_EGL_WAYLAND: Use EGL with the Wayland window system
* @COGL_WINSYS_ID_EGL_KMS: Use EGL with the KMS platform
*
* Identifies specific window system backends that Cogl supports.
@ -175,7 +174,6 @@ typedef enum
COGL_WINSYS_ID_STUB,
COGL_WINSYS_ID_GLX,
COGL_WINSYS_ID_EGL_XLIB,
COGL_WINSYS_ID_EGL_WAYLAND,
COGL_WINSYS_ID_EGL_KMS,
} CoglWinsysID;

64
cogl/cogl-wayland-client.h
View File

@ -1,64 +0,0 @@
/*
* Cogl
*
* A Low Level GPU Graphics and Utilities API
*
* Copyright (C) 2012 Intel Corporation.
*
* 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 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.
*
*/
#ifndef __COGL_WAYLAND_CLIENT_H
#define __COGL_WAYLAND_CLIENT_H
/* NB: this is a top-level header that can be included directly but we
* want to be careful not to define __COGL_H_INSIDE__ when this is
* included internally while building Cogl itself since
* __COGL_H_INSIDE__ is used in headers to guard public vs private api
* definitions
*/
#ifndef COGL_COMPILATION
/* Note: When building Cogl .gir we explicitly define
* __COGL_H_INSIDE__ */
#ifndef __COGL_H_INSIDE__
#define __COGL_H_INSIDE__
#define __COGL_MUST_UNDEF_COGL_H_INSIDE__
#endif
#endif /* COGL_COMPILATION */
#include <cogl/cogl-wayland-renderer.h>
/* The gobject introspection scanner seems to parse public headers in
* isolation which means we need to be extra careful about how we
* define and undefine __COGL_H_INSIDE__ used to detect when internal
* headers are incorrectly included by developers. In the gobject
* introspection case we have to manually define __COGL_H_INSIDE__ as
* a commandline argument for the scanner which means we must be
* careful not to undefine it in a header...
*/
#ifdef __COGL_MUST_UNDEF_COGL_H_INSIDE__
#undef __COGL_H_INSIDE__
#undef __COGL_MUST_UNDEF_COGL_H_INSIDE__
#endif
#endif /* __COGL_WAYLAND_CLIENT_H */

105
cogl/cogl-wayland-renderer.h
View File

@ -1,105 +0,0 @@
/*
* Cogl
*
* A Low Level GPU Graphics and Utilities API
*
* Copyright (C) 2011 Intel Corporation.
*
* 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 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.
*/
#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
#error "Only <cogl/cogl.h> can be included directly."
#endif
#ifndef __COGL_WAYLAND_RENDERER_H__
#define __COGL_WAYLAND_RENDERER_H__
#include <cogl/cogl-types.h>
#include <cogl/cogl-renderer.h>
#include <wayland-client.h>
COGL_BEGIN_DECLS
/**
* cogl_wayland_renderer_set_foreign_display:
* @renderer: A #CoglRenderer
* @display: A Wayland display
*
* Allows you to explicitly control what Wayland display you want Cogl
* to work with instead of leaving Cogl to automatically connect to a
* wayland compositor.
*
* Since: 1.8
* Stability: unstable
*/
void
cogl_wayland_renderer_set_foreign_display (CoglRenderer *renderer,
struct wl_display *display);
/**
* cogl_wayland_renderer_set_event_dispatch_enabled:
* @renderer: A #CoglRenderer
* @enable: The new value
*
* Sets whether Cogl should handle calling wl_display_dispatch() and
* wl_display_flush() as part of its main loop integration via
* cogl_poll_renderer_get_info() and cogl_poll_renderer_dispatch().
* The default value is %TRUE. When it is enabled the application can
* register listeners for Wayland interfaces and the callbacks will be
* invoked during cogl_poll_renderer_dispatch(). If the application
* wants to integrate with its own code that is already handling
* reading from the Wayland display socket, it should disable this to
* avoid having competing code read from the socket.
*
* Since: 1.16
* Stability: unstable
*/
void
cogl_wayland_renderer_set_event_dispatch_enabled (CoglRenderer *renderer,
CoglBool enable);
/**
* cogl_wayland_renderer_get_display:
* @renderer: A #CoglRenderer
*
* Retrieves the Wayland display that Cogl is using. If a foreign
* display has been specified using
* cogl_wayland_renderer_set_foreign_display() then that display will
* be returned. If no foreign display has been specified then the
* display that Cogl creates internally will be returned unless the
* renderer has not yet been connected (either implicitly or explicitly by
* calling cogl_renderer_connect()) in which case %NULL is returned.
*
* Returns: The wayland display currently associated with @renderer,
* or %NULL if the renderer hasn't yet been connected and no
* foreign display has been specified.
*
* Since: 1.8
* Stability: unstable
*/
struct wl_display *
cogl_wayland_renderer_get_display (CoglRenderer *renderer);
COGL_END_DECLS
#endif /* __COGL_WAYLAND_RENDERER_H__ */

11
cogl/cogl.symbols
View File

@ -1023,18 +1023,7 @@ cogl_winsys_feature_get_type
#ifdef COGL_HAS_WAYLAND_EGL_SERVER_SUPPORT
cogl_wayland_display_set_compositor_display
#endif
#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT
cogl_wayland_onscreen_get_shell_surface
cogl_wayland_onscreen_get_surface
#endif
#ifdef COGL_HAS_WAYLAND_EGL_SERVER_SUPPORT
cogl_wayland_onscreen_resize
#endif
#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT
cogl_wayland_onscreen_set_foreign_surface
#endif
#ifdef COGL_HAS_WAYLAND_EGL_SERVER_SUPPORT
cogl_wayland_renderer_get_display
cogl_wayland_renderer_set_event_dispatch_enabled
cogl_wayland_renderer_set_foreign_display

39
cogl/winsys/cogl-winsys-egl-wayland-private.h
View File

@ -1,39 +0,0 @@
/*
* Cogl
*
* A Low Level GPU Graphics and Utilities API
*
* Copyright (C) 2011 Intel Corporation.
*
* 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 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.
*
*
*/
#ifndef __COGL_WINSYS_EGL_WAYLAND_PRIVATE_H
#define __COGL_WINSYS_EGL_WAYLAND_PRIVATE_H
#include "cogl-winsys-private.h"
const CoglWinsysVtable *
_cogl_winsys_egl_wayland_get_vtable (void);
#endif /* __COGL_WINSYS_EGL_WAYLAND_PRIVATE_H */

853
cogl/winsys/cogl-winsys-egl-wayland.c
View File

@ -1,853 +0,0 @@
/*
* Cogl
*
* A Low Level GPU Graphics and Utilities API
*
* Copyright (C) 2011 Intel Corporation.
*
* 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 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:
* Robert Bragg <robert@linux.intel.com>
* Neil Roberts <neil@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <wayland-client.h>
#include <wayland-egl.h>
#include <string.h>
#include <errno.h>
#include "cogl-winsys-egl-wayland-private.h"
#include "cogl-winsys-egl-private.h"
#include "cogl-renderer-private.h"
#include "cogl-onscreen-private.h"
#include "cogl-wayland-renderer.h"
#include "cogl-error-private.h"
#include "cogl-poll-private.h"
#include "cogl-frame-info-private.h"
static const CoglWinsysEGLVtable _cogl_winsys_egl_vtable;
static const CoglWinsysVtable *parent_vtable;
typedef struct _CoglRendererWayland
{
struct wl_display *wayland_display;
struct wl_compositor *wayland_compositor;
struct wl_shell *wayland_shell;
struct wl_registry *wayland_registry;
int fd;
} CoglRendererWayland;
typedef struct _CoglDisplayWayland
{
struct wl_surface *dummy_wayland_surface;
struct wl_egl_window *dummy_wayland_egl_native_window;
} CoglDisplayWayland;
typedef struct _CoglOnscreenWayland
{
struct wl_egl_window *wayland_egl_native_window;
struct wl_surface *wayland_surface;
struct wl_shell_surface *wayland_shell_surface;
/* Resizing a wayland framebuffer doesn't take affect
* until the next swap buffers request, so we have to
* track the resize geometry until then... */
int pending_width;
int pending_height;
int pending_dx;
int pending_dy;
CoglBool has_pending;
CoglBool shell_surface_type_set;
CoglList frame_callbacks;
} CoglOnscreenWayland;
typedef struct
{
CoglList link;
CoglFrameInfo *frame_info;
struct wl_callback *callback;
CoglOnscreen *onscreen;
} FrameCallbackData;
static void
registry_handle_global_cb (void *data,
struct wl_registry *registry,
uint32_t id,
const char *interface,
uint32_t version)
{
CoglRendererEGL *egl_renderer = (CoglRendererEGL *)data;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
if (strcmp (interface, "wl_compositor") == 0)
wayland_renderer->wayland_compositor =
wl_registry_bind (registry, id, &wl_compositor_interface, 1);
else if (strcmp(interface, "wl_shell") == 0)
wayland_renderer->wayland_shell =
wl_registry_bind (registry, id, &wl_shell_interface, 1);
}
static void
registry_handle_global_remove_cb (void *data,
struct wl_registry *registry,
uint32_t name)
{
/* Nothing to do for now */
}
static void
_cogl_winsys_renderer_disconnect (CoglRenderer *renderer)
{
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
if (egl_renderer->edpy)
eglTerminate (egl_renderer->edpy);
if (wayland_renderer->wayland_display)
{
_cogl_poll_renderer_remove_fd (renderer, wayland_renderer->fd);
if (renderer->foreign_wayland_display == NULL)
wl_display_disconnect (wayland_renderer->wayland_display);
}
g_slice_free (CoglRendererWayland, egl_renderer->platform);
g_slice_free (CoglRendererEGL, egl_renderer);
}
static const struct wl_registry_listener registry_listener = {
registry_handle_global_cb,
registry_handle_global_remove_cb
};
static int64_t
prepare_wayland_display_events (void *user_data)
{
CoglRenderer *renderer = user_data;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
int flush_ret;
flush_ret = wl_display_flush (wayland_renderer->wayland_display);
if (flush_ret == -1)
{
/* If the socket buffer became full then we need to wake up the
* main loop once it is writable again */
if (errno == EAGAIN)
{
_cogl_poll_renderer_modify_fd (renderer,
wayland_renderer->fd,
COGL_POLL_FD_EVENT_IN |
COGL_POLL_FD_EVENT_OUT);
}
else if (errno != EINTR)
{
/* If the flush failed for some other reason then it's
* likely that it's going to consistently fail so we'll stop
* waiting on the file descriptor instead of making the
* application take up 100% CPU. FIXME: it would be nice if
* there was some way to report this to the application so
* that it can quit or recover */
_cogl_poll_renderer_remove_fd (renderer, wayland_renderer->fd);
}
}
/* Calling this here is a bit dodgy because Cogl usually tries to
* say that it won't do any event processing until
* cogl_poll_renderer_dispatch is called. However Wayland doesn't
* seem to provide any way to query whether the event queue is empty
* and we would need to do that in order to force the main loop to
* wake up to call it from dispatch. */
wl_display_dispatch_pending (wayland_renderer->wayland_display);
return -1;
}
static void
dispatch_wayland_display_events (void *user_data, int revents)
{
CoglRenderer *renderer = user_data;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
if ((revents & COGL_POLL_FD_EVENT_IN))
{
if (wl_display_dispatch (wayland_renderer->wayland_display) == -1 &&
errno != EAGAIN &&
errno != EINTR)
goto socket_error;
}
if ((revents & COGL_POLL_FD_EVENT_OUT))
{
int ret = wl_display_flush (wayland_renderer->wayland_display);
if (ret == -1)
{
if (errno != EAGAIN && errno != EINTR)
goto socket_error;
}
else
{
/* There is no more data to write so we don't need to wake
* up when the write buffer is emptied anymore */
_cogl_poll_renderer_modify_fd (renderer,
wayland_renderer->fd,
COGL_POLL_FD_EVENT_IN);
}
}
return;
socket_error:
/* If there was an error on the wayland socket then it's likely that
* it's going to consistently fail so we'll stop waiting on the file
* descriptor instead of making the application take up 100% CPU.
* FIXME: it would be nice if there was some way to report this to
* the application so that it can quit or recover */
_cogl_poll_renderer_remove_fd (renderer, wayland_renderer->fd);
}
static CoglBool
_cogl_winsys_renderer_connect (CoglRenderer *renderer,
CoglError **error)
{
CoglRendererEGL *egl_renderer;
CoglRendererWayland *wayland_renderer;
renderer->winsys = g_slice_new0 (CoglRendererEGL);
egl_renderer = renderer->winsys;
wayland_renderer = g_slice_new0 (CoglRendererWayland);
egl_renderer->platform = wayland_renderer;
egl_renderer->platform_vtable = &_cogl_winsys_egl_vtable;
if (renderer->foreign_wayland_display)
{
wayland_renderer->wayland_display = renderer->foreign_wayland_display;
}
else
{
wayland_renderer->wayland_display = wl_display_connect (NULL);
if (!wayland_renderer->wayland_display)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_INIT,
"Failed to connect wayland display");
goto error;
}
}
wayland_renderer->wayland_registry =
wl_display_get_registry (wayland_renderer->wayland_display);
wl_registry_add_listener (wayland_renderer->wayland_registry,
&registry_listener,
egl_renderer);
/*
* Ensure that that we've received the messages setting up the
* compostor and shell object.
*/
wl_display_roundtrip (wayland_renderer->wayland_display);
if (!wayland_renderer->wayland_compositor || !wayland_renderer->wayland_shell)
{
_cogl_set_error (error,
COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_INIT,
"Unable to find wl_compositor or wl_shell");
goto error;
}
egl_renderer->edpy =
eglGetDisplay ((EGLNativeDisplayType) wayland_renderer->wayland_display);
if (!_cogl_winsys_egl_renderer_connect_common (renderer, error))
goto error;
wayland_renderer->fd = wl_display_get_fd (wayland_renderer->wayland_display);
if (renderer->wayland_enable_event_dispatch)
_cogl_poll_renderer_add_fd (renderer,
wayland_renderer->fd,
COGL_POLL_FD_EVENT_IN,
prepare_wayland_display_events,
dispatch_wayland_display_events,
renderer);
return TRUE;
error:
_cogl_winsys_renderer_disconnect (renderer);
return FALSE;
}
static CoglBool
_cogl_winsys_egl_display_setup (CoglDisplay *display,
CoglError **error)
{
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayWayland *wayland_display;
wayland_display = g_slice_new0 (CoglDisplayWayland);
egl_display->platform = wayland_display;
return TRUE;
}
static void
_cogl_winsys_egl_display_destroy (CoglDisplay *display)
{
CoglDisplayEGL *egl_display = display->winsys;
g_slice_free (CoglDisplayWayland, egl_display->platform);
}
static CoglBool
make_dummy_surface (CoglDisplay *display,
CoglError **error)
{
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayWayland *wayland_display = egl_display->platform;
const char *error_message;
wayland_display->dummy_wayland_surface =
wl_compositor_create_surface (wayland_renderer->wayland_compositor);
if (!wayland_display->dummy_wayland_surface)
{
error_message= "Failed to create a dummy wayland surface";
goto fail;
}
wayland_display->dummy_wayland_egl_native_window =
wl_egl_window_create (wayland_display->dummy_wayland_surface,
1,
1);
if (!wayland_display->dummy_wayland_egl_native_window)
{
error_message= "Failed to create a dummy wayland native egl surface";
goto fail;
}
egl_display->dummy_surface =
eglCreateWindowSurface (egl_renderer->edpy,
egl_display->egl_config,
(EGLNativeWindowType)
wayland_display->dummy_wayland_egl_native_window,
NULL);
if (egl_display->dummy_surface == EGL_NO_SURFACE)
{
error_message= "Unable to create dummy window surface";
goto fail;
}
return TRUE;
fail:
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_CONTEXT,
"%s", error_message);
return FALSE;
}
static CoglBool
_cogl_winsys_egl_context_created (CoglDisplay *display,
CoglError **error)
{
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglDisplayEGL *egl_display = display->winsys;
if ((egl_renderer->private_features &
COGL_EGL_WINSYS_FEATURE_SURFACELESS_CONTEXT) == 0 &&
!make_dummy_surface(display, error))
return FALSE;
if (!_cogl_winsys_egl_make_current (display,
egl_display->dummy_surface,
egl_display->dummy_surface,
egl_display->egl_context))
{
_cogl_set_error (error,
COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_CONTEXT,
"%s",
"Unable to eglMakeCurrent with dummy surface");
}
return TRUE;
}
static void
_cogl_winsys_egl_cleanup_context (CoglDisplay *display)
{
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayWayland *wayland_display = egl_display->platform;
if (egl_display->dummy_surface != EGL_NO_SURFACE)
{
eglDestroySurface (egl_renderer->edpy, egl_display->dummy_surface);
egl_display->dummy_surface = EGL_NO_SURFACE;
}
if (wayland_display->dummy_wayland_egl_native_window)
{
wl_egl_window_destroy (wayland_display->dummy_wayland_egl_native_window);
wayland_display->dummy_wayland_egl_native_window = NULL;
}
if (wayland_display->dummy_wayland_surface)
{
wl_surface_destroy (wayland_display->dummy_wayland_surface);
wayland_display->dummy_wayland_surface = NULL;
}
}
static CoglBool
_cogl_winsys_egl_context_init (CoglContext *context,
CoglError **error)
{
context->feature_flags |= COGL_FEATURE_ONSCREEN_MULTIPLE;
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_ONSCREEN_MULTIPLE, TRUE);
COGL_FLAGS_SET (context->winsys_features,
COGL_WINSYS_FEATURE_MULTIPLE_ONSCREEN,
TRUE);
COGL_FLAGS_SET (context->winsys_features,
COGL_WINSYS_FEATURE_SYNC_AND_COMPLETE_EVENT,
TRUE);
/* We'll manually handle queueing dirty events when the surface is
* first shown or when it is resized. Note that this is slightly
* different from the emulated behaviour that CoglFramebuffer would
* provide if we didn't set this flag because we want to emit the
* event on show instead of on allocation. The Wayland protocol
* delays setting the surface type until the next buffer is attached
* so attaching a buffer before setting the type would not cause
* anything to be displayed */
COGL_FLAGS_SET (context->private_features,
COGL_PRIVATE_FEATURE_DIRTY_EVENTS,
TRUE);
return TRUE;
}
static CoglBool
_cogl_winsys_egl_onscreen_init (CoglOnscreen *onscreen,
EGLConfig egl_config,
CoglError **error)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen;
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
wayland_onscreen = g_slice_new0 (CoglOnscreenWayland);
egl_onscreen->platform = wayland_onscreen;
_cogl_list_init (&wayland_onscreen->frame_callbacks);
if (onscreen->foreign_surface)
wayland_onscreen->wayland_surface = onscreen->foreign_surface;
else
wayland_onscreen->wayland_surface =
wl_compositor_create_surface (wayland_renderer->wayland_compositor);
if (!wayland_onscreen->wayland_surface)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Error while creating wayland surface for CoglOnscreen");
return FALSE;
}
wayland_onscreen->wayland_egl_native_window =
wl_egl_window_create (wayland_onscreen->wayland_surface,
cogl_framebuffer_get_width (framebuffer),
cogl_framebuffer_get_height (framebuffer));
if (!wayland_onscreen->wayland_egl_native_window)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Error while creating wayland egl native window "
"for CoglOnscreen");
return FALSE;
}
egl_onscreen->egl_surface =
eglCreateWindowSurface (egl_renderer->edpy,
egl_config,
(EGLNativeWindowType)
wayland_onscreen->wayland_egl_native_window,
NULL);
if (!onscreen->foreign_surface)
wayland_onscreen->wayland_shell_surface =
wl_shell_get_shell_surface (wayland_renderer->wayland_shell,
wayland_onscreen->wayland_surface);
return TRUE;
}
static void
free_frame_callback_data (FrameCallbackData *callback_data)
{
cogl_object_unref (callback_data->frame_info);
wl_callback_destroy (callback_data->callback);
_cogl_list_remove (&callback_data->link);
g_slice_free (FrameCallbackData, callback_data);
}
static void
_cogl_winsys_egl_onscreen_deinit (CoglOnscreen *onscreen)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
FrameCallbackData *frame_callback_data, *tmp;
_cogl_list_for_each_safe (frame_callback_data,
tmp,
&wayland_onscreen->frame_callbacks,
link)
free_frame_callback_data (frame_callback_data);
if (wayland_onscreen->wayland_egl_native_window)
{
wl_egl_window_destroy (wayland_onscreen->wayland_egl_native_window);
wayland_onscreen->wayland_egl_native_window = NULL;
}
if (!onscreen->foreign_surface)
{
/* NB: The wayland protocol docs explicitly state that
* "wl_shell_surface_destroy() must be called before destroying
* the wl_surface object." ... */
if (wayland_onscreen->wayland_shell_surface)
{
wl_shell_surface_destroy (wayland_onscreen->wayland_shell_surface);
wayland_onscreen->wayland_shell_surface = NULL;
}
if (wayland_onscreen->wayland_surface)
{
wl_surface_destroy (wayland_onscreen->wayland_surface);
wayland_onscreen->wayland_surface = NULL;
}
}
g_slice_free (CoglOnscreenWayland, wayland_onscreen);
}
static void
flush_pending_resize (CoglOnscreen *onscreen)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
if (wayland_onscreen->has_pending)
{
wl_egl_window_resize (wayland_onscreen->wayland_egl_native_window,
wayland_onscreen->pending_width,
wayland_onscreen->pending_height,
wayland_onscreen->pending_dx,
wayland_onscreen->pending_dy);
_cogl_framebuffer_winsys_update_size (COGL_FRAMEBUFFER (onscreen),
wayland_onscreen->pending_width,
wayland_onscreen->pending_height);
_cogl_onscreen_queue_full_dirty (onscreen);
wayland_onscreen->pending_dx = 0;
wayland_onscreen->pending_dy = 0;
wayland_onscreen->has_pending = FALSE;
}
}
static void
frame_cb (void *data,
struct wl_callback *callback,
uint32_t time)
{
FrameCallbackData *callback_data = data;
CoglFrameInfo *info = callback_data->frame_info;
CoglOnscreen *onscreen = callback_data->onscreen;
g_assert (callback_data->callback == callback);
_cogl_onscreen_queue_event (onscreen, COGL_FRAME_EVENT_SYNC, info);
_cogl_onscreen_queue_event (onscreen, COGL_FRAME_EVENT_COMPLETE, info);
free_frame_callback_data (callback_data);
}
static const struct wl_callback_listener
frame_listener =
{
frame_cb
};
static void
_cogl_winsys_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen,
const int *rectangles,
int n_rectangles)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
FrameCallbackData *frame_callback_data = g_slice_new (FrameCallbackData);
flush_pending_resize (onscreen);
/* Before calling the winsys function,
* cogl_onscreen_swap_buffers_with_damage() will have pushed the
* frame info object onto the end of the pending frames. We can grab
* it out of the queue now because we don't care about the order and
* we will just directly queue the event corresponding to the exact
* frame that Wayland reports as completed. This will steal the
* reference */
frame_callback_data->frame_info =
g_queue_pop_tail (&onscreen->pending_frame_infos);
frame_callback_data->onscreen = onscreen;
frame_callback_data->callback =
wl_surface_frame (wayland_onscreen->wayland_surface);
wl_callback_add_listener (frame_callback_data->callback,
&frame_listener,
frame_callback_data);
_cogl_list_insert (&wayland_onscreen->frame_callbacks,
&frame_callback_data->link);
parent_vtable->onscreen_swap_buffers_with_damage (onscreen,
rectangles,
n_rectangles);
}
static void
_cogl_winsys_onscreen_set_visibility (CoglOnscreen *onscreen,
CoglBool visibility)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
/* The first time the onscreen is shown we will set it to toplevel
* so that it will appear on the screen. If the surface is foreign
* then we won't have the shell surface and we'll just let the
* application deal with setting the surface type. */
if (visibility &&
wayland_onscreen->wayland_shell_surface &&
!wayland_onscreen->shell_surface_type_set)
{
wl_shell_surface_set_toplevel (wayland_onscreen->wayland_shell_surface);
wayland_onscreen->shell_surface_type_set = TRUE;
_cogl_onscreen_queue_full_dirty (onscreen);
}
/* FIXME: We should also do something here to hide the surface when
* visilibity == FALSE. It sounds like there are currently ongoing
* discussions about adding support for hiding surfaces in the
* Wayland protocol so we might as well wait until then to add that
* here. */
}
void
cogl_wayland_renderer_set_foreign_display (CoglRenderer *renderer,
struct wl_display *display)
{
_COGL_RETURN_IF_FAIL (cogl_is_renderer (renderer));
/* NB: Renderers are considered immutable once connected */
_COGL_RETURN_IF_FAIL (!renderer->connected);
renderer->foreign_wayland_display = display;
}
void
cogl_wayland_renderer_set_event_dispatch_enabled (CoglRenderer *renderer,
CoglBool enable)
{
_COGL_RETURN_IF_FAIL (cogl_is_renderer (renderer));
/* NB: Renderers are considered immutable once connected */
_COGL_RETURN_IF_FAIL (!renderer->connected);
renderer->wayland_enable_event_dispatch = enable;
}
struct wl_display *
cogl_wayland_renderer_get_display (CoglRenderer *renderer)
{
_COGL_RETURN_VAL_IF_FAIL (cogl_is_renderer (renderer), NULL);
if (renderer->foreign_wayland_display)
return renderer->foreign_wayland_display;
else if (renderer->connected)
{
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
return wayland_renderer->wayland_display;
}
else
return NULL;
}
struct wl_surface *
cogl_wayland_onscreen_get_surface (CoglOnscreen *onscreen)
{
CoglOnscreenEGL *egl_onscreen;
CoglOnscreenWayland *wayland_onscreen;
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), NULL);
egl_onscreen = onscreen->winsys;
wayland_onscreen = egl_onscreen->platform;
return wayland_onscreen->wayland_surface;
}
struct wl_shell_surface *
cogl_wayland_onscreen_get_shell_surface (CoglOnscreen *onscreen)
{
CoglOnscreenEGL *egl_onscreen;
CoglOnscreenWayland *wayland_onscreen;
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), NULL);
egl_onscreen = onscreen->winsys;
wayland_onscreen = egl_onscreen->platform;
return wayland_onscreen->wayland_shell_surface;
}
void
cogl_wayland_onscreen_set_foreign_surface (CoglOnscreen *onscreen,
struct wl_surface *surface)
{
CoglFramebuffer *fb;
fb = COGL_FRAMEBUFFER (onscreen);
_COGL_RETURN_IF_FAIL (!fb->allocated);
onscreen->foreign_surface = surface;
}
void
cogl_wayland_onscreen_resize (CoglOnscreen *onscreen,
int width,
int height,
int offset_x,
int offset_y)
{
CoglFramebuffer *fb;
fb = COGL_FRAMEBUFFER (onscreen);
if (fb->allocated)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
if (cogl_framebuffer_get_width (fb) != width ||
cogl_framebuffer_get_height (fb) != height ||
offset_x ||
offset_y)
{
wayland_onscreen->pending_width = width;
wayland_onscreen->pending_height = height;
wayland_onscreen->pending_dx += offset_x;
wayland_onscreen->pending_dy += offset_y;
wayland_onscreen->has_pending = TRUE;
/* If nothing has been drawn to the framebuffer since the
* last swap then wl_egl_window_resize will take effect
* immediately. Otherwise it might not take effect until the
* next swap, depending on the version of Mesa. To keep
* consistent behaviour we'll delay the resize until the
* next swap unless we're sure nothing has been drawn */
if (!fb->mid_scene)
flush_pending_resize (onscreen);
}
}
else
_cogl_framebuffer_winsys_update_size (fb, width, height);
}
static const CoglWinsysEGLVtable
_cogl_winsys_egl_vtable =
{
.display_setup = _cogl_winsys_egl_display_setup,
.display_destroy = _cogl_winsys_egl_display_destroy,
.context_created = _cogl_winsys_egl_context_created,
.cleanup_context = _cogl_winsys_egl_cleanup_context,
.context_init = _cogl_winsys_egl_context_init,
.onscreen_init = _cogl_winsys_egl_onscreen_init,
.onscreen_deinit = _cogl_winsys_egl_onscreen_deinit
};
const CoglWinsysVtable *
_cogl_winsys_egl_wayland_get_vtable (void)
{
static CoglBool vtable_inited = FALSE;
static CoglWinsysVtable vtable;
if (!vtable_inited)
{
/* The EGL_WAYLAND winsys is a subclass of the EGL winsys so we
start by copying its vtable */
parent_vtable = _cogl_winsys_egl_get_vtable ();
vtable = *parent_vtable;
vtable.id = COGL_WINSYS_ID_EGL_WAYLAND;
vtable.name = "EGL_WAYLAND";
vtable.renderer_connect = _cogl_winsys_renderer_connect;
vtable.renderer_disconnect = _cogl_winsys_renderer_disconnect;
vtable.onscreen_swap_buffers_with_damage =
_cogl_winsys_onscreen_swap_buffers_with_damage;
vtable.onscreen_set_visibility =
_cogl_winsys_onscreen_set_visibility;
vtable_inited = TRUE;
}
return &vtable;
}

25
configure.ac
View File

@ -95,7 +95,6 @@ m4_define([xfixes_req_version], [3])
m4_define([xcomposite_req_version], [0.4])
m4_define([xrandr_req_version], [1.2])
m4_define([cairo_req_version], [1.10])
m4_define([wayland_req_version], [1.0.0])
m4_define([wayland_server_req_version], [1.1.90])
m4_define([mirclient_req_version], [0.9.0])
@ -109,7 +108,6 @@ AC_SUBST([XFIXES_REQ_VERSION], [xfixes_req_version])
AC_SUBST([GTK_DOC_REQ_VERSION], [gtk_doc_req_version])
AC_SUBST([GI_REQ_VERSION], [gi_req_version])
AC_SUBST([UPROF_REQ_VERSION], [uprof_req_version])
AC_SUBST([WAYLAND_REQ_VERSION], [wayland_req_version])
AC_SUBST([WAYLAND_SERVER_REQ_VERSION], [wayland_server_req_version])
# Save this value here, since automake will set cflags later and we
@ -840,29 +838,6 @@ AM_CONDITIONAL(SUPPORT_GLX, [test "x$SUPPORT_GLX" = "xyes"])
EGL_PLATFORM_COUNT=0
AC_ARG_ENABLE(
[wayland-egl-platform],
[AC_HELP_STRING([--enable-wayland-egl-platform=@<:@no/yes@:>@], [Enable support for the Wayland egl platform @<:@default=no@:>@])],
[],
enable_wayland_egl_platform=no
)
AS_IF([test "x$enable_wayland_egl_platform" = "xyes"],
[
EGL_PLATFORM_COUNT=$((EGL_PLATFORM_COUNT+1))
NEED_EGL=yes
EGL_PLATFORMS="$EGL_PLATFORMS wayland"
PKG_CHECK_MODULES(WAYLAND_CLIENT,
[wayland-egl >= wayland_req_version wayland-client >= wayland_req_version])
COGL_PKG_REQUIRES="$COGL_PKG_REQUIRES wayland-egl >= wayland_req_version"
COGL_PKG_REQUIRES="$COGL_PKG_REQUIRES wayland-client >= wayland_req_version"
COGL_DEFINES_SYMBOLS="$COGL_DEFINES_SYMBOLS COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT"
])
AM_CONDITIONAL(SUPPORT_EGL_PLATFORM_WAYLAND,
[test "x$enable_wayland_egl_platform" = "xyes"])
AC_ARG_ENABLE(
[kms-egl-platform],
[AC_HELP_STRING([--enable-kms-egl-platform=@<:@no/yes@:>@], [Enable support for the KMS egl platform @<:@default=no@:>@])],

2
examples/cogl-info.c
View File

@ -137,8 +137,6 @@ get_winsys_name_for_id (CoglWinsysID winsys_id)
return "GLX";
case COGL_WINSYS_ID_EGL_XLIB:
return "EGL + Xlib platform";
case COGL_WINSYS_ID_EGL_WAYLAND:
return "EGL + Wayland platform";
case COGL_WINSYS_ID_EGL_KMS:
return "EGL + KMS platform";
}