[0.2.98] modify log message

- use function enter/leave macro
- remove __FUNCTION__ which is included in dlog

Change-Id: I6cc4d0b267ed2f338cc73759fcac3dc3f734e74c

diff --git a/legacy/src/legacy_player.c b/legacy/src/legacy_player.c
index 5f5477e..7c69e18 100644 (file)
--- a/legacy/src/legacy_player.c
+++ b/legacy/src/legacy_player.c
@@ -290,7 +290,7 @@ static int __set_callback(muse_player_event_e type, player_h player, void *callb
 
        handle->user_cb[type] = callback;
        handle->user_data[type] = user_data;
-       LOGI("[%s] Event type : %d ", __FUNCTION__, type);
+       LOGI("Event type : %d ", type);
        return PLAYER_ERROR_NONE;
 }
 
@@ -300,7 +300,7 @@ static int __unset_callback(muse_player_event_e type, player_h player)
        PLAYER_INSTANCE_CHECK(player);
        handle->user_cb[type] = NULL;
        handle->user_data[type] = NULL;
-       LOGI("[%s] Event type : %d ", __FUNCTION__, type);
+       LOGI("Event type : %d ", type);
        return PLAYER_ERROR_NONE;
 }
 
@@ -409,15 +409,16 @@ static int __msg_callback(int message, void *param, void *user_data)
 {
        player_s *handle = (player_s *)user_data;
        MMMessageParamType *msg = (MMMessageParamType *)param;
-       LOGW("[%s] Got message type : 0x%x", __FUNCTION__, message);
        player_error_e err_code = PLAYER_ERROR_NONE;
+
+       LOGW("Got message type : 0x%x", message);
        switch (message) {
        case MM_MESSAGE_ERROR:  /* 0x01 */
                err_code = __player_convert_error_code(msg->code, (char *)__FUNCTION__);
 
                LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
                if (PLAYER_ERROR_NOT_SUPPORTED_FILE == err_code && handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
-                       LOGW("failed to pause, so prepare cb will be released soon");
+                       LOGW("Failed to pause, so prepare cb will be released soon");
                        handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
                        if (handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
                                g_free(handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE]);
@@ -432,7 +433,7 @@ static int __msg_callback(int message, void *param, void *user_data)
                        LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
                        if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
                                /* asyc && prepared cb has been set */
-                               LOGI("[%s] Prepared! [current state : %d]", __FUNCTION__, handle->state);
+                               LOGI("Prepared! [current state : %d]", handle->state);
                                PLAYER_TRACE_ASYNC_END("MM:PLAYER:PREPARE_ASYNC", *(int *)handle);
                                __ADD_MESSAGE(handle, PLAYER_MESSAGE_PREPARED);
                        }
@@ -440,7 +441,7 @@ static int __msg_callback(int message, void *param, void *user_data)
                }
                break;
        case MM_MESSAGE_BEGIN_OF_STREAM:        /* 0x104 */
-               LOGI("[%s] Ready to streaming information (BOS) [current state : %d]", __FUNCTION__, handle->state);
+               LOGI("Ready to streaming information (BOS) [current state : %d]", handle->state);
                break;
        case MM_MESSAGE_END_OF_STREAM:  /* 0x105 */
                if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_COMPLETE])
@@ -467,7 +468,7 @@ static int __msg_callback(int message, void *param, void *user_data)
                }
                break;
        case MM_MESSAGE_CONNECTION_TIMEOUT:     /* 0x102 */
-               LOGI("[%s] PLAYER_ERROR_CONNECTION_FAILED (0x%08x) : CONNECTION_TIMEOUT", __FUNCTION__, PLAYER_ERROR_CONNECTION_FAILED);
+               LOGE("PLAYER_ERROR_CONNECTION_FAILED : CONNECTION_TIMEOUT");
                err_code = PLAYER_ERROR_CONNECTION_FAILED;
                break;
        case MM_MESSAGE_UPDATE_SUBTITLE:        /* 0x109 */
@@ -475,7 +476,7 @@ static int __msg_callback(int message, void *param, void *user_data)
                        ((player_subtitle_updated_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SUBTITLE])(msg->subtitle.duration, (char *)msg->data, handle->user_data[MUSE_PLAYER_EVENT_TYPE_SUBTITLE]);
                break;
        case MM_MESSAGE_VIDEO_NOT_CAPTURED:     /* 0x113 */
-               LOGI("[%s] PLAYER_ERROR_VIDEO_CAPTURE_FAILED (0x%08x)", __FUNCTION__, PLAYER_ERROR_VIDEO_CAPTURE_FAILED);
+               LOGE("PLAYER_ERROR_VIDEO_CAPTURE_FAILED");
                if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR])
                        ((player_error_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR])(PLAYER_ERROR_VIDEO_CAPTURE_FAILED, handle->user_data[MUSE_PLAYER_EVENT_TYPE_ERROR]);
                break;
