Release 0.2.10submit/tizen/20151116.054236accepted/tizen/wearable/20151117.005508accepted/tizen/tv/20151117.005457accepted/tizen/mobile/20151117.005443

1. Fix audio stream callback bug
2. Add recorder API test program
3. Code optimization
4. Add exception handling

Change-Id: I4445929a3972a2227b0628118bdd0612a8a61546
Signed-off-by: Jeongmo Yang <jm80.yang@samsung.com>

6 files changed, 1985 insertions, 1368 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 45529da..078647d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -71,7 +71,7 @@ CONFIGURE_FILE(
 )
 INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
 
-#ADD_SUBDIRECTORY(test)
+ADD_SUBDIRECTORY(test)
 
 IF(UNIX)
 
diff --git a/include/recorder_private.h b/include/recorder_private.h
index 59de601..539e434 100644
--- a/include/recorder_private.h
+++ b/include/recorder_private.h
@@ -57,6 +57,7 @@ typedef struct _callback_cb_info {
 	GCond *pCond;
 	GMutex *pMutex;
 	gint *activating;
+	tbm_bufmgr bufmgr;
 } callback_cb_info_s;
 
 typedef struct _recorder_cli_s{
diff --git a/packaging/capi-media-recorder.spec b/packaging/capi-media-recorder.spec
index abb2034..b219fec 100644
--- a/packaging/capi-media-recorder.spec
+++ b/packaging/capi-media-recorder.spec
@@ -1,7 +1,7 @@
 Name:       capi-media-recorder
-Summary:    A Recorder library in Tizen Native API
-Version:    0.2.9
-Release:    1
+Summary:    A Recorder API
+Version:    0.2.10
+Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0
 Source0:    %{name}-%{version}.tar.gz
@@ -13,6 +13,8 @@ BuildRequires:  pkgconfig(mmsvc-camera)
 BuildRequires:  pkgconfig(mmsvc-recorder)
 BuildRequires:  pkgconfig(glib-2.0)
 BuildRequires:  pkgconfig(mused)
+BuildRequires:  pkgconfig(evas)
+BuildRequires:  pkgconfig(elementary)
 BuildRequires:  pkgconfig(capi-media-tool)
 BuildRequires:  pkgconfig(capi-media-audio-io)
 BuildRequires:  pkgconfig(mm-camcorder)
@@ -24,12 +26,12 @@ A Recorder library in Tizen Native API
 
 
 %package devel
-Summary:  A Recorder library in Tizen C API (Development)
+Summary:  A Recorder API (Development)
 Requires: %{name} = %{version}-%{release}
 
 
 %description devel
-A Recorder library in Tizen Native API Development Package.
+Development related files for a Recorder library in Tizen Native API.
 
 
 %prep
@@ -61,6 +63,7 @@ cp LICENSE.APLv2 %{buildroot}/usr/share/license/%{name}
 %manifest capi-media-recorder.manifest
 %{_libdir}/libcapi-media-recorder.so.*
 %{_datadir}/license/%{name}
+%{_bindir}/multimedia_recorder_test
 
 %files devel
 %{_includedir}/media/recorder.h
diff --git a/src/recorder.c b/src/recorder.c
index 934912a..d4f8d67 100644
--- a/src/recorder.c
+++ b/src/recorder.c
@@ -34,6 +34,53 @@
 #endif
 #define LOG_TAG "TIZEN_N_RECORDER"
 
+
+static int _recorder_import_tbm_key(tbm_bufmgr bufmgr, unsigned int tbm_key, tbm_bo *bo, tbm_bo_handle *bo_handle)
+{
+	tbm_bo tmp_bo = NULL;
+	tbm_bo_handle tmp_bo_handle = {NULL, };
+
+	if (bufmgr == NULL || bo == NULL || bo_handle == NULL || tbm_key == 0) {
+		LOGE("invalid parameter - bufmgr %p, bo %p, bo_handle %p, key %d",
+		     bufmgr, bo, bo_handle, tbm_key);
+		return false;
+	}
+
+	tmp_bo = tbm_bo_import(bufmgr, tbm_key);
+	if (tmp_bo == NULL) {
+		LOGE("bo import failed - bufmgr %p, key %d", bufmgr, tbm_key);
+		return false;
+	}
+
+	tmp_bo_handle = tbm_bo_map(tmp_bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
+	if (tmp_bo_handle.ptr == NULL) {
+		LOGE("bo map failed %p", tmp_bo);
+		tbm_bo_unref(tmp_bo);
+		tmp_bo = NULL;
+		return false;
+	}
+
+	/* set bo and bo_handle */
+	*bo = tmp_bo;
+	*bo_handle = tmp_bo_handle;
+
+	return true;
+}
+
+static void _recorder_release_imported_bo(tbm_bo *bo)
+{
+	if (bo == NULL || *bo == NULL) {
+		LOGW("NULL bo");
+		return;
+	}
+
+	tbm_bo_unmap(*bo);
+	tbm_bo_unref(*bo);
+	*bo = NULL;
+
+	return;
+}
+
 static void _client_user_callback(callback_cb_info_s * cb_info, muse_recorder_event_e event)
 {
 	char *recvMsg = cb_info->recvMsg;
@@ -42,136 +89,154 @@ static void _client_user_callback(callback_cb_info_s * cb_info, muse_recorder_ev
 	switch (event) {
 		case MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE:
 		{
-			int cb_previous, cb_current, cb_by_policy;
-			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]);
+			int previous = 0;
+			int current = 0;
+			int by_policy = 0;
+
+			muse_recorder_msg_get(previous, recvMsg);
+			muse_recorder_msg_get(current, recvMsg);
+			muse_recorder_msg_get(by_policy, recvMsg);
+
+			((recorder_state_changed_cb)cb_info->user_cb[event])((recorder_state_e)previous,
+			                                                     (recorder_state_e)current,
+			                                                     (bool)by_policy,
+			                                                     cb_info->user_data[event]);
 			break;
 		}
 		case MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED:
 		{
-			int cb_type;
-			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]);
+			int type = 0;
+
+			muse_recorder_msg_get(type, recvMsg);
+
+			((recorder_recording_limit_reached_cb)cb_info->user_cb[event])((recorder_recording_limit_type_e)type,
+			                                                               cb_info->user_data[event]);
 			break;
 		}
 		case MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS:
 		{
-			double cb_elapsed_time;
-			double cb_file_size;
+			int64_t cb_elapsed_time = 0;
+			int64_t cb_file_size = 0;
+
 			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]);
+			                                                        (unsigned long long)cb_file_size,
+			                                                        cb_info->user_data[event]);
 			break;
 		}
 		case MUSE_RECORDER_EVENT_TYPE_INTERRUPTED:
 		{
-			int cb_policy, cb_previous, cb_current;
-			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]);
+			int policy = 0;
+			int previous = 0;
+			int current = 0;
+
+			muse_recorder_msg_get(policy, recvMsg);
+			muse_recorder_msg_get(previous, recvMsg);
+			muse_recorder_msg_get(current, recvMsg);
+
+			((recorder_interrupted_cb)cb_info->user_cb[event])((recorder_policy_e)policy,
+			                                                   (recorder_state_e)previous,
+			                                                   (recorder_state_e)current,
+			                                                   cb_info->user_data[event]);
 			break;
 		}
 		case MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM:
 		{
-			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;
-			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(muse_recorder_ipc_init_tbm(&transport_info) == FALSE) {
-					LOGE("Initialize TBM ERROR!!");
-					break;
-				}
+			int tbm_key = 0;
+			int size = 0;
+			int format = 0;
+			int channel = 0;
+			int timestamp = 0;
+			tbm_bo bo = NULL;
+			tbm_bo_handle bo_handle = {.ptr = NULL};
+
+			muse_recorder_msg_get(tbm_key, recvMsg);
+			if (tbm_key == 0) {
+				LOGE("invalid key");
+				break;
+			}
 
-				if(muse_recorder_ipc_import_tbm(&transport_info) == FALSE) {
-					LOGE("Import TBM Key ERROR!!");
-					break;
-				} else {
-					muse_recorder_msg_get(cb_size, recvMsg);
-					if (cb_size > 0) {
-						stream = (unsigned char *)transport_info.bo_handle.ptr;
-					}
-				}
-			} else {
-				LOGE("Get KEY INFO sock msg ERROR!!");
+			if (!_recorder_import_tbm_key(cb_info->bufmgr, tbm_key, &bo, &bo_handle)) {
+				LOGE("tbm key %d import failed", tbm_key);
 				break;
 			}
-			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,
-													cb_channel,
-													(unsigned int)cb_timestamp,
-													cb_info->user_data[event]);
-			//unref tbm after hand over the buffer.
-			muse_recorder_ipc_unref_tbm(&transport_info);
+
+			muse_recorder_msg_get(size, recvMsg);
+			muse_recorder_msg_get(format, recvMsg);
+			muse_recorder_msg_get(channel, recvMsg);
+			muse_recorder_msg_get(timestamp, recvMsg);
+
+			((recorder_audio_stream_cb)cb_info->user_cb[event])((void *)bo_handle.ptr,
+			                                                    size,
+			                                                    (audio_sample_type_e)format,
+			                                                    channel,
+			                                                    (unsigned int)timestamp,
+			                                                    cb_info->user_data[event]);
+
+			/* release imported bo */
+			_recorder_release_imported_bo(&bo);
+
+			/* return buffer */
+			muse_recorder_msg_send1_no_return(MUSE_RECORDER_API_RETURN_BUFFER,
+			                                  cb_info->fd, cb_info,
+			                                  INT, tbm_key);
 			break;
 		}
 		case MUSE_RECORDER_EVENT_TYPE_ERROR:
 		{
-			int cb_error, cb_current_state;
-			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]);
+			int error = 0;
+			int current_state = 0;
+
+			muse_recorder_msg_get(error, recvMsg);
+			muse_recorder_msg_get(current_state, recvMsg);
+
+			((recorder_error_cb)cb_info->user_cb[event])((recorder_error_e)error,
+			                                             (recorder_state_e)current_state,
+			                                             cb_info->user_data[event]);
 			break;
 		}
 		case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER:
 		{
-			int cb_codec;
-			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]);
+			int codec = 0;
+
+			muse_recorder_msg_get(codec, recvMsg);
+
+			((recorder_supported_audio_encoder_cb)cb_info->user_cb[event])((recorder_audio_codec_e)codec,
+			                                                               cb_info->user_data[event]);
 			break;
 		}
 		case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT:
 		{
-			int cb_format;
-			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]);
+			int format = 0;
+
+			muse_recorder_msg_get(format, recvMsg);
+
+			((recorder_supported_file_format_cb)cb_info->user_cb[event])((recorder_file_format_e)format,
+			                                                             cb_info->user_data[event]);
 			break;
 		}
 		case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER:
 		{
-			int cb_codec;
-			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]);
+			int codec = 0;
+
+			muse_recorder_msg_get(codec, recvMsg);
+
+			((recorder_supported_video_encoder_cb)cb_info->user_cb[event])((recorder_video_codec_e)codec,
+			                                                               cb_info->user_data[event]);
 			break;
 		}
 		case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION:
 		{
-			int width;
-			int height;
+			int width = 0;
+			int height = 0;
+
 			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]);
+
+			((recorder_supported_video_resolution_cb)cb_info->user_cb[event])(width, height,
+			                                                                  cb_info->user_data[event]);
 			break;
 		}
 
