wipwip/nielsdg/meta-multi-texture-dmabuf

8 files changed, 122 insertions, 121 deletions

diff --git a/src/compositor/meta-multi-texture.c b/src/compositor/meta-multi-texture.c
index ad2a1357b..28b8122d2 100644
--- a/src/compositor/meta-multi-texture.c
+++ b/src/compositor/meta-multi-texture.c
@@ -20,7 +20,7 @@
 /**
  * SECTION:meta-multi-texture
  * @title: MetaMultiTexture
- * @short_description: A texture that can have multiple planes.
+ * @short_description: A texture that can have multiple subtextures.
  *
  * #MetaMultiTexture allows one to deal with non-trivial formats that
  * have multiple planes, requires subsampling and/or aren't in RGB. A common
@@ -28,8 +28,8 @@
  * YUV colorspace, combined with subsampling.
  *
  * The basic idea of a #MetaMultiTexture is the following:
- * - Each plane is represented by a separate #CoglTexture. That means that you
- *   should add each of these planes as a layer to your CoglPipeline.
+ * - Each subtextures is represented by a separate #CoglTexture. That means
+ *   that you should add each of these planes as a layer to your #CoglPipeline.
  * - When dealing with a color space that is not RGB, you can ask the
  *   #MetaMultiTexture to create a shader for you that does the conversion
  *   in the GPU.
@@ -47,8 +47,8 @@ struct _MetaMultiTexture
 
   MetaMultiTextureFormat format;
 
-  guint n_planes;
-  CoglTexture **planes;
+  guint n_subtextures;
+  CoglTexture **subtextures;
 };
 
 G_DEFINE_TYPE (MetaMultiTexture, meta_multi_texture, G_TYPE_OBJECT);
@@ -87,41 +87,41 @@ meta_multi_texture_is_simple (MetaMultiTexture *self)
 }
 
 /**
- * meta_multi_texture_get_n_planes:
+ * meta_multi_texture_get_n_subtexture:
  * @self: a #MetaMultiTexture
  *
- * Returns the number of planes for this texture. Note that this is entirely
- * dependent on the #CoglPixelFormat that is used. For example, simple RGB
- * textures will have a single plane, while some more convoluted formats like
- * NV12 and YUV 4:4:4 can have 2 and 3 planes respectively.
+ * Returns the number of subtextures for this texture. For example, simple RGB
+ * textures will have a single subtexture, while some more convoluted formats
+ * like NV12 and YUV 4:4:4 can have 2 and 3 subtextures respectively.
  *
- * Returns: The number of planes in this #MetaMultiTexture.
+ * Returns: The number of subtextures in this #MetaMultiTexture.
  */
 guint
-meta_multi_texture_get_n_planes (MetaMultiTexture *self)
+meta_multi_texture_get_n_subtextures (MetaMultiTexture *self)
 {
   g_return_val_if_fail (META_IS_MULTI_TEXTURE (self), 0);
 
-  return self->n_planes;
+  return self->n_subtextures;
 }
 
 /**
- * meta_multi_texture_get_plane:
+ * meta_multi_texture_get_subtexture:
  * @self: a #MetaMultiTexture
- * @index: the index of the plane
+ * @index: the index of the subtexture
  *
- * Returns the n'th plane of the #MetaMultiTexture. Note that it's a programming
- * error to use with an index larger than meta_multi_texture_get_n_planes().
+ * Returns the n'th subtexture of the #MetaMultiTexture. Note that it's a
+ * programming error to use with an index larger than
+ * meta_multi_texture_get_n_subtextures().
  *
- * Returns: (transfer none): The plane at the given @index.
+ * Returns: (transfer none): The subtexture at the given @index.
  */
 CoglTexture *
