From d0ad5ea18bb02112837bcdf7270d58d8ad235a4d Mon Sep 17 00:00:00 2001 From: "Owen W. Taylor" Date: Thu, 8 May 2014 18:44:15 -0400 Subject: [PATCH] Add support for quad-buffer stereo Track the stereo status of windows using the new EXT_stereo_tree GLX extension. When stereo is enabled or disabled, a restart is triggered via meta_restart() after a timeout, setting a _META_ENABLE_STEREO property on the root window to indicate whether we should turn on a stereo stage for clutter. The property avoids a loop, since we need to enable stereo *before* initializing Clutter and GL, but we need GL to figure out whether we have stereo windows. Stereo windows are drawn to the stage using new functionality in Cogl to setup a stereo context, select which buffer to draw to, and draw either the left or right buffer of a stereo texture_from_pixmap. --- src/compositor/compositor-private.h | 9 ++ src/compositor/compositor.c | 125 +++++++++++++++ src/compositor/meta-shaped-texture-private.h | 5 +- src/compositor/meta-shaped-texture.c | 84 +++++++++- src/compositor/meta-surface-actor-wayland.c | 2 +- src/compositor/meta-surface-actor-x11.c | 54 ++++++- src/compositor/meta-surface-actor-x11.h | 5 + src/compositor/meta-window-actor-private.h | 5 + src/compositor/meta-window-actor.c | 22 +++ src/core/main.c | 4 + src/core/stereo.c | 154 +++++++++++++++++++ src/core/stereo.h | 28 ++++ src/meson.build | 2 + src/wayland/meta-wayland-surface.c | 2 +- 14 files changed, 481 insertions(+), 20 deletions(-) create mode 100644 src/core/stereo.c create mode 100644 src/core/stereo.h diff --git a/src/compositor/compositor-private.h b/src/compositor/compositor-private.h index 6ab33416c..f70087512 100644 --- a/src/compositor/compositor-private.h +++ b/src/compositor/compositor-private.h @@ -24,6 +24,10 @@ struct _MetaCompositor gint64 server_time_query_time; gint64 server_time_offset; + int glx_opcode; + guint stereo_tree_ext : 1; + guint have_stereo_windows : 1; + guint server_time_is_monotonic_time : 1; ClutterActor *stage, *window_group, *top_window_group, *feedback_group; @@ -63,6 +67,11 @@ void meta_end_modal_for_plugin (MetaCompositor *compositor, gint64 meta_compositor_monotonic_time_to_server_time (MetaDisplay *display, gint64 monotonic_time); +gboolean meta_compositor_window_is_stereo (MetaDisplay *display, + Window xwindow); +void meta_compositor_select_stereo_notify (MetaDisplay *display, + Window xwindow); + void meta_compositor_flash_window (MetaCompositor *compositor, MetaWindow *window); diff --git a/src/compositor/compositor.c b/src/compositor/compositor.c index 2a2c8fb3b..6c08c8fe4 100644 --- a/src/compositor/compositor.c +++ b/src/compositor/compositor.c @@ -69,6 +69,8 @@ #include "core/core.h" #include "core/display-private.h" #include "core/frame.h" +#include "core/stack-tracker.h" +#include "core/stereo.h" #include "core/util-private.h" #include "core/window-private.h" #include "meta/compositor-mutter.h" @@ -514,6 +516,94 @@ redirect_windows (MetaX11Display *x11_display) } } +#define GLX_STEREO_TREE_EXT 0x20F5 +#define GLX_STEREO_NOTIFY_MASK_EXT 0x00000001 +#define GLX_STEREO_NOTIFY_EXT 0x00000000 + +typedef struct { + int type; + unsigned long serial; + Bool send_event; + Display *display; + int extension; + int evtype; + Drawable window; + Bool stereo_tree; +} StereoNotifyEvent; + +static gboolean +display_has_stereo_tree_ext (MetaX11Display *x11_display) +{ + Display *xdisplay = x11_display->xdisplay; + const char *extensions_string; + + static const char * (*query_extensions_string) (Display *display, + int screen); + + if (query_extensions_string == NULL) + query_extensions_string = + (const char * (*) (Display *, int)) + cogl_get_proc_address ("glXQueryExtensionsString"); + + extensions_string = query_extensions_string (xdisplay, + meta_x11_display_get_screen_number (x11_display)); + + return extensions_string && strstr (extensions_string, "EXT_stereo_tree") != 0; +} + +#include + +gboolean +meta_compositor_window_is_stereo (MetaDisplay *display, + Window xwindow) +{ + MetaCompositor *compositor = get_compositor_for_display (display); + Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display); + + static int (*query_drawable) (Display *dpy, + Drawable draw, + int attribute, + unsigned int *value); + + if (compositor->stereo_tree_ext) + { + unsigned int stereo_tree = 0; + + if (query_drawable == NULL) + query_drawable = + (int (*) (Display *, Drawable, int, unsigned int *)) + cogl_get_proc_address ("glXQueryDrawable"); + + query_drawable (xdisplay, xwindow, GLX_STEREO_TREE_EXT, &stereo_tree); + + return stereo_tree != 0; + } + else + return FALSE; +} + +void +meta_compositor_select_stereo_notify (MetaDisplay *display, + Window xwindow) +{ + MetaCompositor *compositor = get_compositor_for_display (display); + Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display); + + static void (*select_event) (Display *dpy, + Drawable draw, + unsigned long event_mask); + + if (compositor->stereo_tree_ext) + { + if (select_event == NULL) + select_event = + (void (*) (Display *, Drawable, unsigned long)) + cogl_get_proc_address ("glXSelectEvent"); + + select_event (xdisplay, xwindow, GLX_STEREO_NOTIFY_MASK_EXT); + } +} + void meta_compositor_manage (MetaCompositor *compositor) { @@ -525,6 +615,8 @@ meta_compositor_manage (MetaCompositor *compositor) { xdisplay = display->x11_display->xdisplay; meta_x11_display_set_cm_selection (display->x11_display); + + compositor->stereo_tree_ext = display_has_stereo_tree_ext (display->x11_display); } compositor->stage = meta_backend_get_stage (backend); @@ -822,6 +914,23 @@ meta_compositor_process_event (MetaCompositor *compositor, if (window) process_damage (compositor, (XDamageNotifyEvent *) event, window); } + else if (!meta_is_wayland_compositor () && + event->type == GenericEvent && + event->xcookie.extension == compositor->glx_opcode) + { + if (event->xcookie.evtype == GLX_STEREO_NOTIFY_EXT) + { + StereoNotifyEvent *stereo_event = (StereoNotifyEvent *)(event->xcookie.data); + window = meta_x11_display_lookup_x_window (x11_display, stereo_event->window); + + if (window != NULL) + { + MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window)); + meta_window_actor_stereo_notify (window_actor, stereo_event->stereo_tree); + meta_stack_tracker_queue_sync_stack (window->display->stack_tracker); + } + } + } if (compositor->have_x11_sync_object) meta_sync_ring_handle_event (event); @@ -1038,6 +1147,7 @@ meta_compositor_sync_stack (MetaCompositor *compositor, GList *stack) { GList *old_stack; + int stereo_window_count = 0; /* This is painful because hidden windows that we are in the process * of animating out of existence. They'll be at the bottom of the @@ -1113,6 +1223,8 @@ meta_compositor_sync_stack (MetaCompositor *compositor, * near the front of the other.) */ compositor->windows = g_list_prepend (compositor->windows, actor); + if (meta_window_actor_is_stereo (actor)) + stereo_window_count++; stack = g_list_remove (stack, window); old_stack = g_list_remove (old_stack, actor); @@ -1120,6 +1232,8 @@ meta_compositor_sync_stack (MetaCompositor *compositor, sync_actor_stacking (compositor); + meta_stereo_set_have_stereo_windows (stereo_window_count > 0); + if (compositor->top_window_actor) g_signal_handlers_disconnect_by_func (compositor->top_window_actor, on_top_window_actor_destroyed, @@ -1325,6 +1439,17 @@ meta_compositor_new (MetaDisplay *display) meta_post_paint_func, compositor, NULL); + if (!meta_is_wayland_compositor ()) + { + Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display); + int glx_major_opcode, glx_first_event, glx_first_error; + + if (XQueryExtension (xdisplay, + "GLX", + &glx_major_opcode, &glx_first_event, &glx_first_error)) + compositor->glx_opcode = glx_major_opcode; + } + return compositor; } diff --git a/src/compositor/meta-shaped-texture-private.h b/src/compositor/meta-shaped-texture-private.h index a86a2bff0..d0efdd4dc 100644 --- a/src/compositor/meta-shaped-texture-private.h +++ b/src/compositor/meta-shaped-texture-private.h @@ -31,8 +31,9 @@ #include "meta/meta-shaped-texture.h" ClutterActor *meta_shaped_texture_new (void); -void meta_shaped_texture_set_texture (MetaShapedTexture *stex, - CoglTexture *texture); +void meta_shaped_texture_set_textures (MetaShapedTexture *stex, + CoglTexture *texture, + CoglTexture *texture_right); void meta_shaped_texture_set_is_y_inverted (MetaShapedTexture *stex, gboolean is_y_inverted); void meta_shaped_texture_set_snippet (MetaShapedTexture *stex, diff --git a/src/compositor/meta-shaped-texture.c b/src/compositor/meta-shaped-texture.c index ea8daa03d..9a00ccd6d 100644 --- a/src/compositor/meta-shaped-texture.c +++ b/src/compositor/meta-shaped-texture.c @@ -102,8 +102,10 @@ struct _MetaShapedTexture ClutterActor parent; MetaTextureTower *paint_tower; + MetaTextureTower *paint_tower_right; CoglTexture *texture; + CoglTexture *texture_right; CoglTexture *mask_texture; CoglSnippet *snippet; @@ -192,6 +194,7 @@ meta_shaped_texture_init (MetaShapedTexture *stex) clutter_backend_get_cogl_context (clutter_backend); stex->paint_tower = meta_texture_tower_new (); + stex->paint_tower_right = NULL; /* demand create */ stex->texture = NULL; stex->mask_texture = NULL; @@ -335,6 +338,9 @@ meta_shaped_texture_dispose (GObject *object) meta_texture_tower_free (stex->paint_tower); stex->paint_tower = NULL; + g_clear_pointer (&stex->paint_tower, meta_texture_tower_free); + g_clear_pointer (&stex->paint_tower_right, meta_texture_tower_free); + g_clear_pointer (&stex->texture, cogl_object_unref); g_clear_pointer (&stex->opaque_region, cairo_region_destroy); @@ -611,8 +617,9 @@ paint_clipped_rectangle (MetaShapedTexture *stex, } static void -set_cogl_texture (MetaShapedTexture *stex, - CoglTexture *cogl_tex) +set_cogl_textures (MetaShapedTexture *stex, + CoglTexture *cogl_tex, + CoglTexture *cogl_tex_right) { int width, height; @@ -620,10 +627,13 @@ set_cogl_texture (MetaShapedTexture *stex, if (stex->texture) cogl_object_unref (stex->texture); + if (stex->texture_right) + cogl_object_unref (stex->texture_right); g_clear_pointer (&stex->saved_base_surface, cairo_surface_destroy); stex->texture = cogl_tex; + stex->texture_right = cogl_tex_right; if (cogl_tex != NULL) { @@ -637,6 +647,9 @@ set_cogl_texture (MetaShapedTexture *stex, height = 0; } + if (cogl_tex_right != NULL) + cogl_object_ref (cogl_tex_right); + if (stex->tex_width != width || stex->tex_height != height) { @@ -650,8 +663,23 @@ set_cogl_texture (MetaShapedTexture *stex, * previous buffer. We only queue a redraw in response to surface * damage. */ + if (cogl_tex_right != NULL) + { + if (stex->paint_tower_right == NULL) + stex->paint_tower_right = meta_texture_tower_new (); + } + else + { + g_clear_pointer (&stex->paint_tower_right, meta_texture_tower_free); + } + if (stex->create_mipmaps) - meta_texture_tower_set_base_texture (stex->paint_tower, cogl_tex); + { + meta_texture_tower_set_base_texture (stex->paint_tower, cogl_tex); + + if (stex->paint_tower_right) + meta_texture_tower_set_base_texture (stex->paint_tower_right, cogl_tex_right); + } } static gboolean @@ -927,7 +955,9 @@ meta_shaped_texture_paint (ClutterActor *actor) { MetaShapedTexture *stex = META_SHAPED_TEXTURE (actor); CoglTexture *paint_tex; + CoglTexture *paint_tex_right = NULL; CoglFramebuffer *fb; + gboolean stereo; if (!stex->texture) return; @@ -989,7 +1019,32 @@ meta_shaped_texture_paint (ClutterActor *actor) return; fb = cogl_get_draw_framebuffer (); - do_paint (META_SHAPED_TEXTURE (actor), fb, paint_tex, stex->clip_region); + + stereo = stex->texture_right && cogl_framebuffer_get_is_stereo (fb); + + if (stereo) + { + if (stex->create_mipmaps) + paint_tex_right = meta_texture_tower_get_paint_texture (stex->paint_tower_right); + + if (!paint_tex_right) + paint_tex_right = COGL_TEXTURE (stex->texture_right); + } + else + paint_tex_right = NULL; + + if (stereo) + cogl_framebuffer_set_stereo_mode (fb, COGL_STEREO_LEFT); + do_paint (stex, fb, paint_tex, stex->clip_region); + if (stereo) + cogl_framebuffer_set_stereo_mode (fb, COGL_STEREO_BOTH); + + if (paint_tex_right != NULL) + { + cogl_framebuffer_set_stereo_mode (fb, COGL_STEREO_RIGHT); + do_paint (stex, fb, paint_tex_right, stex->clip_region); + cogl_framebuffer_set_stereo_mode (fb, COGL_STEREO_BOTH); + } } static void @@ -1063,6 +1118,12 @@ meta_shaped_texture_set_create_mipmaps (MetaShapedTexture *stex, stex->create_mipmaps = create_mipmaps; base_texture = create_mipmaps ? stex->texture : NULL; meta_texture_tower_set_base_texture (stex->paint_tower, base_texture); + + if (stex->paint_tower_right) + { + base_texture = create_mipmaps ? stex->texture_right : NULL; + meta_texture_tower_set_base_texture (stex->paint_tower_right, base_texture); + } } } @@ -1256,6 +1317,12 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex, clip.y, clip.width, clip.height); + if (stex->paint_tower_right) + meta_texture_tower_update_area (stex->paint_tower_right, + clip.x, + clip.y, + clip.width, + clip.height); stex->prev_invalidation = stex->last_invalidation; stex->last_invalidation = g_get_monotonic_time (); @@ -1302,17 +1369,18 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex, } /** - * meta_shaped_texture_set_texture: + * meta_shaped_texture_set_textures: * @stex: The #MetaShapedTexture * @pixmap: The #CoglTexture to display */ void -meta_shaped_texture_set_texture (MetaShapedTexture *stex, - CoglTexture *texture) +meta_shaped_texture_set_textures (MetaShapedTexture *stex, + CoglTexture *texture, + CoglTexture *texture_right) { g_return_if_fail (META_IS_SHAPED_TEXTURE (stex)); - set_cogl_texture (stex, texture); + set_cogl_textures (stex, texture, texture_right); } /** diff --git a/src/compositor/meta-surface-actor-wayland.c b/src/compositor/meta-surface-actor-wayland.c index f8d6c32b7..a75c4dd09 100644 --- a/src/compositor/meta-surface-actor-wayland.c +++ b/src/compositor/meta-surface-actor-wayland.c @@ -182,7 +182,7 @@ meta_surface_actor_wayland_dispose (GObject *object) MetaShapedTexture *stex = meta_surface_actor_get_texture (META_SURFACE_ACTOR (self)); - meta_shaped_texture_set_texture (stex, NULL); + meta_shaped_texture_set_textures (stex, NULL, NULL); if (self->surface) { g_object_remove_weak_pointer (G_OBJECT (self->surface), diff --git a/src/compositor/meta-surface-actor-x11.c b/src/compositor/meta-surface-actor-x11.c index 244b1e885..3cd164d77 100644 --- a/src/compositor/meta-surface-actor-x11.c +++ b/src/compositor/meta-surface-actor-x11.c @@ -32,6 +32,7 @@ #include "cogl/winsys/cogl-texture-pixmap-x11.h" #include "compositor/meta-cullable.h" #include "compositor/meta-shaped-texture-private.h" +#include "compositor-private.h" #include "core/window-private.h" #include "meta/meta-x11-errors.h" #include "x11/meta-x11-display-private.h" @@ -46,6 +47,7 @@ struct _MetaSurfaceActorX11 MetaDisplay *display; CoglTexture *texture; + CoglTexture *texture_right; Pixmap pixmap; Damage damage; @@ -61,6 +63,8 @@ struct _MetaSurfaceActorX11 guint size_changed : 1; guint unredirected : 1; + + guint stereo : 1; }; G_DEFINE_TYPE (MetaSurfaceActorX11, @@ -96,7 +100,7 @@ detach_pixmap (MetaSurfaceActorX11 *self) * you are supposed to be able to free a GLXPixmap after freeing the underlying * pixmap, but it certainly doesn't work with current DRI/Mesa */ - meta_shaped_texture_set_texture (stex, NULL); + meta_shaped_texture_set_textures (stex, NULL, NULL); cogl_flush (); meta_x11_error_trap_push (display->x11_display); @@ -105,6 +109,7 @@ detach_pixmap (MetaSurfaceActorX11 *self) meta_x11_error_trap_pop (display->x11_display); g_clear_pointer (&self->texture, cogl_object_unref); + g_clear_pointer (&self->texture_right, cogl_object_unref); } static void @@ -114,23 +119,37 @@ set_pixmap (MetaSurfaceActorX11 *self, CoglContext *ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ()); MetaShapedTexture *stex = meta_surface_actor_get_texture (META_SURFACE_ACTOR (self)); CoglError *error = NULL; - CoglTexture *texture; + CoglTexturePixmapX11 *texture; + CoglTexturePixmapX11 *texture_right; g_assert (self->pixmap == None); self->pixmap = pixmap; - texture = COGL_TEXTURE (cogl_texture_pixmap_x11_new (ctx, self->pixmap, FALSE, &error)); + if (self->stereo) + texture = cogl_texture_pixmap_x11_new_left (ctx, pixmap, FALSE, &error); + else + texture = cogl_texture_pixmap_x11_new (ctx, pixmap, FALSE, &error); + + if (self->stereo) + texture_right = cogl_texture_pixmap_x11_new_right (texture); + else + texture_right = NULL; if (error != NULL) { g_warning ("Failed to allocate stex texture: %s", error->message); cogl_error_free (error); } - else if (G_UNLIKELY (!cogl_texture_pixmap_x11_is_using_tfp_extension (COGL_TEXTURE_PIXMAP_X11 (texture)))) + else if (G_UNLIKELY (!cogl_texture_pixmap_x11_is_using_tfp_extension (texture))) g_warning ("NOTE: Not using GLX TFP!\n"); - self->texture = texture; - meta_shaped_texture_set_texture (stex, texture); + self->texture = COGL_TEXTURE (texture); + if (self->stereo) + self->texture_right = COGL_TEXTURE (texture_right); + + meta_shaped_texture_set_textures (stex, + COGL_TEXTURE (texture), + COGL_TEXTURE (texture_right));; } static void @@ -419,8 +438,8 @@ reset_texture (MetaSurfaceActorX11 *self) /* Setting the texture to NULL will cause all the FBO's cached by the * shaped texture's MetaTextureTower to be discarded and recreated. */ - meta_shaped_texture_set_texture (stex, NULL); - meta_shaped_texture_set_texture (stex, self->texture); + meta_shaped_texture_set_textures (stex, NULL, NULL); + meta_shaped_texture_set_textures (stex, self->texture, self->texture_right); } MetaSurfaceActor * @@ -428,12 +447,17 @@ meta_surface_actor_x11_new (MetaWindow *window) { MetaSurfaceActorX11 *self = g_object_new (META_TYPE_SURFACE_ACTOR_X11, NULL); MetaDisplay *display = meta_window_get_display (window); + Window xwindow; g_assert (!meta_is_wayland_compositor ()); self->window = window; self->display = display; + xwindow = meta_window_x11_get_toplevel_xwindow (window); + self->stereo = meta_compositor_window_is_stereo (display, xwindow); + meta_compositor_select_stereo_notify (display, xwindow); + g_signal_connect_object (self->display, "gl-video-memory-purged", G_CALLBACK (reset_texture), self, G_CONNECT_SWAPPED); @@ -463,3 +487,17 @@ meta_surface_actor_x11_set_size (MetaSurfaceActorX11 *self, self->last_height = height; meta_shaped_texture_set_fallback_size (stex, width, height); } + +void +meta_surface_actor_x11_stereo_notify (MetaSurfaceActorX11 *self, + gboolean stereo_tree) +{ + self->stereo = stereo_tree != FALSE; + detach_pixmap (self); +} + +gboolean +meta_surface_actor_x11_is_stereo (MetaSurfaceActorX11 *self) +{ + return self->stereo; +} diff --git a/src/compositor/meta-surface-actor-x11.h b/src/compositor/meta-surface-actor-x11.h index 2c4ed4dd6..3bdd5fdb0 100644 --- a/src/compositor/meta-surface-actor-x11.h +++ b/src/compositor/meta-surface-actor-x11.h @@ -47,6 +47,11 @@ MetaSurfaceActor * meta_surface_actor_x11_new (MetaWindow *window); void meta_surface_actor_x11_set_size (MetaSurfaceActorX11 *self, int width, int height); +void meta_surface_actor_x11_stereo_notify (MetaSurfaceActorX11 *self, + gboolean stereo_tree); + +gboolean meta_surface_actor_x11_is_stereo (MetaSurfaceActorX11 *self); + G_END_DECLS #endif /* __META_SURFACE_ACTOR_X11_H__ */ diff --git a/src/compositor/meta-window-actor-private.h b/src/compositor/meta-window-actor-private.h index 6333f43db..9c1c12d09 100644 --- a/src/compositor/meta-window-actor-private.h +++ b/src/compositor/meta-window-actor-private.h @@ -76,4 +76,9 @@ MetaSurfaceActor *meta_window_actor_get_surface (MetaWindowActor *self); void meta_window_actor_update_surface (MetaWindowActor *self); MetaWindowActor *meta_window_actor_from_window (MetaWindow *window); +void meta_window_actor_stereo_notify (MetaWindowActor *actor, + gboolean stereo_tree); + +gboolean meta_window_actor_is_stereo (MetaWindowActor *actor); + #endif /* META_WINDOW_ACTOR_PRIVATE_H */ diff --git a/src/compositor/meta-window-actor.c b/src/compositor/meta-window-actor.c index 1c8dc8fe5..11686d00b 100644 --- a/src/compositor/meta-window-actor.c +++ b/src/compositor/meta-window-actor.c @@ -2031,3 +2031,25 @@ screen_cast_window_iface_init (MetaScreenCastWindowInterface *iface) iface->capture_into = meta_window_actor_capture_into; iface->has_damage = meta_window_actor_has_damage; } + +void +meta_window_actor_stereo_notify (MetaWindowActor *self, + gboolean stereo_tree) +{ + MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private (self); + + if (META_IS_SURFACE_ACTOR_X11 (priv->surface)) + meta_surface_actor_x11_stereo_notify (META_SURFACE_ACTOR_X11 (priv->surface), + stereo_tree); +} + +gboolean +meta_window_actor_is_stereo (MetaWindowActor *self) +{ + MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private (self); + + if (META_IS_SURFACE_ACTOR_X11 (priv->surface)) + return meta_surface_actor_x11_is_stereo (META_SURFACE_ACTOR_X11 (priv->surface)); + else + return FALSE; +} diff --git a/src/core/main.c b/src/core/main.c index e8464720f..629f8e94e 100644 --- a/src/core/main.c +++ b/src/core/main.c @@ -81,6 +81,7 @@ #include "meta/meta-backend.h" #include "meta/meta-x11-errors.h" #include "meta/prefs.h" +#include "stereo.h" #include "ui/ui.h" #include "x11/session.h" @@ -589,6 +590,9 @@ meta_init (void) meta_init_backend (backend_gtype); + if (!meta_is_wayland_compositor ()) + meta_stereo_init (); + meta_clutter_init (); #ifdef HAVE_WAYLAND diff --git a/src/core/stereo.c b/src/core/stereo.c new file mode 100644 index 000000000..817056527 --- /dev/null +++ b/src/core/stereo.c @@ -0,0 +1,154 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ + +/* + * Copyright (C) 2014 Red Hat, Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +/* + * SECTION:stereo + * @short_description: Keep track of whether we are a stereo compositor + * + * With GLX, we need to use a different GL context for stereo and + * non-stereo support. Support for multiple GL contexts is unfinished + * in Cogl and entirely lacking in Clutter, so it's by far easier + * to just restart Mutter when we detect a stereo window. + * + * A property _MUTTER_ENABLE_STEREO is maintained on the root window + * to know whether we should initialize clutter for stereo or not. + * When the presence or absence of stereo windows mismatches the + * stereo-enabled state for a sufficiently long period of time, + * we restart Mutter. + */ + +#include + +#include +#include +#include + +#include "display-private.h" +#include +#include +#include +#include "stereo.h" +#include "ui/ui.h" +#include "util-private.h" + +static guint stereo_switch_id = 0; +static gboolean stereo_enabled = FALSE; +/* -1 so the first time meta_stereo_set_have_stereo_windows() is called + * we avoid the short-circuit and set up a timeout to restart + * if necessary */ +static gboolean stereo_have_windows = (gboolean)-1; +static gboolean stereo_restart = FALSE; + +#define STEREO_ENABLE_WAIT 1000 +#define STEREO_DISABLE_WAIT 5000 + +void +meta_stereo_init (void) +{ + Display *xdisplay; + Window root; + Atom atom_enable_stereo; + Atom type; + int format; + unsigned long n_items, bytes_after; + guchar *data; + + xdisplay = XOpenDisplay (NULL); + if (xdisplay == NULL) + meta_fatal ("Unable to open X display %s\n", XDisplayName (NULL)); + + root = DefaultRootWindow (xdisplay); + atom_enable_stereo = XInternAtom (xdisplay, "_MUTTER_ENABLE_STEREO", False); + + XGetWindowProperty (xdisplay, root, atom_enable_stereo, + 0, 1, False, XA_INTEGER, + &type, &format, &n_items, &bytes_after, &data); + if (type == XA_INTEGER) + { + if (format == 32 && n_items == 1 && bytes_after == 0) + { + stereo_enabled = *(long *)data; + } + else + { + meta_warning ("Bad value for _MUTTER_ENABLE_STEREO property\n"); + } + + XFree (data); + } + else if (type != None) + { + meta_warning ("Bad type for _MUTTER_ENABLE_STEREO property\n"); + } + + meta_verbose ("On startup, _MUTTER_ENABLE_STEREO=%s", + stereo_enabled ? "yes" : "no"); + clutter_x11_set_use_stereo_stage (stereo_enabled); + XCloseDisplay (xdisplay); +} + +static gboolean +meta_stereo_switch (gpointer data) +{ + stereo_switch_id = 0; + stereo_restart = TRUE; + + meta_restart (stereo_have_windows ? + _("Enabling stereo...") : + _("Disabling stereo...")); + + return FALSE; +} + +void +meta_stereo_set_have_stereo_windows (gboolean have_windows) +{ + have_windows = have_windows != FALSE; + + if (!stereo_restart && have_windows != stereo_have_windows) + { + MetaDisplay *display = meta_get_display (); + Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display); + Window root = DefaultRootWindow (xdisplay); + Atom atom_enable_stereo = XInternAtom (xdisplay, "_MUTTER_ENABLE_STEREO", False); + long value; + + stereo_have_windows = have_windows; + + if (stereo_have_windows) + meta_verbose ("Detected stereo windows\n"); + else + meta_verbose ("No stereo windows detected\n"); + + value = stereo_have_windows; + XChangeProperty (xdisplay, root, + atom_enable_stereo, XA_INTEGER, 32, + PropModeReplace, (guchar *)&value, 1); + + if (stereo_switch_id != 0) + { + g_source_remove (stereo_switch_id); + stereo_switch_id = 0; + } + + if (stereo_have_windows != stereo_enabled) + stereo_switch_id = g_timeout_add (stereo_have_windows ? STEREO_ENABLE_WAIT : STEREO_DISABLE_WAIT, + meta_stereo_switch, NULL); + } +} diff --git a/src/core/stereo.h b/src/core/stereo.h new file mode 100644 index 000000000..ccd1d702a --- /dev/null +++ b/src/core/stereo.h @@ -0,0 +1,28 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ + +/* + * Copyright (C) 2014 Red Hat, Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#ifndef META_STEREO_H +#define META_STEREO_H + +void meta_stereo_init (void); +void meta_stereo_set_have_stereo_windows (gboolean have_windows); +gboolean meta_stereo_is_restart (void); +void meta_stereo_finish_restart (void); + +#endif diff --git a/src/meson.build b/src/meson.build index 9919b5cfb..7cced8f53 100644 --- a/src/meson.build +++ b/src/meson.build @@ -353,6 +353,8 @@ mutter_sources = [ 'core/stack.h', 'core/stack-tracker.c', 'core/stack-tracker.h', + 'core/stereo.c', + 'core/stereo.h', 'core/startup-notification.c', 'core/startup-notification-private.h', 'core/util.c', diff --git a/src/wayland/meta-wayland-surface.c b/src/wayland/meta-wayland-surface.c index da0acfcbb..ddad1a45c 100644 --- a/src/wayland/meta-wayland-surface.c +++ b/src/wayland/meta-wayland-surface.c @@ -731,7 +731,7 @@ meta_wayland_surface_apply_pending_state (MetaWaylandSurface *surface, snippet = meta_wayland_buffer_create_snippet (pending->buffer); is_y_inverted = meta_wayland_buffer_is_y_inverted (pending->buffer); - meta_shaped_texture_set_texture (stex, texture); + meta_shaped_texture_set_textures (stex, texture, NULL); meta_shaped_texture_set_snippet (stex, snippet); meta_shaped_texture_set_is_y_inverted (stex, is_y_inverted); g_clear_pointer (&snippet, cogl_object_unref); -- 2.23.0