[0.3.67] Update player by the splited muse library

Change-Id: Ica5af8cdfaad3b26e43e11c094fd6390519172ba

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 26194a44e4c11ed2c4cf3dd41bc1976165e57945..31febd1c4b17f12cef95e0ca7e84d76c008f722c 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,9 +11,9 @@ SET(INC_DIR include)
 
 INCLUDE_DIRECTORIES(${INC_DIR})
 IF (TIZEN_FEATURE_EVAS_RENDERER)
-SET(dependents "dlog glib-2.0 libtbm capi-media-tool capi-media-sound-manager capi-base-common mused mm-common tizen-extension-client evas ecore elementary mm-evas-renderer storage capi-system-info")
+SET(dependents "dlog glib-2.0 libtbm capi-media-tool capi-media-sound-manager capi-base-common muse-client mm-common tizen-extension-client evas ecore elementary mm-evas-renderer storage capi-system-info")
 ELSE (TIZEN_FEATURE_EVAS_RENDERER)
-SET(dependents "dlog glib-2.0 libtbm capi-media-tool capi-media-sound-manager capi-base-common mused mm-common tizen-extension-client evas ecore elementary storage capi-system-info")
+SET(dependents "dlog glib-2.0 libtbm capi-media-tool capi-media-sound-manager capi-base-common muse-client mm-common tizen-extension-client evas ecore elementary storage capi-system-info")
 ENDIF (TIZEN_FEATURE_EVAS_RENDERER)
 SET(pc_dependents "libtbm capi-media-tool capi-base-common capi-media-sound-manager ecore-wayland")
 