@@ -485,7 +486,7 @@ static int __msg_callback(int message, void *param, void *user_data)
 
                if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE]) {
                        if (!capture || !capture->data) {
-                               LOGE("PLAYER_ERROR_VIDEO_CAPTURE_FAILED (0x%08x) : Failed to get capture data", PLAYER_ERROR_VIDEO_CAPTURE_FAILED);
+                               LOGE("PLAYER_ERROR_VIDEO_CAPTURE_FAILED : Failed to get capture data");
                                err_code = PLAYER_ERROR_VIDEO_CAPTURE_FAILED;
                        } else {
                                LOGI("captured image ori: %d, width: %d, height: %d, size: %d",
@@ -508,11 +509,11 @@ static int __msg_callback(int message, void *param, void *user_data)
                break;
        }
        case MM_MESSAGE_FILE_NOT_SUPPORTED:     /* 0x10f */
-               LOGI("[%s] PLAYER_ERROR_NOT_SUPPORTED_FILE (0x%08x) : FILE_NOT_SUPPORTED", __FUNCTION__, PLAYER_ERROR_NOT_SUPPORTED_FILE);
+               LOGE("PLAYER_ERROR_NOT_SUPPORTED_FILE : FILE_NOT_SUPPORTED");
                err_code = PLAYER_ERROR_NOT_SUPPORTED_FILE;
                break;
        case MM_MESSAGE_FILE_NOT_FOUND: /* 0x110 */
-               LOGI("[%s] PLAYER_ERROR_NOT_SUPPORTED_FILE (0x%08x) : FILE_NOT_FOUND", __FUNCTION__, PLAYER_ERROR_NOT_SUPPORTED_FILE);
+               LOGE("PLAYER_ERROR_NOT_SUPPORTED_FILE : FILE_NOT_FOUND");
                err_code = PLAYER_ERROR_NOT_SUPPORTED_FILE;
                break;
        case MM_MESSAGE_SEEK_COMPLETED: /* 0x114 */
@@ -520,7 +521,7 @@ static int __msg_callback(int message, void *param, void *user_data)
                        if (handle->is_display_visible) {
                                int ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", 1, (char *)NULL);
                                if (ret != MM_ERROR_NONE)
-                                       LOGW("[%s] Failed to set display_visible '1' (0x%x)", __FUNCTION__, ret);
+                                       LOGW("Failed to set display_visible '1' (0x%x)", ret);
                        }
                }
                if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK]) {
@@ -550,7 +551,8 @@ static int __msg_callback(int message, void *param, void *user_data)
                handle->error_code = err_code;
                __ADD_MESSAGE(handle, PLAYER_MESSAGE_ERROR);
        }
-       LOGW("[%s] End", __FUNCTION__);
+
+       LPLAYER_FLEAVE();
        return 1;
 }
 
@@ -589,16 +591,18 @@ int legacy_player_create(player_h *player)
 {
        player_s *handle;
        int ret = MM_ERROR_NONE;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_TRACE_BEGIN("MM:PLAYER:CREATE");
+
        handle = g_try_new0(player_s, 1);
        if (!handle) {
-               LOGE("[%s] PLAYER_ERROR_OUT_OF_MEMORY(0x%08x)", __FUNCTION__, PLAYER_ERROR_OUT_OF_MEMORY);
+               LOGE("PLAYER_ERROR_OUT_OF_MEMORY");
                return PLAYER_ERROR_OUT_OF_MEMORY;
        }
        ret = mm_player_create(&handle->mm_handle);
        if (ret != MM_ERROR_NONE) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION);
+               LOGE("Failed to create player 0x%X", ret);
                __player_update_state(handle, PLAYER_INTERNAL_STATE_NONE);
                g_free(handle);
                handle = NULL;
@@ -623,11 +627,11 @@ int legacy_player_create(player_h *player)
        g_cond_init(&handle->message_queue_cond);
        ret = pthread_create(&handle->message_thread, NULL, (void *)__message_cb_loop, (void *)handle);
        if (ret != 0) {
-               LOGE("[%s] failed to create message thread ret = %d", __FUNCTION__, ret);
+               LOGE("Failed to create message thread 0x%X", ret);
                return PLAYER_ERROR_OUT_OF_MEMORY;
        }
 
-       LOGI("[%s] new handle : %p", __FUNCTION__, *player);
+       LOGI("new handle : %p", *player);
        PLAYER_TRACE_END();
        return PLAYER_ERROR_NONE;
 }
@@ -636,7 +640,8 @@ int legacy_player_destroy(player_h player)
 {
        player_s *handle = (player_s *)player;
        int ret = MM_ERROR_NONE;
-       LOGI("[%s] Start, handle to destroy : %p", __FUNCTION__, player);
+
+       LOGI("<Enter: %p>", player);
        PLAYER_TRACE_BEGIN("MM:PLAYER:DESTROY");
        PLAYER_INSTANCE_CHECK(player);
 
@@ -661,10 +666,10 @@ int legacy_player_destroy(player_h player)
 
        ret = mm_player_destroy(handle->mm_handle);
        if (ret != MM_ERROR_NONE) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION);
+               LOGE("Failed to player destroy 0x%X", ret);
                return PLAYER_ERROR_INVALID_OPERATION;
        }
-       LOGI("[%s] Done mm_player_destroy", __FUNCTION__);
+       LOGI("Done mm_player_destroy");
 
        muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_PREPARE;
 
@@ -686,7 +691,8 @@ int legacy_player_destroy(player_h player)
 
        g_free(handle);
        handle = NULL;
