From 919ae6b2b7685503fdeecd2e444a1bec511d5746 Mon Sep 17 00:00:00 2001 From: Niels De Graef Date: Tue, 7 Apr 2020 17:58:56 +0200 Subject: [PATCH] wip --- src/compositor/meta-multi-texture.c | 98 +++++++++++------------ src/compositor/meta-shaped-texture.c | 54 ++++++------- src/compositor/meta-surface-actor-x11.c | 2 +- src/compositor/meta-texture-tower.c | 32 ++++---- src/meta/meta-multi-texture.h | 24 +++--- src/wayland/meta-wayland-buffer.c | 30 +++---- src/wayland/meta-wayland-cursor-surface.c | 2 +- src/wayland/meta-wayland-dma-buf.c | 1 - 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 - * #CoglTextures represents a plane. + * #CoglTextures 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)