e_comp_wl: Extract function for update damage

This is to improve readability.

Change-Id: I46ec8f3b0d7fe4561b438d4cb69452fb93b5fad2

diff --git a/src/bin/server/e_comp_wl.c b/src/bin/server/e_comp_wl.c
index 1f15022c1a2d76ae7d30a5f9a66a591bf370337f..76f4594e301d07831eb96d4e997b12e2f4ab86c2 100644 (file)
--- a/src/bin/server/e_comp_wl.c
+++ b/src/bin/server/e_comp_wl.c
@@ -2382,14 +2382,14 @@ _e_comp_wl_buffer_damage_set(E_Comp_Wl_Buffer *buffer, pixman_region32_t *buffer
 
    if (!buffer->tbm_surface) return;
 
-   if (buffer_damages)
+   if (!buffer_damages || !pixman_region32_not_empty(buffer_damages))
      {
-        dmg = pixman_region32_extents(buffer_damages);
-        EINA_RECTANGLE_SET(&damage_rect, dmg->x1, dmg->y1, (dmg->x2 - dmg->x1), (dmg->y2 - dmg->y1));
+        EINA_RECTANGLE_SET(&damage_rect, 0, 0, buffer->w, buffer->h);
      }
    else
      {
-        EINA_RECTANGLE_SET(&damage_rect, 0, 0, buffer->w, buffer->h);
+        dmg = pixman_region32_extents(buffer_damages);
+        EINA_RECTANGLE_SET(&damage_rect, dmg->x1, dmg->y1, (dmg->x2 - dmg->x1), (dmg->y2 - dmg->y1));
      }
 
    tbm_surface_internal_set_damage(buffer->tbm_surface,
@@ -2847,10 +2847,109 @@ _e_comp_wl_input_thread_input_area_append(void *data)
    e_input_thread_client_input_region_append(e_input_thread_client_get(ec_data->ec), ec_data->rect);
 }
 
+static void
+_pixman_region_buffer_damage_apply(pixman_region32_t *dest, E_Surface *surface, enum wl_output_transform transform)
+{
+   E_Comp_Wl_Buffer *buffer;
+   pixman_region32_t *buffer_damage;
+   pixman_box32_t *rects;
+   int32_t bw, bh;
+   int32_t x, y, w, h;
+   int nrects, i;
+
+   buffer_damage = e_surface_buffer_damage_get(surface);
+   if (!buffer_damage)
+     return;
+
+   buffer = e_surface_buffer_try_get(surface);
+   rects = pixman_region32_rectangles(buffer_damage, &nrects);
+   for (i = 0; i < nrects; i++)
+     {
+        x = rects[i].x1;
+        y = rects[i].y1;
+        w = rects[i].x2 - x;
+        h = rects[i].y2 - y;
+
+        if (buffer)
+          {
+             e_comp_wl_buffer_size_get(buffer, &bw, &bh);
+             e_comp_wl_rect_convert_inverse(bw, bh, transform,
+                                            e_surface_buffer_scale_get(surface),
+                                            x, y, w, h,
+                                            &x, &y, &w, &h);
+          }
+
+        pixman_region32_union_rect(dest, dest, x, y, w, h);
+     }
+}
+
+static void
+_pixman_region_surface_damage_apply(pixman_region32_t *dest, E_Surface *surface)
+{
+   pixman_region32_t *surface_damage;
+
+   surface_damage = e_surface_surface_damage_get(surface);
+   if (surface_damage)
+     pixman_region32_union(dest, dest, surface_damage);
+}
+
+static void
+_e_comp_wl_surface_damage_set(E_Client *ec)
+{
+   E_Surface *surface = e_surface_from_ec(ec);
+   pixman_region32_t damages;
+   pixman_box32_t *rects;
+   int nrects, i;
+
+   pixman_region32_init(&damages);
+
+   _pixman_region_buffer_damage_apply(&damages, surface, e_comp_wl_output_buffer_transform_get(ec));
+   _pixman_region_surface_damage_apply(&damages, surface);
+
+   rects = pixman_region32_rectangles(&damages, &nrects);
+   for (i = 0; i < nrects; i++)
+     {
+        e_view_client_damage(e_client_view_get(ec),
+                             rects[i].x1,
+                             rects[i].y1,
+                             rects[i].x2 - rects[i].x1,
+                             rects[i].y2 - rects[i].y1);
+     }
+
+   pixman_region32_fini(&damages);
+}
+
+static void
+_e_comp_wl_surface_damage_update(E_Client *ec)
+{
+   E_Surface *surface = e_surface_from_ec(ec);
+   E_Comp_Wl_Buffer *buffer = e_surface_buffer_try_get(surface);
+   int32_t bw, bh;
+
+   if (e_surface_damage_empty(surface))
+     {
+        if (buffer &&
+            (buffer->type == E_COMP_WL_BUFFER_TYPE_NATIVE ||
+             buffer->type == E_COMP_WL_BUFFER_TYPE_TBM))
+          {
+             e_comp_wl_buffer_size_get(buffer, &bw, &bh);
+             e_view_client_damage(e_client_view_get(ec), 0, 0, bw, bh);
+          }
+        return;
+     }
+
+   if (buffer)
+     _e_comp_wl_buffer_damage_set(buffer, e_surface_buffer_damage_get(surface));
+
+   if (e_surface_viewport_changed_get(surface) ||
+       !e_comp_wl_get()->available_hw_accel.underlay ||
+       !buffer || buffer->type != E_COMP_WL_BUFFER_TYPE_VIDEO)
+     _e_comp_wl_surface_damage_set(ec);
+}
+
 static void
 _e_comp_wl_surface_state_commit(E_Client *ec, E_Comp_Wl_Surface_State *state)
 {
-   Eina_Rectangle *dmg;
    Eina_Bool placed = EINA_TRUE;
    int x = 0, y = 0;
    int w, h;
@@ -3035,92 +3134,8 @@ _e_comp_wl_surface_state_commit(E_Client *ec, E_Comp_Wl_Surface_State *state)
                                            state->frames);
    state->frames = NULL;
 
-   buffer = e_surface_buffer_try_get(surface);
-
-   /* put state damages into surface */
    if (e_client_view_get(ec))
-     {
-        pixman_region32_t *buffer_damage, *surface_damage;
-
-        buffer_damage = e_surface_buffer_damage_get(surface);
-        surface_damage = e_surface_surface_damage_get(surface);
-
-        /* FIXME: workaround for bad wayland egl driver which doesn't send damage request */
-        if ((!buffer_damage || !pixman_region32_not_empty(buffer_damage)) &&
-            (!surface_damage || !pixman_region32_not_empty(surface_damage)))
-          {
-             E_Comp_Wl_Buffer *comp_buffer = e_surface_buffer_try_get(surface);
-             if ((comp_buffer) &&
-                 ((comp_buffer->type == E_COMP_WL_BUFFER_TYPE_NATIVE) ||
-                  (comp_buffer->type == E_COMP_WL_BUFFER_TYPE_TBM)))
-               {
-                  int32_t bw, bh;
-
-                  e_comp_wl_buffer_size_get(comp_buffer, &bw, &bh);
-                  e_view_client_damage(e_client_view_get(ec), 0, 0, bw, bh);
-               }
-          }
-        else
-          {
-             Eina_List *damages = NULL;
-             pixman_box32_t *rects;
-             int nrects, i;
-             int32_t x, y, w, h;
-
-             if (buffer)
-               _e_comp_wl_buffer_damage_set(buffer, buffer_damage);
-
-             if (buffer_damage)
-               {
-                  rects = pixman_region32_rectangles(buffer_damage, &nrects);
-                  for (i = 0; i < nrects; i++)
-                    {
-                       if (buffer)
-                         {
-                            int32_t bw, bh;
-
-                            x = rects[i].x1;
-                            y = rects[i].y1;
-                            w = rects[i].x2 - x;
-                            h = rects[i].y2 - y;
-
-                            e_comp_wl_buffer_size_get(buffer, &bw, &bh);
-                            e_comp_wl_rect_convert_inverse(bw, bh,
-                                                           e_comp_wl_output_buffer_transform_get(ec),
-                                                           e_surface_buffer_scale_get(surface),
-                                                           x, y, w, h,
-                                                           &x, &y, &w, &h);
-                         }
-                       damages = eina_list_append(damages, eina_rectangle_new(x, y, w, h));
-                    }
-               }
-
-             if (surface_damage)
-               {
-                  rects = pixman_region32_rectangles(surface_damage, &nrects);
-                  for (i = 0; i < nrects; i++)
-                    {
-                       x = rects[i].x1;
-                       y = rects[i].y1;
-                       w = rects[i].x2 - x;
-                       h = rects[i].y2 - y;
-                       damages = eina_list_append(damages, eina_rectangle_new(x, y, w, h));
-                    }
-               }
-
-             comp_wl = e_comp_wl_get();
-             EINA_LIST_FREE(damages, dmg)
-               {
-                  /* not creating damage for ec that shows a underlay video */
-                  if (state->buffer_viewport.changed ||
-                     (!comp_wl->available_hw_accel.underlay) ||
-                     !buffer || buffer->type != E_COMP_WL_BUFFER_TYPE_VIDEO)
-                  e_view_client_damage(e_client_view_get(ec), dmg->x, dmg->y, dmg->w, dmg->h);
-
-                  eina_rectangle_free(dmg);
-               }
-          }
-     }
+     _e_comp_wl_surface_damage_update(ec);
 
    /* put state opaque into surface */
    e_pixmap_image_opaque_set(ec->pixmap, 0, 0, 0, 0);
@@ -3231,10 +3246,10 @@ _e_comp_wl_surface_state_commit(E_Client *ec, E_Comp_Wl_Surface_State *state)
 
    e_comp_wl_subsurface_check_alpha_mask_rect(ec);
 
-   comp_wl = e_comp_wl_get();
+   buffer = e_surface_buffer_try_get(surface);
    if ((cdata->video_client) &&
        (buffer && (buffer->type == E_COMP_WL_BUFFER_TYPE_VIDEO)) &&
-          (comp_wl->available_hw_accel.underlay))
+          (e_comp_wl_get()->available_hw_accel.underlay))
      {
         e_pixmap_image_clear(ec->pixmap, 1);
      }