-       LOGI("[%s] End", __FUNCTION__);
+
+       LPLAYER_FLEAVE();
        PLAYER_TRACE_END();
        return PLAYER_ERROR_NONE;
 }
@@ -727,7 +733,7 @@ int legacy_player_prepare_async(player_h player, player_prepared_cb callback, vo
        int visible = 0;
        int value = 0;
 
-       LOGI("[%s] Start", __FUNCTION__);
+       LPLAYER_FENTER();
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_TRACE_ASYNC_BEGIN("MM:PLAYER:PREPARE_ASYNC", *(int *)handle);
        PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
@@ -737,13 +743,13 @@ int legacy_player_prepare_async(player_h player, player_prepared_cb callback, vo
 
        handle->last_play_position = 0;
        if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION (0x%08x) : preparing... we can't do any more ", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION);
+               LOGE("player is already prepareing");
                LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
                __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
                return PLAYER_ERROR_INVALID_OPERATION;
        }
 
-       /* LOGI("[%s] Event type : %d ",__FUNCTION__, MUSE_PLAYER_EVENT_TYPE_PREPARE); */
+       /* LOGI("Event type : %d ", MUSE_PLAYER_EVENT_TYPE_PREPARE); */
        handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = callback;
        handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = user_data;
 
@@ -751,12 +757,12 @@ int legacy_player_prepare_async(player_h player, player_prepared_cb callback, vo
 
        ret = mm_player_set_message_callback(handle->mm_handle, __msg_callback, (void *)handle);
        if (ret != MM_ERROR_NONE)
-               LOGW("[%s] Failed to set message callback function (0x%x)", __FUNCTION__, ret);
+               LOGW("Failed to set message callback function (0x%x)", ret);
 
        if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE) {
                ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", MM_DISPLAY_SURFACE_NULL, (char *)NULL);
                if (ret != MM_ERROR_NONE)
-                       LOGW("[%s] Failed to set display surface type 'MM_DISPLAY_SURFACE_NULL' (0x%x)", __FUNCTION__, ret);
+                       LOGW("Failed to set display surface type 'MM_DISPLAY_SURFACE_NULL' (0x%x)", ret);
        } else {
 
                /* FIXME : new funct path is needed to update video instead of set attr again */
@@ -774,14 +780,14 @@ int legacy_player_prepare_async(player_h player, player_prepared_cb callback, vo
 
        ret = mm_player_realize(handle->mm_handle);
        if (ret != MM_ERROR_NONE) {
-               LOGE("[%s] Failed to realize - 0x%x", __FUNCTION__, ret);
+               LOGE("Failed to realize - 0x%x", ret);
                goto ERROR;
        }
 
        ret = pthread_create(&handle->prepare_async_thread, NULL, (void *)__prepare_async_thread_func, (void *)handle);
 
        if (ret != 0) {
-               LOGE("[%s] failed to create thread ret = %d", __FUNCTION__, ret);
+               LOGE("Failed to create thread ret = %d", ret);
                LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
                if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
                        handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
@@ -793,7 +799,7 @@ int legacy_player_prepare_async(player_h player, player_prepared_cb callback, vo
                return PLAYER_ERROR_OUT_OF_MEMORY;
        }
 
-       LOGI("[%s] End", __FUNCTION__);
+       LPLAYER_FLEAVE();
        return PLAYER_ERROR_NONE;
 
 ERROR:
@@ -807,7 +813,7 @@ ERROR:
        LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
        __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
 
-       LOGE("LEAVE mm_err:0x%X", ret);
+       LOGE("LEAVE 0x%X", ret);
        return __player_convert_error_code(ret, (char *)__FUNCTION__);
 }
 
@@ -817,7 +823,7 @@ int legacy_player_prepare(player_h player)
        int visible = 0;
        player_s *handle = (player_s *)player;
 
-       LOGI("[%s] Start", __FUNCTION__);
+       LPLAYER_FENTER();
        PLAYER_TRACE_BEGIN("MM:PLAYER:PREPARE");
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
@@ -826,12 +832,12 @@ int legacy_player_prepare(player_h player)
        handle->last_play_position = 0;
        ret = mm_player_set_message_callback(handle->mm_handle, __msg_callback, (void *)handle);
        if (ret != MM_ERROR_NONE)
-               LOGW("[%s] Failed to set message callback function (0x%x)", __FUNCTION__, ret);
+               LOGW("Failed to set message callback function (0x%x)", ret);
 
        if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE) {
                ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", MM_DISPLAY_SURFACE_NULL, (char *)NULL);
                if (ret != MM_ERROR_NONE)
-                       LOGW("[%s] Failed to set display surface type 'MM_DISPLAY_SURFACE_NULL' (0x%x)", __FUNCTION__, ret);
+                       LOGW("Failed to set display surface type 'MM_DISPLAY_SURFACE_NULL' (0x%x)", ret);
        } else {
                ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_visible", &visible, (char *)NULL);
                if (ret != MM_ERROR_NONE) {
@@ -841,12 +847,12 @@ int legacy_player_prepare(player_h player)
 
                ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", visible, (char *)NULL);
                if (ret != MM_ERROR_NONE)
-                       LOGW("[%s] Failed to set display display_visible '%d' (0x%x)", __FUNCTION__, visible, ret);
+                       LOGW("Failed to set display display_visible '%d' (0x%x)", visible, ret);
        }
 
        ret = mm_player_realize(handle->mm_handle);
        if (ret != MM_ERROR_NONE) {
-               LOGE("[%s] Failed to realize - 0x%x", __FUNCTION__, ret);
+               LOGE("Failed to realize - 0x%x", ret);
                __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
        }
@@ -856,15 +862,16 @@ int legacy_player_prepare(player_h player)
                int uret;
                uret = mm_player_unrealize(handle->mm_handle);
                if (uret != MM_ERROR_NONE)
-                       LOGE("[%s] Failed to unrealize - 0x%x", __FUNCTION__, uret);
+                       LOGE("Failed to unrealize - 0x%x", uret);
 
-               LOGE("[%s] Failed to pause - 0x%x", __FUNCTION__, ret);
+               LOGE("Failed to pause - 0x%x", ret);
                __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
        }
 
        __player_update_state(handle, PLAYER_INTERNAL_STATE_READY);
-       LOGI("[%s] End", __FUNCTION__);
+
+       LPLAYER_FLEAVE();
        PLAYER_TRACE_END();
        return PLAYER_ERROR_NONE;
 }
@@ -887,7 +894,7 @@ int legacy_player_unprepare(player_h player)
        }
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY) && !handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -1063,18 +1070,19 @@ int legacy_player_start(player_h player)
 {
        player_s *handle = (player_s *)player;
        int ret = MM_ERROR_NONE;
-       LOGI("[%s] Start", __FUNCTION__);
+
+       LPLAYER_FENTER();
        PLAYER_INSTANCE_CHECK(player);
 
        if (handle->state > PLAYER_STATE_IDLE) {
                if (handle->display_type == PLAYER_DISPLAY_TYPE_OVERLAY && handle->is_display_visible) {
                        ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", 1, (char *)NULL);
                        if (ret != MM_ERROR_NONE)
-                               LOGW("[%s] Failed to set display_visible '1' (0x%x)", __FUNCTION__, ret);
+                               LOGW("Failed to set display_visible '1' (0x%x)", ret);
                }
                if (handle->internal_state == PLAYER_INTERNAL_STATE_STOPPED) {
                        ret = mm_player_start(handle->mm_handle);
-                       LOGI("[%s] stop -> start() ", __FUNCTION__);
+                       LOGI("stop -> start() ");
                } else {
                        if (handle->state == PLAYER_STATE_READY)
                                ret = mm_player_start(handle->mm_handle);
@@ -1082,7 +1090,7 @@ int legacy_player_start(player_h player)
                                ret = mm_player_resume(handle->mm_handle);
                }
        } else {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -1090,7 +1098,8 @@ int legacy_player_start(player_h player)
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
 
        __player_update_state(handle, PLAYER_INTERNAL_STATE_PLAYING);
-       LOGI("[%s] End", __FUNCTION__);
+
+       LPLAYER_FLEAVE();
        return PLAYER_ERROR_NONE;
 }
 
@@ -1098,14 +1107,15 @@ int legacy_player_stop(player_h player)
 {
        player_s *handle = (player_s *)player;
        int ret = MM_ERROR_NONE;
-       LOGI("[%s] Start", __FUNCTION__);
+
+       LPLAYER_FENTER();
        PLAYER_INSTANCE_CHECK(player);
 
        if (handle->state == PLAYER_STATE_PLAYING || handle->state == PLAYER_STATE_PAUSED) {
                if (handle->display_type == PLAYER_DISPLAY_TYPE_OVERLAY) {
                        ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", 0, (char *)NULL);
                        if (ret != MM_ERROR_NONE)
-                               LOGW("[%s] Failed to set display_visible '0' (0x%x)", __FUNCTION__, ret);
+                               LOGW("Failed to set display_visible '0' (0x%x)", ret);
                }
 
                ret = mm_player_stop(handle->mm_handle);
@@ -1120,11 +1130,11 @@ int legacy_player_stop(player_h player)
 
                __player_update_state(handle, PLAYER_INTERNAL_STATE_STOPPED);
 
-               LOGI("[%s] End", __FUNCTION__);
+               LPLAYER_FLEAVE();
                return PLAYER_ERROR_NONE;
        }
 
-       LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+       LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
        return PLAYER_ERROR_INVALID_STATE;
 }
 
@@ -1132,7 +1142,8 @@ int legacy_player_pause(player_h player)
 {
        player_s *handle = (player_s *)player;
        int ret = MM_ERROR_NONE;
-       LOGI("[%s] Start", __FUNCTION__);
+
+       LPLAYER_FENTER();
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_STATE_CHECK(handle, PLAYER_STATE_PLAYING);
 
@@ -1141,7 +1152,8 @@ int legacy_player_pause(player_h player)
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
 
        __player_update_state(handle, PLAYER_INTERNAL_STATE_PAUSED);
-       LOGI("[%s] End", __FUNCTION__);
+
+       LPLAYER_FLEAVE();
        return PLAYER_ERROR_NONE;
 }
 
@@ -1150,20 +1162,22 @@ int legacy_player_set_play_position(player_h player, int64_t nanoseconds, bool a
        player_s *handle = (player_s *)player;
        int ret = MM_ERROR_NONE;
        int accurated = accurate ? 1 : 0;
+
+       LPLAYER_FENTER();
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_CHECK_CONDITION(nanoseconds >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
        if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK] && !handle->is_media_stream) {
-               LOGE("[%s] PLAYER_ERROR_SEEK_FAILED temp (0x%08x) : seeking... we can't do any more ", __FUNCTION__, PLAYER_ERROR_SEEK_FAILED);
+               LOGE("previous seeking request is in processing.");
                return PLAYER_ERROR_SEEK_FAILED;
        }
 
-       LOGI("[%s] Event type : %d, pos : %"PRId64, __FUNCTION__, MUSE_PLAYER_EVENT_TYPE_SEEK, nanoseconds);
+       LOGI("Event type : %d, pos : %"PRId64, MUSE_PLAYER_EVENT_TYPE_SEEK, nanoseconds);
        handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK] = callback;
        handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = user_data;
 
