Fix pointer to int cast warning

Change-Id: Id0af40582f900c46745f6c1b8e6864789daeca81

diff --git a/src/tpl_tbm.c b/src/tpl_tbm.c
index a41187c..1a66f17 100644 (file)
--- a/src/tpl_tbm.c
+++ b/src/tpl_tbm.c
@@ -250,7 +250,7 @@ __tpl_tbm_surface_enqueue_buffer(tpl_surface_t *surface,
                return TPL_ERROR_INVALID_PARAMETER;
        }
 
-       TRACE_ASYNC_END((int)tbm_surface, "[DEQ]~[ENQ] BO(%d)", tbm_bo_export(tbm_surface_internal_get_bo(tbm_surface, 0)));
+       TRACE_ASYNC_END((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO(%d)", tbm_bo_export(tbm_surface_internal_get_bo(tbm_surface, 0)));
 
        tbm_surface_internal_unref(tbm_surface);
 
@@ -320,7 +320,7 @@ __tpl_tbm_surface_dequeue_buffer(tpl_surface_t *surface, uint64_t timeout_ns,
                          surface, tpl_tbm_surface->tbm_queue, tbm_surface,
                          tbm_bo_export(tbm_surface_internal_get_bo(tbm_surface, 0)));
 
-       TRACE_ASYNC_BEGIN((int)tbm_surface, "[DEQ]~[ENQ] BO(%d)",
+       TRACE_ASYNC_BEGIN((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO(%d)",
                                          tbm_bo_export(tbm_surface_internal_get_bo(tbm_surface, 0)));
 
        return tbm_surface;

diff --git a/src/tpl_wayland_egl.c b/src/tpl_wayland_egl.c
index 16fc9f2..b8b24da 100755 (executable)
--- a/src/tpl_wayland_egl.c
+++ b/src/tpl_wayland_egl.c
@@ -805,7 +805,7 @@ __tpl_wayland_egl_surface_fini(tpl_surface_t *surface)
                                tbm_surface_queue_error_e tsq_err;
                                tbm_surface_h tbm_surface =
                                        __tpl_list_pop_front(wayland_egl_surface->attached_buffers, NULL);
-                               TRACE_ASYNC_END((int)tbm_surface, "[COMMIT ~ RELEASE_CB] BO_NAME:%d",
+                               TRACE_ASYNC_END((intptr_t)tbm_surface, "[COMMIT ~ RELEASE_CB] BO_NAME:%d",
                                                                tbm_bo_export(tbm_surface_internal_get_bo(
                                                                        tbm_surface, 0)));
                                tbm_surface_internal_unref(tbm_surface);
@@ -1018,7 +1018,7 @@ __tpl_wayland_egl_surface_commit(tpl_surface_t *surface,
                if (tdm_lock_res == 0) pthread_mutex_unlock(&wayland_egl_display->tdm_mutex);
        }
 
-       TRACE_ASYNC_BEGIN((int)tbm_surface, "[COMMIT ~ RELEASE_CB] BO_NAME:%d",
+       TRACE_ASYNC_BEGIN((intptr_t)tbm_surface, "[COMMIT ~ RELEASE_CB] BO_NAME:%d",
                                          tbm_bo_export(wayland_egl_buffer->bo));
 }
 
@@ -1074,7 +1074,7 @@ __tpl_wayland_egl_surface_enqueue_buffer(tpl_surface_t *surface,
                        TPL_LOG_B("WL_EGL",
                                  "[ENQ_SKIP][F] Client already uses frontbuffer(%p)",
                                  surface->frontbuffer);
-                       TRACE_ASYNC_END((int)wayland_egl_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
+                       TRACE_ASYNC_END((intptr_t)wayland_egl_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
                                                        tbm_bo_export(wayland_egl_buffer->bo));
                        return TPL_ERROR_NONE;
                }
@@ -1103,7 +1103,7 @@ __tpl_wayland_egl_surface_enqueue_buffer(tpl_surface_t *surface,
                return TPL_ERROR_INVALID_OPERATION;
        }
 
-       TRACE_ASYNC_END((int)wayland_egl_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
+       TRACE_ASYNC_END((intptr_t)wayland_egl_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
                                        tbm_bo_export(wayland_egl_buffer->bo));
 
        TRACE_BEGIN("[WAIT_VBLANK]");
@@ -1333,7 +1333,7 @@ __tpl_wayland_egl_surface_dequeue_buffer(tpl_surface_t *surface, uint64_t timeou
                                __tpl_wayland_egl_get_wayland_buffer_from_tbm_surface(
                                                surface->frontbuffer);
                        if (wayland_egl_buffer)
-                               TRACE_ASYNC_BEGIN((int)wayland_egl_buffer,
+                               TRACE_ASYNC_BEGIN((intptr_t)wayland_egl_buffer,
                                                                  "[DEQ]~[ENQ] BO_NAME:%d",
                                                                  tbm_bo_export(wayland_egl_buffer->bo));
                        if (lock_res == 0) pthread_mutex_unlock(&wayland_egl_display->wl_event_mutex);
@@ -1361,7 +1361,7 @@ __tpl_wayland_egl_surface_dequeue_buffer(tpl_surface_t *surface, uint64_t timeou
        if ((wayland_egl_buffer =
                                __tpl_wayland_egl_get_wayland_buffer_from_tbm_surface(tbm_surface)) != NULL) {
                TRACE_MARK("[DEQ][REUSED]BO_NAME:%d", tbm_bo_export(wayland_egl_buffer->bo));
-               TRACE_ASYNC_BEGIN((int)wayland_egl_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
+               TRACE_ASYNC_BEGIN((intptr_t)wayland_egl_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
                                                  tbm_bo_export(wayland_egl_buffer->bo));
 
                wayland_egl_buffer->dx = wl_egl_window->dx;
@@ -1471,7 +1471,7 @@ __tpl_wayland_egl_surface_dequeue_buffer(tpl_surface_t *surface, uint64_t timeou
                        wayland_egl_buffer);
 
        TRACE_MARK("[DEQ][NEW]BO_NAME:%d", tbm_bo_export(wayland_egl_buffer->bo));
-       TRACE_ASYNC_BEGIN((int)wayland_egl_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
+       TRACE_ASYNC_BEGIN((intptr_t)wayland_egl_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
                                          tbm_bo_export(wayland_egl_buffer->bo));
        TPL_LOG_B("WL_EGL",
                          "[DEQ][N] tpl_wayland_egl_buffer_t(%p) wl_buffer(%p) tbm_surface(%p) bo(%d)",
@@ -1589,7 +1589,7 @@ __cb_client_buffer_release_callback(void *data, struct wl_proxy *proxy)
 
        tbm_surface = (tbm_surface_h) data;
 
-       TRACE_ASYNC_END((int)tbm_surface, "[COMMIT ~ RELEASE_CB] BO_NAME:%d",
+       TRACE_ASYNC_END((intptr_t)tbm_surface, "[COMMIT ~ RELEASE_CB] BO_NAME:%d",
                                        tbm_bo_export(tbm_surface_internal_get_bo(tbm_surface, 0)));
        TPL_LOG_B("WL_EGL", "[RELEASE_CB] wl_buffer(%p) tbm_surface(%p) bo(%d)",
                          proxy, tbm_surface,
@@ -1909,7 +1909,7 @@ static void __cb_tizen_surface_shm_flusher_flush_callback(void *data,
                                tpl_wayland_egl_buffer_t *wayland_egl_buffer =
                                        __tpl_wayland_egl_get_wayland_buffer_from_tbm_surface(tbm_surface);
 
-                               TRACE_ASYNC_END((int)tbm_surface, "[COMMIT ~ RELEASE_CB] BO_NAME:%d",
+                               TRACE_ASYNC_END((intptr_t)tbm_surface, "[COMMIT ~ RELEASE_CB] BO_NAME:%d",
                                                                tbm_bo_export(tbm_surface_internal_get_bo(
                                                                        tbm_surface, 0)));
 

diff --git a/src/tpl_wl_egl_thread.c b/src/tpl_wl_egl_thread.c
index b8830a7..2ad01c2 100755 (executable)
--- a/src/tpl_wl_egl_thread.c
+++ b/src/tpl_wl_egl_thread.c
@@ -2539,7 +2539,7 @@ __tpl_wl_egl_surface_dequeue_buffer(tpl_surface_t *surface, uint64_t timeout_ns,
                        TPL_LOG_T("WL_EGL",
                                          "[DEQ][F] surface->frontbuffer(%p) BO_NAME(%d)",
                                          surface->frontbuffer, bo_name);
-                       TRACE_ASYNC_BEGIN((int)surface->frontbuffer,
+                       TRACE_ASYNC_BEGIN((intptr_t)surface->frontbuffer,
                                                          "[DEQ]~[ENQ] BO_NAME:%d",
                                                          bo_name);
                        tpl_gmutex_unlock(&wl_egl_display->wl_event_mutex);
@@ -2593,7 +2593,7 @@ __tpl_wl_egl_surface_dequeue_buffer(tpl_surface_t *surface, uint64_t timeout_ns,
        wl_egl_surface->reset = TPL_FALSE;
 
        TRACE_MARK("[DEQ][NEW]BO_NAME:%d", wl_egl_buffer->bo_name);
-       TRACE_ASYNC_BEGIN((int)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d",
+       TRACE_ASYNC_BEGIN((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d",
                                          wl_egl_buffer->bo_name);
        TPL_LOG_T("WL_EGL", "[DEQ] wl_egl_buffer(%p) tbm_surface(%p) bo(%d) fence(%d)",
                          wl_egl_buffer, tbm_surface, wl_egl_buffer->bo_name,
@@ -2665,7 +2665,7 @@ __tpl_wl_egl_surface_enqueue_buffer(tpl_surface_t *surface,
        if (!tbm_surface_internal_is_valid(tbm_surface)) {
                TPL_ERR("Failed to enqueue tbm_surface(%p) Invalid value.",
                                tbm_surface);
-               TRACE_ASYNC_END((int)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
+               TRACE_ASYNC_END((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
                return TPL_ERROR_INVALID_PARAMETER;
        }
 
@@ -2705,7 +2705,7 @@ __tpl_wl_egl_surface_enqueue_buffer(tpl_surface_t *surface,
                !wl_egl_buffer->need_to_commit) {
                TPL_WARN("[ENQ_SKIP][Frontbuffer:%s] tbm_surface(%p) need not to enqueue",
                                 ((surface->frontbuffer == tbm_surface) ? "ON" : "OFF"), tbm_surface);
-               TRACE_ASYNC_END((int)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
+               TRACE_ASYNC_END((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
                tpl_gmutex_unlock(&wl_egl_buffer->mutex);
                return TPL_ERROR_NONE;
        }
@@ -2762,7 +2762,7 @@ __tpl_wl_egl_surface_enqueue_buffer(tpl_surface_t *surface,
                tbm_surface_internal_unref(tbm_surface);
                TPL_ERR("Failed to enqueue tbm_surface(%p). wl_egl_surface(%p) tsq_err=%d",
                                tbm_surface, wl_egl_surface, tsq_err);
-               TRACE_ASYNC_END((int)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
+               TRACE_ASYNC_END((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
                return TPL_ERROR_INVALID_OPERATION;
        }
 
@@ -2772,7 +2772,7 @@ __tpl_wl_egl_surface_enqueue_buffer(tpl_surface_t *surface,
 
        tbm_surface_internal_unref(tbm_surface);
 
-       TRACE_ASYNC_END((int)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
+       TRACE_ASYNC_END((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
 
        return TPL_ERROR_NONE;
 }
@@ -2924,7 +2924,7 @@ __cb_tdm_client_vblank(tdm_client_vblank *vblank, tdm_error error,
        tpl_wl_egl_surface_t *wl_egl_surface = (tpl_wl_egl_surface_t *)user_data;
        tpl_wl_egl_buffer_t *wl_egl_buffer   = NULL;
 
-       TRACE_ASYNC_END((int)wl_egl_surface, "WAIT_VBLANK");
+       TRACE_ASYNC_END((intptr_t)wl_egl_surface, "WAIT_VBLANK");
        TPL_DEBUG("[VBLANK] wl_egl_surface(%p)", wl_egl_surface);
 
        if (error == TDM_ERROR_TIMEOUT)
@@ -2987,7 +2987,7 @@ __cb_buffer_fenced_release(void *data,
                        TRACE_MARK("[FENCED_RELEASE] BO(%d) fence(%d)",
                                           _get_tbm_surface_bo_name(tbm_surface),
                                           fence);
-                       TRACE_ASYNC_END((int)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
+                       TRACE_ASYNC_END((intptr_t)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
                                                        _get_tbm_surface_bo_name(tbm_surface));
 
                        TPL_LOG_T("WL_EGL",
@@ -3038,7 +3038,7 @@ __cb_buffer_immediate_release(void *data,
 
                        TRACE_MARK("[IMMEDIATE_RELEASE] BO(%d)",
                                           _get_tbm_surface_bo_name(tbm_surface));
-                       TRACE_ASYNC_END((int)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
+                       TRACE_ASYNC_END((intptr_t)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
                                                        _get_tbm_surface_bo_name(tbm_surface));
 
                        TPL_LOG_T("WL_EGL",
@@ -3094,7 +3094,7 @@ __cb_wl_buffer_release(void *data, struct wl_proxy *wl_buffer)
                        wl_egl_buffer->status = RELEASED;
 
                        TRACE_MARK("[RELEASE] BO(%d)", _get_tbm_surface_bo_name(tbm_surface));
-                       TRACE_ASYNC_END((int)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
+                       TRACE_ASYNC_END((intptr_t)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
                                                        _get_tbm_surface_bo_name(tbm_surface));
 
                        TPL_LOG_T("WL_EGL", "[REL] wl_buffer(%p) tbm_surface(%p) bo(%d)",
@@ -3243,7 +3243,7 @@ _thread_surface_vblank_wait(tpl_wl_egl_surface_t *wl_egl_surface)
 
        if (tdm_err == TDM_ERROR_NONE) {
                wl_egl_surface->vblank_done = TPL_FALSE;
-               TRACE_ASYNC_BEGIN((int)wl_egl_surface, "WAIT_VBLANK");
+               TRACE_ASYNC_BEGIN((intptr_t)wl_egl_surface, "WAIT_VBLANK");
        } else {
                TPL_ERR("Failed to tdm_client_vblank_wait. tdm_err(%d)", tdm_err);
                return TPL_ERROR_INVALID_OPERATION;
@@ -3420,7 +3420,7 @@ _thread_wl_surface_commit(tpl_wl_egl_surface_t *wl_egl_surface,
 
        wl_display_flush(wl_egl_display->wl_display);
 
-       TRACE_ASYNC_BEGIN((int)wl_egl_buffer->tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
+       TRACE_ASYNC_BEGIN((intptr_t)wl_egl_buffer->tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
                                          wl_egl_buffer->bo_name);
 
        tpl_gmutex_lock(&wl_egl_buffer->mutex);

diff --git a/src/tpl_wl_vk_thread.c b/src/tpl_wl_vk_thread.c
index f9d6952..4d8fb2c 100644 (file)
--- a/src/tpl_wl_vk_thread.c
+++ b/src/tpl_wl_vk_thread.c
@@ -2413,7 +2413,7 @@ __cb_tdm_client_vblank(tdm_client_vblank *vblank, tdm_error error,
        tpl_wl_vk_surface_t *wl_vk_surface = (tpl_wl_vk_surface_t *)user_data;
        tpl_wl_vk_buffer_t *wl_vk_buffer   = NULL;
 
-       TRACE_ASYNC_END((int)wl_vk_surface, "WAIT_VBLANK");
+       TRACE_ASYNC_END((intptr_t)wl_vk_surface, "WAIT_VBLANK");
        TPL_DEBUG("[VBLANK] wl_vk_surface(%p)", wl_vk_surface);
 
        if (error == TDM_ERROR_TIMEOUT)
@@ -2454,7 +2454,7 @@ _thread_surface_vblank_wait(tpl_wl_vk_surface_t *wl_vk_surface)
 
        if (tdm_err == TDM_ERROR_NONE) {
                wl_vk_surface->vblank_done = TPL_FALSE;
-               TRACE_ASYNC_BEGIN((int)wl_vk_surface, "WAIT_VBLANK");
+               TRACE_ASYNC_BEGIN((intptr_t)wl_vk_surface, "WAIT_VBLANK");
        } else {
                TPL_ERR("Failed to tdm_client_vblank_wait. tdm_err(%d)", tdm_err);
                return TPL_ERROR_INVALID_OPERATION;

diff --git a/src/unused/tpl_gbm.c b/src/unused/tpl_gbm.c
index 83c9c81..be5f238 100644 (file)
--- a/src/unused/tpl_gbm.c
+++ b/src/unused/tpl_gbm.c
@@ -396,7 +396,7 @@ __tpl_gbm_surface_enqueue_buffer(tpl_surface_t *surface,
                return TPL_ERROR_INVALID_PARAMETER;
        }
 
-       TRACE_ASYNC_END((int)gbm_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
+       TRACE_ASYNC_END((intptr_t)gbm_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
                                        tbm_bo_export(gbm_buffer->bo));
 
        TPL_IMAGE_DUMP(tbm_surface, surface->width, surface->height);
@@ -521,7 +521,7 @@ __tpl_gbm_surface_dequeue_buffer(tpl_surface_t *surface, uint64_t timeout_ns,
        gbm_buffer = __tpl_gbm_get_gbm_buffer_from_tbm_surface(tbm_surface);
        if (gbm_buffer) {
                TRACE_MARK("[DEQ][REUSED]BO_NAME:%d", tbm_bo_export(gbm_buffer->bo));
-               TRACE_ASYNC_BEGIN((int)gbm_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
+               TRACE_ASYNC_BEGIN((intptr_t)gbm_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
                                                  tbm_bo_export(gbm_buffer->bo));
                TPL_LOG_B("GBM", "[DEQ][R] tpl_gbm_surface_t(%p) tbm_surface(%p) bo(%d)",
                                  gbm_surface, tbm_surface, tbm_bo_export(gbm_buffer->bo));
@@ -549,7 +549,7 @@ __tpl_gbm_surface_dequeue_buffer(tpl_surface_t *surface, uint64_t timeout_ns,
        __tpl_gbm_set_gbm_buffer_to_tbm_surface(tbm_surface, gbm_buffer);
 
        TRACE_MARK("[DEQ][NEW]BO_NAME:%d", tbm_bo_export(gbm_buffer->bo));
-       TRACE_ASYNC_BEGIN((int)gbm_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
+       TRACE_ASYNC_BEGIN((intptr_t)gbm_buffer, "[DEQ]~[ENQ] BO_NAME:%d",
                                          tbm_bo_export(gbm_buffer->bo));
        TPL_LOG_B("GBM", "[DEQ][N] tpl_gbm_surface_t(%p) tbm_surface(%p) bo(%d)",
                          gbm_surface, tbm_surface, tbm_bo_export(bo));

diff --git a/src/unused/tpl_wayland_egl_thread.c b/src/unused/tpl_wayland_egl_thread.c
index 0ea5cc4..ccbc370 100755 (executable)
--- a/src/unused/tpl_wayland_egl_thread.c
+++ b/src/unused/tpl_wayland_egl_thread.c
@@ -1692,7 +1692,7 @@ __cb_buffer_release_callback(void *data, struct wl_proxy *wl_buffer)
                        buf_info->need_to_release = TPL_FALSE;
 
                        TRACE_MARK("[RELEASE] BO(%d)", _get_tbm_surface_bo_name(tbm_surface));
-                       TRACE_ASYNC_END((int)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
+                       TRACE_ASYNC_END((intptr_t)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
                                                        _get_tbm_surface_bo_name(tbm_surface));
 
                        TPL_LOG_T(BACKEND, "[REL] wl_buffer(%p) tbm_surface(%p) bo(%d)",
@@ -1742,7 +1742,7 @@ __cb_buffer_fenced_release(void *data,
                        TRACE_MARK("[FENCED_RELEASE] BO(%d) fence(%d)",
                                           _get_tbm_surface_bo_name(tbm_surface),
                                           fence);
-                       TRACE_ASYNC_END((int)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
+                       TRACE_ASYNC_END((intptr_t)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
                                                        _get_tbm_surface_bo_name(tbm_surface));
 
                        TPL_LOG_T(BACKEND,
@@ -1794,7 +1794,7 @@ __cb_buffer_immediate_release(void *data,
 
                        TRACE_MARK("[IMMEDIATE_RELEASE] BO(%d)",
                                           _get_tbm_surface_bo_name(tbm_surface));
-                       TRACE_ASYNC_END((int)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
+                       TRACE_ASYNC_END((intptr_t)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
                                                        _get_tbm_surface_bo_name(tbm_surface));
 
                        TPL_LOG_T(BACKEND,
@@ -2165,7 +2165,7 @@ __cb_tdm_client_vblank(tdm_client_vblank *vblank, tdm_error error,
                return;
        }
 
-       TRACE_ASYNC_END((int)surf_source, "WAIT_VBLANK");
+       TRACE_ASYNC_END((intptr_t)surf_source, "WAIT_VBLANK");
 
        if (error == TDM_ERROR_TIMEOUT)
                TPL_WARN("[TDM_ERROR_TIMEOUT] It will keep going. surf_source(%p)",
@@ -2249,7 +2249,7 @@ _twe_surface_wait_vblank(twe_wl_surf_source *surf_source)
 
        if (tdm_err == TDM_ERROR_NONE) {
                surf_source->vblank_done = TPL_FALSE;
-               TRACE_ASYNC_BEGIN((int)surf_source, "WAIT_VBLANK");
+               TRACE_ASYNC_BEGIN((intptr_t)surf_source, "WAIT_VBLANK");
        } else {
                TPL_ERR("Failed to tdm_client_vblank_wait. tdm_err(%d)", tdm_err);
                return TPL_ERROR_INVALID_OPERATION;
@@ -2316,7 +2316,7 @@ _twe_thread_wl_vk_surface_commit(twe_wl_surf_source *surf_source,
        wl_display_flush(surf_source->disp_source->disp);
 
        TRACE_MARK("[COMMIT] BO(%d)", _get_tbm_surface_bo_name(tbm_surface));
-       TRACE_ASYNC_BEGIN((int)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
+       TRACE_ASYNC_BEGIN((intptr_t)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
                                          _get_tbm_surface_bo_name(tbm_surface));
 
        buf_info->sync_timestamp++;
@@ -2600,7 +2600,7 @@ _twe_thread_wl_surface_commit(twe_wl_surf_source *surf_source,
 
        wl_display_flush(surf_source->disp_source->disp);
 
-       TRACE_ASYNC_BEGIN((int)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
+       TRACE_ASYNC_BEGIN((intptr_t)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
                                          _get_tbm_surface_bo_name(tbm_surface));
 
        buf_info->need_to_commit = TPL_FALSE;
@@ -3107,7 +3107,7 @@ _twe_thread_wl_surf_source_destroy(void *source)
                                __tpl_list_pop_front(surf_source->committed_buffers,
                                        (tpl_free_func_t)__cb_buffer_remove_from_list);
 
-                               TRACE_ASYNC_END((int)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
+                               TRACE_ASYNC_END((intptr_t)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
                                                                _get_tbm_surface_bo_name(tbm_surface));
                                tsq_err = tbm_surface_queue_release(surf_source->tbm_queue, tbm_surface);
                                if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE)
@@ -3564,7 +3564,7 @@ twe_surface_destroy_swapchain(twe_surface_h twe_surface)
                                __tpl_list_pop_front(surf_source->committed_buffers,
                                        (tpl_free_func_t)__cb_buffer_remove_from_list);
 
-                       TRACE_ASYNC_END((int)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
+                       TRACE_ASYNC_END((intptr_t)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
                                                        _get_tbm_surface_bo_name(tbm_surface));
                        tsq_err = tbm_surface_queue_release(surf_source->tbm_queue, tbm_surface);
                        if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE)
@@ -3761,7 +3761,7 @@ _twe_thread_fence_wait_source_dispatch(GSource *source, GSourceFunc cb, gpointer
 
        surf_source->render_done_cnt++;
 
-       TRACE_ASYNC_END((int)wait_source, "FENCE WAIT fd(%d)", wait_source->fence_fd);
+       TRACE_ASYNC_END((intptr_t)wait_source, "FENCE WAIT fd(%d)", wait_source->fence_fd);
 
        g_mutex_lock(&surf_source->surf_mutex);
        /* Since this source is going to be removed, acquire_and_commit must be
@@ -3819,7 +3819,7 @@ _twe_thread_fence_wait_source_attach(twe_wl_surf_source *surf_source,
                return TPL_ERROR_OUT_OF_MEMORY;
        }
 
-       TRACE_ASYNC_BEGIN((int)wait_source, "FENCE WAIT fd(%d)", sync_fd);
+       TRACE_ASYNC_BEGIN((intptr_t)wait_source, "FENCE WAIT fd(%d)", sync_fd);
 
        tbm_surface_internal_ref(tbm_surface);
 
@@ -4008,7 +4008,7 @@ twe_surface_queue_force_flush(twe_surface_h twe_surface)
                                tbm_surface_h tbm_surface =
                                __tpl_list_pop_front(surf_source->committed_buffers,
                                                                         (tpl_free_func_t)__cb_buffer_remove_from_list);
-                       TRACE_ASYNC_END((int)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
+                       TRACE_ASYNC_END((intptr_t)tbm_surface, "[COMMIT ~ RELEASE] BO(%d)",
                                                        _get_tbm_surface_bo_name(tbm_surface));
                        tsq_err = tbm_surface_queue_release(surf_source->tbm_queue, tbm_surface);
                        if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE)

diff --git a/src/unused/tpl_wl_egl_thread_legacy.c b/src/unused/tpl_wl_egl_thread_legacy.c
index bb6a55d..c37ee96 100644 (file)
--- a/src/unused/tpl_wl_egl_thread_legacy.c
+++ b/src/unused/tpl_wl_egl_thread_legacy.c
@@ -529,7 +529,7 @@ __tpl_wl_egl_surface_enqueue_buffer(tpl_surface_t *surface,
        if (!wayland_egl_surface) {
                TPL_ERR("Invalid parameter. surface(%p) wayland_egl_surface(%p)",
                                surface, wayland_egl_surface);
-               TRACE_ASYNC_END((int)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
+               TRACE_ASYNC_END((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
                TPL_OBJECT_UNLOCK(wayland_egl_surface);
                return TPL_ERROR_INVALID_PARAMETER;
        }
@@ -537,7 +537,7 @@ __tpl_wl_egl_surface_enqueue_buffer(tpl_surface_t *surface,
        if (!tbm_surface_internal_is_valid(tbm_surface)) {
                TPL_ERR("Failed to enqueue tbm_surface(%p) Invalid value.",
                                tbm_surface);
-               TRACE_ASYNC_END((int)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
+               TRACE_ASYNC_END((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
                TPL_OBJECT_UNLOCK(wayland_egl_surface);
                return TPL_ERROR_INVALID_PARAMETER;
        }
@@ -564,7 +564,7 @@ __tpl_wl_egl_surface_enqueue_buffer(tpl_surface_t *surface,
                TPL_LOG_T("WL_EGL",
                                  "[ENQ_SKIP][Frontbuffer:%s] tbm_surface(%p) need not to enqueue",
                                  ((surface->frontbuffer == tbm_surface) ? "ON" : "OFF"), tbm_surface);
-               TRACE_ASYNC_END((int)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
+               TRACE_ASYNC_END((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
                TPL_OBJECT_UNLOCK(wayland_egl_surface);
                return TPL_ERROR_NONE;
        }
@@ -602,14 +602,14 @@ __tpl_wl_egl_surface_enqueue_buffer(tpl_surface_t *surface,
                tbm_surface_internal_unref(tbm_surface);
                TPL_ERR("Failed to enqueue tbm_surface(%p). tpl_surface(%p) tsq_err=%d",
                                tbm_surface, surface, tsq_err);
-               TRACE_ASYNC_END((int)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
+               TRACE_ASYNC_END((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
                TPL_OBJECT_UNLOCK(wayland_egl_surface);
                return TPL_ERROR_INVALID_OPERATION;
        }
 
        tbm_surface_internal_unref(tbm_surface);
 
-       TRACE_ASYNC_END((int)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
+       TRACE_ASYNC_END((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
        TPL_OBJECT_UNLOCK(wayland_egl_surface);
 
        return TPL_ERROR_NONE;
@@ -748,7 +748,7 @@ __tpl_wl_egl_surface_dequeue_buffer(tpl_surface_t *surface, uint64_t timeout_ns,
                                          surface->frontbuffer,
                                          tbm_bo_export(tbm_surface_internal_get_bo(
                                                                        surface->frontbuffer, 0)));
-                       TRACE_ASYNC_BEGIN((int)surface->frontbuffer,
+                       TRACE_ASYNC_BEGIN((intptr_t)surface->frontbuffer,
                                                          "[DEQ]~[ENQ] BO_NAME:%d",
                                                          tbm_bo_export(tbm_surface_internal_get_bo(
                                                                                                surface->frontbuffer, 0)));
@@ -791,7 +791,7 @@ __tpl_wl_egl_surface_dequeue_buffer(tpl_surface_t *surface, uint64_t timeout_ns,
        wayland_egl_surface->reset = TPL_FALSE;
 
        TRACE_MARK("[DEQ][NEW]BO_NAME:%d", bo_name);
-       TRACE_ASYNC_BEGIN((int)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
+       TRACE_ASYNC_BEGIN((intptr_t)tbm_surface, "[DEQ]~[ENQ] BO_NAME:%d", bo_name);
        TPL_LOG_T("WL_EGL", "[DEQ][N] tbm_surface(%p) bo(%d) fence(%d)",
                          tbm_surface, bo_name, sync_fence ? *sync_fence : -1);