-meta_multi_texture_get_plane (MetaMultiTexture *self, guint index)
+meta_multi_texture_get_subtexture (MetaMultiTexture *self, guint index)
 {
   g_return_val_if_fail (META_IS_MULTI_TEXTURE (self), 0);
-  g_return_val_if_fail (index < self->n_planes, NULL);
+  g_return_val_if_fail (index < self->n_subtextures, NULL);
 
-  return self->planes[index];
+  return self->subtextures[index];
 }
 
 /**
@@ -139,7 +139,7 @@ meta_multi_texture_get_width (MetaMultiTexture *self)
 {
   g_return_val_if_fail (META_IS_MULTI_TEXTURE (self), 0);
 
-  return cogl_texture_get_width (self->planes[0]);
+  return cogl_texture_get_width (self->subtextures[0]);
 }
 
 /**
@@ -157,7 +157,7 @@ meta_multi_texture_get_height (MetaMultiTexture *self)
 {
   g_return_val_if_fail (META_IS_MULTI_TEXTURE (self), 0);
 
-  return cogl_texture_get_height (self->planes[0]);
+  return cogl_texture_get_height (self->subtextures[0]);
 }
 
 static void
@@ -166,10 +166,10 @@ meta_multi_texture_finalize (GObject *object)
   MetaMultiTexture *self = META_MULTI_TEXTURE (object);
   int i;
 
-  for (i = 0; i < self->n_planes; i++)
-    cogl_clear_object (&self->planes[i]);
+  for (i = 0; i < self->n_subtextures; i++)
+    cogl_clear_object (&self->subtextures[i]);
 
-  g_free (self->planes);
+  g_free (self->subtextures);
 
   G_OBJECT_CLASS (meta_multi_texture_parent_class)->finalize (object);
 }
@@ -190,55 +190,55 @@ meta_multi_texture_class_init (MetaMultiTextureClass *klass)
 /**
  * meta_multi_texture_new:
  * @format: The format of the #MetaMultiTexture
- * @planes: (transfer full): The actual planes of the texture
- * @n_planes: The number of planes
+ * @subtextures: (transfer full): The actual subtextures of the texture
+ * @n_subtextures: The number of subtextures
  *
  * Creates a #MetaMultiTexture with the given @format. Each of the
- * #CoglTexture<!-- -->s represents a plane.
+ * #CoglTexture<!-- -->s represents a subtexture.
  *
  * Returns: (transfer full): A new #MetaMultiTexture. Use g_object_unref() when
  * you're done with it.
  */
 MetaMultiTexture *
 meta_multi_texture_new (MetaMultiTextureFormat format,
-                        CoglTexture          **planes,
-                        guint                  n_planes)
+                        CoglTexture          **subtextures,
+                        guint                  n_subtextures)
 {
   MetaMultiTexture *self;
 
-  g_return_val_if_fail (planes != NULL, NULL);
-  g_return_val_if_fail (n_planes > 0, NULL);
+  g_return_val_if_fail (subtextures != NULL, NULL);
+  g_return_val_if_fail (n_subtextures > 0, NULL);
 
   self = g_object_new (META_TYPE_MULTI_TEXTURE, NULL);
   self->format = format;
-  self->n_planes = n_planes;
-  self->planes = planes;
+  self->n_subtextures = n_subtextures;
+  self->subtextures = subtextures;
 
   return self;
 }
 
 /**
  * meta_multi_texture_new_simple:
- * @plane: (transfer full): The single plane of the texture
+ * @subtexture: (transfer full): The single subtexture of the texture
  *
  * Creates a #MetaMultiTexture for a "simple" texture, i.e. with only one
- * plane, in a format that can be represented using #CoglPixelFormat.
+ * subtexture, in a format that can be represented using #CoglPixelFormat.
  *
  * Returns: (transfer full): A new #MetaMultiTexture. Use g_object_unref() when
  * you're done with it.
  */
 MetaMultiTexture *
-meta_multi_texture_new_simple (CoglTexture *plane)
+meta_multi_texture_new_simple (CoglTexture *subtexture)
 {
   MetaMultiTexture *self;
 
-  g_return_val_if_fail (plane != NULL, NULL);
+  g_return_val_if_fail (subtexture != NULL, NULL);
 
   self = g_object_new (META_TYPE_MULTI_TEXTURE, NULL);
   self->format = META_MULTI_TEXTURE_FORMAT_SIMPLE;
-  self->n_planes = 1;
-  self->planes = g_malloc (sizeof (CoglTexture *));
-  self->planes[0] = plane;
+  self->n_subtextures = 1;
+  self->subtextures = g_malloc (sizeof (CoglTexture *));
+  self->subtextures[0] = subtexture;
 
   return self;
 }