@@ -1178,6 +1192,7 @@ int legacy_player_set_play_position(player_h player, int64_t nanoseconds, bool a
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
        }
 
+       LPLAYER_FLEAVE();
        return PLAYER_ERROR_NONE;
 }
 
@@ -1190,7 +1205,7 @@ int legacy_player_get_play_position(player_h player, int64_t *nanoseconds)
        PLAYER_NULL_ARG_CHECK(nanoseconds);
 
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -1287,7 +1302,7 @@ int legacy_player_get_duration(player_h player, int64_t *duration)
        PLAYER_NULL_ARG_CHECK(duration);
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -1303,8 +1318,9 @@ int legacy_player_set_display_mode(player_h player, player_display_mode_e mode)
 {
        player_s *handle = (player_s *)player;
        int ret = MM_ERROR_NONE;
+
+       LOGI("<ENTER: mode:%d>", mode);
        PLAYER_INSTANCE_CHECK(player);
-       LOGI("[%s] mode:%d", __FUNCTION__, mode);
 
        ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_method", mode, (char *)NULL);
        if (ret != MM_ERROR_NONE)
@@ -1331,12 +1347,12 @@ int legacy_player_set_playback_rate(player_h player, float rate)
 {
        player_s *handle = (player_s *)player;
        int ret = MM_ERROR_NONE;
-       LOGI("[%s] rate : %0.1f", __FUNCTION__, rate);
+       LOGI("<ENTER: rate %0.1f>", rate);
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_CHECK_CONDITION(rate >= -5.0 && rate <= 5.0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -1348,7 +1364,7 @@ int legacy_player_set_playback_rate(player_h player, float rate)
                break;
        case MM_ERROR_NOT_SUPPORT_API:
        case MM_ERROR_PLAYER_SEEK:
-               LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x) : seek error", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION);
+               LOGE("PLAYER_ERROR_INVALID_OPERATION : seek error");
                ret = PLAYER_ERROR_INVALID_OPERATION;
                break;
        default:
@@ -1431,7 +1447,7 @@ int legacy_player_get_content_info(player_h player, player_content_info_e key, c
        PLAYER_NULL_ARG_CHECK(value);
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -1469,7 +1485,7 @@ int legacy_player_get_content_info(player_h player, player_content_info_e key, c
                *value = strndup("", 0);
 
        if (*value == NULL) {
-               LOGE("[%s] PLAYER_ERROR_OUT_OF_MEMORY(0x%08x) : fail to strdup ", __FUNCTION__, PLAYER_ERROR_OUT_OF_MEMORY);
+               LOGE("PLAYER_ERROR_OUT_OF_MEMORY : fail to strdup");
                return PLAYER_ERROR_OUT_OF_MEMORY;
        }
 
@@ -1489,7 +1505,7 @@ int legacy_player_get_codec_info(player_h player, char **audio_codec, char **vid
        PLAYER_NULL_ARG_CHECK(video_codec);
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -1523,7 +1539,7 @@ int legacy_player_get_audio_stream_info(player_h player, int *sample_rate, int *
        PLAYER_NULL_ARG_CHECK(bit_rate);
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
        ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_AUDIO_SAMPLERATE, sample_rate, MM_PLAYER_AUDIO_CHANNEL, channel, MM_PLAYER_AUDIO_BITRATE, bit_rate, (char *)NULL);
@@ -1542,7 +1558,7 @@ int legacy_player_get_video_stream_info(player_h player, int *fps, int *bit_rate
        PLAYER_NULL_ARG_CHECK(bit_rate);
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
        ret = mm_player_get_attribute(handle->mm_handle, NULL, "content_video_fps", fps, "content_video_bitrate", bit_rate, (char *)NULL);
@@ -1562,7 +1578,7 @@ int legacy_player_get_video_size(player_h player, int *width, int *height)
        PLAYER_NULL_ARG_CHECK(width);
        PLAYER_NULL_ARG_CHECK(height);
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
        ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_WIDTH, &w, MM_PLAYER_VIDEO_HEIGHT, &h, (char *)NULL);
@@ -1571,7 +1587,7 @@ int legacy_player_get_video_size(player_h player, int *width, int *height)
 
        *width = w;
        *height = h;
-       LOGI("[%s] width : %d, height : %d", __FUNCTION__, w, h);
+       LOGI("width : %d, height : %d", w, h);
        return PLAYER_ERROR_NONE;
 }
 
@@ -1582,7 +1598,7 @@ int legacy_player_get_album_art(player_h player, void **album_art, int *size)
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(size);
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -1720,7 +1736,7 @@ int legacy_player_audio_effect_equalizer_is_available(player_h player, bool *ava
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(available);
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -1737,6 +1753,8 @@ int legacy_player_set_subtitle_path(player_h player, const char *path)
 {
        player_s *handle = (player_s *)player;
        int ret = MM_ERROR_NONE;
+
+       LPLAYER_FENTER();
        PLAYER_INSTANCE_CHECK(player);
 
        if ((path == NULL) && (handle->state != PLAYER_STATE_IDLE))
@@ -1746,6 +1764,7 @@ int legacy_player_set_subtitle_path(player_h player, const char *path)
        if (ret != MM_ERROR_NONE)
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
 
+       LPLAYER_FLEAVE();
        return PLAYER_ERROR_NONE;
 }
 
@@ -1756,7 +1775,7 @@ int legacy_player_set_subtitle_position_offset(player_h player, int millisecond)
        int ret = MM_ERROR_NONE;
        PLAYER_INSTANCE_CHECK(player);
        if (!__player_state_validate(handle, PLAYER_STATE_PLAYING)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -1771,14 +1790,16 @@ int legacy_player_capture_video(player_h player, player_video_captured_cb callba
 {
        player_s *handle = (player_s *)player;
        int ret = MM_ERROR_NONE;
+
+       LPLAYER_FENTER();
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(callback);
        if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE]) {
-               LOGE("[%s] PLAYER_ERROR_VIDEO_CAPTURE_FAILED (0x%08x) : capturing... we can't do any more ", __FUNCTION__, PLAYER_ERROR_VIDEO_CAPTURE_FAILED);
+               LOGE("previous capturing request is in processing.");
                return PLAYER_ERROR_VIDEO_CAPTURE_FAILED;
        }
 
-       LOGI("[%s] Event type : %d ", __FUNCTION__, MUSE_PLAYER_EVENT_TYPE_CAPTURE);
+       LOGI("Event type : %d ", MUSE_PLAYER_EVENT_TYPE_CAPTURE);
        handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = callback;
        handle->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = user_data;
 
@@ -1787,7 +1808,7 @@ int legacy_player_capture_video(player_h player, player_video_captured_cb callba
                if (ret == MM_ERROR_PLAYER_NO_OP) {
                        handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
                        handle->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
-                       LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION (0x%08x) : video display must be set : %d", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION, handle->display_type);
+                       LOGE("PLAYER_ERROR_INVALID_OPERATION : video display must be set : %d", handle->display_type);
                        return PLAYER_ERROR_INVALID_OPERATION;
                }
                if (ret != MM_ERROR_NONE) {
@@ -1798,9 +1819,11 @@ int legacy_player_capture_video(player_h player, player_video_captured_cb callba
                return PLAYER_ERROR_NONE;
        }
 
-       LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+       LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
        handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
        handle->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
+
+       LPLAYER_FLEAVE();
        return PLAYER_ERROR_INVALID_STATE;
 }
 
@@ -1951,7 +1974,7 @@ static bool __video_stream_changed_callback(void *user_data)
        int ret = MM_ERROR_NONE;
        muse_player_event_e event_type = MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED;
 
-       LOGE("[%s] event type %d", __FUNCTION__, event_type);
+       LOGE("event type %d", event_type);
 
        if (handle->user_cb[event_type]) {
                int width = 0, height = 0, fps = 0, bit_rate = 0;
@@ -1962,14 +1985,14 @@ static bool __video_stream_changed_callback(void *user_data)
                                                                                  "content_video_bitrate", &bit_rate, (char *)NULL);
 
                if (ret != MM_ERROR_NONE) {
-                       LOGE("[%s] get attr is failed", __FUNCTION__);
+                       LOGE("get attr is failed");
                        return false;
                }
                ((player_video_stream_changed_cb)handle->user_cb[event_type])(width, height, fps, bit_rate, handle->user_data[event_type]);
                return true;
        }
 
-       LOGE("[%s] video stream changed cb was not set.", __FUNCTION__);
+       LOGE("video stream changed cb was not set.");
        return false;
 }
 
@@ -2009,12 +2032,12 @@ static bool __media_stream_buffer_status_callback(player_stream_type_e type, pla
        else
                return false;
 
-       LOGE("[%s] event type %d", __FUNCTION__, event_type);
+       LOGE("event type %d", event_type);
 
        if (handle->user_cb[event_type]) {
                ((player_media_stream_buffer_status_cb)handle->user_cb[event_type])(status, handle->user_data[event_type]);
        } else {
-               LOGE("[%s][type:%d] buffer status cb was not set.", __FUNCTION__, type);
+               LOGE("[type:%d] buffer status cb was not set.", type);
                return false;
        }
 
@@ -2033,12 +2056,12 @@ static bool __media_stream_seek_data_callback(player_stream_type_e type, unsigne
        else
                return false;
 
-       LOGE("[%s] event type %d", __FUNCTION__, event_type);
+       LOGE("event type %d", event_type);
 
        if (handle->user_cb[event_type]) {
                ((player_media_stream_seek_cb)handle->user_cb[event_type])(offset, handle->user_data[event_type]);
        } else {
-               LOGE("[%s][type:%d] seek cb was not set.", __FUNCTION__, type);
+               LOGE("[type:%d] seek cb was not set.", type);
                return false;
        }
 
@@ -2055,7 +2078,7 @@ int legacy_player_set_media_stream_buffer_status_cb(player_h player, player_stre
 
        /* the type can be expaned with default and text. */
        if ((type != PLAYER_STREAM_TYPE_VIDEO) && (type != PLAYER_STREAM_TYPE_AUDIO)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_PARAMETER(type : %d)", __FUNCTION__, type);
+               LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", type);
                return PLAYER_ERROR_INVALID_PARAMETER;
        }
 
@@ -2094,7 +2117,7 @@ int legacy_player_set_media_stream_seek_cb(player_h player, player_stream_type_e
 
        /* the type can be expaned with default and text. */
        if ((type != PLAYER_STREAM_TYPE_VIDEO) && (type != PLAYER_STREAM_TYPE_AUDIO)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_PARAMETER(type : %d)", __FUNCTION__, type);
+               LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", type);
                return PLAYER_ERROR_INVALID_PARAMETER;
        }
 
@@ -2165,7 +2188,7 @@ int legacy_player_set_media_stream_buffer_max_size(player_h player, player_strea
        int ret = MM_ERROR_NONE;
        PLAYER_INSTANCE_CHECK(player);
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2198,7 +2221,7 @@ int legacy_player_set_media_stream_buffer_min_threshold(player_h player, player_
        int ret = MM_ERROR_NONE;
        PLAYER_INSTANCE_CHECK(player);
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2234,7 +2257,7 @@ int legacy_player_get_track_count(player_h player, player_stream_type_e type, in
        PLAYER_NULL_ARG_CHECK(count);
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2265,7 +2288,7 @@ int legacy_player_get_current_track(player_h player, player_stream_type_e type,
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(index);
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2293,10 +2316,12 @@ int legacy_player_select_track(player_h player, player_stream_type_e type, int i
        player_s *handle = (player_s *)player;
        int ret = MM_ERROR_NONE;
        MMPlayerTrackType track_type = 0;
+
+       LPLAYER_FENTER();
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_CHECK_CONDITION(index >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2316,6 +2341,7 @@ int legacy_player_select_track(player_h player, player_stream_type_e type, int i
        if (ret != MM_ERROR_NONE)
                return __player_convert_error_code(ret, (char *)__FUNCTION__);
 
+       LPLAYER_FLEAVE();
        return PLAYER_ERROR_NONE;
 }
 
@@ -2328,7 +2354,7 @@ int legacy_player_get_track_language_code(player_h player, player_stream_type_e
        PLAYER_NULL_ARG_CHECK(code);
        PLAYER_NULL_ARG_CHECK(len);
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2423,7 +2449,7 @@ int legacy_player_set_display(player_h player, player_display_type_e type, unsig
        MMDisplaySurfaceType mmType = __player_convert_display_type(type);
        PLAYER_INSTANCE_CHECK(player);
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2562,7 +2588,7 @@ int legacy_player_get_adaptive_variant_info(player_h player, int *num, char **va
        PLAYER_NULL_ARG_CHECK(var_info);
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2609,7 +2635,7 @@ int legacy_player_set_audio_only(player_h player, bool audio_only)
        PLAYER_INSTANCE_CHECK(player);
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2659,7 +2685,7 @@ int legacy_player_get_streaming_buffering_time(player_h player, int *buffer_ms,
        PLAYER_NULL_ARG_CHECK(rebuffer_ms);
 
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2678,7 +2704,7 @@ int legacy_player_360_is_content_spherical(player_h player, bool *is_spherical)
        PLAYER_NULL_ARG_CHECK(is_spherical);
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2696,7 +2722,7 @@ int legacy_player_360_set_enabled(player_h player, bool enabled)
        PLAYER_INSTANCE_CHECK(player);
 
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2714,7 +2740,7 @@ int legacy_player_360_is_enabled(player_h player, bool *enabled)
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(enabled);
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2732,7 +2758,7 @@ int legacy_player_360_set_direction_of_view(player_h player, float yaw, float pi
        PLAYER_INSTANCE_CHECK(player);
 
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2752,7 +2778,7 @@ int legacy_player_360_get_direction_of_view(player_h player, float *yaw, float *
        PLAYER_NULL_ARG_CHECK(pitch);
 
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2770,7 +2796,7 @@ int legacy_player_360_set_zoom(player_h player, float level)
        PLAYER_INSTANCE_CHECK(player);
 
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2788,7 +2814,7 @@ int legacy_player_360_get_zoom(player_h player, float *level)
        PLAYER_INSTANCE_CHECK(player);
 
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2806,7 +2832,7 @@ int legacy_player_360_set_field_of_view(player_h player, int horizontal_degrees,
        PLAYER_INSTANCE_CHECK(player);
 
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2826,7 +2852,7 @@ int legacy_player_360_get_field_of_view(player_h player, int *horizontal_degrees
        PLAYER_NULL_ARG_CHECK(vertical_degrees);
 
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2844,7 +2870,7 @@ int legacy_player_set_replaygain_enabled(player_h player, bool enabled)
        PLAYER_INSTANCE_CHECK(player);
 
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -2864,7 +2890,7 @@ int legacy_player_is_replaygain_enabled(player_h player, bool *enabled)
        PLAYER_NULL_ARG_CHECK(enabled);
 
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 

diff --git a/legacy/src/legacy_player_internal.c b/legacy/src/legacy_player_internal.c
index 26c3e9e..5e9851a 100644 (file)
--- a/legacy/src/legacy_player_internal.c
+++ b/legacy/src/legacy_player_internal.c
@@ -37,7 +37,7 @@ do { \
        PLAYER_NULL_ARG_CHECK(callback); \
        handle->user_cb[event_type] = callback; \
        handle->user_data[event_type] = user_data; \
-       LOGI("[%s] Event type : %d ", __FUNCTION__, event_type); \
+       LOGI("Event type : %d ", event_type); \
 } while (0)
 
 bool __audio_stream_callback(MMPlayerAudioStreamDataType *stream, void *user_data)
@@ -45,7 +45,7 @@ bool __audio_stream_callback(MMPlayerAudioStreamDataType *stream, void *user_dat
        player_s *handle = (player_s *)user_data;
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return true;
        }
 
@@ -105,11 +105,11 @@ int legacy_player_set_streaming_playback_rate(player_h player, float rate)
 {
        player_s *handle = (player_s *)player;
        int ret = MM_ERROR_NONE;
-       LOGI("[%s] rate : %0.1f", __FUNCTION__, rate);
+       LOGI("rate : %0.1f", rate);
        PLAYER_INSTANCE_CHECK(player);
 
        if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -121,7 +121,7 @@ int legacy_player_set_streaming_playback_rate(player_h player, float rate)
                break;
        case MM_ERROR_NOT_SUPPORT_API:
        case MM_ERROR_PLAYER_SEEK:
-               LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x) : seek error", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION);
+               LOGE("PLAYER_ERROR_INVALID_OPERATION : seek error");
                ret = PLAYER_ERROR_INVALID_OPERATION;
                break;
        default:
@@ -147,14 +147,14 @@ static bool __media_stream_buffer_status_callback_ex(player_stream_type_e type,
        else
                return false;
 
-       LOGE("[%s] event type %d, status %d, bytes %llu", __FUNCTION__, event_type, status, bytes);
+       LOGE("event type %d, status %d, bytes %llu", event_type, status, bytes);
 
        LEGACY_PLAYER_USER_CB_LOCK(handle, event_type);
 
        if (handle->user_cb[event_type]) {
                ((player_media_stream_buffer_status_cb_ex)handle->user_cb[event_type])(status, bytes, handle->user_data[event_type]);
        } else {
-               LOGE("[%s][type:%d] buffer status cb was not set.", __FUNCTION__, type);
+               LOGE("[type:%d] buffer status cb was not set.", type);
                LEGACY_PLAYER_USER_CB_UNLOCK(handle, event_type);
                return false;
        }
@@ -174,12 +174,12 @@ int legacy_player_set_media_stream_buffer_status_cb_ex(player_h player, player_s
        PLAYER_NULL_ARG_CHECK(callback);
 
        if (handle->state != PLAYER_STATE_IDLE) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
        /* the type can be expaned with default and text. */
        if ((type != PLAYER_STREAM_TYPE_VIDEO) && (type != PLAYER_STREAM_TYPE_AUDIO)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_PARAMETER(type : %d)", __FUNCTION__, type);
+               LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", type);
                return PLAYER_ERROR_INVALID_PARAMETER;
        }
 
@@ -202,7 +202,7 @@ int legacy_player_set_media_stream_buffer_status_cb_ex(player_h player, player_s
 
        LEGACY_PLAYER_USER_CB_UNLOCK(handle, event_type);
 
-       LOGI("[%s] Event type : %d ", __FUNCTION__, type);
+       LOGI("Event type : %d ", type);
        return PLAYER_ERROR_NONE;
 }
 
@@ -226,7 +226,7 @@ int legacy_player_unset_media_stream_buffer_status_cb_ex(player_h player, player
 
        LEGACY_PLAYER_USER_CB_UNLOCK(handle, event_type);
 
-       LOGI("[%s] Event type : %d ", __FUNCTION__, type);
+       LOGI("Event type : %d ", type);
 
        return PLAYER_ERROR_NONE;
 }
@@ -251,7 +251,7 @@ int legacy_player_set_next_uri(player_h player, const char *uri)
        int ret = MM_ERROR_NONE;
        PLAYER_INSTANCE_CHECK(player);
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
@@ -269,7 +269,7 @@ int legacy_player_get_next_uri(player_h player, char **uri)
        PLAYER_INSTANCE_CHECK(player);
 
        if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
-               LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
+               LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }