monitor: enhance ttrace option for layer, pp, capture

[platform/core/uifw/libtdm.git] / src / tdm_pp.c

diff --git a/src/tdm_pp.c b/src/tdm_pp.c
index 1a61d7f..53f8c73 100644 (file)
--- a/src/tdm_pp.c
+++ b/src/tdm_pp.c
@@ -71,7 +71,7 @@ _tdm_pp_print_list(struct list_head *list)
                        break;
        }
 
-       TDM_INFO("\t %s", str);
+       TDM_WRN("\t %s", str);
 }
 
 static tdm_pp_private_buffer *
@@ -131,15 +131,14 @@ tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst,
                TDM_NEVER_GET_HERE();
 
        if (tdm_debug_dump & TDM_DUMP_FLAG_PP) {
+               /* LCOV_EXCL_START */
                char str[TDM_PATH_LEN];
                static int i;
                snprintf(str, TDM_PATH_LEN, "pp_dst_%03d", i++);
                tdm_helper_dump_buffer_str(dst, tdm_debug_dump_dir, str);
+               /* LCOV_EXCL_STOP */
        }
 
-       if (tdm_debug_module & TDM_DEBUG_BUFFER)
-               TDM_INFO("pp(%p) done: src(%p) dst(%p)", private_pp, src, dst);
-
        if (!LIST_IS_EMPTY(&private_pp->buffer_list)) {
                first_entry = container_of((&private_pp->buffer_list)->next, pp_buffer, link);
                if (first_entry->src != src || first_entry->dst != dst)
@@ -150,6 +149,15 @@ tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst,
 
        if ((pp_buffer = _tdm_pp_find_tbm_buffers(&private_pp->buffer_list, src, dst))) {
                LIST_DEL(&pp_buffer->link);
+               LIST_DELINIT(&pp_buffer->commit_link);
+
+               if (tdm_debug_module & TDM_DEBUG_BUFFER)
+                       TDM_INFO("pp(%p) done: src(%p) dst(%p)", private_pp, src, dst);
+
+               if (tdm_ttrace_module & TDM_TTRACE_PP) {
+                       tbm_bo bo = tbm_surface_internal_get_bo(dst, 0);
+                       TDM_TRACE_ASYNC_END((int)private_pp, "[PP] %d", tbm_bo_export(bo));
+               }
 
                _pthread_mutex_unlock(&private_display->lock);
                if (private_pp->done_func)
@@ -192,35 +200,43 @@ tdm_pp_create_internal(tdm_private_display *private_display, tdm_error *error)
        func_pp = &private_display->func_pp;
 
        if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
+               /* LCOV_EXCL_START */
                TDM_ERR("no pp capability");
                if (error)
                        *error = TDM_ERROR_NO_CAPABILITY;
                return NULL;
+               /* LCOV_EXCL_STOP */
        }
 
        pp_backend = func_display->display_create_pp(private_display->bdata, &ret);
        if (ret != TDM_ERROR_NONE) {
+               /* LCOV_EXCL_START */
                if (error)
                        *error = ret;
                return NULL;
+               /* LCOV_EXCL_STOP */
        }
 
        private_pp = calloc(1, sizeof(tdm_private_pp));
        if (!private_pp) {
+               /* LCOV_EXCL_START */
                TDM_ERR("failed: alloc memory");
                func_pp->pp_destroy(pp_backend);
                if (error)
                        *error = TDM_ERROR_OUT_OF_MEMORY;
                return NULL;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = func_pp->pp_set_done_handler(pp_backend, tdm_pp_cb_done, private_pp);
        if (ret != TDM_ERROR_NONE) {
+               /* LCOV_EXCL_START */
                TDM_ERR("spp(%p) et pp_done_handler failed", private_pp);
                func_pp->pp_destroy(pp_backend);
                if (error)
                        *error = ret;
                return NULL;
+               /* LCOV_EXCL_STOP */
        }
 
        private_pp->stamp = tdm_helper_get_time();
@@ -247,6 +263,7 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp)
        tdm_private_display *private_display;
        tdm_func_pp *func_pp;
        tdm_pp_private_buffer *b = NULL, *bb = NULL;
+       struct list_head clone_list;
 
        TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 
@@ -264,22 +281,52 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp)
                TDM_WRN("pp(%p) not finished:", private_pp);
                _tdm_pp_print_list(&private_pp->pending_buffer_list);
 
+               LIST_INITHEAD(&clone_list);
                LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->pending_buffer_list, link) {
                        LIST_DEL(&b->link);
+                       LIST_ADDTAIL(&b->link, &clone_list);
+               }
+
+               _pthread_mutex_unlock(&private_display->lock);
+               LIST_FOR_EACH_ENTRY_SAFE(b, bb, &clone_list, link) {
+                       LIST_DEL(&b->link);
+
+                       if (tdm_ttrace_module & TDM_TTRACE_PP) {
+                               tbm_bo bo = tbm_surface_internal_get_bo(b->dst, 0);
+                               TDM_TRACE_ASYNC_END((int)private_pp, "[PP] %d", tbm_bo_export(bo));
+                       }
+
+                       tdm_buffer_unref_backend(b->src);
+                       tdm_buffer_unref_backend(b->dst);
+                       free(b);
                }