@@ -184,61 +249,109 @@ static void _client_user_callback(callback_cb_info_s * cb_info, muse_recorder_ev
 
 static void *_client_cb_handler(gpointer data)
 {
-	int ret;
-	int api;
+	int ret = 0;
+	int api = 0;
 	int num_token = 0;
 	int i = 0;
 	int str_pos = 0;
 	int prev_pos = 0;
 	callback_cb_info_s *cb_info = data;
-	char *recvMsg = cb_info->recvMsg;
-	char parseStr[RECORDER_PARSE_STRING_SIZE][MUSE_RECORDER_MSG_MAX_LENGTH] = {{0,0},};
+	char *recvMsg = NULL;
+	char **parseStr = NULL;
+
+	if (cb_info == NULL) {
+		LOGE("cb_info NULL");
+		return NULL;
+	}
+
+	parseStr = (char **)malloc(sizeof(char *) * RECORDER_PARSE_STRING_SIZE);
+	if (parseStr == NULL) {
+		LOGE("parseStr malloc failed");
+		return NULL;
+	}
+
+	for (i = 0 ; i < RECORDER_PARSE_STRING_SIZE ; i++) {
+		parseStr[i] = (char *)malloc(sizeof(char) * MUSE_RECORDER_MSG_MAX_LENGTH);
+		if (parseStr[i] == NULL) {
+			LOGE("parseStr[%d] malloc failed", i);
+			goto CB_HANDLER_EXIT;
+		}
+	}
+
+	recvMsg = cb_info->recvMsg;
 
 	while (g_atomic_int_get(&cb_info->running)) {
 		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, RECORDER_PARSE_STRING_SIZE * MUSE_RECORDER_MSG_MAX_LENGTH);
+
 		LOGD("recvMSg : %s, length : %d", recvMsg, ret);
 
 		/* Need to split the combined entering msgs.
 		    This module supports up to 5 combined msgs. */
 		for (str_pos = 0; str_pos < ret; str_pos++) {
 			if(recvMsg[str_pos] == '}') {
+				memset(parseStr[num_token], 0x0, sizeof(char) * MUSE_RECORDER_MSG_MAX_LENGTH);
 				strncpy(&(parseStr[num_token][0]), recvMsg + prev_pos, str_pos - prev_pos + 1);
 				LOGD("splitted msg : %s, Index : %d", &(parseStr[num_token][0]), num_token);
 				prev_pos = str_pos+1;
 				num_token++;
 			}
 		}
+
 		LOGD("num_token : %d", num_token);
-		/* Re-construct to the useful single msg. */
-		for (i = 0; i < num_token; i++) {
 
-			if (i >= RECORDER_PARSE_STRING_SIZE)
+		/* Re-construct to the useful single msg. */
+		for (i = 0 ; i < num_token ; i++) {
+			if (i >= RECORDER_PARSE_STRING_SIZE) {
+				LOGE("invalid index %d", i);
 				break;
+			}
+
 			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. */
 					memset(cb_info->recvApiMsg, 0, strlen(cb_info->recvApiMsg));
 					strcpy(cb_info->recvApiMsg, &(parseStr[i][0]));
+
 					LOGD("cb_info->recvApiMsg : %s", cb_info->recvApiMsg);
+
 					cb_info->activating[api] = 1;
+
+					if (api == MUSE_RECORDER_API_CREATE) {
+						if (muse_recorder_msg_get(ret, cb_info->recvApiMsg)) {
+							if (ret != RECORDER_ERROR_NONE) {
+								g_atomic_int_set(&cb_info->running, 0);
+								LOGE("recorder create error 0x%x. close client cb handler", ret);
+							}
+						} else {
+							LOGE("failed to get api return");
+						}
+					} else if (api == MUSE_RECORDER_API_DESTROY) {
+						if (muse_recorder_msg_get(ret, cb_info->recvApiMsg)) {
+							if (ret == RECORDER_ERROR_NONE) {
+								g_atomic_int_set(&cb_info->running, 0);
+								LOGD("recorder destroy done. close client cb handler");
+							}
+						} else {
+							LOGE("failed to get api return");
+						}
+					}
+
 					g_cond_signal(&(cb_info->pCond[api]));
 					g_mutex_unlock(&(cb_info->pMutex[api]));
-					if(api == MUSE_RECORDER_API_DESTROY) {
-						g_atomic_int_set(&cb_info->running, 0);
-						LOGD("close client cb handler");
-					}
+				} else if (api == MUSE_RECORDER_CB_EVENT) {
+					int event = -1;
 
-				} else if(api == MUSE_RECORDER_CB_EVENT) {
-					int event;
 					if (muse_recorder_msg_get(event, &(parseStr[i][0]))) {
 						LOGD("go callback : %d", event);
 						_client_user_callback(cb_info, event);
@@ -249,34 +362,90 @@ static void *_client_cb_handler(gpointer data)
 			}
 		}
 	}
+
 	LOGD("client cb exit");
 
+CB_HANDLER_EXIT:
+	if (parseStr) {
+		for (i = 0 ; i < RECORDER_PARSE_STRING_SIZE ; i++) {
+			if (parseStr[i]) {
+				free(parseStr[i]);
+				parseStr[i] = NULL;
+			}
+		}
+
+		free(parseStr);
+		parseStr = NULL;
+	}
+
 	return NULL;
 }
 
 static callback_cb_info_s *_client_callback_new(gint sockfd)
 {
-	callback_cb_info_s *cb_info;
-	GCond *recorder_cond;
-	GMutex *recorder_mutex;
-	gint *recorder_activ;
+	callback_cb_info_s *cb_info = NULL;
+	GCond *recorder_cond = NULL;
+	GMutex *recorder_mutex = NULL;
+	gint *recorder_activ = NULL;
 	g_return_val_if_fail(sockfd > 0, NULL);
 
 	cb_info = g_new0(callback_cb_info_s, 1);
+	if (cb_info == NULL) {
+		LOGE("cb_info_s alloc failed");
+		goto _ERR_RECORDER_EXIT;
+	}
+
 	recorder_cond = g_new0(GCond, MUSE_RECORDER_API_MAX);
+	if (recorder_cond == NULL) {
+		LOGE("recorder_cond alloc failed");
+		goto _ERR_RECORDER_EXIT;
+	}
 	recorder_mutex = g_new0(GMutex, MUSE_RECORDER_API_MAX);
+	if (recorder_mutex == NULL) {
+		LOGE("recorder_mutex alloc failed");
+		goto _ERR_RECORDER_EXIT;
+	}
 	recorder_activ = g_new0(gint, MUSE_RECORDER_API_MAX);
+	if (recorder_activ == NULL) {
+		LOGE("recorder_activ alloc failed");
+		goto _ERR_RECORDER_EXIT;
+	}
 
 	g_atomic_int_set(&cb_info->running, 1);
 	cb_info->fd = sockfd;
 	cb_info->pCond = recorder_cond;
 	cb_info->pMutex = recorder_mutex;
 	cb_info->activating = recorder_activ;
-	cb_info->thread =
-		g_thread_new("callback_thread", _client_cb_handler,
-			     (gpointer) cb_info);
+	cb_info->thread = g_thread_try_new("callback_thread",
+	                                   _client_cb_handler,
+	                                   (gpointer)cb_info,
+	                                   NULL);
+	if (cb_info->thread == NULL) {
+		LOGE("thread create failed");
+		goto _ERR_RECORDER_EXIT;
+	}
 
 	return cb_info;
+
+_ERR_RECORDER_EXIT:
+	if (cb_info) {
+		g_free(cb_info);
+		cb_info = NULL;
+	}
+	if (recorder_cond) {
+		g_free(recorder_cond);
+		recorder_cond = NULL;
+	}
+	if (recorder_mutex) {
+		g_free(recorder_mutex);
+		recorder_mutex = NULL;
+	}
+	if (recorder_activ) {
+		g_free(recorder_activ);
+		recorder_activ = NULL;
+	}
+
+	return NULL;
 }
 
 static int client_wait_for_cb_return(muse_recorder_api_e api, callback_cb_info_s *cb_info, int time_out)
@@ -317,193 +486,173 @@ static void _client_callback_destroy(callback_cb_info_s * cb_info)
 {
 	g_return_if_fail(cb_info != NULL);
 
-	LOGI("%p Callback destroyed", cb_info->thread);
+	LOGD("destroy thread %p", cb_info->thread);
+
 	g_thread_join(cb_info->thread);
 	g_thread_unref(cb_info->thread);
 
-
 	if (cb_info->pCond) {
 		g_free(cb_info->pCond);
+		cb_info->pCond = NULL;
 	}
 	if (cb_info->pMutex) {
 		g_free(cb_info->pMutex);
+		cb_info->pMutex = NULL;
 	}
+
 	g_free(cb_info);
+	cb_info = NULL;
+
+	return;
 }
 
-int recorder_create_videorecorder(camera_h camera, recorder_h *recorder)
+static int _recorder_create_common(recorder_h *recorder, muse_recorder_type_e type, camera_h camera)
 {
-	if (camera == NULL) {
-		LOGE("NULL pointer camera handle");
+	int ret = RECORDER_ERROR_NONE;
+	int destroy_ret = RECORDER_ERROR_NONE;
+	int sock_fd = -1;
+	char *send_msg = NULL;
+	char *root_directory = NULL;
+	intptr_t camera_handle = 0;
+	intptr_t handle = 0;
+	tbm_bufmgr bufmgr = NULL;
+	recorder_cli_s *pc = NULL;
+
+	LOGD("Enter - type %d", type);
+
+	if (recorder == NULL) {
+		LOGE("NULL pointer for recorder handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (recorder == NULL) {
-		LOGE("NULL pointer recorder handle");
+
+	if (type == MUSE_RECORDER_TYPE_VIDEO && camera == NULL) {
+		LOGE("NULL pointer for camera handle on video recorder mode");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
 
-	int sock_fd = -1;
-	char *sndMsg;
-	int ret = RECORDER_ERROR_NONE;
-	camera_cli_s *camera_pc = (camera_cli_s *)camera;
-	recorder_cli_s *pc;
-	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 = MUSE_RECORDER_TYPE_VIDEO;
+	bufmgr = tbm_bufmgr_init(-1);
+	if (bufmgr == NULL) {
+		LOGE("get tbm bufmgr failed");
+		return RECORDER_ERROR_INVALID_OPERATION;
+	}
 
 	pc = g_new0(recorder_cli_s, 1);
 	if (pc == NULL) {
-		return 0;
+		ret = RECORDER_ERROR_OUT_OF_MEMORY;
+		goto _ERR_RECORDER_EXIT;
 	}
 
-	LOGD("remote handle : 0x%x", camera_handle);
 	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);
-	muse_core_msg_json_factory_free(sndMsg);
+	if (sock_fd < 0) {
+		LOGE("muse_core_client_new failed - returned fd %d", sock_fd);
+		ret = RECORDER_ERROR_INVALID_OPERATION;
+		goto _ERR_RECORDER_EXIT;
+	}
+
+	if (type == MUSE_RECORDER_TYPE_AUDIO) {
+		send_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_API_CREATE,
+		                                          MUSE_TYPE_INT, "module", MUSE_RECORDER,
+		                                          MUSE_TYPE_INT, PARAM_RECORDER_TYPE, MUSE_RECORDER_TYPE_AUDIO,
+		                                          MUSE_TYPE_INT, "pid", getpid(),
+		                                          0);
+	} else {
+		camera_handle = (intptr_t)((camera_cli_s *)camera)->remote_handle;
+		send_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_API_CREATE,
+		                                          MUSE_TYPE_INT, "module", MUSE_RECORDER,
+		                                          MUSE_TYPE_INT, PARAM_RECORDER_TYPE, MUSE_RECORDER_TYPE_VIDEO,
+		                                          MUSE_TYPE_POINTER, "camera_handle", camera_handle,
+		                                          0);
+	}
+
+	LOGD("sock_fd : %d, msg : %s", sock_fd, send_msg);
+
+	muse_core_ipc_send_msg(sock_fd, send_msg);
+	muse_core_msg_json_factory_free(send_msg);
 
 	pc->cb_info = _client_callback_new(sock_fd);
-	LOGD("cb info : %d", pc->cb_info->fd);
+	if (pc->cb_info == NULL) {
+		ret = RECORDER_ERROR_OUT_OF_MEMORY;
+		goto _ERR_RECORDER_EXIT;
+	}
 
-	ret = client_wait_for_cb_return(api, pc->cb_info, CALLBACK_TIME_OUT);
+	ret = client_wait_for_cb_return(MUSE_RECORDER_API_CREATE, pc->cb_info, CALLBACK_TIME_OUT);
 	if (ret == RECORDER_ERROR_NONE) {
-		char *root_directory = NULL;
-
 		muse_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg);
 		if (handle == 0) {
 			LOGE("Receiving Handle Failed!!");
-			goto ErrorExit;
-		} else {
-			pc->remote_handle = handle;
+			goto _ERR_RECORDER_EXIT;
 		}
 
-		if (mm_camcorder_client_get_root_directory(&root_directory) == MM_ERROR_NONE &&
-		    root_directory != NULL) {
-			LOGD("set root directory %s", root_directory);
-
-			muse_recorder_msg_send1(MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY, sock_fd, pc->cb_info, ret, STRING, root_directory);
-			if (ret != RECORDER_ERROR_NONE) {
-				LOGE("failed to set root directory %s", root_directory);
-			}
+		if (mm_camcorder_client_get_root_directory(&root_directory) != MM_ERROR_NONE ||
+		    root_directory == NULL) {
+			LOGE("failed to get root directory of internal storage");
+			ret = RECORDER_ERROR_INVALID_OPERATION;
+			goto _ERR_RECORDER_AFTER_CREATE;
 		}
 
-		if (root_directory) {
-			free(root_directory);
-			root_directory = NULL;
+		LOGD("set root directory [%s]", root_directory);
+
+		muse_recorder_msg_send1(MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY,
+		                        sock_fd, pc->cb_info, ret, STRING, root_directory);
+		if (ret != RECORDER_ERROR_NONE) {
+			LOGE("failed to set root directory %s", root_directory);
+			ret = RECORDER_ERROR_INVALID_OPERATION;
+			goto _ERR_RECORDER_AFTER_CREATE;
 		}
 
-		LOGD("recorder create 0x%x", pc->remote_handle);
+		free(root_directory);
+		root_directory = NULL;
+
+		pc->remote_handle = handle;
+		pc->cb_info->bufmgr = bufmgr;
+
+		LOGD("recorder[type %d] %p create success : remote handle 0x%x",
+		     type, pc, pc->remote_handle);
 
 		*recorder = (recorder_h) pc;
 	} else {
-		goto ErrorExit;
+		goto _ERR_RECORDER_EXIT;
 	}
 
 	LOGD("done");
 
 	return RECORDER_ERROR_NONE;
 
-ErrorExit:
-	g_free(pc);
-	LOGD("ErrorExit!!! ret value : %d", ret);
-	return ret;
-}
-
-
-int recorder_create_audiorecorder(recorder_h *recorder)
-{
-	int sock_fd = -1;
-	int pid = 0;
-	char *sndMsg;
-	int ret = RECORDER_ERROR_NONE;
-	recorder_cli_s *pc = NULL;
-	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;
-
-	LOGW("Enter");
-
-	if (recorder == NULL) {
-		LOGE("NULL pointer handle");
-		return RECORDER_ERROR_INVALID_PARAMETER;
-	}
-
-	sock_fd = muse_core_client_new();
-	if (sock_fd < 0) {
-		LOGE("muse_core_client_new failed - returned fd %d", sock_fd);
-		return RECORDER_ERROR_INVALID_OPERATION;
-	}
-
-	pid = getpid();
-	sndMsg = muse_core_msg_json_factory_new(api,
-	                                        MUSE_TYPE_INT, "module", muse_module,
-	                                        MUSE_TYPE_INT, PARAM_RECORDER_TYPE, recorder_type,
-	                                        MUSE_TYPE_INT, "pid", pid,
-	                                        0);
-
-	LOGD("sock_fd : %d, msg : %s", sock_fd, sndMsg);
+_ERR_RECORDER_AFTER_CREATE:
+	muse_recorder_msg_send(MUSE_RECORDER_API_DESTROY, sock_fd, pc->cb_info, destroy_ret);
+	LOGE("destroy return 0x%x", destroy_ret);
 
-	muse_core_ipc_send_msg(sock_fd, sndMsg);
-	muse_core_msg_json_factory_free(sndMsg);
+_ERR_RECORDER_EXIT:
+	tbm_bufmgr_deinit(bufmgr);
+	bufmgr = NULL;
 
-	pc = g_new0(recorder_cli_s, 1);
-	if (pc == NULL) {
-		return 0;
+	if (root_directory) {
+		free(root_directory);
+		root_directory = NULL;
 	}
 
-	pc->cb_info = _client_callback_new(sock_fd);
-	ret = client_wait_for_cb_return(api, pc->cb_info, CALLBACK_TIME_OUT);
-	if (ret == RECORDER_ERROR_NONE) {
-		char *root_directory = NULL;
-		intptr_t handle = 0;
-
-		muse_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg);
-		if (handle == 0) {
-			LOGE("Receiving Handle Failed!!");
-			goto ErrorExit;
-		} else {
-			pc->remote_handle = handle;
-		}
-
-		if (mm_camcorder_client_get_root_directory(&root_directory) == MM_ERROR_NONE &&
-		    root_directory != NULL) {
-			LOGD("set root directory %s", root_directory);
-
-			muse_recorder_msg_send1(MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY, sock_fd, pc->cb_info, ret, STRING, root_directory);
-			if (ret != RECORDER_ERROR_NONE) {
-				LOGE("failed to set root directory %s", root_directory);
-			}
-		}
-
-		if (root_directory) {
-			free(root_directory);
-			root_directory = NULL;
+	if (pc) {
+		if (pc->cb_info) {
+			_client_callback_destroy(pc->cb_info);
+			pc->cb_info = NULL;
 		}
-
-		LOGD("recorder create 0x%x", pc->remote_handle);
-
-		*recorder = (recorder_h)pc;
-	} else {
-		goto ErrorExit;
+		g_free(pc);
+		pc = NULL;
 	}
 
-	LOGD("done");
-
-	return RECORDER_ERROR_NONE;
-
-ErrorExit:
-	g_free(pc);
-	LOGD("ret value : %d", ret);
 	return ret;
 }
 
+int recorder_create_videorecorder(camera_h camera, recorder_h *recorder)
+{
+	return _recorder_create_common(recorder, MUSE_RECORDER_TYPE_VIDEO, camera);
+}
+
+
+int recorder_create_audiorecorder(recorder_h *recorder)
+{
+	return _recorder_create_common(recorder, MUSE_RECORDER_TYPE_AUDIO, NULL);
+}
 
 int recorder_get_state(recorder_h recorder, recorder_state_e *state)
 {
@@ -529,13 +678,16 @@ int recorder_get_state(recorder_h recorder, recorder_state_e *state)
 	int get_state;
 
 	LOGD("Enter, remote_handle : %x", pc->remote_handle);
+
 	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 
 	if (ret == RECORDER_ERROR_NONE) {
 		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);
+
 	return ret;
 }
 
@@ -836,7 +988,7 @@ int recorder_get_audio_level(recorder_h recorder, double *level)
 
 	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 	if (ret == RECORDER_ERROR_NONE) {
-		muse_recorder_msg_get(get_level, pc->cb_info->recvMsg);
+		muse_recorder_msg_get_double(get_level, pc->cb_info->recvMsg);
 		*level = get_level;
 	}
 	LOGD("ret : 0x%x", ret);
@@ -1949,14 +2101,16 @@ int recorder_attr_set_recording_motion_rate(recorder_h recorder, double rate)
 	}
 	sock_fd = pc->cb_info->fd;
 
-	LOGD("ENTER");
+	LOGD("ENTER - %.20lf", rate);
 
 	muse_recorder_msg_send1(api,
 							sock_fd,
 							pc->cb_info,
 							ret,
 							DOUBLE, rate);
+
 	LOGD("ret : 0x%x", ret);
+
 	return ret;
 }
 
@@ -1986,10 +2140,10 @@ int recorder_attr_get_recording_motion_rate(recorder_h recorder, double *rate)
 
 	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 	if (ret == RECORDER_ERROR_NONE) {
-		muse_recorder_msg_get(get_rate, pc->cb_info->recvMsg);
+		muse_recorder_msg_get_double(get_rate, pc->cb_info->recvMsg);
 		*rate = get_rate;
 	}
-	LOGD("ret : 0x%x", ret);
+	LOGD("ret : 0x%x - rate %.20lf", ret, *rate);
 	return ret;
 }
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index c6dc36d..788d88a 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,16 +1,17 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 SET(fw_test "${fw_name}-test")
 
+#INCLUDE_DIRECTORIES(../include)
+#link_directories(${CMAKE_SOURCE_DIR}/../)
+
 INCLUDE(FindPkgConfig)
-pkg_check_modules(${fw_test} REQUIRED mm-camcorder elementary evas capi-media-camera)
+pkg_check_modules(${fw_test} REQUIRED mm-camcorder elementary evas)
 FOREACH(flag ${${fw_test}_CFLAGS})
     SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
     MESSAGE(${flag})
 ENDFOREACH()
 
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Wall")
-
-#ADD_EXECUTABLE("system-sensor" system-sensor.c)
-#TARGET_LINK_LIBRARIES("system-sensor" ${fw_name} ${${fw_test}_LDFLAGS})
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -pie -Wall")
 
 aux_source_directory(. sources)
 FOREACH(src ${sources})
@@ -18,4 +19,6 @@ FOREACH(src ${sources})
     MESSAGE("${src_name}")
     ADD_EXECUTABLE(${src_name} ${src})
     TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS})
