Add new testsuite package for headless target

- Minor change
 : Rename package for testsuite.(tool -> test)
 : Remove build warning.

[Version] 0.4.75
[Issue Type] New feature

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

7 files changed, 2057 insertions, 6 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ca27ab3..243f3bd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -71,6 +71,7 @@ CONFIGURE_FILE(
 INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
 
 ADD_SUBDIRECTORY(test)
+ADD_SUBDIRECTORY(test_headless)
 
 IF(UNIX)
 
diff --git a/capi-media-camera-tool.manifest b/capi-media-camera-test-headless.manifest
index a76fdba..a76fdba 100644
--- a/capi-media-camera-tool.manifest
+++ b/capi-media-camera-test-headless.manifest
diff --git a/capi-media-camera-test.manifest b/capi-media-camera-test.manifest
new file mode 100644
index 0000000..a76fdba
--- /dev/null
+++ b/capi-media-camera-test.manifest
@@ -0,0 +1,5 @@
+<manifest>
+	<request>
+		<domain name="_" />
+	</request>
+</manifest>
diff --git a/packaging/capi-media-camera.spec b/packaging/capi-media-camera.spec
index 7143635..3947dec 100644
--- a/packaging/capi-media-camera.spec
+++ b/packaging/capi-media-camera.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-camera
 Summary:    A Camera API
-Version:    0.4.74
+Version:    0.4.75
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0
@@ -39,13 +39,21 @@ Requires: pkgconfig(capi-media-tool)
 Development related files for a Camera library in Tizen Native API.
 
 
-%package tool
+%package test
 Summary:  A Camera API testsuite
 Requires: %{name} = %{version}-%{release}
 
-%description tool
+%description test
 Tizen Native camera API testsuite.
 
+%package test-headless
+Summary:  A Camera API testsuite for headless target
+Requires: %{name} = %{version}-%{release}
+
+%description test-headless
+Tizen Native camera API testsuite for headless target.
+
+
 %if 0%{?gcov:1}
 %package gcov
 Summary: Line Coverage of Camera library in Tizen Native API
@@ -94,6 +102,14 @@ install -m 0644 gcov-obj/* %{buildroot}%{_datadir}/gcov/obj/%{name}
 %postun -p /sbin/ldconfig
 
 
+%post test
+chsmack -e "System" %{_bindir}/camera_test
+
+
+%post test-headless
+chsmack -e "System" %{_bindir}/camera_test_headless
+
+
 %files
 %manifest capi-media-camera.manifest
 %license LICENSE.APLv2
@@ -105,10 +121,15 @@ install -m 0644 gcov-obj/* %{buildroot}%{_datadir}/gcov/obj/%{name}
 %{_libdir}/pkgconfig/*.pc
 %{_libdir}/libcapi-media-camera.so
 
-%files tool
-%manifest capi-media-camera-tool.manifest
+%files test
+%manifest capi-media-camera-test.manifest
+%license LICENSE.APLv2
+%{_bindir}/camera_test
+
+%files test-headless
+%manifest capi-media-camera-test-headless.manifest
 %license LICENSE.APLv2
-%{_bindir}/*
+%{_bindir}/camera_test_headless
 
 %if 0%{?gcov:1}
 %files gcov
diff --git a/test/camera_test.c b/test/camera_test.c
index 52f7e29..9115cb8 100644
--- a/test/camera_test.c
+++ b/test/camera_test.c
@@ -24,6 +24,7 @@
 =======================================================================================*/
 #include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
 #include <glib.h>
 #include <sys/time.h>
 #include <dlog.h>
diff --git a/test_headless/CMakeLists.txt b/test_headless/CMakeLists.txt
new file mode 100644
index 0000000..4d0cc52
--- /dev/null
+++ b/test_headless/CMakeLists.txt
@@ -0,0 +1,24 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+SET(fw_test "${fw_name}-test-headless")
+
+#INCLUDE_DIRECTORIES(../include)
+#link_directories(${CMAKE_SOURCE_DIR}/../)
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(${fw_test} REQUIRED libtbm)
+FOREACH(flag ${${fw_test}_CFLAGS})
+    SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+    MESSAGE(${flag})
+ENDFOREACH()
+
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -pie -Wall")
+
+aux_source_directory(. sources)
+FOREACH(src ${sources})
+    GET_FILENAME_COMPONENT(src_name ${src} NAME_WE)
+    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_headless/camera_test_headless.c b/test_headless/camera_test_headless.c
new file mode 100644
index 0000000..aa4ac0f
--- /dev/null
+++ b/test_headless/camera_test_headless.c
@@ -0,0 +1,1999 @@
+/*
+ * camera_test_headless
+ *
+ * Copyright (c) 2022 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * 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 f(r the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*=======================================================================================
+|  INCLUDE FILES                                                                        |
+=======================================================================================*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <glib.h>
+#include <sys/time.h>
+#include <dlog.h>
+#include <camera_internal.h>
+#include <tbm_surface.h>
+#include <media_bridge_internal.h>
+
+/*-----------------------------------------------------------------------
+|    GLOBAL VARIABLE DEFINITIONS:                                       |
+-----------------------------------------------------------------------*/
+#define EXPORT_API __attribute__((__visibility__("default")))
+
+#ifdef PACKAGE
+#undef PACKAGE
+#endif
+#define PACKAGE "camera_test"
+
+static GMainLoop *g_mainloop_camera_test = NULL;
+static GIOChannel *stdin_channel;
+static camera_device_e camera_device;
+static GTimer *timer;
+static int g_camera_device_state_changed_cb_id;
+static int g_camera_device_connection_changed_cb_id;
+static int g_camera_preview_cb_dump;
+static int g_camera_extra_preview_cb_dump;
+static int g_camera_mp_preview_cb_dump;
+
+static struct timeval previous_time;
+static struct timeval current_time;
+static struct timeval result_time;
+
+static media_bridge_h bridge;
+
+/*-----------------------------------------------------------------------
+|    GLOBAL CONSTANT DEFINITIONS:                                       |
+-----------------------------------------------------------------------*/
+
+
+/*-----------------------------------------------------------------------
+|    IMPORTED VARIABLE DECLARATIONS:                                    |
+-----------------------------------------------------------------------*/
+
+
+/*-----------------------------------------------------------------------
+|    IMPORTED FUNCTION DECLARATIONS:                                    |
+-----------------------------------------------------------------------*/
+
+
+/*-----------------------------------------------------------------------
+|    LOCAL #defines:                                                    |
+-----------------------------------------------------------------------*/
+#define DEFAULT_FILE_PATH               "/home/owner/media"
+#define PREVIEW_CB_DUMP_FILE_NAME       "preview.data"
+#define EXTRA_PREVIEW_CB_DUMP_FILE_NAME "extra_preview.data"
+#define MP_PREVIEW_CB_DUMP_FILE_NAME    "mp_preview.data"
+#define MAX_FILE_NAME_LENGTH            256
+#define MAX_FILE_PATH_LENGTH            (MAX_FILE_NAME_LENGTH - 20)
+
+#define CHECK_MM_ERROR(expr) \
+	do {\
+		int ret = 0; \
+		ret = expr; \
+		if (ret != 0) {\
+			g_print("[%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
+
+#define SENSOR_WHITEBALANCE_NUM     10
+#define SENSOR_COLOR_TONE_NUM       31
+#define SENSOR_FLIP_NUM             4
+#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         20
+
+
+/*-----------------------------------------------------------------------
+  |    LOCAL CONSTANT DEFINITIONS:                                        |
+  -----------------------------------------------------------------------*/
+enum {
+	MODE_VIDEO_CAPTURE, /* recording and image capture mode */
+	MODE_AUDIO,     /* audio recording*/
+	MODE_NUM,
+};
+
+enum {
+	MENU_STATE_INIT,
+	MENU_STATE_MAIN,
+	MENU_STATE_MAIN_SETTING,
+	MENU_STATE_DEVICE_STATE,
+	MENU_STATE_DEVICE_LIST,
+	MENU_STATE_NUM,
+};
+
+/*-----------------------------------------------------------------------
+  |    LOCAL DATA TYPE DEFINITIONS:                   |
+  -----------------------------------------------------------------------*/
+typedef struct _cam_handle {
+	camera_h camera;
+	int type;
+	int is_multishot;                           /* flag for multishot mode */
+	int stillshot_count;                        /* stillshot count */
+	int multishot_count;                        /* multishot count */
+	char file_path[MAX_FILE_PATH_LENGTH];       /* file path for captured data */
+	int menu_state;
+	unsigned long long elapsed_time;
+} cam_handle_t;
+
+typedef struct {
+	int width[100];
+	int height[100];
+	int count;
+} resolution_stack;
+
+typedef struct {
+	camera_attr_exposure_mode_e mode;
+	int count;
+} exposure_stack;
+
+typedef struct {
+	camera_attr_iso_e mode;
+	int count;
+} iso_stack;
+
+
+/*---------------------------------------------------------------------------
+  |    LOCAL VARIABLE DEFINITIONS:                                            |
+  ---------------------------------------------------------------------------*/
+static cam_handle_t *hcamcorder;
+static camera_device_manager_h g_device_manager;
+
+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 *sensor_flip[SENSOR_FLIP_NUM] = {
+	"NONE",
+	"HORIZONTAL",
+	"VERTICAL",
+	"BOTH"
+};
+
+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 *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 mode",
+	"AE spot 1 mode",
+	"AE custom mode",
+};
+
+const char *image_fmt[SENSOR_IMAGE_FORMAT] = {
+	"NV12",
+	"NV12T",
+	"NV16",
+	"NV21",
+	"YUYV",
+	"UYVY",
+	"422P",
+	"I420",
+	"YV12",
+	"RGB565",
+	"RGB888",
+	"RGBA",
+	"ARGB",
+	"JPEG",
+	"ITLV(YUYV+JPEG, but should not be seen)",
+	"H264",
+	"INVZ",
+	"MJPEG",
+	"VP8",
+	"VP9"
+};
+
+const char *face_zoom_mode[] = {
+	"Face Zoom OFF",
+	"Face Zoom ON",
+};
+
+const char *display_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 *af_scan[SENSOR_AF_SCAN_NUM] = {
+	"None",
+	"Normal",
+	"Macro mode",
+	"Full mode",
+};
+
+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",
+};
+
+const char *facing_direction[] = {
+	"REAR",
+	"FRONT",
+};
+
+
+/*---------------------------------------------------------------------------
+  |    LOCAL FUNCTION PROTOTYPES:                                             |
+  ---------------------------------------------------------------------------*/
+static void print_menu();
+static gboolean cmd_input(GIOChannel *channel, GIOCondition condition, gpointer data);
+static gboolean mode_change(gchar buf);
+int camcordertest_set_attr_int(const char* attr_subcategory, int value);
+
+
+static void __release_media_bridge()
+{
+	if (bridge) {
+		media_bridge_unset_source(bridge); /* not mandatory, it will be done in media_bridge_destroy() */
+		media_bridge_destroy(bridge);
+		bridge = NULL;
+	}
+}
+
+static inline void flush_stdin()
+{
+	int ch;
+	while ((ch = getchar()) != EOF && ch != '\n');
+}
+
+static gboolean _release_idle_event_callback(void *data)
+{
+	g_print("destroy camera handle\n\n");
+
+	camera_destroy(hcamcorder->camera);
+	hcamcorder->camera = NULL;
+	hcamcorder->menu_state = MENU_STATE_INIT;
+
+	print_menu();
+
+	return 0;
+}
+
+static void _camera_error_cb(int error, camera_state_e current_state, void *user_data)
+{
+	g_print("\n\n\tERROR [0x%x], current state %d\n", error, current_state);
+
+	switch (error) {
+	case CAMERA_ERROR_RESOURCE_CONFLICT:
+		g_print("\t\t[CAMERA_ERROR_RESOURCE_CONFLICT]\n\n");
+		break;
+	case CAMERA_ERROR_SECURITY_RESTRICTED:
+		g_print("\t\t[CAMERA_ERROR_SECURITY_RESTRICTED]\n\n");
+		break;
+	case CAMERA_ERROR_SERVICE_DISCONNECTED:
+		g_print("\t\t[CAMERA_ERROR_SERVICE_DISCONNECTED]\n\n");
+		g_idle_add_full(G_PRIORITY_DEFAULT,
+			(GSourceFunc)_release_idle_event_callback,
+			NULL, NULL);
+		break;
+	default:
+		break;
+	}
+}
+
+static void _camera_state_changed_cb(camera_state_e previous, camera_state_e current, bool by_policy, void *user_data)
+{
+	g_print("\n\tcamera state changed %d -> %d\n", previous, current);
+}
+
+static void _camera_device_state_changed_cb(camera_device_e device, camera_device_state_e state, void *user_data)
+{
+	g_print("\n\tcamera device[%d] state changed to %d\n", device, state);
+}
+
+static void _camera_device_connection_changed_cb(camera_device_s *device, bool is_connected, void *user_data)
+{
+	if (!device) {
+		g_print("NULL list");
+		return;
+	}
+
+	g_print("\n\tcamera device changed[is_connected:%d][Type:%d,index:%d,name:%s,id:%s,exstreamnum:%d]\n",
+		is_connected, device->type, device->index, device->name, device->id, device->extra_stream_num);
+}
+
+static void _camera_interrupted_cb(camera_policy_e policy, camera_state_e previous, camera_state_e current, void *user_data)
+{
+	g_print("\n\tcamera interrupted callback called[state %d -> %d, policy %d]\n",
+		previous, current, policy);
+}
+
+static void _camera_interrupt_started_cb(camera_policy_e policy, camera_state_e state, void *user_data)
+{
+	g_print("\n\tcamera interrupt started callback called[state %d, policy %d]\n", state, policy);
+}
+
+static void _dump_preview_data(camera_preview_data_s *frame, const char *file_name)
+{
+	char dump_path[MAX_FILE_NAME_LENGTH] = {'\0',};
+	FILE *fp = NULL;
+
+	if (!frame) {
+		g_print("\n[DUMP_PREVIEW_DATA] NULL frame\n");
+		return;
+	}
+
+	snprintf(dump_path, MAX_FILE_NAME_LENGTH, "%s/%s", DEFAULT_FILE_PATH, file_name);
+
+	fp = fopen(dump_path, "a");
+	if (fp == NULL) {
+		g_print("\n[DUMP_PREVIEW_DATA] file[%s] open failed\n", dump_path);
+		return;
+	}
+
+	switch (frame->format) {
+	case CAMERA_PIXEL_FORMAT_RGBA:
+		/* fall through */
+	case CAMERA_PIXEL_FORMAT_ARGB:
+		fwrite(frame->data.rgb_plane.data, 1, frame->data.rgb_plane.size, fp);
+		break;
+	case CAMERA_PIXEL_FORMAT_INVZ:
+		fwrite(frame->data.depth_plane.data, 1, frame->data.depth_plane.size, fp);
+		break;
+	case CAMERA_PIXEL_FORMAT_H264:
+		/* fall through */
+	case CAMERA_PIXEL_FORMAT_MJPEG:
+		/* fall through */
+	case CAMERA_PIXEL_FORMAT_VP8:
+		/* fall through */
+	case CAMERA_PIXEL_FORMAT_VP9:
+		fwrite(frame->data.encoded_plane.data, 1, frame->data.encoded_plane.size, fp);
+		break;
+	default:
+		switch (frame->num_of_planes) {
+		case 1:
+			fwrite(frame->data.single_plane.yuv, 1, frame->data.single_plane.size, fp);
+			break;
+		case 2:
+			fwrite(frame->data.double_plane.y, 1, frame->data.double_plane.y_size, fp);
+			fwrite(frame->data.double_plane.uv, 1, frame->data.double_plane.uv_size, fp);
+			break;
+		case 3:
+			fwrite(frame->data.triple_plane.y, 1, frame->data.triple_plane.y_size, fp);
+			fwrite(frame->data.triple_plane.u, 1, frame->data.triple_plane.u_size, fp);
+			fwrite(frame->data.triple_plane.v, 1, frame->data.triple_plane.v_size, fp);
+			break;
+		default:
+			break;
+		}
+		break;
+	}
+
+	g_print("[DUMP_PREVIEW_DATA] file[%s] write done\n", dump_path);
+
+	fclose(fp);
+}
+
+static void _camera_print_preview_info(camera_preview_data_s *frame)
+{
+	if (!frame) {
+		g_print("\n[PREVIEW_CB] NULL frame!\n");
+		return;
+	}
+
+	g_print("format[%d] res[%dx%d] num plane[%d] ",
+		frame->format, frame->width, frame->height, frame->num_of_planes);
+
+	if (frame->num_of_planes == 1) {
+		g_print("size [%d]\n",
+			frame->data.single_plane.size);
+	} else if (frame->num_of_planes == 2) {
+		g_print("size Y[%d] UV[%d]\n",
+			frame->data.double_plane.y_size,
+			frame->data.double_plane.uv_size);
+	} else if (frame->num_of_planes == 3) {
+		g_print("size Y[%d] U[%d] V[%d]\n",
+			frame->data.triple_plane.y_size,
+			frame->data.triple_plane.u_size,
+			frame->data.triple_plane.v_size);
+	}
+}
+
+static void _camera_preview_cb(camera_preview_data_s *frame, void *user_data)
+{
+	int ret = CAMERA_ERROR_NONE;
+	camera_h cam_handle = (camera_h)user_data;
+	camera_rotation_e rotation = CAMERA_ROTATION_NONE;
+
+	if (!cam_handle || !frame) {
+		g_print("\n[PREVIEW_CB] NULL param! %p %p\n", cam_handle, frame);
+		return;
+	}
+
+	ret = camera_attr_get_preview_frame_rotation(cam_handle, &rotation);
+	if (ret != CAMERA_ERROR_NONE)
+		g_print("[PREVIEW_CB] get preview frame rotation failed[0x%x]\n", ret);
+
+	g_print("[PREVIEW_CB] preview[rotation:%d] callback - ", rotation);
+
+	_camera_print_preview_info(frame);
+
+	if (g_camera_preview_cb_dump)
+		_dump_preview_data(frame, PREVIEW_CB_DUMP_FILE_NAME);
+}
+
+static void _camera_extra_preview_cb(camera_preview_data_s *frame, int stream_id, void *user_data)
+{
+	if (!frame) {
+		g_print("\n[PREVIEW_CB] NULL frame!\n");
+		return;
+	}
+
+	g_print("[EXTRA_PREVIEW_CB][stream_id:%d] preview callback - ", stream_id);
+
+	_camera_print_preview_info(frame);
+
+	if (g_camera_extra_preview_cb_dump)
+		_dump_preview_data(frame, EXTRA_PREVIEW_CB_DUMP_FILE_NAME);
+}
+
+
+static void _camera_media_packet_preview_cb(media_packet_h pkt, void *user_data)
+{
+	int ret = 0;
+	int width = 0;
+	int height = 0;
+	unsigned int i = 0;
+	char mp_dump_path[MAX_FILE_NAME_LENGTH] = {'\0',};
+	FILE *fp = NULL;
+	media_format_h fmt = NULL;
+	media_format_mimetype_e type = MEDIA_FORMAT_I420;
+	tbm_surface_h surface = NULL;
+	tbm_surface_info_s s_info;
+
+	if (!pkt) {
+		g_print("\n[MP_PREVIEW_CB] NULL packet!\n");
+		return;
+	}
+
+	ret = media_packet_get_format(pkt, &fmt);
+	if (ret != MEDIA_PACKET_ERROR_NONE) {
+		g_print("\n[MP_PREVIEW_CB] get media format failed[0x%x]", ret);
+		goto _MEDIA_PACKET_PREVIEW_CB_OUT;
+	}
+
+	ret = media_format_get_video_info(fmt, &type, &width, &height, NULL, NULL);
+	if (ret != MEDIA_FORMAT_ERROR_NONE) {
+		g_print("\n[MP_PREVIEW_CB] get video info failed[0x%x]", ret);
+		goto _MEDIA_PACKET_PREVIEW_CB_OUT;
+	}
+
+	g_print("[MP_PREVIEW_CB] media_packet_preview_cb[mimetype:0x%x, %dx%d]\n", type, width, height);
+
+	ret = media_packet_get_tbm_surface(pkt, &surface);
+	if (ret != MEDIA_PACKET_ERROR_NONE) {
+		g_print("\n[MP_PREVIEW_CB] get tbm surface failed[0x%x] ====\n", ret);
+		goto _MEDIA_PACKET_PREVIEW_CB_OUT;
+	}
+
+	ret = tbm_surface_get_info(surface, &s_info);
+	if (ret != TBM_SURFACE_ERROR_NONE) {
+		g_print("\n[MP_PREVIEW_CB] get tbm surface info failed[0x%x] ====\n", ret);
+		goto _MEDIA_PACKET_PREVIEW_CB_OUT;
+	}
+
+	g_print("                tbm surface [%dx%d], total size[%u]\n",
+		s_info.width, s_info.height, s_info.size);
+
+	if (g_camera_mp_preview_cb_dump) {
+		snprintf(mp_dump_path, MAX_FILE_NAME_LENGTH, "%s/%s", DEFAULT_FILE_PATH, MP_PREVIEW_CB_DUMP_FILE_NAME);
+		fp = fopen(mp_dump_path, "a");
+		if (fp == NULL) {
+			g_print("\n[MP_PREVIEW_CB] file[%s] open failed ====\n", mp_dump_path);
+			goto _MEDIA_PACKET_PREVIEW_CB_OUT;
+		}
+	}
+
+	for (i = 0 ; i < s_info.num_planes ; i++) {
+		g_print("                    plane[%d][%p] stride[%u] size[%u]\n",
+			i, s_info.planes[i].ptr, s_info.planes[i].stride, s_info.planes[i].size);
+		if (fp)
+			fwrite(s_info.planes[i].ptr, 1, s_info.planes[i].size, fp);
+	}
+
+_MEDIA_PACKET_PREVIEW_CB_OUT:
+	if (fp)
+		fclose(fp);
+
+	media_packet_unref(pkt);
+}
+
+
+static bool preview_resolution_cb(int width, int height, void *user_data)
+{
+	resolution_stack *data = (resolution_stack *)user_data;
+
+	if (data == NULL) {
+		g_print("NULL data\n");
+		return false;
+	}
+
+	data->width[data->count] = width;
+	data->height[data->count] = height;
+
+	g_print("\t%d. %dx%d\n", data->count, width, height);
+
+	data->count++;
+
+	return true;
+}
+
+static bool capture_resolution_test_cb(int width, int height, void *user_data)
+{
+	resolution_stack *data = (resolution_stack *)user_data;
+
+	if (data == NULL) {
+		g_print("NULL data\n");
+		return false;
+	}
+
+	data->width[data->count] = width;
+	data->height[data->count] = height;
+
+	g_print("\t%d. %dx%d\n", data->count, width, height);
+
+	data->count++;
+
+	return true;
+}
+
+static bool af_mode_foreach_cb(camera_attr_iso_e mode, void *user_data)
+{
+	g_print("\t%d. %s\n", mode, af_scan[mode]);
+	return true;
+}
+
+static bool exposure_mode_cb(camera_attr_af_mode_e mode, void *user_data)
+{
+	exposure_stack *data = (exposure_stack *)user_data;
+
+	if (data == NULL) {
+		g_print("NULL data\n");
+		return false;
+	}
+
+	data->mode = mode;
+	data->count++;
+
+	g_print("\t%d. %s\n", mode, exposure_mode[mode]);
+	return true;
+}
+
+static bool iso_mode_cb(camera_attr_iso_e mode, void *user_data)
+{
+	g_print("\t%d. %s\n", mode, iso_mode[mode]);
+	return true;
+}
+
+static bool camera_rotation_cb(camera_rotation_e mode, void *user_data)
+{
+	g_print("\t%d. %s\n", mode, camera_rotation[mode]);
+	return true;
+}
+
+static bool camera_flip_cb(camera_flip_e mode, void *user_data)
+{
+	g_print("\t%d. %s\n", mode, sensor_flip[mode]);
+	return true;
+}
+
+static bool preview_format_cb(camera_pixel_format_e mode, void *user_data)
+{
+	g_print("\t%d. %s\n", mode, image_fmt[mode]);
+	return true;
+}
+
+static bool white_balance_cb(camera_attr_whitebalance_e mode, void *user_data)
+{
+	g_print("\t%d. %s\n", mode, wb[mode]);
+	return true;
+}
+
+static bool colortone_cb(camera_attr_effect_mode_e mode, void *user_data)
+{
+	g_print("\t%d. %s\n", mode, ct[mode]);
+	return true;
+}
+
+static bool program_mode_cb(camera_attr_scene_mode_e mode, void *user_data)
+{
+	g_print("\t%d. %s\n", mode, program_mode[mode]);
+	return true;
+}
+
+static bool strobe_mode_cb(camera_attr_flash_mode_e mode, void *user_data)
+{
+	g_print("\t%d. %s\n", mode, strobe_mode[mode]);
+	return true;
+}
+
+static void _face_detected(camera_detected_face_s *faces, int count, void *user_data)
+{
+	int i;
+
+	g_print("\tface detected!! - count %d\n", count);
+
+	for (i = 0 ; i < count ; i++)
+		g_print("\t%d] %dx%d\n", faces[i].id, faces[i].x, faces[i].y);
+}
+
+static void _file_write(char *path, void *data, int size)
+{
+	FILE *fp = NULL;
+
+	if (!path || !data || size <= 0) {
+		g_print("\n\tERROR %p %p %d\n", path, data, size);
+		return;
+	}
+
+	fp = fopen(path, "w");
+	if (fp) {
+		g_print("\n\topen success [%s]\n", path);
+		if (fwrite(data, size, 1, fp) != 1)
+			g_print("\n\twrite error! errno %d\n", errno);
+		else
+			g_print("\n\twrite success [%s]\n", path);
+
+		fclose(fp);
+		fp = NULL;
+	} else {
+		g_print("\n\topen error! [%s], errno %d\n", path, errno);
+	}
+}
+
+static void capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data)
+{
+	char m_filename[MAX_FILE_NAME_LENGTH];
+
+	/* main image */
+	if (image) {
+		if (hcamcorder->is_multishot) {
+			snprintf(m_filename, MAX_FILE_NAME_LENGTH, "%s/multishot%03d.jpg",
+				hcamcorder->file_path, hcamcorder->multishot_count++);
+		} else {
+			snprintf(m_filename, MAX_FILE_NAME_LENGTH, "%s/stillshot%03d.jpg",
+				hcamcorder->file_path, hcamcorder->stillshot_count++);
+		}
+
+		_file_write(m_filename, image->data, image->size);
+	}
+}
+
+static void capture_completed_cb(void *user_data)
+{
+	camera_start_preview(hcamcorder->camera);
+}
+
+static void print_menu()
+{
+	switch (hcamcorder->menu_state) {
+	case MENU_STATE_INIT:
+		g_print("\n\t=======================================\n");
+		g_print("\t   CAMERA_TESTSUITE\n");
+		g_print("\t=======================================\n");
+		g_print("\t   '1' Video Capture\n");
+		g_print("\t   '2' Device State\n");
+		g_print("\t   '3' Device List\n");
+		g_print("\t   'q' Exit\n");
+		g_print("\t=======================================\n");
+		break;
+	case MENU_STATE_MAIN:
+		g_print("\n\t=======================================\n");
+		g_print("\t   Video Capture (CAMERA%d)\n", camera_device);
+		g_print("\t=======================================\n");
+		g_print("\t   '1' Stillshot test\n");
+		g_print("\t   '2' Multishot test\n");
+		g_print("\t   '3' Setting\n");
+		g_print("\t   '4' Change device (CAMERA0 <-> CAMERA1)\n");
+		g_print("\t   '5' Set/Unset preview callback\n");
+		g_print("\t   '6' Set/Unset extra preview callback\n");
+		g_print("\t   '7' Set/Unset media packet preview callback\n");
+		g_print("\t   'b' back\n");
+		g_print("\t=======================================\n");
+		break;
+	case MENU_STATE_DEVICE_STATE:
+		g_print("\n\t=======================================\n");
+		g_print("\t   Device State\n");
+		g_print("\t=======================================\n");
+		g_print("\t   '1' Get camera device state\n");
+		g_print("\t   '2' Add camera device state changed callback\n");
+		g_print("\t   '3' Remove camera device state changed callback\n");
+		g_print("\t   'b' back\n");
+		g_print("\t=======================================\n");
+		break;
+	case MENU_STATE_DEVICE_LIST:
+		g_print("\n\t=======================================\n");
+		g_print("\t   Device List\n");
+		g_print("\t=======================================\n");
+		g_print("\t   '1' Initialize device manager\n");
+		g_print("\t   '2' Get camera device list\n");
+		g_print("\t   '3' Add camera device connection changed callback\n");
+		g_print("\t   '4' Remove camera device connection changed callback\n");
+		g_print("\t   '9' Deinitialize device manager\n");
+		g_print("\t   'b' back\n");
+		g_print("\t=======================================\n");
+		break;
+	case MENU_STATE_MAIN_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     '1' Capture resolution \n");
+		g_print("\t     '2' Digital zoom level \n");
+		g_print("\t     '3' AF mode \n");
+		g_print("\t     '4' AF scan range \n");
+		g_print("\t     '5' Exposure mode \n");
+		g_print("\t     '6' Exposure value \n");
+		g_print("\t     '7' F number \n");
+		g_print("\t     '8' Display reuse hint \n");
+		g_print("\t     '9' Manual Focus \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     'j' Jpeg quality \n");
+		g_print("\t     'p' Picture format \n");
+		g_print("\t     'E' EXIF orientation \n");
+		g_print("\t     'F' Get facing direction of camera module\n");
+		g_print("\t     's' Extra preview stream format\n");
+		g_print("\t     'B' Extra preview bitrate\n");
+		g_print("\t     'V' Extra preview GOP interval\n");
+		g_print("\t  >>>>>>>>>>>>>>>>>>>> [Display/Filter]\n");
+		g_print("\t     'v' Visible \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     'h' Hue \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     'R' Display ROI area \n");
+		g_print("\t  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [etc.]\n");
+		g_print("\t     'z' Strobe (Flash) \n");
+		g_print("\t     'S' Strobe (Flash) state\n");
+		g_print("\t     'G' Strobe (Flash) brightness\n");
+		g_print("\t     'x' Capture mode (Still/Multishot/HDR)\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     'n' Set file path to write captured image\n");
+		g_print("\t     'm' Set media bridge\n");
+		g_print("\t     'b' back\n");
+		g_print("\t=======================================\n");
+		break;
+	default:
+		g_print("\n\tunknow menu state !!\n");
+		return;
+	}
+
+	g_print("\tCommand >> ");
+}
+
+
+static void main_menu(gchar buf)
+{
+	int err = 0;
+	int interval = 0;
+	int count = 0;
+	int set_cb = 0;
+
+	switch (buf) {
+	case '1': /* Capture */
+		hcamcorder->is_multishot = FALSE;
+		camera_attr_set_image_quality(hcamcorder->camera, 100);
+		camera_set_capture_format(hcamcorder->camera, CAMERA_PIXEL_FORMAT_JPEG);
+		camera_start_capture(hcamcorder->camera, capturing_cb, capture_completed_cb, hcamcorder);
+		break;
+	case '2': /* multishot Capture */
+		g_print("multishot capture");
+		hcamcorder->is_multishot = TRUE;
+		g_print("\n\tinput interval(ms) : ");
+		err = scanf("%d", &interval);
+		flush_stdin();
+		g_print("\n\tinput count : ");
+		err = scanf("%d", &count);
+		flush_stdin();
+		camera_attr_set_image_quality(hcamcorder->camera, 100);
+		camera_set_capture_format(hcamcorder->camera, CAMERA_PIXEL_FORMAT_JPEG);
+		camera_start_continuous_capture(hcamcorder->camera, count, interval, capturing_cb, NULL, NULL);
+		sleep(3);
+		camera_start_preview(hcamcorder->camera);
+		break;
+	case '3': /* Setting */
+		hcamcorder->menu_state = MENU_STATE_MAIN_SETTING;
+		break;
+	case '4': /* Change device (CAMERA0 <-> CAMERA1) */
+		camera_set_display_reuse_hint(hcamcorder->camera, true);
+
+		camera_stop_preview(hcamcorder->camera);
+
+		if (hcamcorder->type == CAMERA_DEVICE_CAMERA0)
+			hcamcorder->type = CAMERA_DEVICE_CAMERA1;
+		else
+			hcamcorder->type = CAMERA_DEVICE_CAMERA0;
+
+		camera_change_device(hcamcorder->camera, hcamcorder->type);
+
+		camera_set_error_cb(hcamcorder->camera, _camera_error_cb, NULL);
+		camera_set_state_changed_cb(hcamcorder->camera, _camera_state_changed_cb, NULL);
+		camera_set_interrupted_cb(hcamcorder->camera, _camera_interrupted_cb, NULL);
+		camera_set_interrupt_started_cb(hcamcorder->camera, _camera_interrupt_started_cb, NULL);
+
+		camera_set_display_mode(hcamcorder->camera, CAMERA_DISPLAY_MODE_LETTER_BOX);
+
+		camera_start_preview(hcamcorder->camera);
+		break;
+	case '5':
+		g_print("* Preview Callback\n");
+		g_print("\tUnset[0] / Set[Others] :");
+		err = scanf("%d", &set_cb);
+		flush_stdin();
+		if (set_cb) {
+			g_print("\n\tDump preview data to file - NO[0], YES[Others] : ");
+			err = scanf("%d", &g_camera_preview_cb_dump);
+			flush_stdin();
+			err = camera_set_preview_cb(hcamcorder->camera, _camera_preview_cb, hcamcorder->camera);
+		} else {
+			err = camera_unset_preview_cb(hcamcorder->camera);
+		}
+		g_print("\tresult[0x%x]\n\n", err);
+		break;
+	case '6':
+		g_print("* Extra Preview Callback\n");
+		g_print("\tUnset[0] / Set[Others] :");
+		err = scanf("%d", &set_cb);
+		flush_stdin();
+		if (set_cb) {
+			g_print("\n\tDump extra preview data to file - NO[0], YES[Others] : ");
+			err = scanf("%d", &g_camera_extra_preview_cb_dump);
+			flush_stdin();
+			err = camera_set_extra_preview_cb(hcamcorder->camera, _camera_extra_preview_cb, hcamcorder->camera);
+		} else {
+			err = camera_unset_extra_preview_cb(hcamcorder->camera);
+		}
+		g_print("\tresult[0x%x]\n\n", err);
+		break;
+	case '7':
+		g_print("* Media Packet Preview Callback\n");
+		g_print("\tUnset[0] / Set[Others] :");
+		err = scanf("%d", &set_cb);
+		flush_stdin();
+		if (set_cb) {
+			g_print("\n\tDump media packet preview data to file - NO[0], YES[Others] : ");
+			err = scanf("%d", &g_camera_mp_preview_cb_dump);
+			flush_stdin();
+			err = camera_set_media_packet_preview_cb(hcamcorder->camera, _camera_media_packet_preview_cb, hcamcorder->camera);
+		} else {
+			err = camera_unset_media_packet_preview_cb(hcamcorder->camera);
+		}
+		g_print("\tresult[0x%x]\n\n", err);
+		break;
+	case 'b': /* back */
+		__release_media_bridge();
+
+		camera_stop_preview(hcamcorder->camera);
+		camera_destroy(hcamcorder->camera);
+		hcamcorder->camera = NULL;
+		hcamcorder->menu_state = MENU_STATE_INIT;
+		break;
+	default:
+		g_print("\t Invalid input \n");
+		break;
+	}
+}
+
+
+static void setting_menu(gchar buf)
+{
+	int bret = FALSE;
+	int idx = 0;
+	int min = 0;
+	int max = 0;
+	int i = 0;
+	int err = 0;
+	int x = 0;
+	int y = 0;
+	int width = 0;
+	int height = 0;
+	int result = 0;
+	int set_bridge = 0;
+	int stream_id;
+	int pixel_format;
+	int fps;
+	int bitrate;
+	int interval;
+
+	switch (buf) {
+	/* Camera setting */
+	case '0':  /* Setting > Preview Resolution setting */
+		g_print("\t* Select the preview resolution!\n");
+		resolution_stack resolution_list;
+		resolution_list.count = 0;
+
+		camera_foreach_supported_preview_resolution(hcamcorder->camera,
+			preview_resolution_cb, &resolution_list);
+
+		g_print("\tCommand >> ");
+
+		err = scanf("%d", &idx);
+		flush_stdin();
+		if (resolution_list.count > idx && idx >= 0) {
+			g_print("\t-----------------PREVIEW RESOLUTION (%dx%d)---------------------\n",
+				resolution_list.width[idx], resolution_list.height[idx]);
+
+			result = camera_set_preview_resolution(hcamcorder->camera,
+				resolution_list.width[idx], resolution_list.height[idx]);
+		} else {
+			g_print("\tInvalid command [%d]\n", idx);
+			result = -1;
+		}
+		resolution_list.count = 0;
+		if (result == CAMERA_ERROR_NONE)
+			g_print("\tPASS\n");
+		else
+			g_print("\tFAIL\n");
+		break;
+	case '1': /* Setting > Capture Resolution setting */
+		g_print("\t* Select the preview resolution!\n");
+		resolution_list.count = 0;
+
+		camera_foreach_supported_capture_resolution(hcamcorder->camera,
+			capture_resolution_test_cb, &resolution_list);
+
+		g_print("\tCommand > ");
+
+		err = scanf("%d", &idx);
+		flush_stdin();
+		if (resolution_list.count > idx && idx >= 0) {
+			g_print("\t-----------------CAPTURE RESOLUTION (%dx%d)---------------------\n",
+				resolution_list.width[idx], resolution_list.height[idx]);
+
+			result = camera_set_capture_resolution(hcamcorder->camera,
+				resolution_list.width[idx], resolution_list.height[idx]);
+		} else {
+			g_print("\tInvalid command [%d]\n", idx);
+			result = -1;
+		}
+		resolution_list.count = 0;
+		if (result == CAMERA_ERROR_NONE)
+			g_print("\tPASS\n");
+		else
+			g_print("\tFAIL\n");
+		break;
+	case '2': /* Setting > Digital zoom level */
+		camera_attr_get_zoom_range(hcamcorder->camera, &min, &max);
+		if (min > max) {
+			g_print("\tDigital Zoom Not supported\n");
+		} else {
+			g_print("\tDigital zoom level [%d ~ %d] > ", min, max);
+			err = scanf("%d", &idx);
+			flush_stdin();
+			bret = camera_attr_set_zoom(hcamcorder->camera, idx);
+		}
+		break;
+	case '3': /* Setting > AF mode */
+		g_print("\tAuto Focus [1:Start, 2:Stop] > ");
+		err = scanf("%d", &idx);
+		flush_stdin();
+		switch (idx) {
+		case 1:
+			camera_start_focusing(hcamcorder->camera, 0);
+			break;
+		case 2:
+			camera_cancel_focusing(hcamcorder->camera);
+			break;
+		default:
+			g_print("\tInvalid command [%d]\n", idx);
+			break;
+		}
+		break;
+	case '4': /* Setting > AF scan range */
+		g_print("\t* AF scan range !\n");
+		camera_attr_foreach_supported_af_mode(hcamcorder->camera, (camera_attr_supported_af_mode_cb)af_mode_foreach_cb, NULL);
+		g_print("\tCommand > ");
+		err = scanf("%d", &idx);
+		flush_stdin();
+		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);
+		g_print("\n Select  Exposure mode \n");
+		err = scanf("%d", &idx);
+		flush_stdin();
+		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 {
+			g_print("\n Select  Exposure mode min%d -max %d\n", min, max);
+			err = scanf("%d", &idx);
+			flush_stdin();
+			bret = camera_attr_set_exposure(hcamcorder->camera, idx);
+		}
+		break;
+	case '7': /* Setting > F number */
+		g_print("Not supported !! \n");
+		break;
+	case '8': /* Setting > Display reuse hint */
+		{
+			bool reuse_hint = false;
+
+			err = camera_get_display_reuse_hint(hcamcorder->camera, &reuse_hint);
+			if (err != CAMERA_ERROR_NONE) {
+				g_print("failed to get display reuse hint 0x%x\n", err);
+				break;
+			}
+
+			g_print("*Display reuse hint : current %d -> set %d\n", reuse_hint, !reuse_hint);
+			reuse_hint = !reuse_hint;
+			err = camera_set_display_reuse_hint(hcamcorder->camera, reuse_hint);
+			g_print("set display reuse hint result : 0x%x\n", err);
+		}
+		break;
+	case '9': /* Setting > Manual focus */
+		g_print("*Manual focus !\n");
+		camera_attr_get_focus_level_range(hcamcorder->camera, &min, &max);
+		if (min > max) {
+			g_print("\n\tManual focus is NOT SUPPORTED\n");
+			break;
+		}
+		camera_attr_get_focus_level(hcamcorder->camera, &idx);
+		g_print("\tCurrent focus level (%d)\n", idx);
+		g_print("\tSelect focus level min(%d) - max(%d) > ", min, max);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		bret = camera_attr_set_focus_level(hcamcorder->camera, idx);
+		idx = -1;
+		if (bret == CAMERA_ERROR_NONE) {
+			bret = camera_attr_get_focus_level(hcamcorder->camera, &idx);
+			g_print("\tfocus level[%d] after set\n", idx);
+		} else {
+			g_print("\tset focus level failed[0x%x]\n", bret);
+		}
+		break;
+	case 'i': /* Setting > ISO */
+		g_print("*ISO !\n");
+		camera_attr_foreach_supported_iso(hcamcorder->camera, iso_mode_cb, NULL);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		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);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		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 */
+		g_print("*Flip camera input\n");
+		camera_attr_foreach_supported_stream_flip(hcamcorder->camera, camera_flip_cb, NULL);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera));
+		bret = camera_attr_set_stream_flip(hcamcorder->camera, idx);
+		CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera));
+		break;
+	case 'j': /* Setting > Jpeg quality */
+		g_print("*Jpeg quality !\n");
+		g_print("\n Select  Jpeg quality \n");
+		err = scanf("%d", &idx);
+		flush_stdin();
+		bret = camera_attr_set_image_quality(hcamcorder->camera, idx);
+		break;
+	case 'p': /* Setting > Picture format */
+		g_print("* Picture format!\n");
+		camera_foreach_supported_preview_format(hcamcorder->camera, preview_format_cb, NULL);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera));
+		bret = camera_set_preview_format(hcamcorder->camera, idx);
+		CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera));
+		break;
+	case 'E': /* Setting > EXIF orientation */
+		g_print("* EXIF Orientation\n");
+		g_print("\t 1. TOP_LEFT\n");
+		g_print("\t 2. TOP_RIGHT(flipped)\n");
+		g_print("\t 3. BOTTOM_RIGHT\n");
+		g_print("\t 4. BOTTOM_LEFT(flipped)\n");
+		g_print("\t 5. LEFT_TOP(flipped)\n");
+		g_print("\t 6. RIGHT_TOP\n");
+		g_print("\t 7. RIGHT_BOTTOM(flipped)\n");
+		g_print("\t 8. LEFT_BOTTOM\n");
+		err = scanf("%d", &idx);
+		flush_stdin();
+		if (idx < 1 || idx > 8)
+			g_print("Wrong INPUT[%d]!! \n", idx);
+		else
+			camera_attr_set_tag_orientation(hcamcorder->camera, idx);
+		break;
+	case 'F': /* Setting > Get Facing direction */
+		g_print("* Get facing direction of camera module\n");
+		err = camera_get_facing_direction(hcamcorder->camera, (camera_facing_direction_e *)&idx);
+		if (CAMERA_ERROR_NONE == err)
+			g_print("* Facing direction : %s(%d)\n", facing_direction[idx], idx);
+		else
+			g_print("* Error : %d\n", err);
+		break;
+	case 's': /* Setting > Set extra preview stream format */
+		g_print("* Set extra preview stream format\n");
+
+		g_print("\tstream_id,pixel format[NV12:0,H264:15,VP8:18],width,height,fps : ");
+		err = scanf("%d,%d,%d,%d,%d", &stream_id, &pixel_format, &width, &height, &fps);
+		flush_stdin();
+
+		err = camera_set_extra_preview_stream_format(hcamcorder->camera,
+			stream_id, pixel_format, width, height, fps);
+		if (err != CAMERA_ERROR_NONE) {
+			g_print("* Set Error : 0x%x\n", err);
+			break;
+		}
+
+		pixel_format = width = height = fps = -1;
+
+		err = camera_get_extra_preview_stream_format(hcamcorder->camera,
+			stream_id, &pixel_format, &width, &height, &fps);
+		if (err != CAMERA_ERROR_NONE) {
+			g_print("* Get Error : 0x%x\n", err);
+			break;
+		}
+
+		g_print("\tGet stream_id[%d],pixel format[%d],res[%dx%d],fps[%d]\n",
+			stream_id, pixel_format, width, height, fps);
+		break;
+	case 'B': /* Setting > Set extra preview bitrate */
+		g_print("* Set extra preview bitrate\n");
+		g_print("\tstream_id : ");
+		err = scanf("%d", &stream_id);
+		flush_stdin();
+
+		err = camera_attr_get_extra_preview_bitrate(hcamcorder->camera, stream_id, &bitrate);
+		if (err != CAMERA_ERROR_NONE) {
+			g_print("\tFailed to get bitrate for stream_id[%d]\n", stream_id);
+			break;
+		}
+
+		g_print("\tCurrent bitrate[%d]bps for stream_id[%d]\n", bitrate, stream_id);
+
+		g_print("\tSet bitrate(bps) : ");
+		err = scanf("%d", &bitrate);
+		flush_stdin();
+
+		err = camera_attr_set_extra_preview_bitrate(hcamcorder->camera, stream_id, bitrate);
+		if (err != CAMERA_ERROR_NONE) {
+			g_print("* Set Error : 0x%x\n", err);
+			break;
+		}
+
+		bitrate = -1;
+
+		err = camera_attr_get_extra_preview_bitrate(hcamcorder->camera, stream_id, &bitrate);
+		if (err != CAMERA_ERROR_NONE) {
+			g_print("* Get Error : 0x%x\n", err);
+			break;
+		}
+
+		g_print("\tResult bitrate[%d]bps for stream_id[%d]\n", bitrate, stream_id);
+		break;
+	case 'V': /* Setting > Set extra preview GOP interval */
+		g_print("* Set extra preview GOP interval\n");
+		g_print("\tstream_id : ");
+		err = scanf("%d", &stream_id);
+		flush_stdin();
+
+		err = camera_attr_get_extra_preview_gop_interval(hcamcorder->camera, stream_id, &interval);
+		if (err != CAMERA_ERROR_NONE) {
+			g_print("\tFailed to get GOP interval for stream_id[%d]\n", stream_id);
+			break;
+		}
+
+		g_print("\tCurrent GOP interval[%d]bps for stream_id[%d]\n", interval, stream_id);
+
+		g_print("\tSet GOP interval(ms) : ");
+		err = scanf("%d", &interval);
+		flush_stdin();
+
+		err = camera_attr_set_extra_preview_gop_interval(hcamcorder->camera, stream_id, interval);
+		if (err != CAMERA_ERROR_NONE) {
+			g_print("* Set Error : 0x%x\n", err);
+			break;
+		}
+
+		interval = -1;
+
+		err = camera_attr_get_extra_preview_gop_interval(hcamcorder->camera, stream_id, &interval);
+		if (err != CAMERA_ERROR_NONE) {
+			g_print("* Get Error : 0x%x\n", err);
+			break;
+		}
+
+		g_print("\tResult GOP interval[%d]bps for stream_id[%d]\n", interval, stream_id);
+		break;
+		/* Display / Filter setting */
+	case 'v': /* Display visible */
+		g_print("* Display visible setting !\n");
+		g_print("\n Select Display visible \n");
+		for (i = 0 ; i < 2 ; i++)
+			g_print("\t %d. %s\n", i, visible_mode[i]);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		if (idx == 0 || idx == 1)
+			bret = camera_set_display_visible(hcamcorder->camera, idx);
+		else
+			g_print("invalid input %d", idx);
+		break;
+	case 'o': /* Setting > Display Mode */
+		g_print("* Display mode!\n");
+		for (i = 0 ; i < 5 ; i++)
+			g_print("%d. %s\n", i, display_mode[i]);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		bret =  camera_set_display_mode(hcamcorder->camera, idx);
+		break;
+	case 'y': /* Setting > Rotate Display */
+		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);
+		flush_stdin();
+		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 */
+		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);
+		flush_stdin();
+		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);
+		g_print("\n Select brightness min (%d) -max(%d) > ", min, max);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		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);
+		g_print("\n Select Contrast min(%d)-max(%d) > ", min, max);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		bret = camera_attr_set_contrast(hcamcorder->camera, idx);
+		break;
+	case 'h': /* Setting > Hue */
+		g_print("*Hue !\n");
+		camera_attr_get_hue_range(hcamcorder->camera, &min, &max);
+		if (max >= min) {
+			g_print("\n Select Hue min(%d)-max(%d) > ", min, max);
+			err = scanf("%d", &idx);
+			flush_stdin();
+			bret = camera_attr_set_hue(hcamcorder->camera, idx);
+		} else {
+			g_print("\n Hue is not supported (%d,%d)\n", min, max);
+		}
+		break;
+	case 'w': /* Setting > White balance */
+		g_print("*White balance !\n");
+		g_print("\n Select White balance \n");
+		camera_attr_foreach_supported_whitebalance(hcamcorder->camera, white_balance_cb, NULL);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		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");
+		err = scanf("%d", &idx);
+		flush_stdin();
+		bret = camera_attr_set_effect(hcamcorder->camera, idx);
+		break;
+	case 'd': /* Setting > WDR */
+		g_print("*WDR !\n");
+		g_print("\n Select WDR Mode \n");
+		for (i = 0 ; i < 2 ; i++)
+			g_print("\t %d. %s\n", i+1, wdr_mode[i]);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		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");
+		err = scanf("%d", &idx);
+		flush_stdin();
+		bret = camera_attr_set_scene_mode(hcamcorder->camera, idx);
+		break;
+	case 'R': /* Setting > Display ROI area */
+		g_print("* Set display roi area. Select x y width height \n");
+		err = scanf("%d %d %d %d", &x, &y, &width, &height);
+		flush_stdin();
+		camera_set_display_mode(hcamcorder->camera, CAMERA_DISPLAY_MODE_CUSTOM_ROI);
+		err = camera_attr_set_display_roi_area(hcamcorder->camera, x, y, width, height);
+		if (CAMERA_ERROR_NONE != err)
+			g_print("* Error : %d\n", err);
+
+		err = camera_attr_get_display_roi_area(hcamcorder->camera, &x, &y, &width, &height);
+		if (CAMERA_ERROR_NONE == err)
+			g_print("Current display roi area : x %d, y %d, width %d, height %d\n", x, y, width, height);
+		else
+			g_print("* Error : %d\n", err);
+		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");
+		err = scanf("%d", &idx);
+		flush_stdin();
+		bret = camera_attr_set_flash_mode(hcamcorder->camera, idx);
+		break;
+	case 'S': /* Setting > flash state */
+		g_print("*flash state\n");
+		err = camera_get_flash_state(camera_device, (camera_flash_state_e *)&idx);
+		if (CAMERA_ERROR_NONE == err)
+			g_print("Current flash state = %s\n", idx ? "ON" : "OFF");
+		else
+			g_print("* Error : %d\n", err);
+		break;
+	case 'G': /* Setting > flash brightness */
+		g_print("*Flash brightness !\n");
+		camera_attr_get_flash_brightness_range(hcamcorder->camera, &min, &max);
+		g_print("\n Select flash brightness min(%d) - max(%d) > ", min, max);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		bret = camera_attr_set_flash_brightness(hcamcorder->camera, idx);
+		break;
+	case 'x': /* Setting > Capture mode ,Muitishot? */
+		g_print("*Select Capture mode!\n");
+		g_print(" \n\t1. Stillshot mode\n\t2. Multishot mode\n\t3. HDR capture\n");
+		err = scanf("%d", &idx);
+		flush_stdin();
+
+		switch (idx) {
+		case 1:
+			g_print("stillshot mode selected and capture callback is set!!!!\n");
+			hcamcorder->is_multishot = FALSE;
+			camera_attr_set_hdr_mode(hcamcorder->camera, 0);
+			break;
+		case 2:
+			g_print("HDR Capture mode selected\n");
+			hcamcorder->is_multishot = FALSE;
+			g_print("\nSelect HDR capture mode\n");
+			for (i = 0 ; i < 3 ; i++)
+				g_print("\t %d. %s\n", i, hdr_mode[i]);
+			err = scanf("%d", &idx);
+			flush_stdin();
+			if (idx >= CAMERA_ATTR_HDR_MODE_DISABLE && idx <= CAMERA_ATTR_HDR_MODE_KEEP_ORIGINAL)
+				bret = camera_attr_set_hdr_mode(hcamcorder->camera, idx);
+			else
+				g_print("invalid input %d\n", idx);
+			break;
+		default:
+			g_print("Wrong input, select again!!\n");
+			break;
+		}
+		break;
+	case 'l': /* Setting > Face detection setting */
+		if (camera_is_supported_face_detection(hcamcorder->camera)) {
+			g_print("* Face detect mode !\n");
+			for (i = 0 ; i < 2 ; i++)
+				g_print("\t %d. %s \n", i, detection_mode[i]);
+			err = scanf("%d", &idx);
+			flush_stdin();
+			if (idx == 0)
+				bret = camera_stop_face_detection(hcamcorder->camera);
+			else if (idx == 1)
+				bret = camera_start_face_detection(hcamcorder->camera, _face_detected, NULL);
+			else
+				g_print("\n invalid input [%d]\n\n", idx);
+		} 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");
+		for (i = 0; i < 2; i++)
+			g_print("\t %d. %s\n", i, ahs_mode[i]);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		if (idx == 0 || idx == 1)
+			bret = camera_attr_enable_anti_shake(hcamcorder->camera, idx);
+		else
+			g_print("invalid input %d\n", idx);
+		break;
+	case 'K': /* Setting > Video-stabilization */
+		g_print("*Video-stabilization !\n");
+		g_print("\n Select Video-stabilization mode \n");
+		for (i = 0 ; i < 2 ; i++)
+			g_print("\t %d. %s\n", i, vs_mode[i]);
+		err = scanf("%d", &idx);
+		flush_stdin();
+		if (idx < 0 || idx > 1) {
+			g_print("invalid input %d\n", idx);
+			break;
+		}
+
+		if (idx == 1) {
+			g_print("\n Restart preview with NV12 and 720p resolution\n");
+			err = camera_stop_preview(hcamcorder->camera);
+			g_print("stop preview result 0x%x\n", err);
+			camera_set_preview_resolution(hcamcorder->camera, 1280, 720);
+			camera_set_preview_format(hcamcorder->camera, CAMERA_PIXEL_FORMAT_NV12);
+		}
+
+		bret = camera_attr_enable_video_stabilization(hcamcorder->camera, idx);
+
+		if (idx == 1) {
+			err = camera_start_preview(hcamcorder->camera);
+			if (err != CAMERA_ERROR_NONE)
+				g_print("\n Restart FAILED! 0x%x\n", err);
+		}
+		break;
+	case 'u': /* Touch AF area */
+		g_print("* Touch AF area !\n");
+		g_print("\n Input x,y,width,height \n");
+		err = scanf("%d,%d,%d,%d", &x, &y, &width, &height);
+		flush_stdin();
+		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 'n': /* file path */
+		g_print("* File path !\n");
+		g_print("\n Input file path to save captured data(string) : ");
+		if (fgets(hcamcorder->file_path, sizeof(hcamcorder->file_path), stdin))
+			g_print("\ncaptured data will be saved in [%s]\n", hcamcorder->file_path);
+		else
+			g_print("\nset file path failed\n");
+		break;
+	case 'm': /* media bridge */
+		g_print("* Media Bridge !\n");
+		g_print("\tUnset[0] / Set[Others] :");
+		err = scanf("%d", &set_bridge);
+		flush_stdin();
+		if (set_bridge) {
+			__release_media_bridge();
+
+			err = media_bridge_create(&bridge);
+			err |= media_bridge_set_source(bridge, MEDIA_BRIDGE_MODULE_CAMERA, hcamcorder->camera);
+		} else {
+			__release_media_bridge();
+		}
+		g_print("\tresult[0x%x]\n\n", err);
+		break;
+	case 'b': /* back */
+		hcamcorder->menu_state = MENU_STATE_MAIN;
+		break;
+	default:
+		g_print("\t Invalid input \n");
+		break;
+	}
+
+	g_print("\t bret : 0x%x \n", bret);
+}
+
+
+static void device_state_menu(gchar buf)
+{
+	int ret = 0;
+	camera_device_e device = CAMERA_DEVICE_CAMERA0;
+	camera_device_state_e device_state = CAMERA_DEVICE_STATE_NULL;
+
+	switch (buf) {
+	case '1': /* Get device state */
+		while (1) {
+			g_print("\n\tEnter Camera Index[0~9]: ");
+
+			ret = scanf("%d", (int *)&device);
+			flush_stdin();
+
+			if (ret == EOF) {
+				g_print("\n\t!!!read input error!!!\n");
+				return;
+			}
+
+			if (device < CAMERA_DEVICE_CAMERA0 ||
+				device > CAMERA_DEVICE_CAMERA9) {
+				g_print("\n\tinvalid input:[%d], try again...\n", device);
+				continue;
+			}
+
+			ret = camera_get_device_state(device, &device_state);
+			g_print("\n\tDevice[%d] state[%d], ret[0x%x]",
+				device, device_state, ret);
+			break;
+		}
+		break;
+	case '2': /* Add device state changed callback */
+		ret = camera_add_device_state_changed_cb(_camera_device_state_changed_cb,
+			NULL, &g_camera_device_state_changed_cb_id);
+		g_print("\n\tadd result[0x%x] - cb id[%d]\n", ret, g_camera_device_state_changed_cb_id);
+		break;
+	case '3': /* Remove device state changed callback */
+		if (g_camera_device_state_changed_cb_id > 0) {
+			ret = camera_remove_device_state_changed_cb(g_camera_device_state_changed_cb_id);
+			g_print("\n\tremove result[0x%x] - cb id[%d]\n", ret, g_camera_device_state_changed_cb_id);
+			g_camera_device_state_changed_cb_id = 0;
+		} else {
+			g_print("\n\tinvalid cb id[%d]\n", g_camera_device_state_changed_cb_id);
+		}
+		break;
+	case 'b': /* back */
+		hcamcorder->menu_state = MENU_STATE_INIT;
+		break;
+	default:
+		g_print("\n\tinvalid input[%c]\n", buf);
+		break;
+	}
+}
+
+static void device_list_menu(gchar buf)
+{
+	int ret = 0;
+	unsigned int i = 0;
+	camera_device_list_s device_list;
+
+	switch (buf) {
+	case '1': /* Initialize device manager */
+		ret = camera_device_manager_initialize(&g_device_manager);
+		g_print("\n\tDevice manager[%p] initialize result[0x%x]\n",
+			g_device_manager, ret);
+		break;
+	case '2': /* Get device list */
+		memset(&device_list, 0x0, sizeof(camera_device_list_s));
+		ret = camera_device_manager_get_device_list(g_device_manager, &device_list);
+		if (ret != CAMERA_ERROR_NONE) {
+			g_print("\n\tGet device list failed[0x%x]\n", ret);
+			return;
+		}
+
+		g_print("\n\tDevice list[count:%d]\n", device_list.count);
+
+		for (i = 0 ; i < device_list.count ; i++) {
+			g_print("\t[%d] : type[%d], index[%d], name[%s], id[%s]\n",
+				i, device_list.device[i].type, device_list.device[i].index,
+				device_list.device[i].name, device_list.device[i].id);
+		}
+		break;
+	case '3': /* Add device connection changed callback */
+		ret = camera_device_manager_add_device_connection_changed_cb(g_device_manager,
+			_camera_device_connection_changed_cb, NULL, &g_camera_device_connection_changed_cb_id);
+		g_print("\n\tadd result[0x%x] - cb id[%d]\n", ret, g_camera_device_connection_changed_cb_id);
+		break;
+	case '4': /* Remove device connection changed callback */
+		if (g_camera_device_connection_changed_cb_id > 0) {
+			ret = camera_device_manager_remove_device_connection_changed_cb(g_device_manager,
+				g_camera_device_connection_changed_cb_id);
+			g_print("\n\tremove result[0x%x] - cb id[%d]\n", ret, g_camera_device_connection_changed_cb_id);
+			g_camera_device_connection_changed_cb_id = 0;
+		} else {
+			g_print("\n\tinvalid cb id[%d]\n", g_camera_device_connection_changed_cb_id);
+		}
+		break;
+	case '9': /* Deinitialize device manager */
+		ret = camera_device_manager_deinitialize(g_device_manager);
+		g_print("\n\tDevice manager[%p] deinitialize result[0x%x]\n",
+			g_device_manager, ret);
+		g_device_manager = NULL;
+		break;
+	case 'b': /* back */
+		hcamcorder->menu_state = MENU_STATE_INIT;
+		break;
+	default:
+		g_print("\n\tinvalid input[%c]\n", buf);
+		break;
+	}
+}
+
+
+/**
+ * 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, GIOCondition condition, gpointer data)
+{
+	gchar *buf = NULL;
+	gsize read_size;
+	GError *g_error = NULL;
+
+	g_print("\n\tENTER\n");
+
+	g_io_channel_read_line(channel, &buf, &read_size, NULL, &g_error);
+	if (g_error) {
+		g_print("\n\tg_io_channel_read_chars error\n");
+		g_error_free(g_error);
+		g_error = NULL;
+	}
+
+	if (buf) {
+		g_strstrip(buf);
+
+		g_print("\n\tMenu Status : %d\n", hcamcorder->menu_state);
+		switch (hcamcorder->menu_state) {
+		case MENU_STATE_INIT:
+			mode_change(buf[0]);
+			break;
+		case MENU_STATE_MAIN:
+			main_menu(buf[0]);
+			break;
+		case MENU_STATE_MAIN_SETTING:
+			setting_menu(buf[0]);
+			break;
+		case MENU_STATE_DEVICE_STATE:
+			device_state_menu(buf[0]);
+			break;
+		case MENU_STATE_DEVICE_LIST:
+			device_list_menu(buf[0]);
+			break;
+		default:
+			break;
+		}
+
+		g_free(buf);
+		buf = NULL;
+
+		print_menu();
+	} else {
+		g_print("\n\tNo read input\n");
+	}
+
+	return TRUE;
+}
+
+static gboolean init_handle()
+{
+	hcamcorder->is_multishot =  FALSE;
+	hcamcorder->stillshot_count = 0;
+	hcamcorder->multishot_count = 0;
+	snprintf(hcamcorder->file_path, MAX_FILE_PATH_LENGTH, DEFAULT_FILE_PATH);
+	hcamcorder->menu_state = MENU_STATE_INIT;
+	hcamcorder->elapsed_time = 0;
+
+	return TRUE;
+}
+
+
+/**
+ * This function is to change camcorder mode.
+ *
+ * @param   buf    [in]    user input
+ *
+ * @return  This function returns TRUE/FALSE
+ * @remark
+ * @see     other functions
+ */
+static gboolean mode_change(gchar buf)
+{
+	int err = 0;
+	int camera_type = 0;
+
+	switch (buf) {
+	case '1':
+		while (1) {
+			g_print("\n\tEnter the Camera Type[0:Local, 1:Network] : ");
+			err = scanf("%d", &camera_type);
+			flush_stdin();
+			if (err == EOF) {
+				g_print("\t!!!read input error!!!\n");
+				continue;
+			}
+
+			if (camera_type != 0 && camera_type != 1) {
+				g_print("\t Invalid camera type(%d)\n", camera_type);
+				continue;
+			}
+
+			g_print("\n\tEnter the Camera Device[0 ~ 9] : ");
+			err = scanf("%d", (int *)&camera_device);
+			flush_stdin();
+			if (err == EOF) {
+				g_print("\t!!!read input error!!!\n");
+				continue;
+			}
+
+			if (camera_device < 0 || camera_device > 9) {
+				g_print("\t Invalid camera device(%d)\n", camera_device);
+				continue;
+			}
+
+			hcamcorder->type = camera_device;
+
+			break;
+		}
+		break;
+	case '2':
+		hcamcorder->menu_state = MENU_STATE_DEVICE_STATE;
+		return TRUE;
+	case '3':
+		hcamcorder->menu_state = MENU_STATE_DEVICE_LIST;
+		return TRUE;
+	case 'q':
+		g_print("\t Quit Camcorder Testsuite!!\n");
+		g_main_loop_quit(g_mainloop_camera_test);
+		return FALSE;
+	default:
+		g_print("\t Invalid media type(%c)\n", buf);
+		return FALSE;
+	}
+
+	g_print("\n[camcorder_create - type %d, device %d]\n", camera_type, camera_device);
+
+	gettimeofday(&previous_time, NULL);
+
+	g_timer_reset(timer);
+
+	if (camera_type)
+		err = camera_create_network(camera_device, &hcamcorder->camera);
+	else
+		err = camera_create(camera_device, &hcamcorder->camera);
+
+	g_print("[camera_create()  : %12.6lfs]\n", g_timer_elapsed(timer, NULL));
+
+	if (err != 0) {
+		g_print("\n\tmmcamcorder_create = 0x%x\n", err);
+		return FALSE;
+	}
+
+	g_print("Display type : NULL for headless\n");
+	camera_set_display(hcamcorder->camera, CAMERA_DISPLAY_TYPE_NONE, NULL);
+
+	camera_set_error_cb(hcamcorder->camera, _camera_error_cb, NULL);
+	camera_set_state_changed_cb(hcamcorder->camera, _camera_state_changed_cb, NULL);
+	camera_set_interrupted_cb(hcamcorder->camera, _camera_interrupted_cb, NULL);
+	camera_set_interrupt_started_cb(hcamcorder->camera, _camera_interrupt_started_cb, NULL);
+	camera_set_display_mode(hcamcorder->camera, CAMERA_DISPLAY_MODE_LETTER_BOX);
+	/*camera_set_display_rotation(hcamcorder->camera, CAMERA_ROTATION_90);*/
+	/*camera_set_display_flip(hcamcorder->camera, CAMERA_FLIP_VERTICAL);*/
+	/*camera_set_preview_cb(hcamcorder->camera, _preview_cb, hcamcorder->camera);*/
+
+	camera_start_preview(hcamcorder->camera);
+
+	gettimeofday(&current_time, NULL);
+	timersub(&current_time, &previous_time, &result_time);
+
+	g_print("\n\tCamera Starting Time  : %ld.%lds\n", result_time.tv_sec, result_time.tv_usec);
+
+	hcamcorder->menu_state = MENU_STATE_MAIN;
+
+	return TRUE;
+}
+
+/**
+ * This function is the example main function for mmcamcorder API.
+ *
+ * @param
+ *
+ * @return  This function returns 0.
+ * @remark
+ * @see     other functions
+ */
+int main(int argc, char **argv)
+{
+	hcamcorder = (cam_handle_t *)g_malloc0(sizeof(cam_handle_t));
+
+	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);
+
+	timer = g_timer_new();
+	g_timer_reset(timer);
+
+	init_handle();
+
+	print_menu();
+
+	g_mainloop_camera_test = g_main_loop_new(NULL, FALSE);
+
+	g_main_loop_run(g_mainloop_camera_test);
+
+	g_print("\n\treturn main loop\n\n");
+
+	g_main_loop_unref(g_mainloop_camera_test);
+
+	if (timer) {
+		g_timer_stop(timer);
+		g_timer_destroy(timer);
+	}
+
+	g_free(hcamcorder);
+	g_io_channel_unref(stdin_channel);
+
+	return 0;
+}
+/*EOF*/