+               _pthread_mutex_lock(&private_display->lock);
        }
 
        if (!LIST_IS_EMPTY(&private_pp->buffer_list)) {
                TDM_WRN("pp(%p) not finished:", private_pp);
                _tdm_pp_print_list(&private_pp->buffer_list);
 
+               LIST_INITHEAD(&clone_list);
                LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->buffer_list, link) {
                        LIST_DEL(&b->link);
-                       _pthread_mutex_unlock(&private_display->lock);
+                       LIST_ADDTAIL(&b->link, &clone_list);
+               }
+
+               _pthread_mutex_unlock(&private_display->lock);
+               LIST_FOR_EACH_ENTRY_SAFE(b, bb, &clone_list, link) {
+                       LIST_DEL(&b->link);
+
+                       if (tdm_ttrace_module & TDM_TTRACE_PP) {
+                               tbm_bo bo = tbm_surface_internal_get_bo(b->dst, 0);
+                               TDM_TRACE_ASYNC_END((int)private_pp, "[PP] %d", tbm_bo_export(bo));
+                       }
+
                        tdm_buffer_unref_backend(b->src);
                        tdm_buffer_unref_backend(b->dst);
-                       _pthread_mutex_lock(&private_display->lock);
+                       free(b);
                }
+               _pthread_mutex_lock(&private_display->lock);
        }
 
        private_pp->stamp = 0;
@@ -312,9 +359,11 @@ tdm_pp_set_info(tdm_pp *pp, tdm_info_pp *info)
        _pthread_mutex_lock(&private_display->lock);
 
        if (!func_pp->pp_set_info) {
+               /* LCOV_EXCL_START */
                _pthread_mutex_unlock(&private_display->lock);
                TDM_DBG("failed: not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
+               /* LCOV_EXCL_STOP */
        }
 
        TDM_INFO("pp(%p) info: src(%dx%d %d,%d %dx%d %c%c%c%c) dst(%dx%d %d,%d %dx%d %c%c%c%c) trans(%d) sync(%d) flags(%x)",
@@ -375,13 +424,16 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
        _pthread_mutex_lock(&private_display->lock);
 
        if (!func_pp->pp_attach) {
+               /* LCOV_EXCL_START */
                _pthread_mutex_unlock(&private_display->lock);
                TDM_DBG("failed: not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
+               /* LCOV_EXCL_STOP */
        }
 
        if (tdm_display_check_module_abi(private_display, 1, 2) &&
                private_display->caps_pp.max_attach_count > 0) {
+               /* LCOV_EXCL_START */
                int length = LIST_LENGTH(&private_pp->pending_buffer_list) +
                                         LIST_LENGTH(&private_pp->buffer_list);
                if (length >= private_display->caps_pp.max_attach_count) {
@@ -390,30 +442,37 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
                                        private_display->caps_pp.max_attach_count);
                        return TDM_ERROR_BAD_REQUEST;
                }
+               /* LCOV_EXCL_STOP */
        }
 
        if (tdm_debug_dump & TDM_DUMP_FLAG_PP) {
+               /* LCOV_EXCL_START */
                char str[TDM_PATH_LEN];
                static int i;
                snprintf(str, TDM_PATH_LEN, "pp_src_%03d", i++);
                tdm_helper_dump_buffer_str(src, tdm_debug_dump_dir, str);
+               /* LCOV_EXCL_STOP */
        }
 
-       pp_buffer = calloc(1, sizeof *pp_buffer);
+       pp_buffer = calloc(1, sizeof * pp_buffer);
        if (!pp_buffer) {
+               /* LCOV_EXCL_START */
                _pthread_mutex_unlock(&private_display->lock);
                TDM_ERR("alloc failed");
                return TDM_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = func_pp->pp_attach(private_pp->pp_backend, src, dst);
        TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
        if (ret != TDM_ERROR_NONE) {
+               /* LCOV_EXCL_START */
                free(pp_buffer);
                _pthread_mutex_unlock(&private_display->lock);
                TDM_ERR("attach failed");
                return ret;
+               /* LCOV_EXCL_STOP */
        }
 
        LIST_ADDTAIL(&pp_buffer->link, &private_pp->pending_buffer_list);
@@ -425,6 +484,11 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
                _tdm_pp_print_list(&private_pp->pending_buffer_list);
        }
 
+       if (tdm_ttrace_module & TDM_TTRACE_PP) {
+               tbm_bo bo = tbm_surface_internal_get_bo(dst, 0);
+               TDM_TRACE_ASYNC_BEGIN((int)pp, "[PP] %d", tbm_bo_export(bo));
+       }
+
        _pthread_mutex_unlock(&private_display->lock);
 
        return ret;
@@ -441,9 +505,11 @@ tdm_pp_commit(tdm_pp *pp)
        _pthread_mutex_lock(&private_display->lock);
 
        if (!func_pp->pp_commit) {
+               /* LCOV_EXCL_START */
                _pthread_mutex_unlock(&private_display->lock);
                TDM_DBG("failed: not implemented!!");
                return TDM_ERROR_NOT_IMPLEMENTED;
+               /* LCOV_EXCL_STOP */
        }
 
        LIST_INITHEAD(&commit_buffer_list);
@@ -458,12 +524,17 @@ tdm_pp_commit(tdm_pp *pp)
        TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
        LIST_FOR_EACH_ENTRY_SAFE(b, bb, &commit_buffer_list, commit_link) {
+               LIST_DELINIT(&b->commit_link);
+
                if (!_tdm_pp_find_buffer(&private_pp->buffer_list, b))
                        continue;
 
-               LIST_DEL(&b->commit_link);
-
                if (ret != TDM_ERROR_NONE) {
+                       /* Not to call the user release handler when failed.
+                        * Do we have to call this function here really?
+                        * User better use set_done_handler to know when pp is done. Using
+                        * buffer_release_handler is not good.
+                        */
                        tdm_buffer_remove_release_handler_internal(b->src);
                        tdm_buffer_remove_release_handler_internal(b->dst);
 
@@ -472,6 +543,8 @@ tdm_pp_commit(tdm_pp *pp)
                        tdm_buffer_unref_backend(b->dst);
                        _pthread_mutex_lock(&private_display->lock);
                        LIST_DEL(&b->link);
+
+                       free(b);
                }
        }