diff --git a/include/player_msg.h b/include/player_msg.h
index ad2396b461a389c6131f18a568a49bd2bf7fedb5..929afc362ea44534f2fbd62c19611adf940cf88a 100644 (file)
--- a/include/player_msg.h
+++ b/include/player_msg.h
@@ -33,11 +33,11 @@ extern "C" {
        do {\
                char *__sndMsg__; \
                int __len__; \
-               __sndMsg__ = muse_core_msg_json_factory_new(0, \
+               __sndMsg__ = muse_core_msg_new(0, \
                                MUSE_TYPE_POINTER, #module, module, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(fd, __sndMsg__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               __len__ = muse_core_msg_send(fd, __sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        return PLAYER_ERROR_INVALID_OPERATION; \
@@ -60,15 +60,15 @@ extern "C" {
                int __timeout__ = client_get_api_timeout(player, api); \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -90,16 +90,16 @@ extern "C" {
                type __value__ = (type)param; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_##type, #param, __value__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -122,17 +122,17 @@ extern "C" {
                type2 __value2__ = (type2)param2; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -156,18 +156,18 @@ extern "C" {
                type3 __value3__ = (type3)param3; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
                                MUSE_TYPE_##type3, #param3, __value3__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -192,19 +192,19 @@ extern "C" {
                type4 __value4__ = (type4)param4; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
                                MUSE_TYPE_##type3, #param3, __value3__, \
                                MUSE_TYPE_##type4, #param4, __value4__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -230,20 +230,20 @@ extern "C" {
                type5 __value5__ = (type5)param5; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                        MUSE_TYPE_##type1, #param1, __value1__, \
                        MUSE_TYPE_##type2, #param2, __value2__, \
                        MUSE_TYPE_##type3, #param3, __value3__, \
                        MUSE_TYPE_##type4, #param4, __value4__, \
                        MUSE_TYPE_##type5, #param5, __value5__, \
                        0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -270,7 +270,7 @@ extern "C" {
                type6 __value6__ = (type6)param6; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
                                MUSE_TYPE_##type3, #param3, __value3__, \
@@ -278,13 +278,13 @@ extern "C" {
                                MUSE_TYPE_##type5, #param5, __value5__, \
                                MUSE_TYPE_##type6, #param6, __value6__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -312,7 +312,7 @@ extern "C" {
                type7 __value7__ = (type7)param7; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
                                MUSE_TYPE_##type3, #param3, __value3__, \
@@ -321,13 +321,13 @@ extern "C" {
                                MUSE_TYPE_##type6, #param6, __value6__, \
                                MUSE_TYPE_##type7, #param7, __value7__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -350,20 +350,20 @@ extern "C" {
                int *__value__ = (int *)param; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_INT, #length, length, \
                                MUSE_TYPE_ARRAY, #param, \
                                        datum_size == sizeof(int) ? length :  \
                                        length / sizeof(int) + (length % sizeof(int) ? 1 : 0), \
                                        __value__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -387,7 +387,7 @@ extern "C" {
                int *__value2__ = (int *)param2; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_INT, #length1, length1, \
                                MUSE_TYPE_ARRAY, #param1, \
                                        datum_size1 == sizeof(int) ? length1 :  \
@@ -399,13 +399,13 @@ extern "C" {
                                        length2 / sizeof(int) + (length2 % sizeof(int) ? 1 : 0), \
                                        __value2__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -430,7 +430,7 @@ extern "C" {
                int *__value3__ = (int *)param3; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                        MUSE_TYPE_##type1, #param1, __value1__, \
                        MUSE_TYPE_INT, #length2, length2, \
                        MUSE_TYPE_ARRAY, #param2, \
@@ -443,13 +443,13 @@ extern "C" {
                                length3 / sizeof(int) + (length3 % sizeof(int) ? 1 : 0), \
                                __value3__, \
                        0); \
-           __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+           __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -475,7 +475,7 @@ extern "C" {
                int *__value_arr__ = (int *)param_arr; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
                                MUSE_TYPE_INT, #length, length, \
@@ -484,13 +484,13 @@ extern "C" {
                                        length / sizeof(int) + (length % sizeof(int) ? 1 : 0), \
                                        __value_arr__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -518,7 +518,7 @@ extern "C" {
                int *__value5__ = (int *)param5; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
                                MUSE_TYPE_##type3, #param3, __value3__, \
@@ -533,13 +533,13 @@ extern "C" {
                                        length5 / sizeof(int) + (length5 % sizeof(int) ? 1 : 0), \
                                        __value5__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -558,11 +558,11 @@ extern "C" {
                type __value__ = (type)param; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_##type, #param, __value__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        return PLAYER_ERROR_INVALID_OPERATION; \
@@ -582,11 +582,11 @@ extern "C" {
                char *__sndMsg__; \
                int __len__; \
                type __value__ = (type)param; \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_##type, #param, __value__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(fd, __sndMsg__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               __len__ = muse_core_msg_send(fd, __sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                } \
@@ -615,16 +615,16 @@ extern "C" {
                __tfd__[0] = tfd; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                0); \
-               __len__ = muse_core_ipc_send_fd_msg(__fd__, __tfd__, __sndMsg__); \
+               __len__ = muse_core_msg_send_fd(__fd__, __tfd__, __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
                } else \
                        ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -651,20 +651,20 @@ do {      \
        __tfd__[0] = tfd; \
        if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
        else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-       __sndMsg__ = muse_core_msg_json_factory_new(api, \
+       __sndMsg__ = muse_core_msg_new(api, \
                        MUSE_TYPE_INT, #length, length, \
                        MUSE_TYPE_ARRAY, #param, \
                                datum_size == sizeof(int) ? length :  \
                                length / sizeof(int) + (length % sizeof(int) ? 1 : 0), \
                                __value__, \
                        0); \
-       __len__ = muse_core_ipc_send_fd_msg(__fd__, __tfd__, __sndMsg__); \
+       __len__ = muse_core_msg_send_fd(__fd__, __tfd__, __sndMsg__); \
        if (__len__ <= 0) { \
                LOGE("sending message failed"); \
                ret = PLAYER_ERROR_INVALID_OPERATION; \
        } else \
                ret = client_wait_for_cb_return(api, CALLBACK_INFO(player), &retbuf, __timeout__); \
-       muse_core_msg_json_factory_free(__sndMsg__); \
+       muse_core_msg_free(__sndMsg__); \
 } while (0)
 
 /**
@@ -683,12 +683,12 @@ do {      \
                int __len__; \
                type1 __value1__ = (type1)param1; \
                type2 __value2__ = (type2)param2; \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(fd, __sndMsg__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               __len__ = muse_core_msg_send(fd, __sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        return PLAYER_ERROR_INVALID_OPERATION; \
@@ -713,12 +713,12 @@ do {      \
                int __value2__ = (int)set; \
                if (CALLBACK_INFO(player)) __fd__ = MSG_FD(player); \
                else {ret = PLAYER_ERROR_INVALID_STATE; break; } \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                                MUSE_TYPE_INT, #event_type, __value1__, \
                                MUSE_TYPE_INT, #set, __value2__, \
                                0); \
-               __len__ = muse_core_ipc_send_msg(__fd__, __sndMsg__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               __len__ = muse_core_msg_send(__fd__, __sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = PLAYER_ERROR_INVALID_OPERATION; \
@@ -737,20 +737,20 @@ do {      \
  */
 #define player_msg_get2_array(buf, param1, type1, param2, type2, arr_param, ret) \
        do { \
-               void *__jobj__ = muse_core_msg_json_object_new(buf, NULL, NULL); \
-               if (!muse_core_msg_json_object_get_value(#param1, __jobj__, &param1, MUSE_TYPE_##type1)) { \
+               void *__jobj__ = muse_core_msg_object_new(buf, NULL, NULL); \
+               if (!muse_core_msg_object_get_value(#param1, __jobj__, MUSE_TYPE_##type1, &param1)) { \
                        LOGE("failed to get value(%s)", #param1); \
                        ret = FALSE; \
                } \
-               if (ret && !muse_core_msg_json_object_get_value(#param2, __jobj__, &param2, MUSE_TYPE_##type2)) { \
+               if (ret && !muse_core_msg_object_get_value(#param2, __jobj__, MUSE_TYPE_##type2, &param2)) { \
                        LOGE("failed to get %s value", #param2); \
                        ret = FALSE; \
                } \
-               if (ret && !muse_core_msg_json_object_get_value(#arr_param, __jobj__, arr_param, MUSE_TYPE_ANY)) { \
+               if (ret && !muse_core_msg_object_get_value(#arr_param, __jobj__, MUSE_TYPE_ANY, arr_param)) { \
                        LOGE("failed to get %s value", #arr_param); \
                        ret = FALSE; \
                } \
-               muse_core_msg_json_object_free(__jobj__); \
+               muse_core_msg_object_free(__jobj__); \
        } while (0)
 
 /**
@@ -763,20 +763,20 @@ do {      \
 #define player_msg_get_string2(buf, str_param1, str_param2, ret) \
        do { \
                muse_core_msg_parse_err_e __err__ = MUSE_MSG_PARSE_ERROR_NONE; \
-               void *__jobj__ = muse_core_msg_json_object_new(buf, NULL, &__err__); \
+               void *__jobj__ = muse_core_msg_object_new(buf, NULL, &__err__); \
                if (!__jobj__) { \
                        LOGE("failed to get msg object. err:%d", __err__); \
                        ret = FALSE; \
                } else { \
-                       if (!muse_core_msg_json_object_get_value(#str_param1, __jobj__, str_param1, MUSE_TYPE_STRING)) { \
+                       if (!muse_core_msg_object_get_value(#str_param1, __jobj__, MUSE_TYPE_STRING, str_param1)) { \
                                LOGE("failed to get %s value", #str_param1); \
                                ret = FALSE; \
                        } \
-                       if (ret && !muse_core_msg_json_object_get_value(#str_param2, __jobj__, str_param2, MUSE_TYPE_STRING)) { \
+                       if (ret && !muse_core_msg_object_get_value(#str_param2, __jobj__, MUSE_TYPE_STRING, str_param2)) { \
                                LOGE("failed to get %s value", #str_param2); \
                                ret = FALSE; \
                        } \
-                       muse_core_msg_json_object_free(__jobj__); \
+                       muse_core_msg_object_free(__jobj__); \
                } \
        } while (0)
 

diff --git a/packaging/capi-media-player.spec b/packaging/capi-media-player.spec
index 77e1e6d9422c2e0443581d9f5574384855754505..543376630e6b96e95e161a2fd0f54c80ebd67a1a 100644 (file)
--- a/packaging/capi-media-player.spec
+++ b/packaging/capi-media-player.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-player
 Summary:    A Media Player API
-Version:    0.3.66
+Version:    0.3.67
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0
@@ -9,7 +9,7 @@ Source1001:     capi-media-player.manifest
 BuildRequires:  cmake
 BuildRequires:  pkgconfig(dlog)
 BuildRequires:  pkgconfig(glib-2.0)
-BuildRequires:  pkgconfig(mused)
+BuildRequires:  pkgconfig(muse-client)
 BuildRequires:  pkgconfig(mm-common)
 BuildRequires:  pkgconfig(capi-base-common)
 BuildRequires:  pkgconfig(capi-media-sound-manager)
@@ -21,7 +21,6 @@ BuildRequires:  pkgconfig(evas)
 BuildRequires:  pkgconfig(ecore-wayland)
 BuildRequires:  pkgconfig(capi-media-tool)
 BuildRequires:  pkgconfig(mmsvc-player)
-BuildRequires:  pkgconfig(json-c)
 BuildRequires:  pkgconfig(libtbm)
 BuildRequires:  pkgconfig(eom)
 BuildRequires:  pkgconfig(storage)

diff --git a/src/player.c b/src/player.c
index f0c0a1399711d6913833428087ad6e561dc5a8aa..d77d6a3144aa8459bba1993df6ad7233003c084a 100644 (file)
--- a/src/player.c
+++ b/src/player.c
@@ -29,9 +29,7 @@
 #include <dlog.h>
 #include <mm_error.h>
 #include <muse_core.h>
-#include <muse_core_msg_json.h>
-#include <muse_core_module.h>
-#include <muse_core_ipc.h>
+#include <muse_client.h>
 #include <muse_player.h>
 #include <muse_player_msg.h>
 #include <sound_manager.h>
@@ -186,16 +184,16 @@ int _player_media_packet_finalize(media_packet_h pkt, int error_code, void *user
                }
        }
 
-       if (muse_core_ipc_fd_is_valid(fin_data->fd)) {
-               if (muse_core_client_check_fd_id_value(fin_data->fd, fin_data->fd_id) == FALSE) {
+       if (muse_core_fd_is_valid(fin_data->fd)) {
+               if (muse_client_check_fd_id_value(fin_data->fd, fin_data->fd_id) == FALSE) {
                        LOGE("[fd:%d,id:%d] is invalid.", fin_data->fd, fin_data->fd_id);
                        goto EXIT;
                }
 
                packet = fin_data->remote_pkt;
-               snd_msg = muse_core_msg_json_factory_new(api, MUSE_TYPE_POINTER, "packet", packet, 0);
-               snd_len = muse_core_ipc_send_msg(fin_data->fd, snd_msg);
-               muse_core_msg_json_factory_free(snd_msg);
+               snd_msg = muse_core_msg_new(api, MUSE_TYPE_POINTER, "packet", packet, 0);
+               snd_len = muse_core_msg_send(fin_data->fd, snd_msg);
+               muse_core_msg_free(snd_msg);
 
                if (snd_len <= 0)
                        LOGE("[fd:%d] fail to send msg.", fin_data->fd);
@@ -279,7 +277,7 @@ static int player_recv_msg(callback_cb_info_s * cb_info, tbm_fd *tfd)
        msg_buff_s *buff = &cb_info->buff;
 
        memset(buff->recvMsg, 0x00, sizeof(char)*buff->bufLen);
-       recvLen = muse_core_ipc_recv_fd_msg(cb_info->fd, buff->recvMsg, tfd);
+       recvLen = muse_core_msg_recv_fd(cb_info->fd, buff->recvMsg, tfd);
        if (recvLen <= 0) {
                LOGE("failed to recv msg %d", recvLen);
                return 0;
@@ -587,7 +585,6 @@ static void __seek_cb_handler(callback_cb_info_s * cb_info, _player_recv_data *r
        g_mutex_lock(&cb_info->seek_cb_mutex);
        if (cb_info->user_cb[ev] && cb_info->seek_cb_state == PLAYER_SEEK_CB_STATE_NONE) {
 #ifdef TIZEN_FEATURE_EVAS_RENDERER
-
                if (cb_info->evas_info && cb_info->evas_info->support_video) {
                        if (cb_info->evas_info->handle && cb_info->evas_info->visible != EVAS_VISIBLE_FALSE) {
                                int ret = mm_evas_renderer_set_visible(cb_info->evas_info->handle, true);
@@ -685,23 +682,23 @@ static void __media_packet_video_frame_cb_handler(callback_cb_info_s * cb_info,
        int i = 0;
        muse_core_msg_parse_err_e err = MUSE_MSG_PARSE_ERROR_NONE;
 
-       void *jobj = muse_core_msg_json_object_new(recv_data->buffer, NULL, &err);
+       void *jobj = muse_core_msg_object_new(recv_data->buffer, NULL, &err);
        if (!jobj ||
-               !muse_core_msg_json_object_get_value("key[0]", jobj, &key[0], MUSE_TYPE_ANY) ||
-               !muse_core_msg_json_object_get_value("key[1]", jobj, &key[1], MUSE_TYPE_ANY) ||
-               !muse_core_msg_json_object_get_value("key[2]", jobj, &key[2], MUSE_TYPE_ANY) ||
-               !muse_core_msg_json_object_get_value("key[3]", jobj, &key[3], MUSE_TYPE_ANY) ||
-               !muse_core_msg_json_object_get_value("packet", jobj, &packet, MUSE_TYPE_POINTER) ||
-               !muse_core_msg_json_object_get_value("mimetype", jobj, &mimetype, MUSE_TYPE_ANY) ||
-               !muse_core_msg_json_object_get_value("pts", jobj, &pts, MUSE_TYPE_INT64) ||
-               !muse_core_msg_json_object_get_value("surface_info", jobj, surface_info, MUSE_TYPE_ARRAY)) {
+               !muse_core_msg_object_get_value("key[0]", jobj, MUSE_TYPE_ANY, &key[0]) ||
+               !muse_core_msg_object_get_value("key[1]", jobj, MUSE_TYPE_ANY, &key[1]) ||
+               !muse_core_msg_object_get_value("key[2]", jobj, MUSE_TYPE_ANY, &key[2]) ||
+               !muse_core_msg_object_get_value("key[3]", jobj, MUSE_TYPE_ANY, &key[3]) ||
+               !muse_core_msg_object_get_value("packet", jobj, MUSE_TYPE_POINTER, &packet) ||
+               !muse_core_msg_object_get_value("mimetype", jobj, MUSE_TYPE_ANY, &mimetype) ||
+               !muse_core_msg_object_get_value("pts", jobj, MUSE_TYPE_INT64, &pts) ||
+               !muse_core_msg_object_get_value("surface_info", jobj, MUSE_TYPE_ARRAY, surface_info)) {
 
                LOGE("failed to get value from msg. jobj:%p, err:%d", jobj, err);
                if (jobj)
-                       muse_core_msg_json_object_free(jobj);
+                       muse_core_msg_object_free(jobj);
                goto ERROR;
        }
-       muse_core_msg_json_object_free(jobj);
+       muse_core_msg_object_free(jobj);
 
        LOGD("width %d, height %d", sinfo.width, sinfo.height);
 
@@ -803,7 +800,7 @@ static void __media_packet_video_frame_cb_handler(callback_cb_info_s * cb_info,
        fin_data->use_tsurf_pool = cb_info->use_tsurf_pool;
 
        /* Keep the fd id to check validation when the pkt is destroyed. */
-       fin_data->fd_id = muse_core_client_get_fd_id_value(fin_data->fd);
+       fin_data->fd_id = muse_client_get_fd_id_value(fin_data->fd);
 
        ret = media_packet_create_from_tbm_surface(cb_info->pkt_fmt, tsurf, (media_packet_finalize_cb) _player_media_packet_finalize, (void *)fin_data, &pkt);
        if (ret != MEDIA_PACKET_ERROR_NONE || !pkt) {
@@ -1496,9 +1493,9 @@ static void *client_cb_handler(gpointer data)
 //                     LOGD(">>>>>> [%d/%d] %p, %s", offset, len, recvMsg + offset, recvMsg + offset);
 //                     usleep(10*1000);
 
-                       void *jobj = muse_core_msg_json_object_new(recvMsg + offset, &parse_len, &err);
+                       void *jobj = muse_core_msg_object_new(recvMsg + offset, &parse_len, &err);
                        if (jobj) {
-                               if (muse_core_msg_json_object_get_value("api", jobj, &api, MUSE_TYPE_INT)) {
+                               if (muse_core_msg_object_get_value("api", jobj, MUSE_TYPE_INT, &api)) {
                                        if (api < MUSE_PLAYER_API_MAX) {
                                                g_mutex_lock(&cb_info->player_mutex);
                                                cb_info->buff.recved++;
@@ -1522,11 +1519,11 @@ static void *client_cb_handler(gpointer data)
                                                } else {
                                                        LOGE("failed to alloc recv_data.");
                                                        g_mutex_unlock(&cb_info->player_mutex);
-                                                       muse_core_msg_json_object_free(jobj);
+                                                       muse_core_msg_object_free(jobj);
                                                        break;
                                                }
                                                g_mutex_unlock(&cb_info->player_mutex);
-                                               if (!muse_core_msg_json_object_get_value("event", jobj, &event, MUSE_TYPE_INT) ||
+                                               if (!muse_core_msg_object_get_value("event", jobj, MUSE_TYPE_INT, &event) ||
                                                        !_user_callback_handler(cb_info, event, recv_data)) {
                                                        LOGE("failed to get value or add event to the queue.");
                                                        if (recv_data) {
@@ -1543,7 +1540,7 @@ static void *client_cb_handler(gpointer data)
                                } else {
                                        LOGE("Failed to get value. offset:%d/%d, [msg][ %s ]", offset, len, (recvMsg+offset));
                                }
-                               muse_core_msg_json_object_free(jobj);
+                               muse_core_msg_object_free(jobj);
                        } else {
                                LOGE("Failed to get msg obj. err:%d", err);
                        }
@@ -1741,7 +1738,7 @@ int player_create(player_h * player)
                return PLAYER_ERROR_OUT_OF_MEMORY;
 
        while (--retry_count) {
-               sock_fd = muse_core_client_new();
+               sock_fd = muse_client_new();
                if (sock_fd <= INVALID_DEFAULT_VALUE) {
                        LOGE("connection failure %d", errno);
                        ret = PLAYER_ERROR_INVALID_OPERATION;
@@ -1777,9 +1774,9 @@ int player_create(player_h * player)
                        intptr_t module_addr = 0;
                        *player = (player_h) pc;
                        if (player_msg_get_type(module_addr, ret_buf, POINTER)) {
-                               pc->cb_info->data_fd = muse_core_client_new_data_ch();
+                               pc->cb_info->data_fd = muse_client_new_data_ch();
                                muse_core_send_module_addr(module_addr, pc->cb_info->data_fd);
-                               LOGD("Data channel fd %d, muse module addr %p", pc->cb_info->data_fd, (void*)module_addr);
+                               LOGD("Data channel fd %d, muse module addr %p", pc->cb_info->data_fd, module_addr);
                        } else {
                                ret = PLAYER_ERROR_INVALID_OPERATION;
                                goto ERROR;
@@ -3162,16 +3159,16 @@ int player_get_album_art(player_h player, void **palbum_art, int *psize)
        player_msg_send(api, pc, ret_buf, ret);
        if (ret == PLAYER_ERROR_NONE) {
                muse_core_msg_parse_err_e err = MUSE_MSG_PARSE_ERROR_NONE;
-               jobj = muse_core_msg_json_object_new(ret_buf, NULL, &err);
+               jobj = muse_core_msg_object_new(ret_buf, NULL, &err);
                if (!jobj) {
                        LOGE("failed to get msg obj, err:%d", err);
                        ret = PLAYER_ERROR_INVALID_OPERATION;
                        goto EXIT;
                }
 
-               if (muse_core_msg_json_object_get_value("size", jobj, &size, MUSE_TYPE_INT) && (size > 0)) {
+               if (muse_core_msg_object_get_value("size", jobj, MUSE_TYPE_INT, &size) && (size > 0)) {
                        LOGD("size : %d", size);
-                       if (!muse_core_msg_json_object_get_value("key", jobj, &key, MUSE_TYPE_INT)) {
+                       if (!muse_core_msg_object_get_value("key", jobj, MUSE_TYPE_INT, &key)) {
                                LOGE("failed to get key value");
                                ret = PLAYER_ERROR_INVALID_OPERATION;
                                goto EXIT;
@@ -3214,7 +3211,7 @@ int player_get_album_art(player_h player, void **palbum_art, int *psize)
 
 EXIT:
        if (jobj)
-               muse_core_msg_json_object_free(jobj);
+               muse_core_msg_object_free(jobj);
 
        if (ret_buf)
                g_free(ret_buf);
@@ -4015,7 +4012,7 @@ int player_push_media_stream(player_h player, media_packet_h packet)
 #endif
        if (push_media.buf_type == PUSH_MEDIA_BUF_TYPE_RAW) {
                buf_size = (int)push_media.size;
-               muse_core_ipc_push_data(pc->cb_info->data_fd, buf, buf_size, push_media.pts);
+               muse_client_ipc_push_data(pc->cb_info->data_fd, buf, buf_size, push_media.pts);
                player_msg_send_array(api, pc, ret_buf, ret, push_media_msg, msg_size, sizeof(char));
        }
 

diff --git a/src/player_display.c b/src/player_display.c
index abc6084f3c7c5a4189f1c094dd65343ed42a9a74..a9a67de6499d96a17266d02ec3f67bdacc773d60 100644 (file)
--- a/src/player_display.c
+++ b/src/player_display.c
@@ -20,7 +20,6 @@
 #include <mm_error.h>
 #include <wayland-client.h>
 #include <tizen-extension-client-protocol.h>
-#include <muse_player_msg.h>
 #include <Evas.h>
 #include <Ecore_Evas.h>
 #include "player_msg.h"

diff --git a/src/player_internal.c b/src/player_internal.c
index 6c38a9d93db944e1706b829ffbb76387c4626165..edc70075e3642565b43dc74e5c0526b77cdc8ecb 100644 (file)
--- a/src/player_internal.c
+++ b/src/player_internal.c
@@ -17,9 +17,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <muse_core.h>
-#include <muse_core_msg_json.h>
-#include <muse_core_ipc.h>
 #include <mm_error.h>
 #include <dlog.h>
 #include <Evas.h>