From: sejong123.park Date: Thu, 1 Oct 2015 07:13:21 +0000 (+0900) Subject: Remove Handle arg, Change Client to Module, Muse naming X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fheads%2Ftizen_dev;p=platform%2Fcore%2Fapi%2Frecorder.git Remove Handle arg, Change Client to Module, Muse naming Change-Id:Ie1c7edc107176a13cd1a770fb86a675b6200193f Signed-off-by: sejong123.park --- diff --git a/CMakeLists.txt b/CMakeLists.txt old mode 100755 new mode 100644 index 0fe2382..5ef5384 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -72,7 +72,7 @@ SET_TARGET_PROPERTIES(${fw_name} CLEAN_DIRECT_OUTPUT 1 ) -TARGET_LINK_LIBRARIES(${fw_name} mused-recorder ${${fw_name}_LDFLAGS}) +TARGET_LINK_LIBRARIES(${fw_name} muse-recorder ${${fw_name}_LDFLAGS}) INSTALL(TARGETS ${fw_name} DESTINATION ${LIB_INSTALL_DIR}) INSTALL( diff --git a/capi-media-recorder.pc.in b/capi-media-recorder.pc.in old mode 100755 new mode 100644 diff --git a/include/recorder_private.h b/include/recorder_private.h index dc01d23..19d3404 100644 --- a/include/recorder_private.h +++ b/include/recorder_private.h @@ -21,7 +21,7 @@ #include #include #include -#include +#include #ifdef __cplusplus extern "C" { @@ -45,12 +45,12 @@ typedef struct _callback_cb_info { GThread *thread; gint running; gint fd; - gpointer user_cb[MMSVC_RECORDER_EVENT_TYPE_NUM]; - gpointer user_cb_completed[MMSVC_RECORDER_EVENT_TYPE_NUM]; - gpointer user_data[MMSVC_RECORDER_EVENT_TYPE_NUM]; - gchar recvMsg[MM_MSG_MAX_LENGTH]; - gchar recvApiMsg[MM_MSG_MAX_LENGTH]; - gchar recvEventMsg[MM_MSG_MAX_LENGTH]; + gpointer user_cb[MUSE_RECORDER_EVENT_TYPE_NUM]; + gpointer user_cb_completed[MUSE_RECORDER_EVENT_TYPE_NUM]; + gpointer user_data[MUSE_RECORDER_EVENT_TYPE_NUM]; + gchar recvMsg[MUSE_RECORDER_MSG_MAX_LENGTH]; + gchar recvApiMsg[MUSE_RECORDER_MSG_MAX_LENGTH]; + gchar recvEventMsg[MUSE_RECORDER_MSG_MAX_LENGTH]; GCond *pCond; GMutex *pMutex; gint *activating; diff --git a/src/recorder.c b/src/recorder.c index 4d69455..180d126 100644 --- a/src/recorder.c +++ b/src/recorder.c @@ -19,94 +19,94 @@ #include #include #include -#include -#include -#include +#include +#include +#include #include #include -#include -#include +#include +#include #include #ifdef LOG_TAG #undef LOG_TAG #endif -#define LOG_TAG "TIZEN_N_RECORDER2" +#define LOG_TAG "TIZEN_N_RECORDER" -static void _client_user_callback(callback_cb_info_s * cb_info, mmsvc_recorder_event_e event ) +static void _client_user_callback(callback_cb_info_s * cb_info, muse_recorder_event_e event ) { char *recvMsg = cb_info->recvMsg; LOGD("get event %d", event); switch (event) { - case MMSVC_RECORDER_EVENT_TYPE_STATE_CHANGE: + case MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE: { int cb_previous, cb_current, cb_by_policy; - mmsvc_recorder_msg_get(cb_previous, recvMsg); - mmsvc_recorder_msg_get(cb_current, recvMsg); - mmsvc_recorder_msg_get(cb_by_policy, recvMsg); + muse_recorder_msg_get(cb_previous, recvMsg); + muse_recorder_msg_get(cb_current, recvMsg); + muse_recorder_msg_get(cb_by_policy, recvMsg); ((recorder_state_changed_cb)cb_info->user_cb[event])((recorder_state_e)cb_previous, (recorder_state_e)cb_current, (bool)cb_by_policy, cb_info->user_data[event]); break; } - case MMSVC_RECORDER_EVENT_TYPE_RECORDING_LIMITED: + case MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED: { int cb_type; - mmsvc_recorder_msg_get(cb_type, recvMsg); + muse_recorder_msg_get(cb_type, recvMsg); ((recorder_recording_limit_reached_cb)cb_info->user_cb[event])((recorder_recording_limit_type_e)cb_type, cb_info->user_data[event]); break; } - case MMSVC_RECORDER_EVENT_TYPE_RECORDING_STATUS: + case MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS: { double cb_elapsed_time; double cb_file_size; - mmsvc_recorder_msg_get(cb_elapsed_time, recvMsg); - mmsvc_recorder_msg_get(cb_file_size, recvMsg); + muse_recorder_msg_get(cb_elapsed_time, recvMsg); + muse_recorder_msg_get(cb_file_size, recvMsg); ((recorder_recording_status_cb)cb_info->user_cb[event])((unsigned long long)cb_elapsed_time, (unsigned long long)cb_file_size, cb_info->user_data[event]); break; } - case MMSVC_RECORDER_EVENT_TYPE_INTERRUPTED: + case MUSE_RECORDER_EVENT_TYPE_INTERRUPTED: { int cb_policy, cb_previous, cb_current; - mmsvc_recorder_msg_get(cb_policy, recvMsg); - mmsvc_recorder_msg_get(cb_previous, recvMsg); - mmsvc_recorder_msg_get(cb_current, recvMsg); + muse_recorder_msg_get(cb_policy, recvMsg); + muse_recorder_msg_get(cb_previous, recvMsg); + muse_recorder_msg_get(cb_current, recvMsg); ((recorder_interrupted_cb)cb_info->user_cb[event])((recorder_policy_e)cb_policy, (recorder_state_e)cb_previous, (recorder_state_e)cb_current, cb_info->user_data[event]); break; } - case MMSVC_RECORDER_EVENT_TYPE_AUDIO_STREAM: + case MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM: { - mmsvc_recorder_transport_info_s transport_info; + muse_recorder_transport_info_s transport_info; int tKey = 0; int cb_size = 0; int cb_format; int cb_channel; int cb_timestamp; unsigned char *stream = NULL; - mmsvc_recorder_msg_get(tKey, recvMsg); + muse_recorder_msg_get(tKey, recvMsg); if (tKey != 0) { transport_info.tbm_key = tKey; LOGE("Read key_info INFO : %d", transport_info.tbm_key); - if(mmsvc_recorder_ipc_init_tbm(&transport_info) == FALSE) { + if(muse_recorder_ipc_init_tbm(&transport_info) == FALSE) { LOGE("Initialize TBM ERROR!!"); break; } - if(mmsvc_recorder_ipc_import_tbm(&transport_info) == FALSE) { + if(muse_recorder_ipc_import_tbm(&transport_info) == FALSE) { LOGE("Import TBM Key ERROR!!"); break; } else { - mmsvc_recorder_msg_get(cb_size, recvMsg); + muse_recorder_msg_get(cb_size, recvMsg); if (cb_size > 0) { stream = (unsigned char *)transport_info.bo_handle.ptr; } @@ -115,9 +115,9 @@ static void _client_user_callback(callback_cb_info_s * cb_info, mmsvc_recorder_e LOGE("Get KEY INFO sock msg ERROR!!"); break; } - mmsvc_recorder_msg_get(cb_format, recvMsg); - mmsvc_recorder_msg_get(cb_channel, recvMsg); - mmsvc_recorder_msg_get(cb_timestamp, recvMsg); + muse_recorder_msg_get(cb_format, recvMsg); + muse_recorder_msg_get(cb_channel, recvMsg); + muse_recorder_msg_get(cb_timestamp, recvMsg); ((recorder_audio_stream_cb)cb_info->user_cb[event])((void *)stream, cb_size, (audio_sample_type_e)cb_format, @@ -125,49 +125,49 @@ static void _client_user_callback(callback_cb_info_s * cb_info, mmsvc_recorder_e (unsigned int)cb_timestamp, cb_info->user_data[event]); //unref tbm after hand over the buffer. - mmsvc_recorder_ipc_unref_tbm(&transport_info); + muse_recorder_ipc_unref_tbm(&transport_info); break; } - case MMSVC_RECORDER_EVENT_TYPE_ERROR: + case MUSE_RECORDER_EVENT_TYPE_ERROR: { int cb_error, cb_current_state; - mmsvc_recorder_msg_get(cb_error, recvMsg); - mmsvc_recorder_msg_get(cb_current_state, recvMsg); + muse_recorder_msg_get(cb_error, recvMsg); + muse_recorder_msg_get(cb_current_state, recvMsg); ((recorder_error_cb)cb_info->user_cb[event])((recorder_error_e)cb_error, (recorder_state_e)cb_current_state, cb_info->user_data[event]); break; } - case MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER: + case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER: { int cb_codec; - mmsvc_recorder_msg_get(cb_codec, recvMsg); + muse_recorder_msg_get(cb_codec, recvMsg); ((recorder_supported_audio_encoder_cb)cb_info->user_cb[event])((recorder_audio_codec_e)cb_codec, cb_info->user_data[event]); break; } - case MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT: + case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT: { int cb_format; - mmsvc_recorder_msg_get(cb_format, recvMsg); + muse_recorder_msg_get(cb_format, recvMsg); ((recorder_supported_file_format_cb)cb_info->user_cb[event])((recorder_file_format_e)cb_format, cb_info->user_data[event]); break; } - case MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER: + case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER: { int cb_codec; - mmsvc_recorder_msg_get(cb_codec, recvMsg); + muse_recorder_msg_get(cb_codec, recvMsg); ((recorder_supported_video_encoder_cb)cb_info->user_cb[event])((recorder_video_codec_e)cb_codec, cb_info->user_data[event]); break; } - case MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION: + case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION: { int width; int height; - mmsvc_recorder_msg_get(width, recvMsg); - mmsvc_recorder_msg_get(height, recvMsg); + muse_recorder_msg_get(width, recvMsg); + muse_recorder_msg_get(height, recvMsg); ((recorder_supported_video_resolution_cb)cb_info->user_cb[event])(width, height, cb_info->user_data[event]); @@ -191,17 +191,17 @@ static void *_client_cb_handler(gpointer data) int prev_pos = 0; callback_cb_info_s *cb_info = data; char *recvMsg = cb_info->recvMsg; - char parseStr[MMSVC_PARSE_STRING_SIZE][MMSVC_MSG_MAX_LENGTH] = {{0,0},}; + char parseStr[MUSE_RECORDER_PARSE_STRING_SIZE][MUSE_RECORDER_MSG_MAX_LENGTH] = {{0,0},}; while (g_atomic_int_get(&cb_info->running)) { - ret = mmsvc_core_ipc_recv_msg(cb_info->fd, recvMsg); + ret = muse_core_ipc_recv_msg(cb_info->fd, recvMsg); if (ret <= 0) break; recvMsg[ret] = '\0'; str_pos = 0; prev_pos = 0; num_token = 0; - memset(parseStr, 0, MMSVC_PARSE_STRING_SIZE * MMSVC_MSG_MAX_LENGTH); + memset(parseStr, 0, MUSE_RECORDER_PARSE_STRING_SIZE * MUSE_RECORDER_MSG_MAX_LENGTH); LOGD("recvMSg : %s, length : %d", recvMsg, ret); /* Need to split the combined entering msgs. @@ -218,10 +218,10 @@ static void *_client_cb_handler(gpointer data) /* Re-construct to the useful single msg. */ for (i = 0; i < num_token; i++) { - if (i >= MMSVC_PARSE_STRING_SIZE) + if (i >= MUSE_RECORDER_PARSE_STRING_SIZE) break; - if (mmsvc_recorder_msg_get(api, &(parseStr[i][0]))) { - if(api < MMSVC_RECORDER_API_MAX){ + if (muse_recorder_msg_get(api, &(parseStr[i][0]))) { + if(api < MUSE_RECORDER_API_MAX){ LOGD("api : %d, wait ends.", api); g_mutex_lock(&(cb_info->pMutex[api])); /* The api msgs should be distinguished from the event msg. */ @@ -231,20 +231,20 @@ static void *_client_cb_handler(gpointer data) cb_info->activating[api] = 1; g_cond_signal(&(cb_info->pCond[api])); g_mutex_unlock(&(cb_info->pMutex[api])); - if(api == MMSVC_RECORDER_API_DESTROY) { + if(api == MUSE_RECORDER_API_DESTROY) { g_atomic_int_set(&cb_info->running, 0); LOGD("close client cb handler"); } - } else if(api == MMSVC_RECORDER_CB_EVENT) { + } else if(api == MUSE_RECORDER_CB_EVENT) { int event; - if (mmsvc_recorder_msg_get(event, &(parseStr[i][0]))) { + if (muse_recorder_msg_get(event, &(parseStr[i][0]))) { LOGD("go callback : %d", event); _client_user_callback(cb_info, event); } } }else{ - LOGD("mmsvc_recorder_msg_get FAIL"); + LOGD("muse_recorder_msg_get FAIL"); } } } @@ -262,9 +262,9 @@ static callback_cb_info_s *_client_callback_new(gint sockfd) g_return_val_if_fail(sockfd > 0, NULL); cb_info = g_new0(callback_cb_info_s, 1); - recorder_cond = g_new0(GCond, MMSVC_RECORDER_API_MAX); - recorder_mutex = g_new0(GMutex, MMSVC_RECORDER_API_MAX); - recorder_activ = g_new0(gint, MMSVC_RECORDER_API_MAX); + recorder_cond = g_new0(GCond, MUSE_RECORDER_API_MAX); + recorder_mutex = g_new0(GMutex, MUSE_RECORDER_API_MAX); + recorder_activ = g_new0(gint, MUSE_RECORDER_API_MAX); g_atomic_int_set(&cb_info->running, 1); cb_info->fd = sockfd; @@ -278,7 +278,7 @@ static callback_cb_info_s *_client_callback_new(gint sockfd) return cb_info; } -static int client_wait_for_cb_return(mmsvc_recorder_api_e api, callback_cb_info_s *cb_info, int time_out) +static int client_wait_for_cb_return(muse_recorder_api_e api, callback_cb_info_s *cb_info, int time_out) { int ret = RECORDER_ERROR_NONE; gint64 end_time; @@ -290,7 +290,7 @@ static int client_wait_for_cb_return(mmsvc_recorder_api_e api, callback_cb_info_ if (cb_info->activating[api] != 1) { if (g_cond_wait_until(&(cb_info->pCond[api]), &(cb_info->pMutex[api]), end_time)) { LOGD("cb_info->recvApiMsg : %s", cb_info->recvApiMsg); - if (!mmsvc_recorder_msg_get(ret, cb_info->recvApiMsg)) { + if (!muse_recorder_msg_get(ret, cb_info->recvApiMsg)) { ret = RECORDER_ERROR_INVALID_OPERATION; } else { LOGD("API %d passed successfully", api); @@ -301,7 +301,7 @@ static int client_wait_for_cb_return(mmsvc_recorder_api_e api, callback_cb_info_ } else { LOGD("condition is already checked for the api : %d.", api); cb_info->activating[api] = 0; - if (!mmsvc_recorder_msg_get(ret, cb_info->recvApiMsg)) { + if (!muse_recorder_msg_get(ret, cb_info->recvApiMsg)) { ret = RECORDER_ERROR_INVALID_OPERATION; } else { LOGD("Already checked condition, Wait passed, ret : 0x%x", ret); @@ -346,11 +346,11 @@ int recorder_create_videorecorder(camera_h camera, recorder_h *recorder) int ret = RECORDER_ERROR_NONE; camera_cli_s *camera_pc = (camera_cli_s *)camera; recorder_cli_s *pc; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_CREATE; - mmsvc_api_client_e api_client = MMSVC_RECORDER; + muse_recorder_api_e api = MUSE_RECORDER_API_CREATE; + muse_core_api_module_e muse_module = MUSE_RECORDER; intptr_t camera_handle = (intptr_t)camera_pc->remote_handle; intptr_t handle; - int recorder_type = MMSVC_RECORDER_TYPE_VIDEO; + int recorder_type = MUSE_RECORDER_TYPE_VIDEO; pc = g_new0(recorder_cli_s, 1); if (pc == NULL) { @@ -358,21 +358,22 @@ int recorder_create_videorecorder(camera_h camera, recorder_h *recorder) } LOGD("remote handle : 0x%x", camera_handle); - sock_fd = mmsvc_core_client_new(); - sndMsg = mmsvc_core_msg_json_factory_new(api, "client", api_client, - MUSED_TYPE_INT, PARAM_RECORDER_TYPE, recorder_type, - MUSED_TYPE_POINTER, PARAM_CAMERA_HANDLE, camera_handle, - 0); - mmsvc_core_ipc_send_msg(sock_fd, sndMsg); + sock_fd = muse_core_client_new(); + sndMsg = muse_core_msg_json_factory_new(api, + MUSE_TYPE_INT, "module", muse_module, + MUSE_TYPE_INT, PARAM_RECORDER_TYPE, recorder_type, + MUSE_TYPE_POINTER, "camera_handle", camera_handle, + 0); + muse_core_ipc_send_msg(sock_fd, sndMsg); LOGD("sock_fd : %d, msg : %s", sock_fd, sndMsg); - mmsvc_core_msg_json_factory_free(sndMsg); + muse_core_msg_json_factory_free(sndMsg); pc->cb_info = _client_callback_new(sock_fd); LOGD("cb info : %d", pc->cb_info->fd); ret = client_wait_for_cb_return(api, pc->cb_info, CALLBACK_TIME_OUT); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg); + muse_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg); if (handle == 0) { LOGE("Receiving Handle Failed!!"); goto ErrorExit; @@ -405,17 +406,20 @@ int recorder_create_audiorecorder(recorder_h *recorder) int ret = RECORDER_ERROR_NONE; recorder_cli_s *pc = NULL; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_CREATE; - mmsvc_api_client_e api_client = MMSVC_RECORDER; - int recorder_type = MMSVC_RECORDER_TYPE_AUDIO; + muse_recorder_api_e api = MUSE_RECORDER_API_CREATE; + muse_core_api_module_e muse_module = MUSE_RECORDER; + int recorder_type = MUSE_RECORDER_TYPE_AUDIO; - sock_fd = mmsvc_core_client_new(); - sndMsg = mmsvc_core_msg_json_factory_new(api, "client", api_client, - MUSED_TYPE_INT, PARAM_RECORDER_TYPE, recorder_type, - 0); - mmsvc_core_ipc_send_msg(sock_fd, sndMsg); + LOGW("Enter"); + sock_fd = muse_core_client_new(); + sndMsg = muse_core_msg_json_factory_new(api, + MUSE_TYPE_INT, "module", muse_module, + MUSE_TYPE_INT, PARAM_RECORDER_TYPE, recorder_type, + 0); + + muse_core_ipc_send_msg(sock_fd, sndMsg); LOGD("sock_fd : %d, msg : %s", sock_fd, sndMsg); - mmsvc_core_msg_json_factory_free(sndMsg); + muse_core_msg_json_factory_free(sndMsg); pc = g_new0(recorder_cli_s, 1); if (pc == NULL) { @@ -423,12 +427,10 @@ int recorder_create_audiorecorder(recorder_h *recorder) } pc->cb_info = _client_callback_new(sock_fd); - LOGD("cb info : %d", pc->cb_info->fd); - ret = client_wait_for_cb_return(api, pc->cb_info, CALLBACK_TIME_OUT); if (ret == RECORDER_ERROR_NONE) { intptr_t handle = 0; - mmsvc_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg); + muse_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg); if (handle == 0) { LOGE("Receiving Handle Failed!!"); goto ErrorExit; @@ -463,7 +465,7 @@ int recorder_get_state(recorder_h recorder, recorder_state_e *state) int ret = RECORDER_ERROR_NONE; recorder_cli_s *pc = (recorder_cli_s *)recorder; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_STATE; + muse_recorder_api_e api = MUSE_RECORDER_API_GET_STATE; int sock_fd; if (pc->cb_info == NULL) { LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER); @@ -473,10 +475,10 @@ int recorder_get_state(recorder_h recorder, recorder_state_e *state) int get_state; LOGD("Enter, remote_handle : %x", pc->remote_handle); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_state, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_state, pc->cb_info->recvMsg); *state = (recorder_state_e)get_state; } LOGD("ret : 0x%x, get_state : %d", ret, get_state); @@ -491,7 +493,7 @@ int recorder_destroy(recorder_h recorder) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_DESTROY; + muse_recorder_api_e api = MUSE_RECORDER_API_DESTROY; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -508,8 +510,7 @@ int recorder_destroy(recorder_h recorder) return RECORDER_ERROR_INVALID_OPERATION; } - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); - LOGD("ret : 0x%x", ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); _client_callback_destroy(pc->cb_info); g_free(pc); pc = NULL; @@ -526,7 +527,7 @@ int recorder_prepare(recorder_h recorder) } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_PREPARE; + muse_recorder_api_e api = MUSE_RECORDER_API_PREPARE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -537,7 +538,7 @@ int recorder_prepare(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); @@ -552,7 +553,7 @@ int recorder_unprepare(recorder_h recorder) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNPREPARE; + muse_recorder_api_e api = MUSE_RECORDER_API_UNPREPARE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -563,7 +564,7 @@ int recorder_unprepare(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -576,7 +577,7 @@ int recorder_start(recorder_h recorder) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_START; + muse_recorder_api_e api = MUSE_RECORDER_API_START; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -587,7 +588,7 @@ int recorder_start(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -600,7 +601,7 @@ int recorder_pause(recorder_h recorder) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_PAUSE; + muse_recorder_api_e api = MUSE_RECORDER_API_PAUSE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -611,7 +612,7 @@ int recorder_pause(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -624,7 +625,7 @@ int recorder_commit(recorder_h recorder) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_COMMIT; + muse_recorder_api_e api = MUSE_RECORDER_API_COMMIT; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -635,7 +636,7 @@ int recorder_commit(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -648,7 +649,7 @@ int recorder_cancel(recorder_h recorder) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_CANCEL; + muse_recorder_api_e api = MUSE_RECORDER_API_CANCEL; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -659,7 +660,7 @@ int recorder_cancel(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -672,7 +673,7 @@ int recorder_set_video_resolution(recorder_h recorder, int width, int height) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_VIDEO_RESOLUTION; + muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_RESOLUTION; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -683,12 +684,12 @@ int recorder_set_video_resolution(recorder_h recorder, int width, int height) LOGD("ENTER"); - mmsvc_recorder_msg_send2(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - INT, width, - INT, height); + muse_recorder_msg_send2(api, + sock_fd, + pc->cb_info, + ret, + INT, width, + INT, height); LOGD("ret : 0x%x", ret); return ret; } @@ -705,7 +706,7 @@ int recorder_get_video_resolution(recorder_h recorder, int *width, int *height) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_VIDEO_RESOLUTION; + muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_RESOLUTION; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -718,10 +719,10 @@ int recorder_get_video_resolution(recorder_h recorder, int *width, int *height) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_width, pc->cb_info->recvMsg); - mmsvc_recorder_msg_get(get_height, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_width, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_height, pc->cb_info->recvMsg); *width = get_width; *height = get_height; } @@ -740,7 +741,7 @@ int recorder_foreach_supported_video_resolution(recorder_h recorder, int ret = RECORDER_ERROR_NONE; recorder_cli_s *pc = (recorder_cli_s *)recorder; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION; + muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION; LOGD("Enter, handle :%x", pc->remote_handle); @@ -750,10 +751,10 @@ int recorder_foreach_supported_video_resolution(recorder_h recorder, return RECORDER_ERROR_INVALID_PARAMETER; } sock_fd = pc->cb_info->fd; - pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = foreach_cb; - pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = user_data; + pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = foreach_cb; + pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = user_data; - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -767,7 +768,7 @@ int recorder_get_audio_level(recorder_h recorder, double *level) } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_AUDIO_LEVEL; + muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_LEVEL; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -779,9 +780,9 @@ int recorder_get_audio_level(recorder_h recorder, double *level) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_level, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_level, pc->cb_info->recvMsg); *level = get_level; } LOGD("ret : 0x%x", ret); @@ -801,7 +802,7 @@ int recorder_set_filename(recorder_h recorder, const char *filename) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_FILENAME; + muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILENAME; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -812,7 +813,7 @@ int recorder_set_filename(recorder_h recorder, const char *filename) LOGD("ENTER"); - mmsvc_recorder_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, STRING, filename); + muse_recorder_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, filename); LOGD("ret : 0x%x", ret); return ret; } @@ -830,7 +831,7 @@ int recorder_get_filename(recorder_h recorder, char **filename) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_FILENAME; + muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILENAME; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -838,14 +839,14 @@ int recorder_get_filename(recorder_h recorder, char **filename) return RECORDER_ERROR_INVALID_PARAMETER; } sock_fd = pc->cb_info->fd; - char get_filename[MMSVC_RECORDER_MSG_MAX_LENGTH] = {0,}; + char get_filename[MUSE_RECORDER_MSG_MAX_LENGTH] = {0,}; LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get_string(get_filename, pc->cb_info->recvMsg); + muse_recorder_msg_get_string(get_filename, pc->cb_info->recvMsg); *filename = strdup(get_filename); } LOGD("ret : 0x%x, filename : %s", ret, *filename); @@ -864,7 +865,7 @@ int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_FILE_FORMAT; + muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILE_FORMAT; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -876,7 +877,7 @@ int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format) LOGD("ENTER, set_format : %d", set_format); - mmsvc_recorder_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_format); + muse_recorder_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format); LOGD("ret : 0x%x", ret); return ret; } @@ -893,7 +894,7 @@ int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_FILE_FORMAT; + muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILE_FORMAT; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -905,10 +906,10 @@ int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_format, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_format, pc->cb_info->recvMsg); LOGD("get_fileformat : %d", get_format); *format = (recorder_file_format_e)get_format; } @@ -926,7 +927,7 @@ int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb int ret = RECORDER_ERROR_NONE; recorder_cli_s *pc = (recorder_cli_s *)recorder; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_STATE_CHANGED_CB; + muse_recorder_api_e api = MUSE_RECORDER_API_SET_STATE_CHANGED_CB; LOGD("Enter, handle :%x", pc->remote_handle); @@ -936,10 +937,10 @@ int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb return RECORDER_ERROR_INVALID_PARAMETER; } sock_fd = pc->cb_info->fd; - pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_STATE_CHANGE] = callback; - pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_STATE_CHANGE] = user_data; + pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = callback; + pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = user_data; - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -952,7 +953,7 @@ int recorder_unset_state_changed_cb(recorder_h recorder) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNSET_STATE_CHANGED_CB; + muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -963,7 +964,7 @@ int recorder_unset_state_changed_cb(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -978,7 +979,7 @@ int recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb cal int ret = RECORDER_ERROR_NONE; recorder_cli_s *pc = (recorder_cli_s *)recorder; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_INTERRUPTED_CB; + muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPTED_CB; LOGD("Enter, handle :%x", pc->remote_handle); @@ -988,10 +989,10 @@ int recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb cal return RECORDER_ERROR_INVALID_PARAMETER; } sock_fd = pc->cb_info->fd; - pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_INTERRUPTED] = callback; - pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data; + pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = callback; + pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data; - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1004,7 +1005,7 @@ int recorder_unset_interrupted_cb(recorder_h recorder) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNSET_INTERRUPTED_CB; + muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPTED_CB; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1015,7 +1016,7 @@ int recorder_unset_interrupted_cb(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1030,7 +1031,7 @@ int recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb c int ret = RECORDER_ERROR_NONE; recorder_cli_s *pc = (recorder_cli_s *)recorder; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_AUDIO_STREAM_CB; + muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_STREAM_CB; LOGD("Enter, handle :%x", pc->remote_handle); @@ -1040,10 +1041,10 @@ int recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb c return RECORDER_ERROR_INVALID_PARAMETER; } sock_fd = pc->cb_info->fd; - pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_AUDIO_STREAM] = callback; - pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_AUDIO_STREAM] = user_data; + pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = callback; + pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = user_data; - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1056,7 +1057,7 @@ int recorder_unset_audio_stream_cb(recorder_h recorder) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNSET_AUDIO_STREAM_CB; + muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_AUDIO_STREAM_CB; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1067,7 +1068,7 @@ int recorder_unset_audio_stream_cb(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1082,7 +1083,7 @@ int recorder_set_error_cb(recorder_h recorder, recorder_error_cb callback, void int ret = RECORDER_ERROR_NONE; recorder_cli_s *pc = (recorder_cli_s *)recorder; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_ERROR_CB; + muse_recorder_api_e api = MUSE_RECORDER_API_SET_ERROR_CB; LOGD("Enter, handle :%x", pc->remote_handle); @@ -1092,10 +1093,10 @@ int recorder_set_error_cb(recorder_h recorder, recorder_error_cb callback, void return RECORDER_ERROR_INVALID_PARAMETER; } sock_fd = pc->cb_info->fd; - pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_ERROR] = callback; - pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_ERROR] = user_data; + pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_ERROR] = callback; + pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_ERROR] = user_data; - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1108,7 +1109,7 @@ int recorder_unset_error_cb(recorder_h recorder) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNSET_ERROR_CB; + muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_ERROR_CB; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1119,7 +1120,7 @@ int recorder_unset_error_cb(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1134,7 +1135,7 @@ int recorder_set_recording_status_cb(recorder_h recorder, recorder_recording_sta int ret = RECORDER_ERROR_NONE; recorder_cli_s *pc = (recorder_cli_s *)recorder; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_RECORDING_STATUS_CB; + muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_STATUS_CB; LOGD("Enter, handle :%x", pc->remote_handle); @@ -1144,10 +1145,10 @@ int recorder_set_recording_status_cb(recorder_h recorder, recorder_recording_sta return RECORDER_ERROR_INVALID_PARAMETER; } sock_fd = pc->cb_info->fd; - pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_RECORDING_STATUS] = callback; - pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_RECORDING_STATUS] = user_data; + pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = callback; + pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = user_data; - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1160,7 +1161,7 @@ int recorder_unset_recording_status_cb(recorder_h recorder) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNSET_RECORDING_STATUS_CB; + muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_STATUS_CB; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1171,7 +1172,7 @@ int recorder_unset_recording_status_cb(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1186,7 +1187,7 @@ int recorder_set_recording_limit_reached_cb(recorder_h recorder, recorder_record int ret = RECORDER_ERROR_NONE; recorder_cli_s *pc = (recorder_cli_s *)recorder; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_RECORDING_LIMIT_REACHED_CB; + muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_LIMIT_REACHED_CB; LOGD("Enter, handle :%x", pc->remote_handle); @@ -1196,10 +1197,10 @@ int recorder_set_recording_limit_reached_cb(recorder_h recorder, recorder_record return RECORDER_ERROR_INVALID_PARAMETER; } sock_fd = pc->cb_info->fd; - pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = callback; - pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = user_data; + pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = callback; + pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = user_data; - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1212,7 +1213,7 @@ int recorder_unset_recording_limit_reached_cb(recorder_h recorder) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNSET_RECORDING_LIMIT_REACHED_CB; + muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_LIMIT_REACHED_CB; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1223,7 +1224,7 @@ int recorder_unset_recording_limit_reached_cb(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1238,7 +1239,7 @@ int recorder_foreach_supported_file_format(recorder_h recorder, recorder_support int ret = RECORDER_ERROR_NONE; recorder_cli_s *pc = (recorder_cli_s *)recorder; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT; + muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT; LOGD("Enter, handle :%x", pc->remote_handle); @@ -1248,10 +1249,10 @@ int recorder_foreach_supported_file_format(recorder_h recorder, recorder_support return RECORDER_ERROR_INVALID_PARAMETER; } sock_fd = pc->cb_info->fd; - pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = foreach_cb; - pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = user_data; + pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = foreach_cb; + pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = user_data; - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1264,7 +1265,7 @@ int recorder_attr_set_size_limit(recorder_h recorder, int kbyte) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_SIZE_LIMIT; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1275,11 +1276,11 @@ int recorder_attr_set_size_limit(recorder_h recorder, int kbyte) LOGD("ENTER"); - mmsvc_recorder_msg_send1(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - INT, kbyte); + muse_recorder_msg_send1(api, + sock_fd, + pc->cb_info, + ret, + INT, kbyte); LOGD("ret : 0x%x", ret); return ret; } @@ -1292,7 +1293,7 @@ int recorder_attr_set_time_limit(recorder_h recorder, int second) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_TIME_LIMIT; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_TIME_LIMIT; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1303,11 +1304,11 @@ int recorder_attr_set_time_limit(recorder_h recorder, int second) LOGD("ENTER"); - mmsvc_recorder_msg_send1(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - INT, second); + muse_recorder_msg_send1(api, + sock_fd, + pc->cb_info, + ret, + INT, second); LOGD("ret : 0x%x", ret); return ret; } @@ -1320,7 +1321,7 @@ int recorder_attr_set_audio_device(recorder_h recorder, recorder_audio_device_e return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_AUDIO_DEVICE; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1332,11 +1333,11 @@ int recorder_attr_set_audio_device(recorder_h recorder, recorder_audio_device_e LOGD("ENTER"); - mmsvc_recorder_msg_send1(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - INT, set_device); + muse_recorder_msg_send1(api, + sock_fd, + pc->cb_info, + ret, + INT, set_device); LOGD("ret : 0x%x", ret); return ret; } @@ -1354,7 +1355,7 @@ int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e codec return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_AUDIO_ENCODER; + muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_ENCODER; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1366,11 +1367,11 @@ int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e codec LOGD("ENTER"); - mmsvc_recorder_msg_send1(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - INT, set_codec); + muse_recorder_msg_send1(api, + sock_fd, + pc->cb_info, + ret, + INT, set_codec); LOGD("ret : 0x%x", ret); return ret; } @@ -1387,7 +1388,7 @@ int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *code return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_AUDIO_ENCODER; + muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_ENCODER; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1399,9 +1400,9 @@ int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *code LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_codec, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_codec, pc->cb_info->recvMsg); *codec = (recorder_audio_codec_e)get_codec; } LOGD("ret : 0x%x", ret); @@ -1420,7 +1421,7 @@ int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_VIDEO_ENCODER; + muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_ENCODER; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1432,11 +1433,11 @@ int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec LOGD("ENTER"); - mmsvc_recorder_msg_send1(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - INT, set_codec); + muse_recorder_msg_send1(api, + sock_fd, + pc->cb_info, + ret, + INT, set_codec); LOGD("ret : 0x%x", ret); return ret; } @@ -1453,7 +1454,7 @@ int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *code return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_VIDEO_ENCODER; + muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_ENCODER; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1465,9 +1466,9 @@ int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *code LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_codec, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_codec, pc->cb_info->recvMsg); *codec = (recorder_audio_codec_e)get_codec; } LOGD("ret : 0x%x", ret); @@ -1486,7 +1487,7 @@ int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1497,11 +1498,11 @@ int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate) LOGD("ENTER, samplerate : %d", samplerate); - mmsvc_recorder_msg_send1(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - INT, samplerate); + muse_recorder_msg_send1(api, + sock_fd, + pc->cb_info, + ret, + INT, samplerate); LOGD("ret : 0x%x, samplerate : %d", ret, samplerate); return ret; } @@ -1518,7 +1519,7 @@ int recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1529,11 +1530,11 @@ int recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate) LOGD("ENTER"); - mmsvc_recorder_msg_send1(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - INT, bitrate); + muse_recorder_msg_send1(api, + sock_fd, + pc->cb_info, + ret, + INT, bitrate); LOGD("ret : 0x%x", ret); return ret; } @@ -1547,7 +1548,7 @@ int recorder_attr_set_video_encoder_bitrate(recorder_h recorder, int bitrate) } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1558,11 +1559,11 @@ int recorder_attr_set_video_encoder_bitrate(recorder_h recorder, int bitrate) LOGD("ENTER"); - mmsvc_recorder_msg_send1(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - INT, bitrate); + muse_recorder_msg_send1(api, + sock_fd, + pc->cb_info, + ret, + INT, bitrate); LOGD("ret : 0x%x", ret); return ret; } @@ -1579,7 +1580,7 @@ int recorder_attr_get_size_limit(recorder_h recorder, int *kbyte) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_SIZE_LIMIT; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1591,9 +1592,9 @@ int recorder_attr_get_size_limit(recorder_h recorder, int *kbyte) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_kbyte, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_kbyte, pc->cb_info->recvMsg); *kbyte = get_kbyte; } LOGD("ret : 0x%x", ret); @@ -1612,7 +1613,7 @@ int recorder_attr_get_time_limit(recorder_h recorder, int *second) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_TIME_LIMIT; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1624,9 +1625,9 @@ int recorder_attr_get_time_limit(recorder_h recorder, int *second) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_second, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_second, pc->cb_info->recvMsg); *second = get_second; } LOGD("ret : 0x%x", ret); @@ -1645,7 +1646,7 @@ int recorder_attr_get_audio_device(recorder_h recorder, recorder_audio_device_e return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_AUDIO_DEVICE; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1657,9 +1658,9 @@ int recorder_attr_get_audio_device(recorder_h recorder, recorder_audio_device_e LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_device, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_device, pc->cb_info->recvMsg); *device = (recorder_audio_device_e)get_device; } @@ -1679,7 +1680,7 @@ int recorder_attr_get_audio_samplerate(recorder_h recorder, int *samplerate) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1691,9 +1692,9 @@ int recorder_attr_get_audio_samplerate(recorder_h recorder, int *samplerate) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_samplerate, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_samplerate, pc->cb_info->recvMsg); *samplerate = get_samplerate; } LOGD("ret : 0x%x, get_samplerate : %d", ret, get_samplerate); @@ -1712,7 +1713,7 @@ int recorder_attr_get_audio_encoder_bitrate(recorder_h recorder, int *bitrate) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1725,9 +1726,9 @@ int recorder_attr_get_audio_encoder_bitrate(recorder_h recorder, int *bitrate) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_bitrate, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_bitrate, pc->cb_info->recvMsg); *bitrate = get_bitrate; } LOGD("ret : 0x%x", ret); @@ -1746,7 +1747,7 @@ int recorder_attr_get_video_encoder_bitrate(recorder_h recorder, int *bitrate) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1758,9 +1759,9 @@ int recorder_attr_get_video_encoder_bitrate(recorder_h recorder, int *bitrate) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_bitrate, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_bitrate, pc->cb_info->recvMsg); *bitrate = get_bitrate; } LOGD("ret : 0x%x", ret); @@ -1777,7 +1778,7 @@ int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_suppo int ret = RECORDER_ERROR_NONE; recorder_cli_s *pc = (recorder_cli_s *)recorder; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER; + muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER; LOGD("Enter, handle :%x", pc->remote_handle); @@ -1787,10 +1788,10 @@ int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_suppo return RECORDER_ERROR_INVALID_PARAMETER; } sock_fd = pc->cb_info->fd; - pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = foreach_cb; - pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = user_data; + pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = foreach_cb; + pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = user_data; - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1805,7 +1806,7 @@ int recorder_foreach_supported_video_encoder(recorder_h recorder, recorder_suppo int ret = RECORDER_ERROR_NONE; recorder_cli_s *pc = (recorder_cli_s *)recorder; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER; + muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER; LOGD("Enter, handle :%x", pc->remote_handle); @@ -1815,10 +1816,10 @@ int recorder_foreach_supported_video_encoder(recorder_h recorder, recorder_suppo return RECORDER_ERROR_INVALID_PARAMETER; } sock_fd = pc->cb_info->fd; - pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = foreach_cb; - pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = user_data; + pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = foreach_cb; + pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = user_data; - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1831,7 +1832,7 @@ int recorder_attr_set_mute(recorder_h recorder, bool enable) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_MUTE; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_MUTE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1844,11 +1845,11 @@ int recorder_attr_set_mute(recorder_h recorder, bool enable) LOGD("ENTER"); - mmsvc_recorder_msg_send1(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - INT, set_enable); + muse_recorder_msg_send1(api, + sock_fd, + pc->cb_info, + ret, + INT, set_enable); LOGD("ret : 0x%x", ret); return ret; } @@ -1861,7 +1862,7 @@ bool recorder_attr_is_muted(recorder_h recorder) return false; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_IS_MUTED; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_IS_MUTED; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1872,7 +1873,7 @@ bool recorder_attr_is_muted(recorder_h recorder) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); LOGD("ret : 0x%x", ret); return ret; } @@ -1885,7 +1886,7 @@ int recorder_attr_set_recording_motion_rate(recorder_h recorder, double rate) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1896,11 +1897,11 @@ int recorder_attr_set_recording_motion_rate(recorder_h recorder, double rate) LOGD("ENTER"); - mmsvc_recorder_msg_send1(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - DOUBLE, rate); + muse_recorder_msg_send1(api, + sock_fd, + pc->cb_info, + ret, + DOUBLE, rate); LOGD("ret : 0x%x", ret); return ret; } @@ -1917,7 +1918,7 @@ int recorder_attr_get_recording_motion_rate(recorder_h recorder, double *rate) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1929,9 +1930,9 @@ int recorder_attr_get_recording_motion_rate(recorder_h recorder, double *rate) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_rate, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_rate, pc->cb_info->recvMsg); *rate = get_rate; } LOGD("ret : 0x%x", ret); @@ -1950,7 +1951,7 @@ int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_AUDIO_CHANNEL; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_CHANNEL; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1961,11 +1962,11 @@ int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count) LOGD("ENTER"); - mmsvc_recorder_msg_send1(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - INT, channel_count); + muse_recorder_msg_send1(api, + sock_fd, + pc->cb_info, + ret, + INT, channel_count); LOGD("ret : 0x%x", ret); return ret; } @@ -1982,7 +1983,7 @@ int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count) return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_AUDIO_CHANNEL; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -1994,9 +1995,9 @@ int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count) LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_channel_count, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_channel_count, pc->cb_info->recvMsg); *channel_count = get_channel_count; } LOGD("ret : 0x%x", ret); @@ -2015,7 +2016,7 @@ int recorder_attr_set_orientation_tag(recorder_h recorder, recorder_rotation_e o return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_ORIENTATION_TAG; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -2027,11 +2028,11 @@ int recorder_attr_set_orientation_tag(recorder_h recorder, recorder_rotation_e o LOGD("ENTER"); - mmsvc_recorder_msg_send1(api, pc->remote_handle, - sock_fd, - pc->cb_info, - ret, - INT, set_orientation); + muse_recorder_msg_send1(api, + sock_fd, + pc->cb_info, + ret, + INT, set_orientation); LOGD("ret : 0x%x", ret); return ret; } @@ -2048,7 +2049,7 @@ int recorder_attr_get_orientation_tag(recorder_h recorder, recorder_rotation_e return RECORDER_ERROR_INVALID_PARAMETER; } int ret = RECORDER_ERROR_NONE; - mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_ORIENTATION_TAG; + muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG; recorder_cli_s *pc = (recorder_cli_s *)recorder; int sock_fd; if (pc->cb_info == NULL) { @@ -2060,9 +2061,9 @@ int recorder_attr_get_orientation_tag(recorder_h recorder, recorder_rotation_e LOGD("ENTER"); - mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret); + muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret); if (ret == RECORDER_ERROR_NONE) { - mmsvc_recorder_msg_get(get_orientation, pc->cb_info->recvMsg); + muse_recorder_msg_get(get_orientation, pc->cb_info->recvMsg); *orientation = (recorder_rotation_e)get_orientation; } LOGD("ret : 0x%x", ret);