@@ -264,17 +264,17 @@ meta_multi_texture_to_string (MetaMultiTexture *self)
   g_string_append_printf (str, "MetaMultiTexture (%p) {\n", self);
   format_str = g_enum_to_string (META_TYPE_MULTI_TEXTURE_FORMAT, self->format);
   g_string_append_printf (str, "  .format   =  %s;\n", format_str);
-  g_string_append_printf (str, "  .n_planes =  %u;\n", self->n_planes);
-  g_string_append (str, "  .planes   =  {\n");
+  g_string_append_printf (str, "  .n_subtextures =  %u;\n", self->n_subtextures);
+  g_string_append (str, "  .subtextures   =  {\n");
 
-  for (i = 0; i < self->n_planes; i++)
+  for (i = 0; i < self->n_subtextures; i++)
     {
-      CoglTexture *plane = self->planes[i];
-      CoglPixelFormat plane_format = _cogl_texture_get_format (plane);
+      CoglTexture *subtexture = self->subtextures[i];
+      CoglPixelFormat subtexture_format = _cogl_texture_get_format (subtexture);
 
       g_string_append_printf (str, "    (%p) { .format = %s },\n",
-                              plane,
-                              cogl_pixel_format_to_string (plane_format));
+                              subtexture,
+                              cogl_pixel_format_to_string (subtexture_format));
     }
 
   g_string_append (str, "  }\n");
