all refactoring.

Change-Id: I7df3a0f5c3181b7779d210da7613240b918f0465

diff --git a/src/bin/e_comp.c b/src/bin/e_comp.c
index 9f1486d7d433885a909aeae90b7970658c7b9fbb..bc60ae3aaee8514150b52df81349e4ddf578397f 100644 (file)
--- a/src/bin/e_comp.c
+++ b/src/bin/e_comp.c
@@ -930,6 +930,9 @@ e_comp_hwc_end(const char *location)
 EINTERN void
 e_comp_hwc_multi_plane_set(Eina_Bool set)
 {
+   E_Comp_Config *conf = e_comp_config_get();
+
+   if (!conf->hwc_use_multi_plane) return;
    if (e_comp->hwc_use_multi_plane == set) return;
 
    e_comp_hwc_end(__FUNCTION__);

diff --git a/src/bin/e_output.c b/src/bin/e_output.c
index 6cafc05c76ef2120ba4f210a8b706f77b29e0a77..f3c0aa20880414a7106b1d4945ba82fd318db986 100644 (file)
--- a/src/bin/e_output.c
+++ b/src/bin/e_output.c
@@ -675,8 +675,8 @@ e_output_commit(E_Output *output)
         if (!fb_commit) return EINA_TRUE;
 
         /* zoom commit */
-        if (!e_plane_zoom_commit(fb_target))
-          ERR("fail to e_plane_zoom_commit");
+        if (!e_plane_pp_commit(fb_target))
+          ERR("fail to e_plane_pp_commit");
      }
    else
      {

diff --git a/src/bin/e_plane.c b/src/bin/e_plane.c
index 71234b5f34eda444e5fd6b794ff716fe560b804a..7b7e9a8c89c1ccd6dab622c6682155fe9b91579e 100644 (file)
--- a/src/bin/e_plane.c
+++ b/src/bin/e_plane.c
@@ -24,8 +24,8 @@ static E_Client_Hook *client_hook_new = NULL;
 static E_Client_Hook *client_hook_del = NULL;
 static const char *_e_plane_ec_last_err = NULL;
 static Eina_Bool plane_trace_debug = 0;
-static void _e_plane_zoom_pending_commit(E_Plane *plane);
-static void _e_plane_zoom_pending_data_pp(E_Plane *plane);
+static Eina_Bool _e_plane_pp_layer_commit(E_Plane *plane, tbm_surface_h tsurface);
+static Eina_Bool _e_plane_pp_commit(E_Plane *plane, E_Plane_Commit_Data *data);
 
 E_API int E_EVENT_PLANE_WIN_CHANGE = -1;
 
@@ -106,8 +106,8 @@ _e_plane_surface_unset(E_Plane *plane)
    error = tdm_layer_unset_buffer(tlayer);
    if (error != TDM_ERROR_NONE)
      {
-         ERR("fail to tdm_layer_unset_buffer");
-         return EINA_FALSE;
+        ERR("fail to tdm_layer_unset_buffer");
+        return EINA_FALSE;
      }
 
    return EINA_TRUE;
@@ -926,23 +926,6 @@ _e_plane_commit_hanler(tdm_layer *layer, unsigned int sequence,
    e_plane_commit_data_release(data);
 }
 
-static void
-_e_plane_zoom_destroy(E_Plane *plane)
-{
-   if (plane->zoom_tqueue)
-     {
-        tbm_surface_queue_destroy(plane->zoom_tqueue);
-        plane->zoom_tqueue = NULL;
-     }
-   if (plane->tpp)
-     {
-        tdm_pp_destroy(plane->tpp);
-        plane->tpp = NULL;
-     }
-
-   ERR("_e_plane_zoom_destroy done");
-}
-
 EINTERN Eina_Bool
 e_plane_commit(E_Plane *plane)
 {
@@ -980,28 +963,6 @@ e_plane_commit(E_Plane *plane)
    if (plane->ec)
       e_pixmap_image_clear(plane->ec->pixmap, 1);
 
-   if (plane->zoom_unset)
-     {
-        if (e_plane_is_fb_target(plane))
-          {
-             if (plane->zoom_tsurface)
-               {
-                  tbm_surface_queue_release(plane->zoom_tqueue, plane->zoom_tsurface);
-                  tbm_surface_internal_unref(plane->zoom_tsurface);
-
-                  plane->zoom_tsurface = NULL;
-               }
-
-             if ((eina_list_count(plane->pending_commit_zoom_data_list) == 0) &&
-                 (eina_list_count(plane->pending_pp_zoom_data_list) == 0) &&
-                 (eina_list_count(plane->zoom_data_list) == 0))
-               {
-                  _e_plane_zoom_destroy(plane);
-                  plane->zoom_unset = EINA_FALSE;
-               }
-          }
-     }
-
    plane->wait_commit = EINA_TRUE;
 
    return EINA_TRUE;
@@ -1550,7 +1511,7 @@ e_plane_show_state(E_Plane *plane)
 }
 
 static Eina_Bool
-_e_plane_zoom_set_pp_info(E_Plane *plane)
+_e_plane_pp_info_set(E_Plane *plane)
 {
    tdm_info_pp pp_info;
    tdm_error ret = TDM_ERROR_NONE;
@@ -1559,6 +1520,10 @@ _e_plane_zoom_set_pp_info(E_Plane *plane)
    tbm_surface_h tsurface = plane->tsurface;
    int dst_w, dst_h;
 
+   /* when the pp_set_info is true, change the pp set_info */
+   if (!plane->pp_set_info) return EINA_TRUE;
+   plane->pp_set_info = EINA_FALSE;
+
    tbm_surface_get_info(tsurface, &surf_info);
 
    aligned_width = _e_plane_aligned_width_get(tsurface);
@@ -1568,10 +1533,10 @@ _e_plane_zoom_set_pp_info(E_Plane *plane)
 
    pp_info.src_config.size.h = aligned_width;
    pp_info.src_config.size.v = surf_info.height;
-   pp_info.src_config.pos.x = plane->zoom_rect_temp.x;
-   pp_info.src_config.pos.y = plane->zoom_rect_temp.y;
-   pp_info.src_config.pos.w = plane->zoom_rect_temp.w;
-   pp_info.src_config.pos.h = plane->zoom_rect_temp.h;
+   pp_info.src_config.pos.x = plane->zoom_rect.x;
+   pp_info.src_config.pos.y = plane->zoom_rect.y;
+   pp_info.src_config.pos.w = plane->zoom_rect.w;
+   pp_info.src_config.pos.h = plane->zoom_rect.h;
    pp_info.src_config.format = TBM_FORMAT_ARGB8888;
 
    pp_info.dst_config.size.h = aligned_width;
@@ -1589,133 +1554,102 @@ _e_plane_zoom_set_pp_info(E_Plane *plane)
    ret = tdm_pp_set_info(plane->tpp, &pp_info);
    EINA_SAFETY_ON_FALSE_RETURN_VAL(ret == TDM_ERROR_NONE, EINA_FALSE);
 
-   plane->zoom_rect.x = plane->zoom_rect_temp.x;
-   plane->zoom_rect.y = plane->zoom_rect_temp.y;
-   plane->zoom_rect.w = plane->zoom_rect_temp.w;
-   plane->zoom_rect.h = plane->zoom_rect_temp.h;
-
-   DBG("_e_plane_zoom_set_pp_info success(src x:%d,y:%d,w:%d,h:%d)",
-       plane->zoom_rect.x, plane->zoom_rect.y, plane->zoom_rect.w, plane->zoom_rect.h);
+   if (plane_trace_debug)
+     ELOGF("E_PLANE", "PP Info  Plane(%p) rect(x,y,w,h = %d,%d,%d,%d)",
+           NULL, NULL, plane, plane->zoom_rect.x, plane->zoom_rect.y, plane->zoom_rect.w, plane->zoom_rect.h);
 
    return EINA_TRUE;
 }
 
 static void
-_e_plane_zoom_commit_data_release(E_Plane_Pp_Data *pp_data)
+_e_plane_pp_layer_commit_handler(tdm_layer *layer, unsigned int sequence,
+                                  unsigned int tv_sec, unsigned int tv_usec,
+                                  void *user_data)
 {
+   E_Plane_Commit_Data *data = (E_Plane_Commit_Data *)user_data;
    E_Plane *plane = NULL;
-   tbm_surface_h zoom_tsurface = NULL;
-
-   EINA_SAFETY_ON_NULL_RETURN(pp_data);
 
-   plane = pp_data->plane;
-   zoom_tsurface = pp_data->zoom_tsurface;
+   EINA_SAFETY_ON_NULL_RETURN(data);
 
-   if (plane->zoom_tsurface)
-     {
-        tbm_surface_queue_release(plane->zoom_tqueue, plane->zoom_tsurface);
+   plane = data->plane;
 
-        tbm_surface_internal_unref(plane->zoom_tsurface);
-     }
-   plane->zoom_tsurface = zoom_tsurface;
+   plane->pp_commit = EINA_FALSE;
 
-   plane->zoom_data_list = eina_list_remove(plane->zoom_data_list, pp_data);
+   /* if pp_set is false, do not deal with pending list */
+   if (!plane->pp_set)
+   {
+      free(data);
+      return;
+   }
 
-   free(pp_data);
-}
+   if (plane->pp_tqueue && plane->pp_tsurface)
+     {
+        /* release and unref the current pp surface on the plane */
+        tbm_surface_queue_release(plane->pp_tqueue, plane->pp_tsurface);
+        tbm_surface_internal_unref(plane->pp_tsurface);
+     }
 
-static void
-_e_plane_zoom_commit_handler(tdm_layer *layer, unsigned int sequence,
-                                  unsigned int tv_sec, unsigned int tv_usec,
-                                  void *user_data)
-{
-   E_Plane_Pp_Data *pp_data = (E_Plane_Pp_Data *)user_data;
-   E_Plane *plane = NULL;
+   /* set the new pp surface to the plane */
+   plane->pp_tsurface = data->tsurface;
 
-   EINA_SAFETY_ON_NULL_RETURN(pp_data);
+   free(data);
 
-   TRACE_DS_ASYNC_END((unsigned int)layer, [PLANE:COMMIT~HANDLER]);
+   if (plane_trace_debug)
+     ELOGF("E_PLANE", "PP Layer Commit Handler Plane(%p)", NULL, NULL, plane);
 
-   _e_plane_zoom_commit_data_release(pp_data);
+   /* deal with the pending layer commit */
+   data = eina_list_nth(plane->pending_pp_commit_data_list, 0);
+   if (data)
+     {
+        plane->pending_pp_commit_data_list = eina_list_remove(plane->pending_pp_commit_data_list, data);
 
-   plane = pp_data->plane;
+        if (!_e_plane_pp_layer_commit(plane, data->tsurface))
+          {
+             ERR("fail to _e_plane_pp_layer_commit");
+             return;
+          }
+     }
 
-   if (eina_list_count(plane->pending_commit_zoom_data_list) != 0)
-     _e_plane_zoom_pending_commit(plane);
-   else
-     plane->zoom_commit = EINA_FALSE;
+   /* deal with the pending pp commit */
+   data = eina_list_nth(plane->pending_pp_data_list, 0);
+   if (data)
+     {
+        plane->pending_pp_data_list = eina_list_remove(plane->pending_pp_data_list, data);
 
-   if (eina_list_count(plane->pending_pp_zoom_data_list) != 0)
-     _e_plane_zoom_pending_data_pp(plane);
+        if (!_e_plane_pp_commit(plane, data))
+          {
+             ERR("fail _e_plane_pp_commit");
+             return;
+          }
+     }
 }
 
-static void
-_e_plane_zoom_pp_cb(tdm_pp *pp, tbm_surface_h tsurface_src, tbm_surface_h tsurface_dst, void *user_data)
+static Eina_Bool
+_e_plane_pp_layer_commit(E_Plane *plane, tbm_surface_h tsurface)
 {
-   E_Plane_Pp_Data *pp_data = NULL;
-   E_Plane_Commit_Data *data = NULL;
-   E_Plane *plane = NULL;
    tbm_surface_info_s surf_info;
-   tbm_surface_h zoom_tsurface;
+   tbm_surface_h pp_tsurface;
    tbm_error_e tbm_err;
    tdm_error tdm_err;
-   tdm_layer *tlayer = NULL;
+   tdm_layer *tlayer = plane->tlayer;
    unsigned int aligned_width;
    int dst_w, dst_h;
+   E_Plane_Commit_Data *data = NULL;
 
-   pp_data = (E_Plane_Pp_Data *)user_data;
-   if (!pp_data)
-     {
-        ERR("fail no pp_data");
-        return;
-     }
-
-   data = pp_data->data;
-   if (!data)
-     ERR("fail no data");
-
-   plane = pp_data->plane;
-   if (!plane)
-     {
-        ERR("fail no plane");
-        return;
-     }
-
-   if (data)
-     {
-        if (data->ec)
-          e_pixmap_image_clear(data->ec->pixmap, 1);
-        e_plane_commit_data_release(data);
-        pp_data->data = NULL;
-     }
-
-   plane->wait_commit = EINA_FALSE;
-   if (plane->zoom_unset)
-     {
-        tbm_surface_queue_release(plane->zoom_tqueue, tsurface_dst);
-        tbm_surface_internal_unref(tsurface_dst);
-
-        plane->zoom_data_list = eina_list_remove(plane->zoom_data_list, pp_data);
-
-        free(pp_data);
-
-        return;
-     }
-
-   tlayer = plane->tlayer;
+   if (plane_trace_debug)
+     ELOGF("E_PLANE", "PP Layer Commit  Plane(%p)     pp_tsurface(%p)", NULL, NULL, plane, tsurface);
 
    /* set layer when the layer infomation is different from the previous one */
-   tbm_surface_get_info(tsurface_dst, &surf_info);
+   tbm_surface_get_info(tsurface, &surf_info);
 
    /* get the size of the output */
    e_output_size_get(plane->output, &dst_w, &dst_h);
 
-   aligned_width = _e_plane_aligned_width_get(tsurface_dst);
+   aligned_width = _e_plane_aligned_width_get(tsurface);
    if (aligned_width == 0)
      {
         ERR("aligned_width 0");
-        _e_plane_zoom_commit_data_release(pp_data);
-        return;
+        goto fail;
      }
 
    if (_e_plane_tlayer_info_set(plane, aligned_width, surf_info.height,
@@ -1727,288 +1661,190 @@ _e_plane_zoom_pp_cb(tdm_pp *pp, tbm_surface_h tsurface_src, tbm_surface_h tsurfa
         if (tdm_err != TDM_ERROR_NONE)
           {
              ERR("fail tdm_layer_set_info");
-             _e_plane_zoom_commit_data_release(pp_data);
-             return;
+             goto fail;
           }
      }
 
-   tbm_err = tbm_surface_queue_enqueue(plane->zoom_tqueue, tsurface_dst);
+   tbm_err = tbm_surface_queue_enqueue(plane->pp_tqueue, tsurface);
    if (tbm_err != TBM_ERROR_NONE)
      {
         ERR("fail tbm_surface_queue_enqueue");
-        _e_plane_zoom_commit_data_release(pp_data);
-        return;
+        goto fail;
      }
 
-   tbm_err = tbm_surface_queue_acquire(plane->zoom_tqueue, &zoom_tsurface);
+   tbm_err = tbm_surface_queue_acquire(plane->pp_tqueue, &pp_tsurface);
    if (tbm_err != TBM_ERROR_NONE)
      {
         ERR("fail tbm_surface_queue_acquire");
-        _e_plane_zoom_commit_data_release(pp_data);
-        return;
+        goto fail;
      }
 
-   pp_data->zoom_tsurface = zoom_tsurface;
-   pp_data->plane = plane;
+   data = E_NEW(E_Plane_Commit_Data, 1);
+   data->plane = plane;
+   data->renderer = NULL;
+   data->tsurface = pp_tsurface;
+   tbm_surface_internal_ref(data->tsurface);
+   data->ec = NULL;
 
-   if (plane->zoom_commit)
+   if (plane->pp_commit)
      {
-        plane->pending_commit_zoom_data_list = eina_list_append(plane->pending_commit_zoom_data_list, pp_data);
-        return;
+        plane->pending_pp_commit_data_list = eina_list_append(plane->pending_pp_commit_data_list, data);
+        return EINA_TRUE;
      }
 
-   plane->zoom_commit = EINA_TRUE;
-
-   if (plane_trace_debug)
-     ELOGF("E_PLANE", "Set  Plane(%p)     zoom_tsurface(%p)", NULL, NULL, plane, zoom_tsurface);
-
-   tdm_err = tdm_layer_set_buffer(tlayer, zoom_tsurface);
+   tdm_err = tdm_layer_set_buffer(tlayer, pp_tsurface);
    if (tdm_err != TDM_ERROR_NONE)
      {
         ERR("fail to tdm_layer_set_buffer");
-        _e_plane_zoom_commit_data_release(pp_data);
-        return;
+        goto fail;
      }
 
-   tdm_err = tdm_layer_commit(tlayer, _e_plane_zoom_commit_handler, pp_data);
+   tdm_err = tdm_layer_commit(tlayer, _e_plane_pp_layer_commit_handler, data);
    if (tdm_err != TDM_ERROR_NONE)
      {
         ERR("fail to tdm_layer_commit plane:%p, zpos:%d", plane, plane->zpos);
-        _e_plane_zoom_commit_data_release(pp_data);
-        return;
+        goto fail;
      }
 
-   return;
+   plane->pp_commit = EINA_TRUE;
+
+   return EINA_TRUE;
+
+fail:
+   if (data)
+     {
+        tbm_surface_internal_unref(data->tsurface);
+        free(data);
+     }
+   tbm_surface_queue_release(plane->pp_tqueue, tsurface);
+   if (pp_tsurface && pp_tsurface != tsurface)
+    tbm_surface_queue_release(plane->pp_tqueue, pp_tsurface);
+
+   return EINA_FALSE;
 }
 
 static void
-_e_plane_zoom_pending_commit(E_Plane *plane)
+_e_plane_pp_commit_handler(tdm_pp *pp, tbm_surface_h tsurface_src, tbm_surface_h tsurface_dst, void *user_data)
 {
-   tbm_surface_h zoom_tsurface = NULL;
-   tdm_error tdm_err = TDM_ERROR_NONE;
-   tdm_layer *tlayer = NULL;
-   E_Plane_Pp_Data *pp_data = NULL;
-   Eina_List *l, *ll;
+   E_Plane_Commit_Data *data = NULL;
+   E_Plane *plane = NULL;
 
+   data = (E_Plane_Commit_Data *)user_data;
+   EINA_SAFETY_ON_NULL_RETURN(data);
+   plane = data->plane;
    EINA_SAFETY_ON_NULL_RETURN(plane);
 
-   if (plane->zoom_unset)
-     {
-        EINA_LIST_FOREACH_SAFE(plane->pending_commit_zoom_data_list, l, ll, pp_data)
-          {
-             if (!pp_data) continue;
-
-             plane->pending_commit_zoom_data_list = eina_list_remove_list(plane->pending_commit_zoom_data_list, l);
-
-             _e_plane_zoom_commit_data_release(pp_data);
-          }
-
-        return;
-     }
+   /* release the commit data */
+   if (data->ec) e_pixmap_image_clear(data->ec->pixmap, 1);
+   e_plane_commit_data_release(data);
 
-   pp_data = NULL;
-   pp_data = eina_list_nth(plane->pending_commit_zoom_data_list, 0);
-   if (!pp_data)
-     {
-        ERR("fail E_Plane_Pp_Data get");
-        return;
-     }
-   plane->pending_commit_zoom_data_list = eina_list_remove(plane->pending_commit_zoom_data_list, pp_data);
+   plane->wait_commit = EINA_FALSE;
 
-   zoom_tsurface = pp_data->zoom_tsurface;
-   tlayer = plane->tlayer;
+   if (plane_trace_debug)
+     ELOGF("E_PLANE", "PP Commit Handler Plane(%p)", NULL, NULL, plane);
 
-   tdm_err = tdm_layer_set_buffer(tlayer, zoom_tsurface);
-   if (tdm_err != TDM_ERROR_NONE)
-     {
-        ERR("fail to tdm_layer_set_buffer");
-        _e_plane_zoom_commit_data_release(pp_data);
-        return;
-     }
+   /* if pp_set is false, skip the commit */
+   if (!plane->pp_set) goto done;
 
-   tdm_err = tdm_layer_commit(tlayer, _e_plane_zoom_commit_handler, pp_data);
-   if (tdm_err != TDM_ERROR_NONE)
-     {
-        ERR("fail to tdm_layer_commit plane:%p, zpos:%d", plane, plane->zpos);
-        _e_plane_zoom_commit_data_release(pp_data);
-        return;
-     }
+   if (!_e_plane_pp_layer_commit(plane, tsurface_dst))
+     ERR("fail to _e_plane_pp_layer_commit");
 
-   return;
+done:
+   tbm_surface_internal_unref(tsurface_src);
+   tbm_surface_internal_unref(tsurface_dst);
 }
 
-static void
-_e_plane_zoom_pending_data_pp(E_Plane *plane)
+static Eina_Bool
+_e_plane_pp_commit(E_Plane *plane, E_Plane_Commit_Data *data)
 {
-   tbm_surface_h tsurface = plane->tsurface;
-   E_Plane_Commit_Data *data = NULL;
-   E_Plane_Pp_Data *pp_data = NULL;
+   tbm_surface_h pp_tsurface = NULL;
    tbm_error_e tbm_err = TBM_ERROR_NONE;
-   tbm_surface_h zoom_tsurface = NULL;
    tdm_error tdm_err = TDM_ERROR_NONE;
-   Eina_List *l, *ll;
-
-   EINA_SAFETY_ON_NULL_RETURN(plane);
-
-   if (plane->zoom_unset)
-     {
-        EINA_LIST_FOREACH_SAFE(plane->pending_pp_zoom_data_list, l, ll, data)
-          {
-             if (!data) continue;
-
-             plane->pending_pp_zoom_data_list = eina_list_remove_list(plane->pending_pp_zoom_data_list, l);
-
-             if (data->ec)
-               e_pixmap_image_clear(data->ec->pixmap, 1);
-             e_plane_commit_data_release(data);
-          }
-
-        return;
-     }
+   tbm_surface_h tsurface = plane->tsurface;
 
-   data = eina_list_nth(plane->pending_pp_zoom_data_list, 0);
-   if (!data)
-     {
-        ERR("_e_plane_zoom_pending_data_pp: fail E_Plane_Commit_Data get");
-        return;
-     }
+   if (plane_trace_debug)
+     ELOGF("E_PLANE", "PP Commit  Plane(%p) zpos(%d)   tsurface(%p) tqueue(%p) wl_buffer(%p) data(%p)",
+           NULL, NULL, plane, plane->zpos, data->tsurface, plane->renderer ? plane->renderer->tqueue : NULL,
+           data->buffer_ref.buffer ? data->buffer_ref.buffer->resource : NULL, data);
 
-   tbm_err = tbm_surface_queue_dequeue(plane->zoom_tqueue, &zoom_tsurface);
+   tbm_err = tbm_surface_queue_dequeue(plane->pp_tqueue, &pp_tsurface);
    if (tbm_err != TBM_ERROR_NONE)
      {
-        ERR("_e_plane_zoom_pending_data_pp: fail tbm_surface_queue_dequeue");
-        return;
+        ERR("fail tbm_surface_queue_dequeue");
+        return EINA_FALSE;
      }
-   tbm_surface_internal_ref(zoom_tsurface);
-
-   plane->pending_pp_zoom_data_list = eina_list_remove(plane->pending_pp_zoom_data_list, data);
-
-   pp_data = E_NEW(E_Plane_Pp_Data, 1);
-   pp_data->zoom_tsurface = zoom_tsurface;
-   pp_data->data = data;
-   pp_data->plane = plane;
 
-   plane->zoom_data_list = eina_list_append(plane->zoom_data_list, pp_data);
-
-   if (plane->zoom_rect.x != plane->zoom_rect_temp.x || plane->zoom_rect.y != plane->zoom_rect_temp.y ||
-       plane->zoom_rect.w != plane->zoom_rect_temp.w || plane->zoom_rect.h != plane->zoom_rect_temp.h)
+   if (!_e_plane_pp_info_set(plane))
      {
-        if (!_e_plane_zoom_set_pp_info(plane))
-          {
-             ERR("_e_plane_zoom_pending_data_pp: fail _e_plane_zoom_set_pp_info");
-             goto pp_fail;
-          }
+        ERR("fail _e_plane_pp_info_set");
+        goto pp_fail;
      }
 
-   tdm_err = tdm_pp_set_done_handler(plane->tpp, _e_plane_zoom_pp_cb, pp_data);
+   tdm_err = tdm_pp_set_done_handler(plane->tpp, _e_plane_pp_commit_handler, data);
    EINA_SAFETY_ON_FALSE_GOTO(tdm_err == TDM_ERROR_NONE, pp_fail);
 
-   tdm_err = tdm_pp_attach(plane->tpp, tsurface, zoom_tsurface);
-   EINA_SAFETY_ON_FALSE_GOTO(tdm_err == TDM_ERROR_NONE, pp_fail);
+   tbm_surface_internal_ref(pp_tsurface);
+   tbm_surface_internal_ref(tsurface);
+   tdm_err = tdm_pp_attach(plane->tpp, tsurface, pp_tsurface);
+   EINA_SAFETY_ON_FALSE_GOTO(tdm_err == TDM_ERROR_NONE, attach_fail);
 
    tdm_err = tdm_pp_commit(plane->tpp);
-   EINA_SAFETY_ON_FALSE_GOTO(tdm_err == TDM_ERROR_NONE, pp_fail);
-
-   return;
+   EINA_SAFETY_ON_FALSE_GOTO(tdm_err == TDM_ERROR_NONE, commit_fail);
 
-pp_fail:
-   plane->zoom_data_list = eina_list_remove(plane->zoom_data_list, pp_data);
+   plane->wait_commit = EINA_TRUE;
 
-   if (data)
-     e_plane_commit_data_release(data);
+   return EINA_TRUE;
 
-   if (pp_data)
-     free(pp_data);
+commit_fail:
+attach_fail:
+   tbm_surface_internal_unref(pp_tsurface);
+   tbm_surface_internal_unref(tsurface);
+pp_fail:
 
-   ERR("_e_plane_zoom_pending_data_pp: fail");
+   ERR("failed _e_plane_pp_commit");
 
-   return;
+   return EINA_FALSE;
 }
 
 EINTERN Eina_Bool
-e_plane_zoom_commit(E_Plane *plane)
+e_plane_pp_commit(E_Plane *plane)
 {
-   tbm_surface_h tsurface = plane->tsurface;
    E_Plane_Commit_Data *data = NULL;
-   E_Plane_Pp_Data *pp_data = NULL;
-   tbm_error_e tbm_err = TBM_ERROR_NONE;
-   tbm_surface_h zoom_tsurface = NULL;
-   tdm_error tdm_err = TDM_ERROR_NONE;
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(plane, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(plane->pp_tqueue, EINA_FALSE);
 
    data = e_plane_commit_data_aquire(plane);
    if (!data) return EINA_TRUE;
 
-   TRACE_DS_ASYNC_BEGIN((unsigned int)plane->tlayer, [PLANE:COMMIT~HANDLER]);
-
-   if (plane_trace_debug)
-     ELOGF("E_PLANE", "Commit  Plane(%p) zpos(%d)   tsurface(%p) tqueue(%p) wl_buffer(%p) data(%p)",
-           NULL, NULL, plane, plane->zpos, data->tsurface, plane->renderer ? plane->renderer->tqueue : NULL,
-           data->buffer_ref.buffer ? data->buffer_ref.buffer->resource : NULL, data);
-
-   if (!tbm_surface_queue_can_dequeue(plane->zoom_tqueue, 0))
+   if (!tbm_surface_queue_can_dequeue(plane->pp_tqueue, 0))
      {
-        plane->pending_pp_zoom_data_list = eina_list_append(plane->pending_pp_zoom_data_list, data);
+        if (plane_trace_debug)
+          ELOGF("E_PLANE", "PP Commit  Can Dequeue filed Plane(%p) zpos(%d)   tsurface(%p) tqueue(%p) wl_buffer(%p) data(%p)",
+                NULL, NULL, plane, plane->zpos, data->tsurface, plane->renderer ? plane->renderer->tqueue : NULL,
+                data->buffer_ref.buffer ? data->buffer_ref.buffer->resource : NULL, data);
+        plane->pending_pp_data_list = eina_list_append(plane->pending_pp_data_list, data);
         return EINA_TRUE;
      }
 
-   if (eina_list_count(plane->pending_pp_zoom_data_list) != 0)
+   if (eina_list_count(plane->pending_pp_data_list) != 0)
      {
-        plane->pending_pp_zoom_data_list = eina_list_append(plane->pending_pp_zoom_data_list, data);
+        if (plane_trace_debug)
+          ELOGF("E_PLANE", "PP Commit  Pending pp data remained Plane(%p) zpos(%d)   tsurface(%p) tqueue(%p) wl_buffer(%p) data(%p)",
+                NULL, NULL, plane, plane->zpos, data->tsurface, plane->renderer ? plane->renderer->tqueue : NULL,
+                data->buffer_ref.buffer ? data->buffer_ref.buffer->resource : NULL, data);
+        plane->pending_pp_data_list = eina_list_append(plane->pending_pp_data_list, data);
         return EINA_TRUE;
      }
 
-   tbm_err = tbm_surface_queue_dequeue(plane->zoom_tqueue, &zoom_tsurface);
-   if (tbm_err != TBM_ERROR_NONE)
+   if (!_e_plane_pp_commit(plane, data))
      {
-        ERR("fail tbm_surface_queue_dequeue");
+        ERR("fail _e_plane_pp_commit");
+        e_plane_commit_data_release(data);
         return EINA_FALSE;
      }
-   tbm_surface_internal_ref(zoom_tsurface);
-
-   pp_data = E_NEW(E_Plane_Pp_Data, 1);
-   pp_data->zoom_tsurface = zoom_tsurface;
-   pp_data->data = data;
-   pp_data->plane = plane;
-
-   plane->zoom_data_list = eina_list_append(plane->zoom_data_list, pp_data);
-
-   if (plane->zoom_rect.x != plane->zoom_rect_temp.x || plane->zoom_rect.y != plane->zoom_rect_temp.y ||
-       plane->zoom_rect.w != plane->zoom_rect_temp.w || plane->zoom_rect.h != plane->zoom_rect_temp.h)
-     {
-        if (!_e_plane_zoom_set_pp_info(plane))
-          {
-             ERR("fail _e_plane_zoom_set_pp_info");
-             goto pp_fail;
-          }
-     }
-
-   tdm_err = tdm_pp_set_done_handler(plane->tpp, _e_plane_zoom_pp_cb, pp_data);
-   EINA_SAFETY_ON_FALSE_GOTO(tdm_err == TDM_ERROR_NONE, pp_fail);
-
-   tdm_err = tdm_pp_attach(plane->tpp, tsurface, zoom_tsurface);
-   EINA_SAFETY_ON_FALSE_GOTO(tdm_err == TDM_ERROR_NONE, pp_fail);
-
-   tdm_err = tdm_pp_commit(plane->tpp);
-   EINA_SAFETY_ON_FALSE_GOTO(tdm_err == TDM_ERROR_NONE, pp_fail);
-
-   plane->wait_commit = EINA_TRUE;
 
    return EINA_TRUE;
-
-pp_fail:
-   plane->zoom_data_list = eina_list_remove(plane->zoom_data_list, pp_data);
-
-   if (data)
-     e_plane_commit_data_release(data);
-
-   if (pp_data)
-     free(pp_data);
-
-   ERR("fail");
-
-   return EINA_FALSE;
 }
 
 EINTERN Eina_Bool
@@ -2020,8 +1856,10 @@ e_plane_zoom_set(E_Plane *plane, Eina_Rectangle *rect)
    tdm_error ret = TDM_ERROR_NONE;
    int w, h;
 
-   if ((plane->zoom_rect_temp.x == rect->x) && (plane->zoom_rect_temp.y == rect->y) &&
-       (plane->zoom_rect_temp.w == rect->w) && (plane->zoom_rect_temp.h == rect->h))
+   if ((plane->zoom_rect.x == rect->x) &&
+       (plane->zoom_rect.y == rect->y) &&
+       (plane->zoom_rect.w == rect->w) &&
+       (plane->zoom_rect.h == rect->h))
      return EINA_TRUE;
 
    e_comp_screen = e_comp->e_comp_screen;
@@ -2037,23 +1875,24 @@ e_plane_zoom_set(E_Plane *plane, Eina_Rectangle *rect)
           }
      }
 
-   if (!plane->zoom_tqueue)
+   if (!plane->pp_tqueue)
      {
-        plane->zoom_tqueue = tbm_surface_queue_create(3, w, h, TBM_FORMAT_ARGB8888, plane->buffer_flags | TBM_BO_SCANOUT);
-        if (!plane->zoom_tqueue)
+        plane->pp_tqueue = tbm_surface_queue_create(3, w, h, TBM_FORMAT_ARGB8888, plane->buffer_flags | TBM_BO_SCANOUT);
+        if (!plane->pp_tqueue)
           {
              ERR("fail tbm_surface_queue_create");
              goto fail;
           }
      }
 
-   plane->zoom_rect_temp.x = rect->x;
-   plane->zoom_rect_temp.y = rect->y;
-   plane->zoom_rect_temp.w = rect->w;
-   plane->zoom_rect_temp.h = rect->h;
+   plane->zoom_rect.x = rect->x;
+   plane->zoom_rect.y = rect->y;
+   plane->zoom_rect.w = rect->w;
+   plane->zoom_rect.h = rect->h;
 
-   plane->zoom_unset = EINA_FALSE;
+   plane->pp_set = EINA_TRUE;
    plane->skip_surface_set = EINA_TRUE;
+   plane->pp_set_info = EINA_TRUE;
 
    return EINA_TRUE;
 
@@ -2070,13 +1909,53 @@ fail:
 EINTERN void
 e_plane_zoom_unset(E_Plane *plane)
 {
-   EINA_SAFETY_ON_NULL_RETURN(plane);
+   E_Plane_Commit_Data *data = NULL;
+   Eina_List *l, *ll;
 
-   plane->zoom_rect.x = plane->zoom_rect_temp.x = 0;
-   plane->zoom_rect.y = plane->zoom_rect_temp.y = 0;
-   plane->zoom_rect.w = plane->zoom_rect_temp.w = 0;
-   plane->zoom_rect.h = plane->zoom_rect_temp.h = 0;
+   EINA_SAFETY_ON_NULL_RETURN(plane);
 
-   plane->zoom_unset = EINA_TRUE;
+   plane->pp_set_info = EINA_FALSE;
    plane->skip_surface_set = EINA_FALSE;
+   plane->pp_set = EINA_FALSE;
+
+   plane->zoom_rect.x = 0;
+   plane->zoom_rect.y = 0;
+   plane->zoom_rect.w = 0;
+   plane->zoom_rect.h = 0;
+
+   EINA_LIST_FOREACH_SAFE(plane->pending_pp_commit_data_list, l, ll, data)
+     {
+        if (!data) continue;
+        plane->pending_pp_commit_data_list = eina_list_remove_list(plane->pending_pp_commit_data_list, l);
+        tbm_surface_queue_release(plane->pp_tqueue, data->tsurface);
+        tbm_surface_internal_unref(data->tsurface);
+        free(data);
+     }
+
+   EINA_LIST_FOREACH_SAFE(plane->pending_pp_data_list, l, ll, data)
+     {
+        if (!data) continue;
+        plane->pending_pp_data_list = eina_list_remove_list(plane->pending_pp_data_list, l);
+        if (data->ec) e_pixmap_image_clear(data->ec->pixmap, 1);
+        e_plane_commit_data_release(data);
+     }
+
+   if (plane->pp_tsurface)
+     {
+        tbm_surface_queue_release(plane->pp_tqueue, plane->pp_tsurface);
+        tbm_surface_internal_unref(plane->pp_tsurface);
+        plane->pp_tsurface = NULL;
+     }
+
+   if (plane->pp_tqueue)
+     {
+        tbm_surface_queue_destroy(plane->pp_tqueue);
+        plane->pp_tqueue = NULL;
+     }
+
+   if (plane->tpp)
+     {
+        tdm_pp_destroy(plane->tpp);
+        plane->tpp = NULL;
+     }
 }

diff --git a/src/bin/e_plane.h b/src/bin/e_plane.h
index b83a6cf0f4fa6d23b124cc4434d9a68726c20909..b5b0b091d2d9125c13b8e3f2a6290e581fadfd19 100644 (file)
--- a/src/bin/e_plane.h
+++ b/src/bin/e_plane.h
@@ -25,7 +25,6 @@ typedef enum _E_Plane_Color
 
 typedef struct _E_Plane                      E_Plane;
 typedef struct _E_Plane_Commit_Data          E_Plane_Commit_Data;
-typedef struct _E_Plane_Pp_Data              E_Plane_Pp_Data;
 typedef struct _E_Event_Plane_Win_Change     E_Event_Plane_Win_Change;
 #else
 #ifndef E_PLANE_H
@@ -70,8 +69,6 @@ struct _E_Plane
    Eina_Bool             unset_commit;
    int                   unset_counter;
 
-   Eina_Bool             skip_surface_set;
-
    /* true if plane's ec is set or unset.
     * false when E_Event_Plane_Win_Change has been generated.
     */
@@ -79,17 +76,18 @@ struct _E_Plane
 
    E_Plane_Role          role;
 
-   /* for zoom */
+   /* for pp */
    tdm_pp               *tpp;
-   Eina_List            *zoom_data_list;
-   Eina_List            *pending_pp_zoom_data_list;
-   Eina_List            *pending_commit_zoom_data_list;
-   tbm_surface_queue_h   zoom_tqueue;
-   tbm_surface_h         zoom_tsurface;
+   Eina_List            *pending_pp_data_list;
+   Eina_List            *pending_pp_commit_data_list;
+   tbm_surface_queue_h   pp_tqueue;
+   tbm_surface_h         pp_tsurface;
+   Eina_Bool             pp_set_info;
+   Eina_Bool             pp_set;
+   Eina_Bool             pp_commit;
+   Eina_Bool             skip_surface_set;
+
    Eina_Rectangle        zoom_rect;
-   Eina_Rectangle        zoom_rect_temp;
-   Eina_Bool             zoom_unset;
-   Eina_Bool             zoom_commit;
 
    /* current display information */
    struct
@@ -109,12 +107,6 @@ struct _E_Plane_Commit_Data {
    E_Comp_Wl_Buffer_Ref  buffer_ref;
 };
 
-struct _E_Plane_Pp_Data {
-   E_Plane_Commit_Data *data;
-   E_Plane       *plane;
-   tbm_surface_h  zoom_tsurface;
-};
-
 struct _E_Event_Plane_Win_Change
 {
    E_Plane *ep;
@@ -142,7 +134,7 @@ EINTERN Eina_Bool            e_plane_is_unset_candidate(E_Plane *plane);
 EINTERN Eina_Bool            e_plane_is_unset_try(E_Plane *plane);
 EINTERN void                 e_plane_unset_try_set(E_Plane *plane, Eina_Bool set);
 EINTERN Eina_Bool            e_plane_unset_commit_check(E_Plane *plane);
-EINTERN Eina_Bool            e_plane_zoom_commit(E_Plane *plane);
+EINTERN Eina_Bool            e_plane_pp_commit(E_Plane *plane);
 EINTERN Eina_Bool            e_plane_zoom_set(E_Plane *plane, Eina_Rectangle *rect);
 EINTERN void                 e_plane_zoom_unset(E_Plane *plane);
 

diff --git a/src/bin/e_plane_renderer.c b/src/bin/e_plane_renderer.c
index 26f0c071104002f4cada0d54824c65e10de142d0..53bc55ec5250b66802a7d83ebe137d9304c002ae 100644 (file)
--- a/src/bin/e_plane_renderer.c
+++ b/src/bin/e_plane_renderer.c
@@ -1382,12 +1382,7 @@ e_plane_renderer_render(E_Plane_Renderer *renderer, Eina_Bool is_fb)
         TRACE_DS_BEGIN(MANUAL RENDER);
 
         if (e_plane_renderer_surface_queue_can_dequeue(renderer) || !renderer->tqueue)
-          {
-             if (renderer_trace_debug)
-               ELOGF("E_PLANE_RENDERER", "Canvas Manual Render.", NULL, NULL);
-
-             ecore_evas_manual_render(renderer->ee);
-          }
+           ecore_evas_manual_render(renderer->ee);
 
         TRACE_DS_END();
      }