From 2b45c3e37da7a590227e965d8a18e89337b791ba Mon Sep 17 00:00:00 2001

From: "Owen W. Taylor" <otaylor@fishsoup.net>

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         |  86 ++++++++++-

 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, 483 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 <GL/gl.h>

+

+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..9665ce2b6 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;

@@ -193,6 +195,9 @@ meta_shaped_texture_init (MetaShapedTexture *stex)

   stex->paint_tower = meta_texture_tower_new ();

+  stex->paint_tower = meta_texture_tower_new ();

+  stex->paint_tower_right = NULL; /* demand create */

+

   stex->texture = NULL;

   stex->mask_texture = NULL;

   stex->create_mipmaps = TRUE;

@@ -335,6 +340,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 +619,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 +629,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 +649,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 +665,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 +957,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 +1021,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 +1120,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 +1319,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 +1371,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 <http://www.gnu.org/licenses/>.

+ */

+

+/*

+ * 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.