+    INSTALL(TARGETS ${src_name} DESTINATION bin)
+
 ENDFOREACH()
diff --git a/test/multimedia_recorder_test.c b/test/multimedia_recorder_test.c
index 7ac9c40..65cb737 100755
--- a/test/multimedia_recorder_test.c
+++ b/test/multimedia_recorder_test.c
@@ -1,5 +1,9 @@
 /*
-* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+* recorder_testsuite
+*
+* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+*
+* Contact: Jeongmo Yang <jm80.yang@samsung.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -11,1210 +15,1662 @@
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
-* limitations under the License. 
+* limitations under the License.
+*
 */
 
-
-
-
+/*=======================================================================================
+|  INCLUDE FILES                                                                        |
+=======================================================================================*/
 #include <stdio.h>
-#include <Elementary.h>
+#include <stdlib.h>
 #include <glib.h>
+#include <gst/gst.h>
+#include <sys/time.h>
+#include <camera.h>
+#include <recorder.h>
+#include <dlog.h>
 #include <Ecore.h>
-#include <Ecore_X.h>
 #include <Elementary.h>
-#include <pthread.h>
-#include <recorder.h>
-#include <camera.h>
-#include <mm.h>
-#include <mm_camcorder.h>
-#include <mm_types.h>
-
-Evas_Object* mEvasWindow;
-Ecore_X_Window mXwindow;	
-Ecore_X_Window preview_win;
-
-bool record_state_cb(recorder_state_e previous , recorder_state_e current , int by_asm, void *user_data){
-	char * state_table[] = {
-		"MEDIARECORDER_STATE_NONE",				/**< recorder is not created yet */
-		"MEDIARECORDER_STATE_CREATED",				/**< recorder is created, but not initialized yet */
-		"MEDIARECORDER_STATE_READY",			/**< prepare to record if video recorder is playing preview */
-		"MEDIARECORDER_STATE_RECORDING",	/**< While recording */
-		"MEDIARECORDER_STATE_PAUSED",			/**< Pause recording */
-		"MEDIARECORDER_STATE_NUM"				/**< Number of recorder states */
-		};
-	printf("%s\n", state_table[current]);
-	return 0;
-}
 
