From d12ee6919c20ecd797b8f10e00e2c4fa1d0bcf61 Mon Sep 17 00:00:00 2001 From: Jeongmo Yang Date: Tue, 13 Sep 2016 15:39:55 +0900 Subject: [PATCH] Add sub thread for audio stream callback [Version] 0.2.37 [Profile] Common [Issue Type] Enhancement [Dependency module] N/A [Dependency commit] N/A [Test] [M(T) - Boot=(OK), sdb=(OK), Home=(OK), Touch=(OK), Version=tizen-mobile_20160913.1] Change-Id: I56243fbcfa660c410218a38220f436a597c2b390 Signed-off-by: Jeongmo Yang --- include/recorder.h | 4 +- include/recorder_private.h | 46 ++++- packaging/capi-media-recorder.spec | 2 +- src/recorder.c | 371 ++++++++++++++++++++----------------- 4 files changed, 241 insertions(+), 182 deletions(-) diff --git a/include/recorder.h b/include/recorder.h index 8fbd344..682a2ee 100644 --- a/include/recorder.h +++ b/include/recorder.h @@ -804,8 +804,8 @@ int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_suppo * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif * @remarks This function should be called before recording (recorder_start()). * @param[in] recorder The handle to the media recorder - * @param[in] width The preview width - * @param[in] height The preview height + * @param[in] width The video width + * @param[in] height The video height * @return @c 0 on success, otherwise a negative error value * @retval #RECORDER_ERROR_NONE Successful * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter diff --git a/include/recorder_private.h b/include/recorder_private.h index b42b831..76608dc 100644 --- a/include/recorder_private.h +++ b/include/recorder_private.h @@ -60,27 +60,51 @@ enum { _RECORDER_GET_DOUBLE_MAX }; +enum { + _RECORDER_MESSAGE_HANDLER_TYPE_GENERAL, + _RECORDER_MESSAGE_HANDLER_TYPE_AUDIO_STREAM_CB +}; + +typedef struct _recorder_msg_handler_info_s { + int type; + void *cb_info; + int running; + GCond cond; + GMutex mutex; + GQueue *queue; + GThread *thread; +} recorder_msg_handler_info_s; + typedef struct _recorder_cb_info_s { + /* server connection */ gint fd; gboolean is_server_connected; + /* message receive thread */ GThread *msg_recv_thread; - GThread *msg_handler_thread; gint msg_recv_running; - gint msg_handler_running; - GCond msg_handler_cond; - GMutex msg_handler_mutex; - GQueue *msg_queue; + gchar recv_msg[RECORDER_MSG_LENGTH_MAX]; + GCond api_cond[MUSE_RECORDER_API_MAX]; + GMutex api_mutex[MUSE_RECORDER_API_MAX]; + gint api_activating[MUSE_RECORDER_API_MAX]; + gint api_ret[MUSE_RECORDER_API_MAX]; + + /* general message handler info */ + recorder_msg_handler_info_s msg_handler_info; + + /* preview cb message handler info */ + recorder_msg_handler_info_s audio_stream_cb_info; + + /* idle event */ GList *idle_event_list; GCond idle_event_cond; GMutex idle_event_mutex; + + /* user callback */ gpointer user_cb[MUSE_RECORDER_EVENT_TYPE_NUM]; gpointer user_data[MUSE_RECORDER_EVENT_TYPE_NUM]; - gchar recv_msg[RECORDER_MSG_LENGTH_MAX]; - GCond api_cond[MUSE_RECORDER_API_MAX]; - GMutex api_mutex[MUSE_RECORDER_API_MAX]; - gint *api_activating; - gint *api_ret; + + /* tbm */ tbm_bufmgr bufmgr; /* get values */ @@ -92,6 +116,8 @@ typedef struct _recorder_cb_info_s { typedef struct _recorder_message_s { gchar recv_msg[MUSE_RECORDER_MSG_MAX_LENGTH]; muse_recorder_api_e api; + muse_recorder_event_e event; + muse_recorder_event_class_e event_class; } recorder_message_s; typedef struct _recorder_idle_event_s { diff --git a/packaging/capi-media-recorder.spec b/packaging/capi-media-recorder.spec index a87bc07..692bb3e 100644 --- a/packaging/capi-media-recorder.spec +++ b/packaging/capi-media-recorder.spec @@ -1,6 +1,6 @@ Name: capi-media-recorder Summary: A Recorder API -Version: 0.2.36 +Version: 0.2.37 Release: 0 Group: Multimedia/API License: Apache-2.0 diff --git a/src/recorder.c b/src/recorder.c index b545e8e..a5e453a 100644 --- a/src/recorder.c +++ b/src/recorder.c @@ -411,47 +411,95 @@ static void _recorder_remove_idle_event_all(recorder_cb_info_s *cb_info) } +static void __recorder_add_msg_to_queue(recorder_cb_info_s *cb_info, int api, int event, int event_class, char *msg) +{ + recorder_message_s *rec_msg = NULL; + + if (!cb_info || !msg) { + LOGE("NULL pointer %p %p", cb_info, msg); + return; + } + + rec_msg = g_new0(recorder_message_s, 1); + if (!rec_msg) { + LOGE("failed to alloc rec_msg for [%s]", msg); + return; + } + + rec_msg->api = api; + rec_msg->event = event; + rec_msg->event_class = event_class; + + strncpy(rec_msg->recv_msg, msg, sizeof(rec_msg->recv_msg) - 1); + + /*LOGD("add recorder message to queue : api %d, event %d, event_class %d", api, event, event_class);*/ + + if (event == MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM) { + g_mutex_lock(&cb_info->audio_stream_cb_info.mutex); + g_queue_push_tail(cb_info->audio_stream_cb_info.queue, (gpointer)rec_msg); + g_cond_signal(&cb_info->audio_stream_cb_info.cond); + g_mutex_unlock(&cb_info->audio_stream_cb_info.mutex); + } else { + g_mutex_lock(&cb_info->msg_handler_info.mutex); + g_queue_push_tail(cb_info->msg_handler_info.queue, (gpointer)rec_msg); + g_cond_signal(&cb_info->msg_handler_info.cond); + g_mutex_unlock(&cb_info->msg_handler_info.mutex); + } + + rec_msg = NULL; + + return; +} + + static void *_recorder_msg_handler_func(gpointer data) { - int ret = 0; int api = 0; - int event = 0; - int event_class = 0; + int type = 0; recorder_message_s *rec_msg = NULL; recorder_idle_event_s *rec_idle_event = NULL; - recorder_cb_info_s *cb_info = (recorder_cb_info_s *)data; + recorder_msg_handler_info_s *handler_info = (recorder_msg_handler_info_s *)data; + recorder_cb_info_s *cb_info = NULL; - if (cb_info == NULL) { - LOGE("cb_info NULL"); + if (!handler_info || !handler_info->cb_info) { + LOGE("NULL handler %p", handler_info); return NULL; } - LOGD("start"); + cb_info = (recorder_cb_info_s *)handler_info->cb_info; + type = handler_info->type; - g_mutex_lock(&cb_info->msg_handler_mutex); + LOGD("t:%d start", type); - while (g_atomic_int_get(&cb_info->msg_handler_running)) { - if (g_queue_is_empty(cb_info->msg_queue)) { + g_mutex_lock(&handler_info->mutex); + + while (g_atomic_int_get(&handler_info->running)) { + if (g_queue_is_empty(handler_info->queue)) { /*LOGD("signal wait...");*/ - g_cond_wait(&cb_info->msg_handler_cond, &cb_info->msg_handler_mutex); + g_cond_wait(&handler_info->cond, &handler_info->mutex); /*LOGD("signal received");*/ - if (g_atomic_int_get(&cb_info->msg_handler_running) == 0) { + if (g_atomic_int_get(&handler_info->running) == 0) { LOGD("stop event thread"); break; } } - rec_msg = (recorder_message_s *)g_queue_pop_head(cb_info->msg_queue); - g_mutex_unlock(&cb_info->msg_handler_mutex); + rec_msg = (recorder_message_s *)g_queue_pop_head(handler_info->queue); + g_mutex_unlock(&handler_info->mutex); if (rec_msg == NULL) { LOGE("NULL message"); - g_mutex_lock(&cb_info->msg_handler_mutex); + g_mutex_lock(&handler_info->mutex); continue; } + api = rec_msg->api; + if (api < MUSE_RECORDER_API_MAX) { + int ret = 0; + g_mutex_lock(&cb_info->api_mutex[api]); + if (muse_recorder_msg_get(ret, rec_msg->recv_msg)) { cb_info->api_ret[api] = ret; cb_info->api_activating[api] = 1; @@ -460,28 +508,14 @@ static void *_recorder_msg_handler_func(gpointer data) g_cond_signal(&cb_info->api_cond[api]); } else { - LOGE("failed to get ret for api %d, msg %s", rec_msg->api, rec_msg->recv_msg); + LOGE("t:%d failed to get ret for api %d, msg %s", type, api, rec_msg->recv_msg); } g_mutex_unlock(&cb_info->api_mutex[api]); } else if (api == MUSE_RECORDER_CB_EVENT) { - event = -1; - event_class = -1; - - if (!muse_recorder_msg_get(event, rec_msg->recv_msg) || - !muse_recorder_msg_get(event_class, rec_msg->recv_msg)) { - LOGE("get failed : event %d, class %d", event, event_class); - - g_free(rec_msg); - rec_msg = NULL; - - g_mutex_lock(&cb_info->msg_handler_mutex); - continue; - } - - switch (event_class) { + switch (rec_msg->event_class) { case MUSE_RECORDER_EVENT_CLASS_THREAD_SUB: - _recorder_client_user_callback(cb_info, rec_msg->recv_msg, event); + _recorder_client_user_callback(cb_info, rec_msg->recv_msg, rec_msg->event); break; case MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN: rec_idle_event = g_new0(recorder_idle_event_s, 1); @@ -490,12 +524,12 @@ static void *_recorder_msg_handler_func(gpointer data) break; } - rec_idle_event->event = event; + rec_idle_event->event = rec_msg->event; rec_idle_event->cb_info = cb_info; g_mutex_init(&rec_idle_event->event_mutex); - memcpy(rec_idle_event->recv_msg, rec_msg->recv_msg, sizeof(rec_idle_event->recv_msg)); + strncpy(rec_idle_event->recv_msg, rec_msg->recv_msg, sizeof(rec_idle_event->recv_msg) - 1); - /*LOGD("add recorder event[%d, %p] to IDLE", event, rec_idle_event);*/ + /*LOGD("add recorder event[%d, %p] to IDLE", rec_msg->event, rec_idle_event);*/ g_mutex_lock(&cb_info->idle_event_mutex); cb_info->idle_event_list = g_list_append(cb_info->idle_event_list, (gpointer)rec_idle_event); @@ -507,7 +541,7 @@ static void *_recorder_msg_handler_func(gpointer data) NULL); break; default: - LOGE("unknown event class %d", event_class); + LOGE("unknown event class %d", rec_msg->event_class); break; } } else { @@ -517,12 +551,12 @@ static void *_recorder_msg_handler_func(gpointer data) g_free(rec_msg); rec_msg = NULL; - g_mutex_lock(&cb_info->msg_handler_mutex); + g_mutex_lock(&handler_info->mutex); } /* remove remained event */ - while (!g_queue_is_empty(cb_info->msg_queue)) { - rec_msg = (recorder_message_s *)g_queue_pop_head(cb_info->msg_queue); + while (!g_queue_is_empty(handler_info->queue)) { + rec_msg = (recorder_message_s *)g_queue_pop_head(handler_info->queue); if (rec_msg) { LOGD("remove message %p", rec_msg); free(rec_msg); @@ -532,7 +566,7 @@ static void *_recorder_msg_handler_func(gpointer data) } } - g_mutex_unlock(&cb_info->msg_handler_mutex); + g_mutex_unlock(&handler_info->mutex); LOGD("return"); @@ -681,6 +715,8 @@ static void *_recorder_msg_recv_func(gpointer data) int ret = 0; int api = 0; int api_class = 0; + int event = 0; + int event_class = 0; int num_token = 0; int str_pos = 0; int prev_pos = 0; @@ -688,7 +724,6 @@ static void *_recorder_msg_recv_func(gpointer data) char *error_msg = NULL; char **parse_str = NULL; recorder_cb_info_s *cb_info = (recorder_cb_info_s *)data; - recorder_message_s *rec_msg = NULL; if (cb_info == NULL) { LOGE("cb_info NULL"); @@ -757,9 +792,15 @@ static void *_recorder_msg_recv_func(gpointer data) continue; } - if (api != MUSE_RECORDER_CB_EVENT) { + if (api == MUSE_RECORDER_CB_EVENT) { + if (!muse_recorder_msg_get(event, parse_str[i]) || + !muse_recorder_msg_get(event_class, parse_str[i])) { + LOGE("failed to get event or event_class [%s]", parse_str[i]); + continue; + } + } else { if (!muse_recorder_msg_get(api_class, parse_str[i])) { - LOGE("failed to get recorder api_class"); + LOGE("failed to get api_class [%s]", parse_str[i]); continue; } } @@ -801,25 +842,8 @@ static void *_recorder_msg_recv_func(gpointer data) g_cond_signal(&cb_info->api_cond[api]); g_mutex_unlock(&cb_info->api_mutex[api]); - } else if (api_class == MUSE_RECORDER_API_CLASS_THREAD_SUB || - api == MUSE_RECORDER_CB_EVENT) { - rec_msg = g_new0(recorder_message_s, 1); - if (rec_msg == NULL) { - LOGE("failed to alloc rec_msg"); - continue; - } - - rec_msg->api = api; - memcpy(rec_msg->recv_msg, parse_str[i], sizeof(rec_msg->recv_msg)); - - /*LOGD("add recorder message to queue : api %d", api);*/ - - g_mutex_lock(&cb_info->msg_handler_mutex); - g_queue_push_tail(cb_info->msg_queue, (gpointer)rec_msg); - g_cond_signal(&cb_info->msg_handler_cond); - g_mutex_unlock(&cb_info->msg_handler_mutex); - - rec_msg = NULL; + } else if (api_class == MUSE_RECORDER_API_CLASS_THREAD_SUB || api == MUSE_RECORDER_CB_EVENT) { + __recorder_add_msg_to_queue(cb_info, api, event, event_class, parse_str[i]); } else { LOGW("unknown recorder api %d and api_class %d", api, api_class); } @@ -831,8 +855,6 @@ static void *_recorder_msg_recv_func(gpointer data) if (!cb_info->is_server_connected) { /* send error msg for server disconnection */ error_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_CB_EVENT, - MUSE_TYPE_INT, PARAM_EVENT, MUSE_RECORDER_EVENT_TYPE_ERROR, - MUSE_TYPE_INT, PARAM_EVENT_CLASS, MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN, MUSE_TYPE_INT, "error", RECORDER_ERROR_SERVICE_DISCONNECTED, MUSE_TYPE_INT, "current_state", RECORDER_STATE_NONE, NULL); @@ -841,33 +863,21 @@ static void *_recorder_msg_recv_func(gpointer data) goto CB_HANDLER_EXIT; } - rec_msg = g_new0(recorder_message_s, 1); - if (rec_msg == NULL) { - LOGE("failed to alloc rec_msg"); - goto CB_HANDLER_EXIT; - } - - rec_msg->api = MUSE_RECORDER_CB_EVENT; - memcpy(rec_msg->recv_msg, error_msg, sizeof(rec_msg->recv_msg)); - - /*LOGD("add recorder message to queue : api %d", api);*/ + LOGE("add error msg for service disconnection done"); - g_mutex_lock(&cb_info->msg_handler_mutex); - g_queue_push_tail(cb_info->msg_queue, (gpointer)rec_msg); - g_cond_signal(&cb_info->msg_handler_cond); - g_mutex_unlock(&cb_info->msg_handler_mutex); + __recorder_add_msg_to_queue(cb_info, + MUSE_RECORDER_CB_EVENT, + MUSE_RECORDER_EVENT_TYPE_ERROR, + MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN, + error_msg); - rec_msg = NULL; + muse_core_msg_json_factory_free(error_msg); + error_msg = NULL; LOGE("add error msg for service disconnection done"); } CB_HANDLER_EXIT: - if (error_msg) { - muse_core_msg_json_factory_free(error_msg); - error_msg = NULL; - } - if (parse_str) { for (i = 0 ; i < RECORDER_PARSE_STRING_SIZE ; i++) { if (parse_str[i]) { @@ -883,11 +893,91 @@ CB_HANDLER_EXIT: return NULL; } -static recorder_cb_info_s *_recorder_client_callback_new(gint sockfd) + +static bool __create_msg_handler_thread(recorder_msg_handler_info_s *handler_info, + int type, const char *thread_name, recorder_cb_info_s *cb_info) +{ + if (!handler_info || !thread_name || !cb_info) { + LOGE("t:%d NULL %p %p %p", + type, handler_info, thread_name, cb_info); + return false; + } + + LOGD("t:%d", type); + + handler_info->type = type; + handler_info->queue = g_queue_new(); + if (handler_info->queue == NULL) { + LOGE("t:%d queue failed", type); + return false; + } + + g_mutex_init(&handler_info->mutex); + g_cond_init(&handler_info->cond); + + handler_info->cb_info = (void *)cb_info; + g_atomic_int_set(&handler_info->running, 1); + + handler_info->thread = g_thread_try_new(thread_name, + _recorder_msg_handler_func, (gpointer)handler_info, NULL); + if (handler_info->thread == NULL) { + LOGE("t:%d thread failed", type); + + g_mutex_clear(&handler_info->mutex); + g_cond_clear(&handler_info->cond); + g_queue_free(handler_info->queue); + handler_info->queue = NULL; + + return false; + } + + LOGD("t:%d done", type); + + return true; +} + + +static void __destroy_msg_handler_thread(recorder_msg_handler_info_s *handler_info) +{ + int type = 0; + + if (!handler_info) { + LOGE("NULL handler"); + return; + } + + if (!handler_info->thread) { + LOGW("thread is not created"); + return; + } + + type = handler_info->type; + + LOGD("t:%d thread %p", type, handler_info->thread); + + g_mutex_lock(&handler_info->mutex); + g_atomic_int_set(&handler_info->running, 0); + g_cond_signal(&handler_info->cond); + g_mutex_unlock(&handler_info->mutex); + + g_thread_join(handler_info->thread); + g_thread_unref(handler_info->thread); + handler_info->thread = NULL; + + g_mutex_clear(&handler_info->mutex); + g_cond_clear(&handler_info->cond); + g_queue_free(handler_info->queue); + handler_info->queue = NULL; + + LOGD("t:%d done", type); + + return; +} + + +static recorder_cb_info_s *_recorder_client_callback_new(gint sockfd, bool need_msg_handler_thread) { recorder_cb_info_s *cb_info = NULL; - gint *tmp_activating = NULL; - gint *tmp_ret = NULL; gint i = 0; g_return_val_if_fail(sockfd > 0, NULL); @@ -898,46 +988,33 @@ static recorder_cb_info_s *_recorder_client_callback_new(gint sockfd) goto ErrorExit; } - g_mutex_init(&cb_info->msg_handler_mutex); - g_cond_init(&cb_info->msg_handler_cond); - g_mutex_init(&cb_info->idle_event_mutex); - g_cond_init(&cb_info->idle_event_cond); - for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) { g_mutex_init(&cb_info->api_mutex[i]); g_cond_init(&cb_info->api_cond[i]); } - tmp_activating = g_new0(gint, MUSE_RECORDER_API_MAX); - if (tmp_activating == NULL) { - LOGE("tmp_activating failed"); - goto ErrorExit; - } - - tmp_ret = g_new0(gint, MUSE_RECORDER_API_MAX); - if (tmp_ret == NULL) { - LOGE("tmp_ret failed"); - goto ErrorExit; - } + g_mutex_init(&cb_info->idle_event_mutex); + g_cond_init(&cb_info->idle_event_cond); - cb_info->msg_queue = g_queue_new(); - if (cb_info->msg_queue == NULL) { - LOGE("msg_queue new failed"); - goto ErrorExit; - } + if (need_msg_handler_thread) { + /* message handler thread */ + if (!__create_msg_handler_thread(&cb_info->msg_handler_info, + _RECORDER_MESSAGE_HANDLER_TYPE_GENERAL, "recorder_msg_handler", cb_info)) { + LOGE("msg_handler_info failed"); + goto ErrorExit; + } - g_atomic_int_set(&cb_info->msg_handler_running, 1); - cb_info->msg_handler_thread = g_thread_try_new("recorder_msg_handler", - _recorder_msg_handler_func, (gpointer)cb_info, NULL); - if (cb_info->msg_handler_thread == NULL) { - LOGE("message handler thread creation failed"); - goto ErrorExit; + /* message handler thread for audio stream callback */ + if (!__create_msg_handler_thread(&cb_info->audio_stream_cb_info, + _RECORDER_MESSAGE_HANDLER_TYPE_AUDIO_STREAM_CB, "recorder_msg_handler:audio_stream_cb", cb_info)) { + LOGE("audio_stream_cb_info failed"); + goto ErrorExit; + } } cb_info->fd = sockfd; - cb_info->api_activating = tmp_activating; - cb_info->api_ret = tmp_ret; + /* message receive thread */ g_atomic_int_set(&cb_info->msg_recv_running, 1); cb_info->msg_recv_thread = g_thread_try_new("recorder_msg_recv", _recorder_msg_recv_func, (gpointer)cb_info, NULL); @@ -952,45 +1029,21 @@ static recorder_cb_info_s *_recorder_client_callback_new(gint sockfd) ErrorExit: if (cb_info) { - if (cb_info->msg_handler_thread) { - g_mutex_lock(&cb_info->msg_handler_mutex); - g_atomic_int_set(&cb_info->msg_handler_running, 0); - g_cond_signal(&cb_info->msg_handler_cond); - g_mutex_unlock(&cb_info->msg_handler_mutex); - - g_thread_join(cb_info->msg_handler_thread); - g_thread_unref(cb_info->msg_handler_thread); - cb_info->msg_handler_thread = NULL; - } + __destroy_msg_handler_thread(&cb_info->msg_handler_info); + __destroy_msg_handler_thread(&cb_info->audio_stream_cb_info); - for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) { - g_mutex_clear(&cb_info->api_mutex[i]); - g_cond_clear(&cb_info->api_cond[i]); - } - - g_mutex_clear(&cb_info->msg_handler_mutex); - g_cond_clear(&cb_info->msg_handler_cond); g_mutex_clear(&cb_info->idle_event_mutex); g_cond_clear(&cb_info->idle_event_cond); - if (cb_info->msg_queue) { - g_queue_free(cb_info->msg_queue); - cb_info->msg_queue = NULL; + for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) { + g_mutex_clear(&cb_info->api_mutex[i]); + g_cond_clear(&cb_info->api_cond[i]); } g_free(cb_info); cb_info = NULL; } - if (tmp_activating) { - g_free(tmp_activating); - tmp_activating = NULL; - } - if (tmp_ret) { - g_free(tmp_ret); - tmp_ret = NULL; - } - return NULL; } @@ -1141,21 +1194,11 @@ static void _recorder_client_callback_destroy(recorder_cb_info_s *cb_info) g_thread_unref(cb_info->msg_recv_thread); cb_info->msg_recv_thread = NULL; - LOGD("msg thread removed"); + LOGD("msg_recv thread removed"); - g_mutex_lock(&cb_info->msg_handler_mutex); - g_atomic_int_set(&cb_info->msg_handler_running, 0); - g_cond_signal(&cb_info->msg_handler_cond); - g_mutex_unlock(&cb_info->msg_handler_mutex); + __destroy_msg_handler_thread(&cb_info->msg_handler_info); + __destroy_msg_handler_thread(&cb_info->audio_stream_cb_info); - g_thread_join(cb_info->msg_handler_thread); - g_thread_unref(cb_info->msg_handler_thread); - cb_info->msg_handler_thread = NULL; - - g_queue_free(cb_info->msg_queue); - cb_info->msg_queue = NULL; - g_mutex_clear(&cb_info->msg_handler_mutex); - g_cond_clear(&cb_info->msg_handler_cond); g_mutex_clear(&cb_info->idle_event_mutex); g_cond_clear(&cb_info->idle_event_cond); @@ -1164,8 +1207,6 @@ static void _recorder_client_callback_destroy(recorder_cb_info_s *cb_info) g_cond_clear(&cb_info->api_cond[i]); } - LOGD("event thread removed"); - if (cb_info->fd > -1) { muse_core_connection_close(cb_info->fd); cb_info->fd = -1; @@ -1175,14 +1216,6 @@ static void _recorder_client_callback_destroy(recorder_cb_info_s *cb_info) tbm_bufmgr_deinit(cb_info->bufmgr); cb_info->bufmgr = NULL; } - if (cb_info->api_activating) { - g_free(cb_info->api_activating); - cb_info->api_activating = NULL; - } - if (cb_info->api_ret) { - g_free(cb_info->api_ret); - cb_info->api_ret = NULL; - } if (cb_info->get_filename) { free(cb_info->get_filename); cb_info->get_filename = NULL; @@ -1323,7 +1356,7 @@ static int _recorder_create_common(recorder_h *recorder, muse_recorder_type_e ty goto _ERR_RECORDER_EXIT; } - pc->cb_info = _recorder_client_callback_new(sock_fd); + pc->cb_info = _recorder_client_callback_new(sock_fd, true); if (pc->cb_info == NULL) { ret = RECORDER_ERROR_OUT_OF_MEMORY; goto _ERR_RECORDER_EXIT; -- 2.7.4