diff --git a/src/bin/server/e_compositor.c b/src/bin/server/e_compositor.c
index ea53abaa36a8d65dd4f907534df24d455a0c81f4..8e532de3f282a844c084a2c057441b4ff81566bb 100644 (file)
--- a/src/bin/server/e_compositor.c
+++ b/src/bin/server/e_compositor.c
@@ -639,6 +639,16 @@ e_surface_surface_damage_get(E_Surface *surface)
    return &surface->ds_surface->current.surface_damage;
 }
 
+EINTERN Eina_Bool
+e_surface_damage_empty(E_Surface *surface)
+{
+   if (!surface->ds_surface)
+     return EINA_TRUE;
+
+   return !pixman_region32_not_empty(&surface->ds_surface->current.buffer_damage) &&
+      !pixman_region32_not_empty(&surface->ds_surface->current.surface_damage);
+}
+
 EINTERN E_Subsurface *
 e_subsurface_try_from_surface(E_Surface *surface)
 {

diff --git a/src/bin/server/e_compositor_intern.h b/src/bin/server/e_compositor_intern.h
index cf81934b99eb60c586ad4dd9d90e0feba863fe32..c5f7d008551b2e1f79d6e60a94caaa2e81ffe4a2 100644 (file)
--- a/src/bin/server/e_compositor_intern.h
+++ b/src/bin/server/e_compositor_intern.h
@@ -46,6 +46,7 @@ void e_surface_unmap(E_Surface *surface);
 Eina_Bool e_surface_is_mapped(E_Surface *surface);
 Eina_Bool e_surface_has_subsurfaces(E_Surface *surface);
 void e_surface_frame_done_send(E_Surface *surface);
+Eina_Bool e_surface_damage_empty(E_Surface *surface);
 pixman_region32_t *e_surface_buffer_damage_get(E_Surface *surface);
 pixman_region32_t *e_surface_surface_damage_get(E_Surface *surface);