-int recording_size_limit_test(recorder_h recorder){
-	int ret;
-	int fail=0;
-	int int_value;
-	// negative test
-	printf("-------------limit size test----------------------\n");
-	printf("-negative test\n");
-	ret = recorder_attr_set_size_limit(recorder, -1);
-	if( ret == 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-	printf("-0 test\n");
-	ret = recorder_attr_set_size_limit(recorder, 0);
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_size_limit(recorder,&int_value);
-	if( int_value != 0){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-
-	printf("-1212 set test\n");
-	ret = recorder_attr_set_size_limit(recorder, 1212);
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_size_limit(recorder,&int_value);
-	if( int_value != 1212){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	return -fail;	
-}
+/*-----------------------------------------------------------------------
+|    GLOBAL VARIABLE DEFINITIONS:                                       |
+-----------------------------------------------------------------------*/
+#define EXPORT_API __attribute__((__visibility__("default")))
 
-int recording_time_limit_test(recorder_h recorder){
-	int ret;
-	int fail=0;
-	int int_value;
-	// negative test
-	printf("-------------limit time test----------------------\n");
-	
-	ret = recorder_attr_set_time_limit(recorder, -1);
-	if( ret == 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-	printf("-0 test\n");
-	ret = recorder_attr_set_time_limit(recorder, 0);
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_time_limit(recorder,&int_value);
-	if( int_value != 0){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-
-	printf("-1212 set test\n");
-	ret = recorder_attr_set_time_limit(recorder, 1212);
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_time_limit(recorder,&int_value);
-	if( int_value != 1212){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-
-	return -fail;	
-}
+#define PACKAGE "recorder_testsuite"
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "RECORDER_TESTSUITE"
 
-int fileformat_test_fail = 0;
-bool _file_format_test_cb(recorder_file_format_e format, void *user_data){
-	int ret;
-	recorder_h recorder = (recorder_h)user_data;
-	recorder_file_format_e get_format;
-	ret = recorder_set_file_format(recorder, format);
-	recorder_get_file_format(recorder, &get_format);
-
-	if( get_format != format){
-		printf("FAIL\n");
-		fileformat_test_fail++;
-	}else
-		printf("PASS\n");
-	return true;
-}
+GMainLoop *g_loop;
+GIOChannel *stdin_channel;
+int resolution_set;
+int g_current_state;
+int src_w, src_h;
+GstCaps *filtercaps;
+bool isMultishot;
+int  cam_info;
+int recorder_state;
+int multishot_num;
+static GTimer *timer = NULL;
+void *display;
 
+/*-----------------------------------------------------------------------
+|    GLOBAL CONSTANT DEFINITIONS:                                       |
+-----------------------------------------------------------------------*/
 
-int fileformat_test(recorder_h recorder){
-	fileformat_test_fail = 0;
-	printf("----------------file format test ------------------\n");
-	recorder_foreach_supported_file_format(recorder, _file_format_test_cb, recorder);
-	return -fileformat_test_fail;
-}
 
-int videoencoder_test_fail = 0;
-bool _video_encoder_test_cb(recorder_video_codec_e codec, void *user_data){
-	int ret;
-	recorder_h recorder = (recorder_h)user_data;
-	recorder_video_codec_e get_codec;
-	ret = recorder_set_video_encoder(recorder, codec);
-	recorder_get_video_encoder(recorder, &get_codec);
-	
-
-	if( get_codec != codec){
-		printf("FAIL\n");
-		videoencoder_test_fail++;
-	}else
-		printf("PASS\n");
-	return true;
-}
+/*-----------------------------------------------------------------------
+|    IMPORTED VARIABLE DECLARATIONS:                                    |
+-----------------------------------------------------------------------*/
 
 
-int video_encoder_test(recorder_h recorder){
-	videoencoder_test_fail = 0;
-	printf("----------------video encoder test ------------------\n");
-	recorder_foreach_supported_video_encoder(recorder, _video_encoder_test_cb, recorder);
-	return -videoencoder_test_fail;
-}
+/*-----------------------------------------------------------------------
+|    IMPORTED FUNCTION DECLARATIONS:                                    |
+-----------------------------------------------------------------------*/
 
-int audioencoder_test_fail = 0;
-bool _audio_encoder_test_cb(recorder_audio_codec_e codec, void *user_data){
-	int ret;
-	recorder_h recorder = (recorder_h)user_data;
-	recorder_audio_codec_e get_codec;
-	ret = recorder_set_audio_encoder(recorder, codec);
-	recorder_get_audio_encoder(recorder, &get_codec);
-	
-
-	if( get_codec != codec){
-		printf("FAIL\n");
-		audioencoder_test_fail++;
-	}else
-		printf("PASS\n");
-	return true;
-}
 
+/*-----------------------------------------------------------------------
+|    LOCAL #defines:                                                    |
+-----------------------------------------------------------------------*/
 
-int audio_encoder_test(recorder_h recorder){
-	audioencoder_test_fail = 0;
-	printf("----------------audio encoder test ------------------\n");
-	recorder_foreach_supported_audio_encoder(recorder, _audio_encoder_test_cb, recorder);
-	return -audioencoder_test_fail;
-}
- 
-int recording_audio_device_test(recorder_h recorder)
-{
-	int ret;
-	int fail=0;
-	recorder_audio_device_e  int_value;
-	// negative test
-	printf("-------------audio device test----------------------\n");
-	printf("-negative test\n");
-	ret = recorder_attr_set_audio_device (recorder, -1);
-	if( ret == 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-	printf("-RECORDER_AUDIO_DEVICE_MIC test\n");
-	ret = recorder_attr_set_audio_device(recorder, RECORDER_AUDIO_DEVICE_MIC);
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_audio_device(recorder,&int_value);
-	if( int_value != RECORDER_AUDIO_DEVICE_MIC){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-
-	printf("-RECORDER_AUDIO_DEVICE_MODEM  set test\n");
-	ret = recorder_attr_set_audio_device(recorder, RECORDER_AUDIO_DEVICE_MODEM );
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_audio_device(recorder,&int_value);
-	if( int_value != RECORDER_AUDIO_DEVICE_MODEM){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	return -fail;	
-}
 
-int recording_samplerate_test(recorder_h recorder){
-	int ret;
-	int fail=0;
-	int int_value;
-	// negative test
-	printf("-------------samplerate test----------------------\n");
-	
-	ret = recorder_attr_set_audio_samplerate(recorder, -1);
-	if( ret == 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-	printf("-44100 test\n");
-	ret = recorder_attr_set_audio_samplerate(recorder, 44100);
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_audio_samplerate(recorder,&int_value);
-	if( int_value != 44100){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-
-	printf("-1212 set test\n");
-	ret = recorder_attr_set_audio_samplerate(recorder, 1212);
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_audio_samplerate(recorder,&int_value);
-	if( int_value != 1212){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-
-	return -fail;	
-}
+#define DISPLAY_W_320                       320                 //for direct FB
+#define DISPLAY_H_240                       240                     //for direct FB
 
 
-int recording_audio_encoder_bitrate_test(recorder_h recorder){
-	int ret;
-	int fail=0;
-	int int_value;
-	// negative test
-	printf("-------------audio encoder bitrate test----------------------\n");
-	printf("-negative test\n");
-	ret = recorder_attr_set_audio_encoder_bitrate (recorder, -2);
-	if( ret == 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-	printf("-12200 test\n");
-	ret = recorder_attr_set_audio_encoder_bitrate (recorder, 12200);
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_audio_encoder_bitrate (recorder,&int_value);
-	if( int_value != 12200){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-
-	printf("-288000  set test\n");
-	ret = recorder_attr_set_audio_encoder_bitrate (recorder, 288000 );
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_audio_encoder_bitrate (recorder,&int_value);
-	if( int_value != 288000 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-	printf("-1212  set test\n");
-	ret = recorder_attr_set_audio_encoder_bitrate (recorder, 1212 );
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_audio_encoder_bitrate (recorder,&int_value);
-	if( int_value != 1212 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-	return -fail;	
-}
+#define SRC_VIDEO_FRAME_RATE_15         15    // video input frame rate
+#define SRC_VIDEO_FRAME_RATE_30         30    // video input frame rate
+#define IMAGE_ENC_QUALITY               85    // quality of jpeg
 
-int recording_video_encoder_bitrate_test(recorder_h recorder){
-	int ret;
-	int fail=0;
-	int int_value;
-	// negative test
-	printf("-------------video encoder bitrate test----------------------\n");
-	printf("-negative test\n");
-	ret = recorder_attr_set_video_encoder_bitrate (recorder, -2);
-	if( ret == 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-	printf("-12200 test\n");
-	ret = recorder_attr_set_video_encoder_bitrate (recorder, 12200);
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_video_encoder_bitrate (recorder,&int_value);
-	if( int_value != 12200){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-
-	printf("-288000  set test\n");
-	ret = recorder_attr_set_video_encoder_bitrate (recorder, 288000 );
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_video_encoder_bitrate (recorder,&int_value);
-	if( int_value != 288000 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-	printf("-1212  set test\n");
-	ret = recorder_attr_set_video_encoder_bitrate (recorder, 1212 );
-	if( ret != 0 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-	
-	ret = recorder_attr_get_video_encoder_bitrate (recorder,&int_value);
-	if( int_value != 1212 ){
-		printf("FAIL\n");
-		fail++;
-	}else
-		printf("PASS\n");
-
-	return -fail;	
-}
+#define MAX_FILE_SIZE_FOR_MMS           (250 * 1024)
 
+#define EXT_JPEG                        "jpg"
+#define EXT_MP4                         "mp4"
+#define EXT_3GP                         "3gp"
+#define EXT_AMR                         "amr"
+#define EXT_MKV                         "mkv"
+
+#define TARGET_FILENAME_PATH            "/opt/usr/media/"
+#define IMAGE_CAPTURE_EXIF_PATH         TARGET_FILENAME_PATH"exif.raw"
+#define TARGET_FILENAME_VIDEO           TARGET_FILENAME_PATH"test_rec_video.mp4"
+#define TARGET_FILENAME_AUDIO           TARGET_FILENAME_PATH"test_rec_audio.m4a"
+#define CAPTURE_FILENAME_LEN            256
+
+#define AUDIO_SOURCE_SAMPLERATE_AAC     44100
+#define AUDIO_SOURCE_SAMPLERATE_AMR     8000
+#define AUDIO_SOURCE_FORMAT             MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE
+#define AUDIO_SOURCE_CHANNEL_AAC        2
+#define AUDIO_SOURCE_CHANNEL_AMR        1
+#define VIDEO_ENCODE_BITRATE            40000000 /* bps */
+
+#define CHECK_MM_ERROR(expr) \
+    do {\
+    int ret = 0; \
+    ret = expr; \
+    if (ret != 0) {\
+    printf("[%s:%d] error code : %x \n", __func__, __LINE__, ret); \
+    return; \
+    }\
+    } while(0)
+
+
+#ifndef SAFE_FREE
+#define SAFE_FREE(x)       if(x) {g_free(x); x = NULL;}
+#endif
+
+
+GTimeVal previous;
+GTimeVal current;
+GTimeVal res;
+//temp
+
+/**
+* Enumerations for command
+*/
+#define SENSOR_WHITEBALANCE_NUM     10
+#define SENSOR_COLOR_TONE_NUM       31
+#define SENSOR_FLIP_NUM         3
+#define SENSOR_PROGRAM_MODE_NUM     15
+#define SENSOR_FOCUS_NUM        6
+#define SENSOR_INPUT_ROTATION       4
+#define SENSOR_AF_SCAN_NUM      4
+#define SENSOR_ISO_NUM          8
+#define SENSOR_EXPOSURE_NUM     9
+#define SENSOR_IMAGE_FORMAT     9
+
+
+/*-----------------------------------------------------------------------
+|    LOCAL CONSTANT DEFINITIONS:                                        |
+-----------------------------------------------------------------------*/
+enum
+{
+    MODE_VIDEO_CAPTURE, /* recording and image capture mode */
+    MODE_AUDIO,     /* audio recording*/
+    MODE_NUM,
+};
+
+enum
+{
+    MENU_STATE_MAIN,
+    MENU_STATE_SETTING,
+    MENU_STATE_NUM,
+};
+
+/*-----------------------------------------------------------------------
+|    LOCAL DATA TYPE DEFINITIONS:                   |
+-----------------------------------------------------------------------*/
+typedef struct _cam_handle
+{
+    camera_h camera;
+    recorder_h recorder;
+    int mode;                       /*video/audio(recording) mode */
+    int menu_state;
+    int fps;
+    bool isMute;
+    unsigned long long elapsed_time;
+} cam_handle_t;
+
+typedef struct _cam_xypair
+{
+    const char *attr_subcat_x;
+    const char *attr_subcat_y;
+    int x;
+    int y;
+} cam_xypair_t;
 
 typedef struct{
-	bool iscalled;
-	bool isprepare;
-	bool isrecording;
-	bool ispaused;
-	recorder_state_e state;
-} state_change_data;
-
-void _state_change_test_cb(recorder_state_e previous, recorder_state_e current, bool by_asm, void *user_data){
-	printf(" state change %d => %d\n", previous , current);
-	state_change_data * data = (state_change_data*)user_data;
-	if( current == RECORDER_STATE_READY )
-		data->isprepare = true;
-	if( current == RECORDER_STATE_RECORDING )
-		data->isrecording = true;
-	if( current == RECORDER_STATE_PAUSED )
-		data->ispaused = true;
-
-	data->state = current;
-
-	//printf("state %d\n",current);
-}
+    int expected_width;
+    int expected_height;
+    int ispass;
+}preview_test_data;
 
-int recorder_state_change_test(){
-	char *state_str[] = {	"RECORDER_STATE_NONE",				/**< recorder is not created yet */
-		"RECORDER_STATE_CREATED",				/**< recorder is created, but not initialized yet */
-		"RECORDER_STATE_READY",			/**< prepare to record if video recorder is playing preview */
-		"RECORDER_STATE_RECORDING",	/**< While recording */
-		"RECORDER_STATE_PAUSED",			/**< Pause recording */
-	};
-	recorder_h recorder;
-	state_change_data data;
-	int ret;
-	recorder_state_e state;
-	recorder_create_audiorecorder(&recorder);
-	data.iscalled = false;
-	data.isprepare = false;
-	data.isrecording = false;
-	data.ispaused = false;
-	data.state = 0;
-	printf("-------------------------recorder state change test -------------------\n");
-	recorder_get_state(recorder, &state);
-	printf("state = %s\n", state_str[state]);	
-	recorder_set_state_changed_cb(recorder, _state_change_test_cb, &data);
-	recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
-	ret = recorder_prepare(recorder);
-	printf("recorder_prepare ret = %x\n", ret);	
-	recorder_get_state(recorder, &state);
-	printf("state = %s\n", state_str[state]);
-	ret = recorder_start(recorder);
-	printf("recorder_start ret = %x\n", ret);
-	recorder_get_state(recorder, &state);
-	printf("state = %s\n", state_str[state]);
-	sleep(1);
-	ret = recorder_pause(recorder);
-	printf("recorder_pause ret = %x\n", ret);
-	recorder_get_state(recorder, &state);
-	printf("state = %s\n", state_str[state]);
-	
-	ret =recorder_commit(recorder);
-	sleep(2);
-
-	if( data.isprepare && data.isrecording && data.ispaused && data.state == RECORDER_STATE_READY ){
-		printf("PASS\n");
-		ret = 0;
-	}else{
-		printf("FAIL data.isprepare %d, data.isrecording %d,  data.ispaused %d,  data.state %d \n", data.isprepare , data.isrecording , data.ispaused , data.state );
-		ret = -1;
-	}
-
-	ret = recorder_unprepare(recorder);
-	printf("recorder_unprepare ret = %x\n", ret);
-	recorder_get_state(recorder, &state);
-	printf("state = %s\n", state_str[state]);
-	
-	ret = recorder_destroy(recorder);	
-	printf("recorder_destroy ret = %x\n", ret);	
-
-	return ret;
-		
-}
+typedef struct{
+    int width[100];
+    int height[100];
+    int count;
+} resolution_stack;
+
+typedef struct{
+    camera_attr_af_mode_e mode;
+    int count;
+} af_stack;
 
+typedef struct{
+    int expected_mode;
+    int ispass;
+}af_test_data;
 
-typedef struct {
-	int elapsed_time;
-	int file_size;
-} recording_result;
-void _recording_status_test_cb(unsigned long long elapsed_time, unsigned long long file_size, void *user_data){
-	recording_result *result = (recording_result*)user_data;
-	result->elapsed_time = elapsed_time;
-	result->file_size = file_size;
+typedef struct{
+    camera_attr_exposure_mode_e mode;
+    int count;
+}exposure_stack;
 
-}
+typedef struct{
+    camera_attr_iso_e mode;
+    int count;
+}iso_stack;
 
-int recorder_recoding_status_cb_test(){
-	recorder_h recorder;
-	recording_result result;
-	int ret;
-
-	printf("--------------recording status cb test-------------------\n");
-	recorder_create_audiorecorder(&recorder);
-	recorder_set_recording_status_cb(recorder,_recording_status_test_cb, &result);
-	recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
-	ret = recorder_prepare(recorder);
-	printf("prepare %d\n", ret);
-	ret = recorder_start(recorder);
-	printf("start %d\n", ret);
-	result.elapsed_time = 0;
-	result.file_size = 0;
-	sleep(3);
-	ret = recorder_cancel(recorder);
-	printf("cancel %d\n", ret);
-	ret =recorder_unprepare(recorder);
-	printf("unprepare %d\n", ret);
-	ret =recorder_destroy(recorder);	
-	printf("destroy %d\n", ret);
-	if( result.elapsed_time > 0  && result.file_size > 0){
-		printf("PASS\n");
-		return 0;
-	}else{
-		printf("FAIL\n");
-		return -1;	
-	}
-}
+typedef struct{
+    camera_rotation_e mode;
+    int count;
+}camera_rotation_stack;
+
+/*---------------------------------------------------------------------------
+|    LOCAL VARIABLE DEFINITIONS:                                            |
+---------------------------------------------------------------------------*/
+static cam_handle_t *hcamcorder ;
+
+const char *wb[SENSOR_WHITEBALANCE_NUM]={
+    "None",
+    "Auto",
+    "Daylight",
+    "Cloudy",
+    "Fluoroscent",
+    "Incandescent",
+    "Shade",
+    "Horizon",
+    "Flash",
+    "Custom",
+};
+
+const char *ct[SENSOR_COLOR_TONE_NUM] = {
+    "NONE",
+    "MONO",
+    "SEPIA",
+    "NEGATIVE",
+    "BLUE",
+    "GREEN",
+    "AQUA",
+    "VIOLET",
+    "ORANGE",
+    "GRAY",
+    "RED",
+    "ANTIQUE",
+    "WARM",
+    "PINK",
+    "YELLOW",
+    "PURPLE",
+    "EMBOSS",
+    "OUTLINE",
+    "SOLARIZATION",
+    "SKETCH",
+    "WASHED",
+    "VINTAGE_WARM",
+    "VINTAGE_COLD",
+    "POSTERIZATION",
+    "CARTOON",
+    "SELECTVE_COLOR_RED",
+    "SELECTVE_COLOR_GREEN",
+    "SELECTVE_COLOR_BLUE",
+    "SELECTVE_COLOR_YELLOW",
+    "SELECTVE_COLOR_RED_YELLOW",
+    "GRAPHICS"
+};
+
+const char *flip[SENSOR_FLIP_NUM] = {
+    "Horizontal",
+    "Vertical",
+    "Not flipped",
+};
+
+const char *program_mode[SENSOR_PROGRAM_MODE_NUM] = {
+    "NORMAL",
+    "PORTRAIT",
+    "LANDSCAPE",
+    "SPORTS",
+    "PARTY_N_INDOOR",
+    "BEACH_N_INDOOR",
+    "SUNSET",
+    "DUSK_N_DAWN",
+    "FALL_COLOR",
+    "NIGHT_SCENE",
+    "FIREWORK",
+    "TEXT",
+    "SHOW_WINDOW",
+    "CANDLE_LIGHT",
+    "BACKLIGHT",
+};
+
+const char *focus_mode[SENSOR_FOCUS_NUM] = {
+    "None",
+    "Pan",
+    "Auto",
+    "Manual",
+    "Touch Auto",
+    "Continuous Auto",
+};
+
+const char *camera_rotation[SENSOR_INPUT_ROTATION] = {
+    "None",
+    "90",
+    "180",
+    "270",
+};
+
+const char *af_scan[SENSOR_AF_SCAN_NUM] = {
+    "None",
+    "Normal",
+    "Macro mode",
+    "Full mode",
+};
+
+const char *iso_mode[SENSOR_ISO_NUM] = {
+    "ISO Auto",
+    "ISO 50",
+    "ISO 100",
+    "ISO 200",
+    "ISO 400",
+    "ISO 800",
+    "ISO 1600",
+    "ISO 3200",
+};
+
+const char *exposure_mode[SENSOR_EXPOSURE_NUM] = {
+    "AE off",
+    "AE all mode",
+    "AE center 1 mode",
+    "AE center 2 mode",
+    "AE center 3 mode",
+    "AE spot 1 mode",
+    "AE spot 2 mode",
+    "AE custom 1 mode",
+    "AE custom 2 mode",
+};
+
+const char *image_fmt[SENSOR_IMAGE_FORMAT] = {
+    "NV12",
+    "NV12T",
+    "NV16",
+    "NV21",
+    "YUYV",
+    "UYVY",
+    "422P",
+    "I420",
+    "YV12",
+};
+
+const char *face_zoom_mode[] = {
+    "Face Zoom OFF",
+    "Face Zoom ON",
+};
+
+const char *display_mode[] = {
+    "Default",
+    "Primary Video ON and Secondary Video Full Screen",
+    "Primary Video OFF and Secondary Video Full Screen",
+};
+
+const char *output_mode[] = {
+    "Letter Box mode",
+    "Original Size mode",
+    "Full Screen mode",
+    "Cropped Full Screen mode",
+    "ROI mode",
+};
+
+const char *capture_sound[] = {
+    "Default",
+    "Extra 01",
+    "Extra 02",
+};
+
+const char *rotate_mode[] = {
+    "0",
+    "90",
+    "180",
+    "270",
+};
+
+const char* strobe_mode[] = {
+    "Strobe OFF",
+    "Strobe ON",
+    "Strobe Auto",
+    "Strobe RedEyeReduction",
+    "Strobe SlowSync",
+    "Strobe FrontCurtain",
+    "Strobe RearCurtain",
+    "Strobe Permanent",
+};
+
+const char *detection_mode[2] = {
+    "Face Detection OFF",
+    "Face Detection ON",
+};
+
+const char *wdr_mode[] = {
+    "WDR OFF",
+    "WDR ON",
+    "WDR AUTO",
+};
+
+const char *hdr_mode[] = {
+    "HDR OFF",
+    "HDR ON",
+    "HDR ON and Original",
+};
+
+const char *ahs_mode[] = {
+    "Anti-handshake OFF",
+    "Anti-handshake ON",
+    "Anti-handshake AUTO",
+    "Anti-handshake MOVIE",
+};
+
+const char *vs_mode[] = {
+    "Video-stabilization OFF",
+    "Video-stabilization ON",
+};
+
+const char *visible_mode[] = {
+    "Display OFF",
+    "Display ON",
+};
+
+
+/*---------------------------------------------------------------------------
+|    LOCAL FUNCTION PROTOTYPES:                                             |
+---------------------------------------------------------------------------*/
+static void print_menu();
+static gboolean cmd_input(GIOChannel *channel);
+static gboolean init(int type);
+static gboolean mode_change();
+
+
+bool preview_resolution_cb(int width, int height, void *user_data)
+{
+    resolution_stack *data = (resolution_stack*)user_data;
 
+    if (data == NULL) {
+        printf("NULL data\n");
+        return false;
+    }
 
-int recorder_attribute_test(){
-	int fail =0;
-	int ret;
-	recorder_h recorder;
-	ret = recorder_create_audiorecorder(&recorder);
-	fail = recording_size_limit_test(recorder);
-	fail +=recording_time_limit_test(recorder);
-	fail +=fileformat_test(recorder);
-	fail +=video_encoder_test(recorder);
-	fail +=audio_encoder_test(recorder);
-	fail +=recording_audio_device_test(recorder);
-	fail +=recording_samplerate_test(recorder);
-	fail +=recording_audio_encoder_bitrate_test(recorder);
-	fail +=recording_video_encoder_bitrate_test(recorder);
-	return fail;
-}
+    data->width[data->count] = width;
+    data->height[data->count] = height;
 
+    printf("%d. %dx%d\n", data->count, width, height);
 
+    data->count++;
 
-void _recording_status_cb2(unsigned long long elapsed_time, unsigned long long file_size, void *user_data){
-	//printf("elapsed time :%d , file_size :%d\n", elapsed_time , file_size);
+    return true;
 }
 
-void _recording_limit_reached_cb(recorder_recording_limit_type_e type, void *user_data){
-	printf("limited!! %d\n", type);
-	int *ischeck = (int*)user_data;
-	*ischeck = 1;
+bool af_mode_foreach_cb(camera_attr_iso_e mode , void *user_data)
+{
+    printf("%d.%s\n", mode,af_scan[mode]);
+    return true;
 }
 
+bool exposure_mode_cb(camera_attr_af_mode_e mode , void *user_data)
+{
+    exposure_stack *data = (exposure_stack*)user_data;
 
-int recorder_limit_cb_test(){
-	recorder_h recorder;
-	int ischeck = 0;
-	int ret =0;
-	recorder_create_audiorecorder(&recorder);
-	printf("------------------------limit cb test -------------------------\n");
-	//recorder_set_state_changed_cb(recorder, record_state_cb, NULL);
-	recorder_set_recording_status_cb(recorder, _recording_status_cb2, NULL);
-	recorder_set_recording_limit_reached_cb(recorder, _recording_limit_reached_cb, &ischeck);	
-	recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
-	recorder_prepare(recorder);
-
-
-	printf("-time limit test\n");
-	recorder_attr_set_time_limit(recorder, 2);
-	recorder_start(recorder);
-	sleep(5);
-	recorder_cancel(recorder);
-	if( ischeck ){
-		printf("PASS\n");
-	}else{
-		printf("FAIL\n");
-		ret--;
-	}
-
-
-	printf("-time unlimit test\n");
-	//recorder_unprepare(recorder);
-	recorder_attr_set_time_limit(recorder, 0);		
-	//recorder_prepare(recorder);
-	ischeck = 0;
-	recorder_set_recording_limit_reached_cb(recorder, _recording_limit_reached_cb, &ischeck);	
-	recorder_start(recorder);
-	sleep(5);
-	recorder_cancel(recorder);
-	if( ischeck ){
-		printf("FAIL\n");
-		ret--;
-	}else{
-		printf("PASS\n");
-	}
-
-
-	printf("-size limit test\n");
-	ischeck = 0;
-	recorder_attr_set_size_limit(recorder, 2);
-	recorder_start(recorder);
-	sleep(5);
-	recorder_cancel(recorder);
-	
-	if( ischeck ){
-		printf("PASS\n");
-	}else{
-		printf("FAIL\n");
-		ret--;
-	}
-
-	printf("-size unlimit test\n");
-	ischeck = 0;
-	recorder_attr_set_size_limit(recorder, 0);
-	recorder_start(recorder);
-	sleep(5);
-	recorder_cancel(recorder);
-	
-	if( ischeck ){
-		printf("FAIL\n");
-		ret--;
-	}else{
-		printf("PASS\n");
-	}
-	
-
-	recorder_unprepare(recorder);
-	recorder_destroy(recorder);
-
-	return ret;
-		
-}
+    if (data == NULL) {
+        printf("NULL data\n");
+        return false;
+    }
 
-int video_recorder_test(){
-	camera_h camera ;
-	recorder_h recorder;
-	int ret;
-
-	printf("-----------------video recorder test--------------------\n");
-	camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
-	recorder_create_videorecorder(camera, &recorder);
-	camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11,GET_DISPLAY(preview_win));
-	camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
-	//camera_set_preview_resolution(camera, 320, 240);
-	camera_attr_set_preview_fps(camera, CAMERA_ATTR_FPS_AUTO);
-	ret = recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_MP4);
-	printf("ret = %x\n", ret);
-	ret = recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_H263);
-	printf("ret = %x\n", ret);	
-	ret = recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
-	printf("ret = %x\n", ret);	
-	ret = recorder_set_filename(recorder, "/mnt/nfs/video_recorder_test.mp4");
-	printf("ret = %x\n", ret);	
-	
-
-	ret=  recorder_prepare(recorder);
-	printf("ret = %x\n", ret);	
-	ret = recorder_start(recorder);
-	printf("ret = %x\n", ret);	
-	sleep(10);
-	ret = recorder_pause(recorder);
-	printf("ret = %x\n", ret);		
-	ret = recorder_commit(recorder);
-	printf("ret = %x\n", ret);	
-	ret =recorder_unprepare(recorder);
-	printf("ret = %x\n", ret);	
-	ret= recorder_destroy(recorder);
-	printf("ret = %x\n", ret);	
-	return 0;
+    data->mode = mode;
+    data->count++;
+
+    printf("%d.%s\n", mode,exposure_mode[mode]);
+    return true;
 }
 
-int mm_test(){
-	MMCamPreset info;
-	info.videodev_type= MM_VIDEO_DEVICE_NONE;
-	MMHandleType camcorder;
-	int ret;	
-	ret = mm_camcorder_create(&camcorder, &info);
-	printf("mm_camcorder_create %x\n", ret);
-	ret = mm_camcorder_set_attributes(camcorder, NULL, 
-																MMCAM_MODE , MM_CAMCORDER_MODE_AUDIO, 
-																(void*)NULL);
-	printf("mm_camcorder_set_attributes %x\n", ret);
-	
-	ret = mm_camcorder_set_attributes(camcorder ,NULL, MMCAM_AUDIO_ENCODER ,MM_AUDIO_CODEC_AAC , NULL);
-	printf("mm_camcorder_set_attributes %x\n", ret);
-
-	ret = mm_camcorder_set_attributes(camcorder ,NULL, MMCAM_FILE_FORMAT ,MM_FILE_FORMAT_MP4 , NULL);
-	printf("mm_camcorder_set_attributes %x\n", ret);
-
-	ret = mm_camcorder_realize(camcorder);	
-	printf("mm_camcorder_realize %x\n", ret);
-	
-	ret = mm_camcorder_start(camcorder);
-	printf("mm_camcorder_start %x\n", ret);
-	
-	ret = mm_camcorder_record(camcorder);
-	printf("mm_camcorder_record %x\n", ret);
-	
-
-
-	ret = mm_camcorder_pause(camcorder);
-	printf("mm_camcorder_pause %x\n", ret);
-
-	ret = mm_camcorder_cancel(camcorder);
-	printf("mm_camcorder_cancel %x\n", ret);
-
-	ret = mm_camcorder_stop(camcorder);
-	printf("mm_camcorder_stop %x\n", ret);
-
-	ret = mm_camcorder_unrealize(camcorder);
-	printf("mm_camcorder_unrealize %x\n", ret);	
-
-	ret = mm_camcorder_destroy(camcorder);
-	printf("mm_camcorder_destroy %x\n", ret);	
-
-	
-	
-	return 0;
-	
+bool iso_mode_cb(camera_attr_iso_e mode , void *user_data)
+{
+    printf("%d.%s\n", mode,iso_mode[mode]);
+    return true;
 }
 
+bool camera_rotation_cb(camera_rotation_e mode , void *user_data)
+{
+    camera_rotation_stack *data = (camera_rotation_stack*)user_data;
+
+    if (data == NULL) {
+        printf("NULL data\n");
+        return false;
+    }
 
+    data->mode = mode;
+    data->count++;
 
-int recorder_encoder_test(){
-	recorder_h recorder;
-	camera_h camera;
-	int ret;
-
-	printf("3GP - AMR\n");
-	ret=recorder_create_audiorecorder(&recorder);
-	ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
-	ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
-	ret+=recorder_set_filename(recorder , "/mnt/nfs/audiotest_amr.3gp");
-	ret+=recorder_prepare(recorder);
-	ret+=recorder_start(recorder);
-	sleep(4);
-	ret+=recorder_commit(recorder);
-	ret += recorder_unprepare(recorder);
-	ret+=recorder_destroy(recorder);
-
-	printf("3GP - AAC\n");
-	ret=recorder_create_audiorecorder(&recorder);
-	ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
-	ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
-	ret+=recorder_set_filename(recorder , "/mnt/nfs/audiotest_aac.3gp");
-	ret+=recorder_prepare(recorder);
-	ret+=recorder_start(recorder);
-	sleep(4);
-	ret+=recorder_commit(recorder);
-	ret += recorder_unprepare(recorder);
-	ret+=recorder_destroy(recorder);
-
-	printf("AMR - AMR\n");
-	ret=recorder_create_audiorecorder(&recorder);
-	ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
-	ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
-	ret+=recorder_set_filename(recorder , "/mnt/nfs/audiotest.amr");
-	ret+=recorder_prepare(recorder);
-	ret+=recorder_start(recorder);
-	sleep(4);
-	ret+=recorder_commit(recorder);
-	ret += recorder_unprepare(recorder);
-	ret+=recorder_destroy(recorder);
-
-	printf("MP4 - AAC\n");
-	ret=recorder_create_audiorecorder(&recorder);
-	ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_MP4);
-	ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
-	ret+=recorder_set_filename(recorder , "/mnt/nfs/audiotest_aac.mp4");
-	ret+=recorder_prepare(recorder);
-	ret+=recorder_start(recorder);
-	sleep(4);
-	ret+=recorder_commit(recorder);
-	ret += recorder_unprepare(recorder);
-	ret+=recorder_destroy(recorder);
-	
-
-	ret+=camera_create(CAMERA_DEVICE_CAMERA0,&camera);
-	ret+=camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
-	ret+=camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
-
-
-	printf("3GP - AMR- H263\n");	
-	ret+=recorder_create_videorecorder(camera, &recorder);
-	ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
-	ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
-	ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_H263);
-	ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_amr_h263.3gp");
-	ret+=recorder_prepare(recorder);
-	ret+=recorder_start(recorder);
-	sleep(10);
-	ret+=recorder_commit(recorder);
-	ret += recorder_unprepare(recorder);
-	ret+=recorder_destroy(recorder);
-
-
-	printf("3GP - AMR- H264\n");	
-	ret+=recorder_create_videorecorder(camera, &recorder);
-	ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
-	ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
-	ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_H264);
-	ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_amr_h264.3gp");
-	ret+=recorder_prepare(recorder);
-	ret+=recorder_start(recorder);
-	sleep(10);
-	ret+=recorder_commit(recorder);
-	ret += recorder_unprepare(recorder);
-	ret+=recorder_destroy(recorder);
-	
-	printf("3GP - AMR- MPEG4\n");	
-	ret+=recorder_create_videorecorder(camera, &recorder);
-	ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
-	ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
-	ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
-	ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_amr_mpeg4.3gp");
-	ret+=recorder_prepare(recorder);
-	ret+=recorder_start(recorder);
-	sleep(10);
-	ret+=recorder_commit(recorder);
-	ret += recorder_unprepare(recorder);
-	ret+=recorder_destroy(recorder);
-
-
-	printf("3GP - AAC- H263\n");	
-	ret+=recorder_create_videorecorder(camera, &recorder);
-	ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
-	ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
-	ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_H263);
-	ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_AAC_h263.3gp");
-	ret+=recorder_prepare(recorder);
-	ret+=recorder_start(recorder);
-	sleep(10);
-	ret+=recorder_commit(recorder);
-	ret += recorder_unprepare(recorder);
-	ret+=recorder_destroy(recorder);
-		
-
-	printf("3GP - AAC- H264\n");	
-	ret+=recorder_create_videorecorder(camera, &recorder);
-	ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
-	ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
-	ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_H264);
-	ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_AAC_h264.3gp");
-	ret+=recorder_prepare(recorder);
-	ret+=recorder_start(recorder);
-	sleep(10);
-	ret+=recorder_commit(recorder);
-	ret += recorder_unprepare(recorder);
-	ret+=recorder_destroy(recorder);	
-
-	printf("3GP - AAC- MPEG4\n");	
-	ret+=recorder_create_videorecorder(camera, &recorder);
-	ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
-	ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
-	ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
-	ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_AAC_MPEG4.3gp");
-	ret+=recorder_prepare(recorder);
-	ret+=recorder_start(recorder);
-	sleep(10);
-	ret+=recorder_commit(recorder);
-	ret += recorder_unprepare(recorder);
-	ret+=recorder_destroy(recorder);
-
-	printf("MP4 - AAC- H264\n");	
-	ret+=recorder_create_videorecorder(camera, &recorder);
-	ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_MP4);
-	ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
-	ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_H264);
-	ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_AAC_h264.mp4");
-	ret+=recorder_prepare(recorder);
-	ret+=recorder_start(recorder);
-	sleep(10);
-	ret+=recorder_commit(recorder);
-	ret += recorder_unprepare(recorder);
-	ret+=recorder_destroy(recorder);
-
-	printf("MP4 - AAC- MPEG4\n");	
-	ret+=recorder_create_videorecorder(camera, &recorder);
-	ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_MP4);
-	ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
-	ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
-	ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_AAC_MPEG4.mp4");
-	ret+=recorder_prepare(recorder);
-	ret+=recorder_start(recorder);
-	sleep(10);
-	ret+=recorder_commit(recorder);
-	ret += recorder_unprepare(recorder);
-	ret+=recorder_destroy(recorder);
-
-
-	camera_destroy(camera);
-	
-	
-	return ret;
+    printf("%d.%s\n", mode,camera_rotation[mode]);
+    return true;
 }
 
- Eina_Bool print_audio_level(void *data){
- 	recorder_h recorder = (recorder_h)data;
-	if( recorder ){
-		double level; 
-		recorder_get_audio_level(recorder,&level);
-		printf("%g\n", level);
-	}
- 	return 1;
+bool preview_format_cb(camera_pixel_format_e mode , void *user_data)
+{
+    printf("%d.%s\n", mode,image_fmt[mode]);
+    return true;
 }
 
-int audio_level_test(){
-	recorder_h recorder;
-	recorder_create_audiorecorder(&recorder);
-	recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
-	recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
-	recorder_set_filename(recorder, "/mnt/nfs/test.amr");
-	
-	recorder_prepare(recorder);
-	recorder_start(recorder);
-	ecore_timer_add(0.1, print_audio_level, recorder);
-	sleep(2);
-	return 0;
+bool white_balance_cb(camera_attr_whitebalance_e mode , void *user_data)
+{
+    printf("%d.%s\n", mode,wb[mode]);
+    return true;
 }
 
-void _camera_state_changed_cb(camera_state_e previous, camera_state_e current,bool by_policy, void *user_data){
-	printf("camera state changed %d -> %d\n", previous , current);
+bool colortone_cb(camera_attr_effect_mode_e mode , void *user_data)
+{
+    printf("%d.%s\n", mode,ct[mode]);
+    return true;
+}
+
+bool program_mode_cb(camera_attr_scene_mode_e mode ,void *user_data)
+{
+    printf("%d.%s\n", mode,program_mode[mode]);
+    return true;
 }
 
-void _recorder_state_changed_cb(recorder_state_e previous , recorder_state_e current , bool by_policy, void *user_data){
-	printf("recorder state changed %d -> %d\n", previous , current);
+bool strobe_mode_cb(camera_attr_flash_mode_e mode ,void *user_data)
+{
+    printf("%d.%s\n", mode,strobe_mode[mode]);
+    return true;
 }
 
-int slow_motion_test(){
-	camera_h camera;
-	recorder_h recorder;
-	int ret;
-	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
-	printf("camera_create ret = %x\n", ret);
-	camera_set_state_changed_cb(camera, _camera_state_changed_cb, NULL);
-	ret = recorder_create_videorecorder(camera, &recorder);
-	printf("recorder_create_videorecorder ret = %x\n", ret);
-	ret = recorder_set_state_changed_cb(recorder, _recorder_state_changed_cb , NULL);
-	ret = recorder_set_filename(recorder, "/mnt/nfs/test.3gp");
-	printf("recorder_set_filename ret = %x\n", ret);
-	ret = recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
-	printf("recorder_set_audio_encoder ret = %x\n", ret);
-	ret = recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
-	printf("recorder_set_video_encoder ret = %x\n", ret);
-	ret = recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
-	printf("recorder_set_file_format ret = %x\n", ret);
-	ret = recorder_attr_set_recording_motion_rate(recorder, 0.5);
-	printf("recorder_attr_set_slow_motion_rate ret = %x\n", ret);
-	ret = recorder_prepare(recorder);
-	printf("recorder_prepare ret = %x\n", ret);
-	ret = recorder_start(recorder);
-	printf("recorder_start ret = %x\n", ret);
-	sleep(10);
-	ret = recorder_commit(recorder);
-	printf("recorder_commit ret = %x\n", ret);
-	ret = recorder_unprepare(recorder);
-	printf("recorder_unprepare ret = %x\n", ret);
-	ret = recorder_destroy(recorder);
-	printf("recorder_destroy ret = %x\n", ret);
-	return 0;
+void _face_detected(camera_detected_face_s *faces, int count, void *user_data){
+    printf("face detected!!\n");
+    int i;
+    for(i = 0 ; i < count ; i++){
+        printf("%d) - %dx%d\n", faces[i].id, faces[i].x, faces[i].y);
+    }
 }
 
-void _capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
-	printf("capturing callback!\n");
+void _recording_status_cb(unsigned long long elapsed_time, unsigned long long file_size, void *user_data){
+    //printf("elapsed time :%d , file_size :%d\n", elapsed_time , file_size);
 }
 
-void _capture_completed_cb(void *user_data){
-	printf("capture completed callback\n");
+void _recording_limit_reached_cb(recorder_recording_limit_type_e type, void *user_data){
+    printf("limited!! %d\n", type);
+    int *ischeck = (int*)user_data;
+    *ischeck = 1;
 }
 
 
-int recording_capture_test(){
-	camera_h camera;
-	recorder_h recorder;
-	int ret;
-	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
-	printf("camera_create ret = %x\n", ret);
-	camera_set_state_changed_cb(camera, _camera_state_changed_cb, NULL);
-	ret = recorder_create_videorecorder(camera, &recorder);
-	printf("recorder_create_videorecorder ret = %x\n", ret);
-	ret = recorder_set_state_changed_cb(recorder, _recorder_state_changed_cb , NULL);
-	ret = recorder_set_filename(recorder, "/mnt/nfs/test.3gp");
-	printf("recorder_set_filename ret = %x\n", ret);
-	ret = recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
-	printf("recorder_set_audio_encoder ret = %x\n", ret);
-	ret = recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
-	printf("recorder_set_video_encoder ret = %x\n", ret);
-	ret = recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
-	printf("recorder_set_file_format ret = %x\n", ret);
-
-	camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
-	//camera_set_preview_resolution(camera, 640, 480);
-	//camera_set_capture_resolution(camera, 640, 480);
-
-	ret = recorder_prepare(recorder);
-	printf("recorder_prepare ret = %x\n", ret);
-	ret = recorder_start(recorder);
-	printf("recorder_start ret = %x\n", ret);
-	sleep(10);
-	ret = camera_start_capture(camera, _capturing_cb , _capture_completed_cb, NULL);
-	printf("camera_start_capture ret =%x\n", ret);
-	sleep(10);
-
-	ret = recorder_commit(recorder);
-	printf("recorder_commit ret = %x\n", ret);
-	ret = recorder_unprepare(recorder);
-	printf("recorder_unprepare ret = %x\n", ret);
-	ret = recorder_destroy(recorder);
-	printf("recorder_destroy ret = %x\n", ret);
-	return 0;
+static inline void flush_stdin()
+{
+    int ch;
+    while ((ch=getchar()) != EOF && ch != '\n');
 }
 
 
-void _audio_stream_cb(void* stream, int size, audio_sample_type_e format, int channel, unsigned int timestamp, void *user_data){
-	printf("size = %d[%d]( %d )\n", size, format, timestamp);
+static void print_menu()
+{
+    switch(hcamcorder->menu_state)
+    {
+    case MENU_STATE_MAIN:
+        if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
+            g_print("\n\t=======================================\n");
+            if(recorder_state <= RECORDER_STATE_NONE) {
+                g_print("\t   '1' Start Recording\n");
+                g_print("\t   '2' Setting\n");
+                g_print("\t   'b' back\n");
+            } else if(recorder_state == RECORDER_STATE_RECORDING) {
+                g_print("\t   'p' Pause Recording\n");
+                g_print("\t   'c' Cancel\n");
+                g_print("\t   's' Save\n");
+            } else if(recorder_state == RECORDER_STATE_PAUSED) {
+                g_print("\t   'r' Resume Recording\n");
+                g_print("\t   'c' Cancel\n");
+                g_print("\t   's' Save\n");
+            }
+            g_print("\t=======================================\n");
+        } else if (hcamcorder->mode == MODE_AUDIO) {
+            g_print("\n\t=======================================\n");
+            g_print("\t   Audio Recording\n");
+            g_print("\t=======================================\n");
+            if(recorder_state <= RECORDER_STATE_NONE) {
+                g_print("\t   '1' Start Recording\n");
+                g_print("\t   'b' back\n");
+            }
+            else if(recorder_state == RECORDER_STATE_RECORDING) {
+                g_print("\t   'p' Pause Recording\n");
+                g_print("\t   'c' Cancel\n");
+                g_print("\t   's' Save\n");
+            }
+            else if(recorder_state == RECORDER_STATE_PAUSED) {
+                g_print("\t   'r' Resume Recording\n");
+                g_print("\t   'c' Cancel\n");
+                g_print("\t   's' Save\n");
+            }
+            g_print("\t=======================================\n");
+        }
+        break;
+
+    case MENU_STATE_SETTING:
+        g_print("\n\t=======================================\n");
+        g_print("\t   Video Capture > Setting\n");
+        g_print("\t=======================================\n");
+        g_print("\t  >>>>>>>>>>>>>>>>>>>>>>>>>>>> [Camera]  \n");
+        g_print("\t     '0' Preview resolution \n");
+        g_print("\t     '2' Digital zoom level \n");
+        g_print("\t     '3' Optical zoom level \n");
+        g_print("\t     '4' AF mode \n");
+        g_print("\t     '5' AF scan range \n");
+        g_print("\t     '6' Exposure mode \n");
+        g_print("\t     '7' Exposure value \n");
+        g_print("\t     '8' F number \n");
+        g_print("\t     '9' Shutter speed \n");
+        g_print("\t     'i' ISO \n");
+        g_print("\t     'r' Rotate camera input \n");
+        g_print("\t     'f' Flip camera input \n");
+        g_print("\t  >>>>>>>>>>>>>>>>>>>> [Display/Filter]\n");
+        g_print("\t     'v' Visible \n");
+        g_print("\t     'n' Display mode \n");
+        g_print("\t     'o' Output mode \n");
+        g_print("\t     'y' Rotate display \n");
+        g_print("\t     'Y' Flip display \n");
+        g_print("\t     'g' Brightness \n");
+        g_print("\t     'c' Contrast \n");
+        g_print("\t     's' Saturation \n");
+        g_print("\t     'h' Hue \n");
+        g_print("\t     'a' Sharpness \n");
+        g_print("\t     'w' White balance \n");
+        g_print("\t     't' Color tone \n");
+        g_print("\t     'd' WDR \n");
+        g_print("\t     'e' EV program mode \n");
+        g_print("\t  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [etc.]\n");
+        g_print("\t     'z' Strobe (Flash) \n");
+        g_print("\t     'l' Face detection \n");
+        g_print("\t     'k' Anti-handshake \n");
+        g_print("\t     'K' Video-stabilization \n");
+        g_print("\t     'u' Touch AF area \n");;
+        g_print("\t     'M' Camcorder Motion Rate setting \n");
+        g_print("\t     'b' back\n");
+        g_print("\t=======================================\n");
+        break;
+
+    default:
+        LOGE("unknow menu state !!\n");
+        break;
+    }
+
+    return;
 }
 
-int audio_stream_cb_test(){
-	recorder_h recorder;
-	int ret = 0;
-	ret = recorder_create_audiorecorder(&recorder);
-	printf(" create ret =%d\n", ret);
-	ret = recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
-	printf(" create2 ret =%d\n", ret);
-	ret = recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
-	printf(" create3 ret =%d\n", ret);
-	ret = recorder_set_filename(recorder, "/mnt/nfs/test.amr");
-	printf(" create4 ret =%d\n", ret);
-	ret = recorder_set_audio_stream_cb(recorder, _audio_stream_cb, NULL);
-	printf(" recorder_set_audio_stream_cb ret =%d\n", ret);
-	ret = recorder_prepare(recorder);
-	printf(" recorder_prepare ret =%d\n", ret);
-	ret = recorder_set_audio_stream_cb(recorder, _audio_stream_cb, NULL);
-	printf(" recorder_set_audio_stream_cb ret =%d\n", ret);
-	ret = recorder_start(recorder);
-	printf(" recorder_start ret =%d\n", ret);
-	sleep(10);
-	ret = recorder_commit(recorder);
-	printf(" recorder_commit ret =%d\n", ret);
-	return 0;
+static void main_menu(gchar buf)
+{
+    int err = 0;
+
+    if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
+        if (recorder_state == RECORDER_STATE_NONE) {
+            switch (buf) {
+
+            case '1' : // Start Recording
+                g_print("*Recording start!\n");
+                hcamcorder->elapsed_time = 0;
+
+                g_timer_reset(timer);
+                err = recorder_start(hcamcorder->recorder);
+
+                if (err != 0) {
+                    LOGE("Rec start camcorder_record 0x%x", err);
+                }
+
+                recorder_state = RECORDER_STATE_RECORDING;
+                break;
+
+            case '2' : // Setting
+                hcamcorder->menu_state = MENU_STATE_SETTING;
+                break;
+
+            case 'b' : // back
+                hcamcorder->menu_state = MENU_STATE_MAIN;
+                mode_change();
+                break;
+
+            default:
+                g_print("\t Invalid input \n");
+                break;
+            }
+        } else if (recorder_state == RECORDER_STATE_RECORDING || recorder_state == RECORDER_STATE_PAUSED) {
+            switch (buf) {
+                if (recorder_state == RECORDER_STATE_RECORDING) {
+            case 'p'  : // Pause Recording
+                g_print("*Pause!\n");
+                err = recorder_pause(hcamcorder->recorder);
+
+                if (err < 0) {
+                    LOGE("Rec pause camcorder_pause  = %x", err);
+                }
+                recorder_state = RECORDER_STATE_PAUSED;
+                break;
+
+                } else {
+            case 'r'  : // Resume Recording
+                g_print("*Resume!\n");
+                err = recorder_start(hcamcorder->recorder);
+                if (err < 0) {
+                    LOGE("Rec start camcorder_record  = %x", err);
+                }
+                recorder_state = RECORDER_STATE_RECORDING;
+                break;
+                }
+
+            case 'c' : // Cancel
+                g_print("*Cancel Recording !\n");
+
+                err = recorder_cancel(hcamcorder->recorder);
+
+                if (err < 0) {
+                    LOGE("Cancel recording camcorder_cancel  = %x", err);
+                }
+                recorder_state = RECORDER_STATE_NONE;
+                break;
+
+            case 's' : // Save
+                g_print("*Save Recording!\n");
+                g_timer_reset(timer);
+
+                err = recorder_commit(hcamcorder->recorder);
+
+                if (err < 0) {
+                    LOGE("Save recording recorder_commit  = %x", err);
+                }
+                recorder_state = RECORDER_STATE_NONE;
+                break;
+
+            default :
+                g_print("\t Invalid input \n");
+                break;
+            } //switch
+        } else {
+            LOGE("Wrong camcorder state, check status!!");
+        }
+    } else if (hcamcorder->mode == MODE_AUDIO) {
+        if (recorder_state == RECORDER_STATE_NONE) {
+            switch(buf) {
+            case '1' : //  Start Recording
+                g_print("*Recording start!\n");
+                hcamcorder->elapsed_time = 0;
+                g_timer_reset(timer);
+                err = recorder_start(hcamcorder->recorder);
+
+                if (err < 0) {
+                    LOGE("Rec start camcorder_record  = %x", err);
+                }
+                recorder_state = RECORDER_STATE_RECORDING;
+                break;
+
+            case 'b' : // back
+                hcamcorder->menu_state = MENU_STATE_MAIN;
+                mode_change();
+                break;
+
+            default :
+                g_print("\t Invalid input \n");
+                break;
+            }
+        } else if (recorder_state == RECORDER_STATE_RECORDING || recorder_state == RECORDER_STATE_PAUSED) {
+            switch(buf) {
+                if (recorder_state == RECORDER_STATE_RECORDING) {
+            case 'p' : // Pause Recording
+                g_print("*Pause!\n");
+                err = recorder_pause(hcamcorder->recorder);
+
+                if (err < 0) {
+                    LOGE("Rec pause camcorder_pause  = %x", err);
+                }
+                recorder_state = RECORDER_STATE_PAUSED;
+                break;
+                } else {
+            case 'r'  : // Resume Recording
+                g_print("*Resume!\n");
+                err = recorder_start(hcamcorder->recorder);
+                if (err < 0) {
+                    LOGE("Rec start camcorder_record  = %x", err);
+                }
+                recorder_state = RECORDER_STATE_RECORDING;
+                break;
+                }
+
+            case 'c' : // Cancel
+                g_print("*Cancel Recording !\n");
+                err = recorder_cancel(hcamcorder->recorder);
+
+                if (err < 0) {
+                    LOGE("Cancel recording camcorder_cancel  = %x", err);
+                }
+                recorder_state = RECORDER_STATE_NONE;
+                break;
+
+            case 's' : //  Save
+                g_print("*Save Recording!\n");
+                g_timer_reset(timer);
+                err = recorder_commit(hcamcorder->recorder);
+
+                if (err < 0) {
+                    LOGE("Save recording recorder_commit  = %x", err);
+                }
+                recorder_state = RECORDER_STATE_NONE;
+                break;
+
+            default :
+                g_print("\t Invalid input \n");
+                break;
+            }
+        } else {
+            LOGE("Wrong camcorder state, check status!!");
+        }
+    }
+    else {
+        g_print("\t Invalid mode, back to upper menu \n");
+        hcamcorder->menu_state = MENU_STATE_MAIN;
+        mode_change();
+    }
 }
 
 
-void _camera_capturing_cb_modechange(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
-	printf("capturing callback\n");
-}
-void _camera_capture_completed_cb_modechange(void *user_data){
-	printf("capture complete\n");
+static void setting_menu(gchar buf)
+{
+    gboolean bret = FALSE;
+    int idx = 0;
+    int min = 0;
+    int max = 0;
+    int value = 0;
+    int err = 0;
+    int x = 0, y = 0, width = 0, height = 0;
+
+    if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
+        switch (buf) {
+            /* Camera setting */
+        case '0':  // Setting > Preview Resolution setting
+            g_print("*Select the preview resolution!\n");
+            resolution_stack resolution_list;
+            resolution_list.count = 0;
+            recorder_foreach_supported_video_resolution(hcamcorder->recorder, preview_resolution_cb, &resolution_list);
+            flush_stdin();
+            err = scanf("%d",&idx);
+            int result = 0;
+            preview_test_data data;
+            data.ispass = false;
+            if (resolution_list.count > idx && idx >= 0) {
+
+                data.expected_width = resolution_list.width[idx];
+                data.expected_height = resolution_list.height[idx];
+
+                printf("-----------------PREVIEW RESOLUTION (%dx%d)---------------------\n",data.expected_width  ,data.expected_height);
+                result = recorder_set_video_resolution(hcamcorder->recorder,data.expected_width ,data.expected_height);
+            } else {
+                printf("invalid input %d\n", idx);
+                result = -1;
+            }
+
+            resolution_list.count = 0;
+
+            if (result != 0)
+                printf("FAIL\n");
+            else
+                printf("PASS\n");
+            break;
+
+        case '2' : // Setting > Digital zoom level
+            g_print("*Digital zoom level  !\n");
+
+            camera_attr_get_zoom_range(hcamcorder->camera,&min,&max);
+            if(min >= max) {
+                g_print("Not supported !! \n");
+            } else {
+                flush_stdin();
+                g_print("\n Select  Digital zoom level min %d - max %d\n",min,max);
+                err = scanf("%d",&idx);
+                bret = camera_attr_set_zoom(hcamcorder->camera,idx);
+            }
+            break;
+
+
+        case '3' : // Setting > AF mode
+
+            g_print("*AF mode !\n");
+            g_print("\t1. AF Start !\n");
+            g_print("\t2. AF Stop !\n\n");
+
+            flush_stdin();
+            err = scanf("%d", &idx);
+            switch(idx)
+            {
+            case 1:
+                camera_start_focusing(hcamcorder->camera,0);
+                break;
+            case 2:
+                camera_cancel_focusing(hcamcorder->camera);
+                break;
+            default:
+                g_print("Wrong Input[%d] !! \n", idx);
+                break;
+            }
+
+            break;
+
+        case '4' : // Setting > AF scan range
+            g_print("*AF scan range !\n");
+
+            af_stack af_mode_list;
+            af_mode_list.count = 0;
+            camera_attr_foreach_supported_af_mode(hcamcorder->camera, (camera_attr_supported_af_mode_cb)af_mode_foreach_cb , NULL);
+
+            af_test_data data1;
+            data1.ispass = false;
+            data1.expected_mode = af_mode_list.mode;
+            flush_stdin();
+            err = scanf("%d", &idx);
+
+            bret=camera_attr_set_af_mode(hcamcorder->camera,idx);
+            break;
+
+        case '5' : // Setting > Exposure mode
+            g_print("* Exposure mode!\n");
+
+            camera_attr_foreach_supported_exposure_mode(hcamcorder->camera,(camera_attr_supported_exposure_mode_cb)exposure_mode_cb,NULL);
+
+            flush_stdin();
+
+            g_print("\n Select  Exposure mode \n");
+            err = scanf("%d",&idx);
+            bret = camera_attr_set_exposure_mode(hcamcorder->camera, idx);
+
+            break;
+
+        case '6' :  // Setting > Exposure value
+            camera_attr_get_exposure_range(hcamcorder->camera,&min,&max);
+            if(min >= max) {
+                g_print("Not supported !! \n");
+            }
+            else {
+
+                flush_stdin();
+                g_print("\n Select  Exposure mode min%d -max %d\n",min,max);
+                err = scanf("%d",&idx);
+                bret = camera_attr_set_exposure(hcamcorder->camera, idx);
+            }
+            break;
+
+        case '7' : // Setting > F number
+            g_print("Not supported !! \n");
+            break;
+
+        case 'i' : // Setting > ISO
+            g_print("*ISO !\n");
+            camera_attr_foreach_supported_iso(hcamcorder->camera,iso_mode_cb, NULL);
+
+            flush_stdin();
+
+            err = scanf("%d",&idx);
+            bret =  camera_attr_set_iso(hcamcorder->camera, idx);
+            break;
+
+        case 'r' : // Setting > Rotate camera input when recording
+            g_print("*Rotate camera input\n");
+            camera_attr_foreach_supported_stream_rotation(hcamcorder->camera,camera_rotation_cb,NULL);
+
+            flush_stdin();
+            err = scanf("%d",&idx);
+            CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera));
+            bret = camera_attr_set_stream_rotation(hcamcorder->camera, idx);
+            CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera));
+            break;
+
+        case 'f' : // Setting > Flip camera input
+            flush_stdin();
+            g_print("*Flip camera input\n");
+            g_print(" 0. Flip NONE\n");
+            g_print(" 1. Flip HORIZONTAL\n");
+            g_print(" 2. Flip VERTICAL\n");
+            g_print(" 3. Flip BOTH\n");
+
+            err = scanf("%d", &idx);
+
+            CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera));
+            camera_attr_set_stream_flip(hcamcorder->camera,idx);
+            CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera));
+            break;
+
+            /* Display / Filter setting */
+        case 'v' : // Display visible
+            g_print("* Display visible setting !\n");
+
+            g_print("\n Select Display visible \n");
+            flush_stdin();
+            int i;
+            for (i = 0; i < 2; i++) {
+                g_print("\t %d. %s\n", i+1, visible_mode[i]);
+            }
+            err = scanf("%d",&value);
+            bret = camera_set_display_visible(hcamcorder->camera,idx-1);
+
+            break;
+
+
+        case 'o' : //  Setting > Display MODe
+            g_print("* Display mode!\n");
+
+            flush_stdin();
+            for (i = 1 ; i <= 2  ; i++ ) {
+                g_print( "%d. %s\n", i, display_mode[i] );
+            }
+            err = scanf("%d",&idx);
+            bret =  camera_set_display_mode(hcamcorder->camera,idx-1);
+            break;
+
+        case 'y' : // Setting > Rotate Display
+
+            flush_stdin();
+            g_print("\n Select Rotate mode\n");
+            g_print("\t0. 0\n\t1. 90\n\t2. 180\n\t3. 270\n\n");
+            err = scanf("%d",&idx);
+            CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera));
+            bret = camera_set_display_rotation(hcamcorder->camera,idx);
+            CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera));
+            break;
+
+        case 'Y' : // Setting > Flip Display
+            flush_stdin();
+            g_print("\n Select Rotate mode\n");
+            g_print("\t0. NONE\n\t1. HORIZONTAL\n\t2. VERTICAL\n\t3. BOTH\n\n");
+            err = scanf("%d",&idx);
+            bret=camera_set_display_flip(hcamcorder->camera,idx);
+            break;
+
+        case 'g' : // Setting > Brightness
+            g_print("*Brightness !\n");
+            camera_attr_get_brightness_range(hcamcorder->camera,&min,&max);
+
+            flush_stdin();
+            g_print("\n Select  brightness min (%d) -max(%d)",min,max);
+            err = scanf("%d",&idx);
+            bret = camera_attr_set_brightness(hcamcorder->camera, idx);
+            break;
+
+        case 'c' : // Setting > Contrast
+            g_print("*Contrast !\n");
+            camera_attr_get_contrast_range(hcamcorder->camera,&min,&max);
+
+            flush_stdin();
+            g_print("\n Select  Contrast min(%d)-max(%d)",min,max);
+            err = scanf("%d",&idx);
+            bret = camera_attr_set_contrast(hcamcorder->camera,idx);
+            break;
+
+
+
+        case 'w' : // Setting > White balance
+            g_print("*White balance !\n");
+
+            flush_stdin();
+            g_print("\n Select White balance \n");
+            camera_attr_foreach_supported_whitebalance(hcamcorder->camera,white_balance_cb,NULL);
+            err = scanf("%d",&idx);
+            bret = camera_attr_set_whitebalance(hcamcorder->camera,idx);
+            break;
+
+        case 't' : // Setting > Color tone
+            g_print("*Color tone !\n");
+            camera_attr_foreach_supported_effect(hcamcorder->camera,colortone_cb,NULL);
+
+            g_print("\n Select Color tone \n");
+            flush_stdin();
+            err = scanf("%d",&idx);
+            bret = camera_attr_set_effect(hcamcorder->camera, idx);
+
+            break;
+
+        case 'd' : // Setting > WDR
+            g_print("*WDR !\n");
+
+            g_print("\n Select WDR Mode \n");
+            flush_stdin();
+            for (i = 0; i < 2; i++) {
+                g_print("\t %d. %s\n", i+1, wdr_mode[i]);
+            }
+            err = scanf("%d",&idx);
+            if( idx == 1)
+                bret = camera_attr_enable_auto_contrast(hcamcorder->camera,0);
+            else if (idx == 2)
+                bret = camera_attr_enable_auto_contrast(hcamcorder->camera,1);
+
+            break;
+
+        case 'e' : // Setting > EV program mode
+            g_print("* EV program mode!\n");
+            camera_attr_foreach_supported_scene_mode(hcamcorder->camera,program_mode_cb,NULL);
+
+            g_print("\n Select EV program mode \n");
+            flush_stdin();
+            err = scanf("%d",&idx);
+            bret = camera_attr_set_scene_mode(hcamcorder->camera,idx);
+
+            break;
+
+            /* ext. setting */
+        case 'z' : // Setting > Strobe setting
+            g_print("*Strobe Mode\n");
+            camera_attr_foreach_supported_flash_mode(hcamcorder->camera,strobe_mode_cb,NULL);
+            g_print("\n Select Strobe Mode \n");
+            flush_stdin();
+            err = scanf("%d",&idx);
+            bret = camera_attr_set_flash_mode(hcamcorder->camera, idx);
+
+            break;
+
+        case 'l' : // Setting > Face detection setting
+            //hcamcorder->menu_state = MENU_STATE_SETTING_DETECTION;
+            g_print("* Face detect mode !\n");
+
+
+            flush_stdin();
+            for (i = 0; i < 2; i++) {
+                g_print("\t %d. %s \n", i+1, detection_mode[i]);
+            }
+            err = scanf("%d",&idx);
+            if(camera_is_supported_face_detection(hcamcorder->camera))
+            {
+                if( idx >= 0 && idx < 2 )
+                    bret = camera_start_face_detection(hcamcorder->camera,_face_detected,NULL);
+            }
+            else {
+                g_print("face detection_not supported");
+            }
+
+            break;
+
+        case 'k' : // Setting > Anti-handshake
+            g_print("*Anti-handshake !\n");
+
+            g_print("\n Select Anti-handshake mode \n");
+            flush_stdin();
+            for (i = 0; i < 2; i++) {
+                g_print("\t %d. %s\n", i+1, ahs_mode[i]);
+            }
+            err = scanf("%d",&idx);
+            bret = camera_attr_enable_anti_shake(hcamcorder->camera,idx-1);
+
+            break;
+
+        case 'K' : // Setting > Video-stabilization
+            g_print("*Video-stabilization !\n");
+
+            g_print("\n Select Video-stabilization mode \n");
+            flush_stdin();
+            for (i = 0; i < 2; i++) {
+                g_print("\t %d. %s\n", i+1, vs_mode[i]);
+            }
+            err = scanf("%d",&idx);
+
+            if (idx == 2) {
+                g_print("\n Restart preview with NV12 and 720p resolution\n");
+
+                err = camera_stop_preview(hcamcorder->camera);
+
+                camera_set_preview_resolution(hcamcorder->camera,1280,720);
+                camera_set_preview_format(hcamcorder->camera, CAMERA_PIXEL_FORMAT_NV12);
+                camera_attr_enable_video_stabilization(hcamcorder->camera, idx-1);
+
+                if (err == 0) {
+                    err = camera_start_preview(hcamcorder->camera);
+
+                    if (err != 0)
+                        g_print("\n Restart FAILED! %x\n", err);
+                }
+            }
+            break;
+
+        case 'u': // Touch AF area
+            g_print("* Touch AF area !\n");
+
+            flush_stdin();
+            g_print( "\n Input x,y,width,height \n" );
+            err = scanf( "%d,%d,%d,%d", &x, &y, &width, &height );
+            err =camera_attr_set_af_area(hcamcorder->camera,width,height);
+
+            if (err != 0 ) {
+                g_print( "Failed to set touch AF area.(%x)\n", err );
+            } else {
+                g_print( "Succeed to set touch AF area.\n" );
+            }
+            break;
+
+
+        case 'M':
+            {
+                float motion_rate = 0.0;
+
+                flush_stdin();
+
+                g_print("*Camcorder Motion Rate setting! (should be bigger than zero)\n");
+
+                err = scanf("%f", &motion_rate);
+                err = recorder_attr_set_recording_motion_rate(hcamcorder->recorder,motion_rate);
+                if (err != 0) {
+                    g_print("Failed to set Camcorder Motion Rate %f [err:0x%x]\n", motion_rate, err);
+                } else {
+                    g_print("Succeed to set Motion Rate %f\n", motion_rate);
+                }
+            }
+            break;
+
+        case 'b' : // back
+            hcamcorder->menu_state = MENU_STATE_MAIN;
+            break;
+
+        default :
+            g_print("\t Invalid input \n");
+            break;
+        }
+    } else {
+        g_print("\t Invalid mode, back to upper menu \n");
+        hcamcorder->menu_state = MENU_STATE_MAIN;
+    }
+
+    g_print("\t bret : 0x%x \n", bret);
 }
 
-void _camera_capturing_cb_modechange2(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
-	printf("in recording capture callback\n");
-}
-void _camera_capture_completed_cb_modechange2(void *user_data){
-	printf("in recording capture complete\n");
-}
 
+/**
+* This function is to execute command.
+*
+* @param    channel [in]    1st parameter
+*
+* @return   This function returns TRUE/FALSE
+* @remark
+* @see
+*/
+static gboolean cmd_input(GIOChannel *channel)
+{
+    gchar *buf = NULL;
+    gsize read_size;
+    GError *g_error = NULL;
+
+    LOGD("ENTER");
+
+    g_io_channel_read_line(channel, &buf, &read_size, NULL, &g_error);
+    if (g_error) {
+        LOGD("g_io_channel_read_chars error");
+        g_error_free(g_error);
+        g_error = NULL;
+    }
+
+    if (buf) {
+        g_strstrip(buf);
+
+        LOGD("Menu Status : %d", hcamcorder->menu_state);
+        switch(hcamcorder->menu_state)
+        {
+        case MENU_STATE_MAIN:
+            main_menu(buf[0]);
+            break;
+        case MENU_STATE_SETTING:
+            setting_menu(buf[0]);
+            break;
+        default:
+            break;
+        }
+
+        g_free(buf);
+        buf = NULL;
+
+        print_menu();
+    } else {
+        LOGD("No read input");
+    }
+
+    return TRUE;
+}
 
-int modechange_test(){
-	camera_h camera;
-	recorder_h recorder;
-	int ret;
-	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
-	printf("camera_create %d\n", ret);
-	ret = recorder_create_videorecorder(camera, &recorder);
-	printf("recorder_create_videorecorder %d\n", ret);
-	camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11 , GET_DISPLAY(preview_win));
-
-	ret =recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
-	printf("recorder_set_file_format %d\n", ret);
-	ret =recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
-	printf("recorder_set_audio_encoder %d\n", ret);
-	ret =recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
-	printf("recorder_set_video_encoder %d\n", ret);
-	ret =recorder_set_filename(recorder , "/mnt/nfs/videotest_AAC_MPEG4.3gp");
-	printf("recorder_set_filename %d\n", ret);
-
-	ret = camera_start_preview(camera);
-	printf("camera_start_preview %d\n", ret);
-	ret = camera_start_capture(camera, _camera_capturing_cb_modechange, _camera_capture_completed_cb_modechange, NULL);
-	printf("camera_start_capture %d\n", ret);
-	camera_state_e state;
-	camera_get_state(camera, &state);
-	while( state == CAMERA_STATE_CAPTURING ){
-		sleep(1);
-		camera_get_state(camera, &state);
-		printf("camera state = %d\n", state);
-	}
-
-	ret =recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
-	printf("recorder_set_audio_encoder %d\n", ret);
-	ret =recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
-	printf("recorder_set_video_encoder %d\n", ret);
-
-	ret = camera_start_preview(camera);
-	printf("camera_start_preview %d\n", ret);
-
-	ret = recorder_start(recorder);
-	printf("recorder_start %d\n", ret);
-	sleep(5);
-	ret = camera_start_capture(camera, _camera_capturing_cb_modechange2, _camera_capture_completed_cb_modechange2, NULL);
-	sleep(5);
-
-	ret = recorder_commit(recorder);
-	printf("recorder_commit %d\n", ret);
-	return 0;
+static gboolean init(int type)
+{
+    int err;
+    int ischeck=0;
+
+    if (!hcamcorder)
+        return FALSE;
+
+    if (!hcamcorder->recorder)
+        return FALSE;
+
+    /*================================================================================
+    Video capture mode
+    *=================================================================================*/
+    if (type == MODE_VIDEO_CAPTURE) {
+        err = recorder_set_file_format(hcamcorder->recorder,RECORDER_FILE_FORMAT_MP4);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_attr_set_audio_device(hcamcorder->recorder,RECORDER_AUDIO_DEVICE_MIC);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_set_audio_encoder(hcamcorder->recorder,RECORDER_AUDIO_CODEC_AAC);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_set_video_encoder(hcamcorder->recorder,RECORDER_VIDEO_CODEC_MPEG4);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_attr_set_video_encoder_bitrate(hcamcorder->recorder,VIDEO_ENCODE_BITRATE);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_attr_set_audio_samplerate(hcamcorder->recorder,AUDIO_SOURCE_SAMPLERATE_AAC);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_attr_set_audio_channel(hcamcorder->recorder,AUDIO_SOURCE_CHANNEL_AAC);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_set_filename(hcamcorder->recorder,TARGET_FILENAME_VIDEO);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+    }
+    /*================================================================================
+    Audio mode
+    *=================================================================================*/
+    else if (type == MODE_AUDIO)
+    {
+        err = recorder_set_file_format(hcamcorder->recorder,RECORDER_FILE_FORMAT_MP4);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_attr_set_audio_device(hcamcorder->recorder,RECORDER_AUDIO_DEVICE_MIC);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_set_audio_encoder(hcamcorder->recorder,RECORDER_AUDIO_CODEC_AAC);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_attr_set_audio_samplerate(hcamcorder->recorder,AUDIO_SOURCE_SAMPLERATE_AAC);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_attr_set_audio_channel(hcamcorder->recorder,AUDIO_SOURCE_CHANNEL_AAC);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_set_filename(hcamcorder->recorder,TARGET_FILENAME_AUDIO);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_attr_set_time_limit(hcamcorder->recorder,360000);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+        err = recorder_attr_set_audio_encoder_bitrate(hcamcorder->recorder,128000);
+        if (err < 0) {
+            LOGE("Init fail. (%x)",err);
+            goto ERROR;
+        }
+    }
+
+    recorder_set_recording_status_cb(hcamcorder->recorder, _recording_status_cb, NULL);
+    recorder_set_recording_limit_reached_cb(hcamcorder->recorder, _recording_limit_reached_cb, &ischeck);
+
+    LOGD("Init DONE.");
+
+    return TRUE;
+
+ERROR:
+    LOGE("init failed.");
+    return FALSE;
 }
 
+static gboolean init_handle()
+{
+    hcamcorder->mode = MODE_VIDEO_CAPTURE;  /* image(capture)/video(recording) mode */
+    hcamcorder->menu_state = MENU_STATE_MAIN;
+    hcamcorder->isMute = FALSE;
+    hcamcorder->elapsed_time = 0;
+    hcamcorder->fps = SRC_VIDEO_FRAME_RATE_15; /*SRC_VIDEO_FRAME_RATE_30;*/
 
-void* test_main(void *arg){
-	int ret = 0;
-	//ret = recorder_encoder_test();
-	/*
-	ret = recorder_attribute_test();
-	ret += recorder_state_change_test();
-	ret += recorder_recoding_status_cb_test();
-	ret += recorder_limit_cb_test();
-	ret += video_recorder_test();
-	ret = mm_test();
-	*/
-
-	//audio_level_test();
-	//slow_motion_test();
-	//recording_capture_test();
-	//audio_stream_cb_test();
-	//modechange_test();
-	recorder_recoding_status_cb_test();
-
-	if( ret == 0 )
-		printf("--------------RECORDER TEST ALL PASS--------------------------\n");
-	else
-		printf("--------------RECORDER TEST FAIL %d--------------------------\n", -ret);
-
-
-	return 0;
+    return TRUE;
+}
+/**
+* This function is to change camcorder mode.
+*
+* @param    type    [in]    image(capture)/video(recording) mode
+*
+* @return   This function returns TRUE/FALSE
+* @remark
+* @see      other functions
+*/
+static gboolean mode_change()
+{
+    int err = RECORDER_ERROR_NONE;
+    int state = RECORDER_STATE_NONE;
+    char media_type = '\0';
+    bool check= FALSE;
+
+    if (hcamcorder->recorder) {
+        err = recorder_get_state(hcamcorder->recorder,(recorder_state_e*)&state);
+        if (state != RECORDER_STATE_NONE) {
+            if (state == RECORDER_STATE_RECORDING ||
+                state == RECORDER_STATE_PAUSED) {
+                LOGD("recorder_cancel");
+                err = recorder_cancel(hcamcorder->recorder);
+                if (err != RECORDER_ERROR_NONE) {
+                    LOGE("exit recorder_cancel failed 0x%x", err);
+                    return FALSE;
+                }
+            }
+
+            err = recorder_get_state(hcamcorder->recorder, (recorder_state_e*)&state);
+            if (state == RECORDER_STATE_READY) {
+                LOGD("recorder_unprepare");
+                recorder_unprepare(hcamcorder->recorder);
+            }
+
+            err = recorder_get_state(hcamcorder->recorder, (recorder_state_e*)&state);
+            if (state == RECORDER_STATE_CREATED) {
+                LOGD("recorder_destroy");
+                err = recorder_destroy(hcamcorder->recorder);
+                if (err == RECORDER_ERROR_NONE) {
+                    LOGD("recorder_destroy done");
+                    hcamcorder->recorder = NULL;
+                }
+            }
+        }
+    } else {
+        LOGW("NULL handle");
+    }
+
+    init_handle();
+
+    g_get_current_time(&previous);
+    g_timer_reset(timer);
+
+    while (!check) {
+        g_print("\n\t=======================================\n");
+        g_print("\t   RECORDER_TESTSUIT\n");
+        g_print("\t=======================================\n");
+        g_print("\t   '1' Video Capture - Rear Camera\n");
+        g_print("\t   '2' Audio Recording - MIC\n");
+        g_print("\t   '3' Audio Recording - MODEM\n");
+        g_print("\t   'q' Exit\n");
+        g_print("\t=======================================\n");
+
+        g_print("\t  Enter the media type:\n\t");
+
+        err = scanf("%c", &media_type);
+        if (err == EOF) {
+            g_print("\t!!!read input error!!!\n");
+            continue;
+        }
+
+        LOGD("media type : %c", media_type);
+
+        switch (media_type) {
+        case '1':
+            hcamcorder->mode = MODE_VIDEO_CAPTURE;
+
+            LOGD("camera_create");
+
+            err = camera_create(CAMERA_DEVICE_CAMERA0, &hcamcorder->camera);
+            if (err != CAMERA_ERROR_NONE) {
+                LOGE("camera create failed 0x%d", err);
+                continue;
+            }
+
+            err = camera_set_display(hcamcorder->camera, CAMERA_DISPLAY_TYPE_OVERLAY,GET_DISPLAY(display));
+            if (err != CAMERA_ERROR_NONE) {
+                LOGE("set display failed 0x%d", err);
+                camera_destroy(hcamcorder->camera);
+                hcamcorder->camera = NULL;
+                continue;
+            }
+
+            err = camera_start_preview(hcamcorder->camera);
+            if (err != CAMERA_ERROR_NONE) {
+                LOGE("start preview failed 0x%d", err);
+                camera_destroy(hcamcorder->camera);
+                hcamcorder->camera = NULL;
+                continue;
+            }
+
+            err = recorder_create_videorecorder(hcamcorder->camera,&hcamcorder->recorder);
+            if (err != RECORDER_ERROR_NONE) {
+                LOGE("video recorder create failed 0x%d", err);
+                camera_stop_preview(hcamcorder->camera);
+                camera_destroy(hcamcorder->camera);
+                hcamcorder->camera = NULL;
+                continue;
+            }
+
+            check = TRUE;
+            break;
+        case '2':
+            hcamcorder->mode = MODE_AUDIO;
+            err = recorder_create_audiorecorder(&hcamcorder->recorder);
+            if (err != RECORDER_ERROR_NONE) {
+                LOGE("audio recorder create failed 0x%x", err);
+                continue;
+            }
+			{
+				double set_rate = 1, get_rate;
+				recorder_attr_set_recording_motion_rate(hcamcorder->recorder, set_rate);
+				recorder_attr_get_recording_motion_rate(hcamcorder->recorder, &get_rate);
+				g_print("set_rate %.20lf, get_rate %.20lf\n", set_rate, get_rate);
+				if (set_rate == get_rate) {
+					g_print("SAME\n");
+				} else {
+					g_print("DIFF\n");
+				}
+			}
+
+            err = recorder_attr_set_audio_device(hcamcorder->recorder,RECORDER_AUDIO_DEVICE_MIC);
+            if (err != RECORDER_ERROR_NONE) {
+                LOGE("set audio device failed 0x%x", err);
+                recorder_destroy(hcamcorder->recorder);
+                hcamcorder->recorder = NULL;
+                continue;
+            }
+
+            check = TRUE;
+            break;
+        case '3':
+            hcamcorder->mode = MODE_AUDIO;
+            err = recorder_create_audiorecorder(&hcamcorder->recorder);
+            if (err != RECORDER_ERROR_NONE) {
+                LOGE("audio recorder create failed 0x%d", err);
+                continue;
+            }
+
+            recorder_attr_set_audio_device(hcamcorder->recorder,RECORDER_AUDIO_DEVICE_MODEM);
+            if (err != RECORDER_ERROR_NONE) {
+                LOGE("set audio device failed 0x%d", err);
+                recorder_destroy(hcamcorder->recorder);
+                hcamcorder->recorder = NULL;
+                continue;
+            }
+
+            check = TRUE;
+            break;
+        case 'q':
+            g_print("\t Quit Camcorder Testsuite!!\n");
+            hcamcorder->mode = -1;
+            if (g_main_loop_is_running(g_loop)) {
+                g_main_loop_quit(g_loop);
+            }
+            return FALSE;
+        default:
+            g_print("\t Invalid media type(%c)\n", media_type);
+            continue;
+        }
+    }
+
+    g_timer_reset(timer);
+
+    if (!init(hcamcorder->mode)) {
+        LOGE("testsuite init() failed.");
+        return -1;
+    }
+
+    g_timer_reset(timer);
+
+    err = recorder_prepare(hcamcorder->recorder);
+
+    LOGD("recorder_start()  : %12.6lfs", g_timer_elapsed(timer, NULL));
+
+    if (err != RECORDER_ERROR_NONE) {
+        LOGE("recorder_start  = %x", err);
+        return -1;
+    }
+
+    g_get_current_time(&current);
+    timersub(&current, &previous, &res);
+
+    LOGD("Recorder Starting Time  : %ld.%lds", res.tv_sec, res.tv_usec);
+
+    return TRUE;
 }
 
-int main(int argc, char ** argv)
+
+/**
+* This function is the example main function for recorder API.
+*
+* @param
+*
+* @return   This function returns 0.
+* @remark
+* @see      other functions
+*/
+int main(int argc, char **argv)
 {
-	
-	elm_init(argc, argv);
+    int bret;
+
+#if !GLIB_CHECK_VERSION(2,35,0)
+    if (!g_thread_supported())
+        g_thread_init (NULL);
+#endif
 
+    timer = g_timer_new();
 
+    gst_init(&argc, &argv);
+    elm_init(argc, argv);
 
-	mEvasWindow = elm_win_add(NULL, "VIDEO OVERLAY", ELM_WIN_BASIC);
-	elm_win_title_set(mEvasWindow, "video overlay window");
-	elm_win_borderless_set(mEvasWindow, 0);
-	evas_object_resize(mEvasWindow, 800, 480);
-	evas_object_move(mEvasWindow, 0, 0);
-	evas_object_show(mEvasWindow);	
+    LOGD("gst_init() : %12.6lfs", g_timer_elapsed(timer, NULL));
 
-	//To support full-screen
-	elm_win_rotation_set(mEvasWindow, 270);
-	//elm_win_fullscreen_set(mEvasWindow, 1);
-	
-	evas_object_color_set(mEvasWindow, 0,0,0,0);
-	preview_win = elm_win_xwindow_get(mEvasWindow);
+    hcamcorder = (cam_handle_t *) g_malloc0(sizeof(cam_handle_t));
 
-	fprintf(stderr, "end of elm\n");
+    Evas_Object *eo = NULL;
+    eo = elm_win_add(NULL, "VIDEO OVERLAY", ELM_WIN_BASIC);
+    elm_win_title_set(eo, "VIDEO oVERLAY");
+    evas_object_resize(eo,200,200);
+    evas_object_show(eo);
+    display=(void *)eo;
 
-	pthread_t gloop_thread;
+    recorder_state = RECORDER_STATE_NONE;
 
-	pthread_create(&gloop_thread, NULL, test_main,  NULL);
+    g_timer_reset(timer);
 
+    bret = mode_change();
+    if (!bret)
+        return bret;
 
+    print_menu();
 
-	elm_run();
-	elm_shutdown();
-	
+    g_loop = g_main_loop_new(NULL, FALSE);
 
-	return 0;
+    stdin_channel = g_io_channel_unix_new(fileno(stdin));/* read from stdin */
+    g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)cmd_input, NULL);
+
+    LOGD("RUN main loop");
+
+    g_main_loop_run(g_loop);
+
+    LOGD("STOP main loop");
+
+    if (timer) {
+        g_timer_stop(timer);
+        g_timer_destroy(timer);
+        timer = NULL;
+    }
+    //g_print("\t Exit from the application.\n");
+    g_free(hcamcorder);
+    g_main_loop_unref(g_loop);
+    g_io_channel_unref(stdin_channel);
+
+    return bret;
 }
+
+/*EOF*/