diff --git a/src/compositor/meta-shaped-texture.c b/src/compositor/meta-shaped-texture.c
index 16f0ee89e..5abac1ebb 100644
--- a/src/compositor/meta-shaped-texture.c
+++ b/src/compositor/meta-shaped-texture.c
@@ -249,7 +249,7 @@ static CoglPipeline *
 get_base_pipeline (MetaShapedTexture *stex,
                    CoglContext       *ctx)
 {
-  guint i, n_planes;
+  guint i, n_subtextures;
   MetaMultiTextureFormat format;
   CoglPipeline *pipeline;
   CoglMatrix matrix;
@@ -257,13 +257,13 @@ get_base_pipeline (MetaShapedTexture *stex,
   if (stex->base_pipeline)
     return stex->base_pipeline;
 
-  /* We'll add as many layers as there are planes in the multi texture,
+  /* We'll add as many layers as there are subtextures in the multi texture,
    * plus an extra one for the mask */
-  n_planes = meta_multi_texture_get_n_planes (stex->texture);
+  n_subtextures = meta_multi_texture_get_n_subtextures (stex->texture);
 
   pipeline = cogl_pipeline_new (ctx);
 
-  for (i = 0; i < n_planes; i++)
+  for (i = 0; i < n_subtextures; i++)
     {
       cogl_pipeline_set_layer_wrap_mode_s (pipeline, i,
                                            COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE);
@@ -357,7 +357,7 @@ get_base_pipeline (MetaShapedTexture *stex,
                              0);
     }
 
-  for (i = 0; i < n_planes + 1; i++)
+  for (i = 0; i < n_subtextures + 1; i++)
     cogl_pipeline_set_layer_matrix (pipeline, i, &matrix);
 
   /* Add color conversion shaders if needed */
@@ -375,7 +375,7 @@ get_base_pipeline (MetaShapedTexture *stex,
       cogl_pipeline_add_snippet (pipeline, vertex_snippet);
       cogl_pipeline_add_snippet (pipeline, fragment_snippet);
 
-      for (i = 0; i < n_planes; i++)
+      for (i = 0; i < n_subtextures; i++)
         cogl_pipeline_add_layer_snippet (pipeline, i, layer_snippet);
     }
 
@@ -400,14 +400,14 @@ get_masked_pipeline (MetaShapedTexture *stex,
                      CoglContext       *ctx)
 {
   CoglPipeline *pipeline;
-  guint n_planes;
+  guint n_subtextures;
 
   if (stex->masked_pipeline)
     return stex->masked_pipeline;
 
   pipeline = cogl_pipeline_copy (get_base_pipeline (stex, ctx));
-  n_planes = meta_multi_texture_get_n_planes (stex->texture);
-  cogl_pipeline_set_layer_combine (pipeline, n_planes,
+  n_subtextures = meta_multi_texture_get_n_subtextures (stex->texture);
+  cogl_pipeline_set_layer_combine (pipeline, n_subtextures,
                                    "RGBA = MODULATE (PREVIOUS, TEXTURE[A])",
                                    NULL);
 
@@ -565,7 +565,7 @@ do_paint_content (MetaShapedTexture   *stex,
   CoglPipelineFilter filter;
   CoglFramebuffer *framebuffer;
   int sample_width, sample_height;
-  guint n_planes;
+  guint n_subtextures;
 
   ensure_size_valid (stex);
 
@@ -597,8 +597,8 @@ do_paint_content (MetaShapedTexture   *stex,
     }
   else
     {
-      sample_width = cogl_texture_get_width (stex->texture);
-      sample_height = cogl_texture_get_height (stex->texture);
+      sample_width = meta_multi_texture_get_width (stex->texture);
+      sample_height = meta_multi_texture_get_height (stex->texture);
     }
   if (meta_monitor_transform_is_rotated (stex->transform))
     flip_ints (&sample_width, &sample_height);
@@ -641,7 +641,7 @@ do_paint_content (MetaShapedTexture   *stex,
         }
     }
 
-  n_planes = meta_multi_texture_get_n_planes (paint_tex);
+  n_subtextures = meta_multi_texture_get_n_subtextures (paint_tex);
 
   /* First, paint the unblended parts, which are part of the opaque region. */
   if (use_opaque_region)
@@ -655,11 +655,11 @@ do_paint_content (MetaShapedTexture   *stex,
 
           opaque_pipeline = get_unblended_pipeline (stex, ctx);
 
-          for (i = 0; i < n_planes; i++)
+          for (i = 0; i < n_subtextures; i++)
             {
-              CoglTexture *plane = meta_multi_texture_get_plane (paint_tex, i);
+              CoglTexture *subtexture = meta_multi_texture_get_subtexture (paint_tex, i);
 
-              cogl_pipeline_set_layer_texture (opaque_pipeline, i, plane);
+              cogl_pipeline_set_layer_texture (opaque_pipeline, i, subtexture);
               cogl_pipeline_set_layer_filters (opaque_pipeline, i, filter, filter);
             }
 
@@ -697,15 +697,15 @@ do_paint_content (MetaShapedTexture   *stex,
       else
         {
           blended_pipeline = get_masked_pipeline (stex, ctx);
-          cogl_pipeline_set_layer_texture (blended_pipeline, n_planes, stex->mask_texture);
-          cogl_pipeline_set_layer_filters (blended_pipeline, n_planes, filter, filter);
+          cogl_pipeline_set_layer_texture (blended_pipeline, n_subtextures, stex->mask_texture);
+          cogl_pipeline_set_layer_filters (blended_pipeline, n_subtextures, filter, filter);
         }
 
-      for (i = 0; i < n_planes; i++)
+      for (i = 0; i < n_subtextures; i++)
         {
-          CoglTexture *plane = meta_multi_texture_get_plane (paint_tex, i);
+          CoglTexture *subtexture = meta_multi_texture_get_subtexture (paint_tex, i);
 
-          cogl_pipeline_set_layer_texture (blended_pipeline, i, plane);
+          cogl_pipeline_set_layer_texture (blended_pipeline, i, subtexture);
           cogl_pipeline_set_layer_filters (blended_pipeline, i, filter, filter);
         }
 
@@ -1111,10 +1111,10 @@ meta_shaped_texture_has_alpha (MetaShapedTexture *stex)
     return TRUE;
 
   /* FIXME: for now we don't support alpha (except simple textures) */
-  if (meta_multi_texture_get_n_planes (multi_texture) > 1)
+  if (meta_multi_texture_get_n_subtextures (multi_texture) > 1)
     return FALSE;
 
-  cogl_texture = meta_multi_texture_get_plane (multi_texture, 0);
+  cogl_texture = meta_multi_texture_get_subtexture (multi_texture, 0);
   switch (cogl_texture_get_components (cogl_texture))
     {
     case COGL_TEXTURE_COMPONENTS_A:
@@ -1232,10 +1232,10 @@ should_get_via_offscreen (MetaShapedTexture *stex)
 {
   CoglTexture *cogl_texture;
 
-  if (meta_multi_texture_get_n_planes (stex->texture) > 1)
+  if (meta_multi_texture_get_n_subtextures (stex->texture) > 1)
     return FALSE;
 
-  cogl_texture = meta_multi_texture_get_plane (stex->texture, 0);
+  cogl_texture = meta_multi_texture_get_subtexture (stex->texture, 0);
   if (!cogl_texture_is_get_data_supported (cogl_texture))
     return TRUE;
 
@@ -1422,8 +1422,8 @@ meta_shaped_texture_get_image (MetaShapedTexture     *stex,
                                       image_height);
     }
 
-  /* We know that we only have 1 plane at this point */
-  texture = meta_multi_texture_get_plane (stex->texture, 0);
+  /* We know that we only have 1 subtexture at this point */
+  texture = meta_multi_texture_get_subtexture (stex->texture, 0);
 
   if (image_clip)
     texture = cogl_texture_new_from_sub_texture (texture,
diff --git a/src/compositor/meta-surface-actor-x11.c b/src/compositor/meta-surface-actor-x11.c
index ba7b6cbef..50dc0f4ab 100644
--- a/src/compositor/meta-surface-actor-x11.c
+++ b/src/compositor/meta-surface-actor-x11.c
@@ -220,7 +220,7 @@ meta_surface_actor_x11_process_damage (MetaSurfaceActor *actor,
   if (!meta_multi_texture_is_simple (self->texture))
     return;
 
-  pixmap = COGL_TEXTURE_PIXMAP_X11 (meta_multi_texture_get_plane (self->texture, 0));
+  pixmap = COGL_TEXTURE_PIXMAP_X11 (meta_multi_texture_get_subtexture (self->texture, 0));
   cogl_texture_pixmap_x11_update_area (pixmap, x, y, width, height);
 }
 
diff --git a/src/compositor/meta-texture-tower.c b/src/compositor/meta-texture-tower.c
index 8dde49884..1d050e569 100644
--- a/src/compositor/meta-texture-tower.c
+++ b/src/compositor/meta-texture-tower.c
@@ -348,25 +348,27 @@ texture_tower_create_texture (MetaTextureTower *tower,
                               int               height)
 {
   MetaMultiTextureFormat format;
-  guint i, n_planes;
-  GPtrArray *planes;
+  guint i, n_subtextures;
+  GPtrArray *subtextures;
   CoglTexture **textures;
 
   format = meta_multi_texture_get_format (tower->textures[0]);
-  n_planes = meta_multi_texture_format_get_n_planes (format);
-  planes = g_ptr_array_new_full (n_planes, g_object_unref);
-  for (i = 0; i < n_planes; i++)
+  n_subtextures = meta_multi_texture_format_get_n_planes (format);
+  subtextures = g_ptr_array_new_full (n_subtextures, g_object_unref);
+  for (i = 0; i < n_subtextures; i++)
     {
       CoglTexture *texture;
 
        texture = cogl_texture_new_with_size (width, height,
                                              COGL_TEXTURE_NO_AUTO_MIPMAP,
                                              TEXTURE_FORMAT);
-       g_ptr_array_add (planes, texture);
+       g_ptr_array_add (subtextures, texture);
     }
 
-  textures = (CoglTexture **) g_ptr_array_free (planes, FALSE);
-  tower->textures[level] = meta_multi_texture_new (format, textures, n_planes);
+  textures = (CoglTexture **) g_ptr_array_free (subtextures, FALSE);
+  tower->textures[level] = meta_multi_texture_new (format,
+                                                   textures,
+                                                   n_subtextures);
 
   tower->invalid[level].x1 = 0;
   tower->invalid[level].y1 = 0;
@@ -381,7 +383,7 @@ texture_tower_revalidate (MetaTextureTower *tower,
   MetaMultiTexture *src_tex = tower->textures[level - 1];
   int src_width = meta_multi_texture_get_width (src_tex);
   int src_height = meta_multi_texture_get_height (src_tex);
-  guint src_n_planes = meta_multi_texture_get_n_planes (src_tex);
+  guint src_n_subtextures = meta_multi_texture_get_n_subtextures (src_tex);
   MetaMultiTexture *dest_tex = tower->textures[level];
   int dest_width = meta_multi_texture_get_width (dest_tex);
   int dest_height = meta_multi_texture_get_height (dest_tex);
@@ -390,16 +392,16 @@ texture_tower_revalidate (MetaTextureTower *tower,
 
   /* FIXME: cogl_offscreen_texture_new_with_texture doesn't work for
    * multi-plane textures, so we have to make an FBO for each layer */
-    for (i = 0; i < src_n_planes; i++)
+    for (i = 0; i < src_n_subtextures; i++)
     {
       Box *invalid = &tower->invalid[level];
-      CoglTexture *src_plane, *dest_plane;
+      CoglTexture *src_subtexture, *dest_subtexture;
       CoglFramebuffer *fb;
       GError *catch_error = NULL;
       CoglPipeline *pipeline;
 
-      src_plane = meta_multi_texture_get_plane (src_tex, i);
-      dest_plane = meta_multi_texture_get_plane (dest_tex, i);
+      src_subtexture = meta_multi_texture_get_subtexture (src_tex, i);
+      dest_subtexture = meta_multi_texture_get_subtexture (dest_tex, i);
 
       if (g_list_nth (tower->fbos[level], i) != NULL)
         {
@@ -407,7 +409,7 @@ texture_tower_revalidate (MetaTextureTower *tower,
         }
       else
         {
-          fb = COGL_FRAMEBUFFER (cogl_offscreen_new_with_texture (dest_plane));
+          fb = COGL_FRAMEBUFFER (cogl_offscreen_new_with_texture (dest_subtexture));
           tower->fbos[level] = g_list_append (tower->fbos[level], fb);
         }
 
@@ -428,7 +430,7 @@ texture_tower_revalidate (MetaTextureTower *tower,
         }
 
       pipeline = cogl_pipeline_copy (tower->pipeline_template);
-      cogl_pipeline_set_layer_texture (pipeline, 0, src_plane);
+      cogl_pipeline_set_layer_texture (pipeline, 0, src_subtexture);
 
       cogl_framebuffer_draw_textured_rectangle (fb, pipeline,
                                                 invalid->x1, invalid->y1,
diff --git a/src/meta/meta-multi-texture.h b/src/meta/meta-multi-texture.h
index 3c895e505..13af05530 100644
--- a/src/meta/meta-multi-texture.h
+++ b/src/meta/meta-multi-texture.h
@@ -38,34 +38,34 @@ G_DECLARE_FINAL_TYPE (MetaMultiTexture, meta_multi_texture,
 
 
 META_EXPORT
-MetaMultiTexture *     meta_multi_texture_new              (MetaMultiTextureFormat format,
-                                                            CoglTexture          **planes,
-                                                            guint                  n_planes);
+MetaMultiTexture *     meta_multi_texture_new               (MetaMultiTextureFormat format,
+                                                             CoglTexture          **subtextures,
+                                                             guint                  n_subtextures);
 
 META_EXPORT
-MetaMultiTexture *     meta_multi_texture_new_simple       (CoglTexture    *plane);
+MetaMultiTexture *     meta_multi_texture_new_simple        (CoglTexture *subtexture);
 
 META_EXPORT
-MetaMultiTextureFormat meta_multi_texture_get_format       (MetaMultiTexture *self);
+MetaMultiTextureFormat meta_multi_texture_get_format        (MetaMultiTexture *self);
 
 META_EXPORT
-gboolean               meta_multi_texture_is_simple        (MetaMultiTexture *self);
+gboolean               meta_multi_texture_is_simple         (MetaMultiTexture *self);
 
 META_EXPORT
-guint                  meta_multi_texture_get_n_planes     (MetaMultiTexture *self);
+guint                  meta_multi_texture_get_n_subtextures (MetaMultiTexture *self);
 
 META_EXPORT
-CoglTexture *          meta_multi_texture_get_plane        (MetaMultiTexture *self,
-                                                            guint index);
+CoglTexture *          meta_multi_texture_get_subtexture    (MetaMultiTexture *self,
+                                                             guint index);
 
 META_EXPORT
-int                    meta_multi_texture_get_width        (MetaMultiTexture *self);
+int                    meta_multi_texture_get_width         (MetaMultiTexture *self);
 
 META_EXPORT
-int                    meta_multi_texture_get_height       (MetaMultiTexture *self);
+int                    meta_multi_texture_get_height        (MetaMultiTexture *self);
 
 META_EXPORT
-char *                 meta_multi_texture_to_string        (MetaMultiTexture *self);
+char *                 meta_multi_texture_to_string         (MetaMultiTexture *self);
 
 G_END_DECLS
 
diff --git a/src/wayland/meta-wayland-buffer.c b/src/wayland/meta-wayland-buffer.c
index 1f8812ca6..b95222d50 100644
--- a/src/wayland/meta-wayland-buffer.c
+++ b/src/wayland/meta-wayland-buffer.c
@@ -253,7 +253,7 @@ shm_buffer_attach (MetaWaylandBuffer  *buffer,
       meta_multi_texture_get_height (*texture) == height &&
       meta_multi_texture_get_format (*texture) == multi_format)
     {
-      CoglTexture *cogl_texture = meta_multi_texture_get_plane (*texture, 0);
+      CoglTexture *cogl_texture = meta_multi_texture_get_subtexture (*texture, 0);
       if (cogl_texture_get_components (cogl_texture) == components &&
           _cogl_texture_get_format (cogl_texture) == cogl_format)
         {
@@ -321,8 +321,8 @@ egl_image_buffer_attach (MetaWaylandBuffer  *buffer,
   int format, width, height, y_inverted;
   MetaMultiTextureFormat multi_format = META_MULTI_TEXTURE_FORMAT_SIMPLE;
   CoglPixelFormat cogl_format = COGL_PIXEL_FORMAT_ANY;
-  guint i, n_planes;
-  GPtrArray *planes;
+  guint i, n_subtextures;
+  GPtrArray *subtextures;
 
   if (buffer->egl_image.texture)
     {
@@ -361,12 +361,12 @@ egl_image_buffer_attach (MetaWaylandBuffer  *buffer,
       cogl_format = COGL_PIXEL_FORMAT_RGBA_8888_PRE;
       break;
     case EGL_TEXTURE_Y_UV_WL:
-      /* Technically it can be anything with a separate Y and UV plane
+      /* Technically it can be anything with a separate Y and UV subtexture
        * but since this is only used for shaders later, it's ok */
       multi_format = META_MULTI_TEXTURE_FORMAT_NV12;
       break;
     case EGL_TEXTURE_Y_U_V_WL:
-      /* Technically it can be anything with a separate Y and UV plane
+      /* Technically it can be anything with a separate Y and UV subtexture
        * but since this is only used for shaders later, it's ok */
       multi_format = META_MULTI_TEXTURE_FORMAT_YUV444;
       break;
@@ -377,20 +377,20 @@ egl_image_buffer_attach (MetaWaylandBuffer  *buffer,
       return FALSE;
     }
 
-  /* Each EGLImage is a plane in the final texture */
-  n_planes = meta_multi_texture_format_get_n_planes (multi_format);
-  planes = g_ptr_array_new_full (n_planes, cogl_object_unref);
+  /* Each EGLImage is a subtexture in the final texture */
+  n_subtextures = meta_multi_texture_format_get_n_planes (multi_format);
+  subtextures = g_ptr_array_new_full (n_subtextures, cogl_object_unref);
 
   g_warning ("Got EGL with format %u", multi_format);
 
-  for (i = 0; i < n_planes; i++)
+  for (i = 0; i < n_subtextures; i++)
     {
       EGLint egl_attribs[3];
       EGLImageKHR egl_img;
       CoglEglImageFlags flags;
       CoglTexture2D *texture_2d;
 
-      /* Specify that we want the i'th plane */
+      /* Specify that we want the i'th subtexture */
       egl_attribs[0] = EGL_WAYLAND_PLANE_WL;
       egl_attribs[1] = i;
       egl_attribs[2] = EGL_NONE;
@@ -418,13 +418,13 @@ egl_image_buffer_attach (MetaWaylandBuffer  *buffer,
       if (G_UNLIKELY (!texture_2d))
         goto on_error;
 
-      g_ptr_array_add (planes, COGL_TEXTURE (texture_2d));
+      g_ptr_array_add (subtextures, COGL_TEXTURE (texture_2d));
     }
 
   buffer->egl_image.texture =
       meta_multi_texture_new (multi_format,
-                              (CoglTexture**) g_ptr_array_free (planes, FALSE),
-                              n_planes);
+                              (CoglTexture**) g_ptr_array_free (subtextures, FALSE),
+                              n_subtextures);
   buffer->is_y_inverted = !!y_inverted;
 
   g_clear_object (texture);
@@ -433,7 +433,7 @@ egl_image_buffer_attach (MetaWaylandBuffer  *buffer,
   return TRUE;
 
 on_error:
-  g_ptr_array_free (planes, TRUE);
+  g_ptr_array_free (subtextures, TRUE);
   return FALSE;
 }
 
@@ -562,7 +562,7 @@ process_shm_buffer_damage (MetaWaylandBuffer *buffer,
 
   shm_buffer_get_format (shm_buffer, &multi_format, &cogl_format, NULL);
   g_return_val_if_fail (multi_format == META_MULTI_TEXTURE_FORMAT_SIMPLE, FALSE);
-  cogl_texture = meta_multi_texture_get_plane (texture, 0);
+  cogl_texture = meta_multi_texture_get_subtexture (texture, 0);
 
   wl_shm_buffer_begin_access (shm_buffer);
 
diff --git a/src/wayland/meta-wayland-cursor-surface.c b/src/wayland/meta-wayland-cursor-surface.c
index 71bad9cc6..3b7ab7b75 100644
--- a/src/wayland/meta-wayland-cursor-surface.c
+++ b/src/wayland/meta-wayland-cursor-surface.c
@@ -71,7 +71,7 @@ update_cursor_sprite_texture (MetaWaylandCursorSurface *cursor_surface)
       g_return_if_fail (meta_multi_texture_is_simple (texture));
 
       meta_cursor_sprite_set_texture (cursor_sprite,
-                                      meta_multi_texture_get_plane (texture, 0),
+                                      meta_multi_texture_get_subtexture (texture, 0),
                                       priv->hot_x * surface->scale,
                                       priv->hot_y * surface->scale);
     }
diff --git a/src/wayland/meta-wayland-dma-buf.c b/src/wayland/meta-wayland-dma-buf.c
index 7b3a202c3..fb9af0a19 100644
--- a/src/wayland/meta-wayland-dma-buf.c
+++ b/src/wayland/meta-wayland-dma-buf.c
@@ -205,7 +205,6 @@ meta_wayland_dma_buf_realize_texture (MetaWaylandBuffer  *buffer,
                                                      flags,
                                                      error);
 
-  G_BREAKPOINT();
   meta_egl_destroy_image (egl, egl_display, egl_image, NULL);
 
   if (cogl_texture == NULL)