2.0 initHEADsubmit/master/20120920.1510212.0_alphamaster2.0alpha

Change-Id: Ic2e7bdadbaefd1e5dd222f8f9197e4bf9b6601ab

33 files changed, 5677 insertions, 699 deletions

diff --git a/TC/_export_env.sh b/TC/_export_env.sh
new file mode 100755
index 0000000..72a11ec
--- /dev/null
+++ b/TC/_export_env.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+. ./config
+export TET_INSTALL_PATH=$TET_INSTALL_HOST_PATH # tetware root path
+export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target # tetware target path
+export PATH=$TET_TARGET_PATH/bin:$PATH
+export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
+export TET_ROOT=$TET_TARGET_PATH
diff --git a/TC/_export_target_env.sh b/TC/_export_target_env.sh
new file mode 100755
index 0000000..5ddaa53
--- /dev/null
+++ b/TC/_export_target_env.sh
@@ -0,0 +1,7 @@
+#!/bin/sh
+. ./config
+export TET_INSTALL_PATH=$TET_INSTALL_TARGET_PATH # path to path
+export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target
+export PATH=$TET_TARGET_PATH/bin:$PATH
+export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
+export TET_ROOT=$TET_TARGET_PATH
diff --git a/TC/build.sh b/TC/build.sh
new file mode 100755
index 0000000..72aad6c
--- /dev/null
+++ b/TC/build.sh
@@ -0,0 +1,16 @@
+#!/bin/sh
+
+. ./_export_env.sh                              # setting environment variables
+
+export TET_SUITE_ROOT=`pwd`
+FILE_NAME_EXTENSION=`date +%s`
+
+RESULT_DIR=results
+HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html
+JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal
+
+mkdir -p $RESULT_DIR
+
+tcc -c -p ./
+tcc -b -j $JOURNAL_RESULT -p ./
+grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT
diff --git a/TC/clean.sh b/TC/clean.sh
new file mode 100755
index 0000000..29743e0
--- /dev/null
+++ b/TC/clean.sh
@@ -0,0 +1,11 @@
+#!/bin/sh
+
+. ./_export_env.sh                              # setting environment variables
+
+export TET_SUITE_ROOT=`pwd`
+RESULT_DIR=results
+
+tcc -c -p ./                                # executing tcc, with clean option (-c)
+rm -r $RESULT_DIR
+rm -r tet_tmp_dir
+rm testcase/tet_captured
diff --git a/TC/config.default b/TC/config.default
new file mode 100644
index 0000000..12ac1e2
--- /dev/null
+++ b/TC/config.default
@@ -0,0 +1,3 @@
+CAPI_PROJECT_ROOT=/home/abyss/capi
+TET_INSTALL_HOST_PATH=/home/abyss/TETware
+TET_INSTALL_TARGET_PATH=/mnt/nfs/TETware
diff --git a/TC/execute.sh b/TC/execute.sh
new file mode 100755
index 0000000..a4f6095
--- /dev/null
+++ b/TC/execute.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+. ./_export_target_env.sh                    # setting environment variables
+
+export TET_SUITE_ROOT=`pwd`
+FILE_NAME_EXTENSION=`date +%s`
+
+RESULT_DIR=results
+HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html
+JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal
+
+mkdir -p $RESULT_DIR
+
+tcc -e -j $JOURNAL_RESULT -p ./
+grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT
diff --git a/TC/testcase/Makefile b/TC/testcase/Makefile
new file mode 100755
index 0000000..49e33e0
--- /dev/null
+++ b/TC/testcase/Makefile
@@ -0,0 +1,28 @@
+CC ?= gcc
+
+TCS = utc_media_camera_attr \
+	utc_media_camera_lifecycle \
+	utc_media_camera_setting \
+	utc_media_camera_working \
+
+
+PKGS = capi-media-camera dlog glib-2.0 gthread-2.0
+
+LDFLAGS = `pkg-config --libs $(PKGS)`
+LDFLAGS += $(TET_ROOT)/lib/tet3/tcm_s.o
+LDFLAGS += -L$(TET_ROOT)/lib/tet3 -ltcm_s
+LDFLAGS += -L$(TET_ROOT)/lib/tet3 -lapi_s
+
+CFLAGS = -I. `pkg-config --cflags $(PKGS)`
+CFLAGS += -I$(TET_ROOT)/inc/tet3
+CFLAGS += -Wall -Werror
+
+all: $(TCS)
+
+
+%: %.c
+	$(CC) -o $@ $< $(CFLAGS) $(LDFLAGS)
+
+
+clean:
+	rm -f $(TCS)
diff --git a/TC/testcase/tslist b/TC/testcase/tslist
new file mode 100644
index 0000000..3fb30e5
--- /dev/null
+++ b/TC/testcase/tslist
@@ -0,0 +1,5 @@
+/testcase/utc_media_camera_attr
+/testcase/utc_media_camera_lifecycle
+/testcase/utc_media_camera_setting
+/testcase/utc_media_camera_working
+
diff --git a/TC/testcase/utc_media_camera_attr.c b/TC/testcase/utc_media_camera_attr.c
new file mode 100755
index 0000000..85edb1a
--- /dev/null
+++ b/TC/testcase/utc_media_camera_attr.c
@@ -0,0 +1,718 @@
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* 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 for the specific language governing permissions and
+* limitations under the License. 
+*/
+
+
+
+#include <tet_api.h>
+#include <media/camera.h>
+#include <stdio.h>
+
+#define MY_ASSERT( fun , test , msg ) \
+{\
+	if( !test ) \
+		dts_fail(fun , msg ); \
+}		
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_media_camera_attr_set_preview_fps_negative(void);
+static void utc_media_camera_attr_set_preview_fps_positive(void);
+
+static void utc_media_camera_attr_set_image_quality_negative(void);
+static void utc_media_camera_attr_set_image_quality_positive(void);
+
+static void utc_media_camera_attr_get_preview_fps_negative(void);
+static void utc_media_camera_attr_get_preview_fps_positive(void);
+
+static void utc_media_camera_attr_get_image_quality_negative(void);
+static void utc_media_camera_attr_get_image_quality_positive(void);
+
+static void utc_media_camera_attr_set_zoom_negative(void);
+static void utc_media_camera_attr_set_zoom_positive(void);
+
+static void utc_media_camera_attr_set_af_mode_negative(void);
+static void utc_media_camera_attr_set_af_mode_positive(void);
+
+static void utc_media_camera_attr_set_exposure_mode_negative(void);
+static void utc_media_camera_attr_set_exposure_mode_positive(void);
+
+static void utc_media_camera_attr_set_exposure_negative(void);
+static void utc_media_camera_attr_set_exposure_positive(void);
+
+static void utc_media_camera_attr_set_iso_negative(void);
+static void utc_media_camera_attr_set_iso_positive(void);
+
+static void utc_media_camera_attr_set_brightness_negative(void);
+static void utc_media_camera_attr_set_brightness_positive(void);
+
+static void utc_media_camera_attr_set_contrast_negative(void);
+static void utc_media_camera_attr_set_contrast_positive(void);
+
+static void utc_media_camera_attr_set_whitebalance_negative(void);
+static void utc_media_camera_attr_set_whitebalance_positive(void);
+
+static void utc_media_camera_attr_get_effect_negative(void);
+static void utc_media_camera_attr_get_effect_positive(void);
+
+static void utc_media_camera_attr_get_scene_mode_negative(void);
+static void utc_media_camera_attr_get_scene_mode_positive(void);
+
+static void utc_media_camera_attr_is_enable_tag_negative(void);
+static void utc_media_camera_attr_is_enable_tag_positive(void);
+
+static void utc_media_camera_attr_get_tag_image_description_negative(void);
+static void utc_media_camera_attr_get_tag_image_description_positive(void);
+
+static void utc_media_camera_attr_get_tag_orientation_negative(void);
+static void utc_media_camera_attr_get_tag_orientation_positive(void);
+
+static void utc_media_camera_attr_get_tag_software_negative(void);
+static void utc_media_camera_attr_get_tag_software_positive(void);
+
+static void utc_media_camera_attr_get_geotag_negative(void);
+static void utc_media_camera_attr_get_geotag_positive(void);
+
+static void utc_media_camera_attr_get_flash_mode_negative(void);
+static void utc_media_camera_attr_get_flash_mode_positive(void);
+
+static void utc_media_camera_attr_foreach_supported_af_mode_negative(void);
+static void utc_media_camera_attr_foreach_supported_af_mode_positive(void);
+
+static void utc_media_camera_attr_foreach_supported_exposure_mode_negative(void);
+static void utc_media_camera_attr_foreach_supported_exposure_mode_positive(void);
+
+static void utc_media_camera_attr_foreach_supported_iso_negative(void);
+static void utc_media_camera_attr_foreach_supported_iso_positive(void);
+
+static void utc_media_camera_attr_foreach_supported_whitebalance_negative(void);
+static void utc_media_camera_attr_foreach_supported_whitebalance_positive(void);
+
+static void utc_media_camera_attr_foreach_supported_effect_negative(void);
+static void utc_media_camera_attr_foreach_supported_effect_positive(void);
+
+static void utc_media_camera_attr_foreach_supported_scene_mode_negative(void);
+static void utc_media_camera_attr_foreach_supported_scene_mode_positive(void);
+
+static void utc_media_camera_attr_foreach_supported_flash_mode_negative(void);
+static void utc_media_camera_attr_foreach_supported_flash_mode_positive(void);
+
+static void utc_media_camera_attr_foreach_supported_fps_negative(void);
+static void utc_media_camera_attr_foreach_supported_fps_positive(void);
+
+static void utc_media_camera_attr_get_lens_orientation_negative(void);
+static void utc_media_camera_attr_get_lens_orientation_positive(void);
+
+
+struct tet_testlist tet_testlist[] = {
+	{utc_media_camera_attr_set_preview_fps_negative , 1},
+	{utc_media_camera_attr_set_preview_fps_positive , 2 },
+	{utc_media_camera_attr_set_image_quality_negative, 3 },
+	{utc_media_camera_attr_set_image_quality_positive, 4},
+	{utc_media_camera_attr_get_preview_fps_negative, 5},
+	{utc_media_camera_attr_get_preview_fps_positive, 6},
+	{utc_media_camera_attr_get_image_quality_negative, 7},
+	{utc_media_camera_attr_get_image_quality_positive, 8},
+	{utc_media_camera_attr_set_zoom_negative, 9},
+	{utc_media_camera_attr_set_zoom_positive, 10},
+	{utc_media_camera_attr_set_af_mode_negative, 11},
+	{utc_media_camera_attr_set_af_mode_positive, 12},
+	{utc_media_camera_attr_set_exposure_mode_negative, 13},
+	{utc_media_camera_attr_set_exposure_mode_positive, 14},
+	{utc_media_camera_attr_set_exposure_negative, 15},
+	{utc_media_camera_attr_set_exposure_positive, 16},
+	{utc_media_camera_attr_set_iso_negative, 17},
+	{utc_media_camera_attr_set_iso_positive, 18},
+	{utc_media_camera_attr_set_brightness_negative, 19},
+	{utc_media_camera_attr_set_brightness_positive, 20},
+	{utc_media_camera_attr_set_contrast_negative, 21},
+	{utc_media_camera_attr_set_contrast_positive, 22},
+	{utc_media_camera_attr_set_whitebalance_negative, 23},
+	{utc_media_camera_attr_set_whitebalance_positive, 24},
+	{utc_media_camera_attr_get_effect_negative, 25},
+	{utc_media_camera_attr_get_effect_positive, 26},
+	{utc_media_camera_attr_get_scene_mode_negative, 27},
+	{utc_media_camera_attr_get_scene_mode_positive, 28},
+	{utc_media_camera_attr_is_enable_tag_negative, 29},
+	{utc_media_camera_attr_is_enable_tag_positive, 30},
+	{utc_media_camera_attr_get_tag_image_description_negative, 31},
+	{utc_media_camera_attr_get_tag_image_description_positive, 32},
+	{utc_media_camera_attr_get_tag_orientation_negative, 33},
+	{utc_media_camera_attr_get_tag_orientation_positive, 34},
+	{utc_media_camera_attr_get_tag_software_negative, 35},
+	{utc_media_camera_attr_get_tag_software_positive, 36},
+	{utc_media_camera_attr_get_geotag_negative, 37},
+	{utc_media_camera_attr_get_geotag_positive, 38},
+	{utc_media_camera_attr_get_flash_mode_negative, 43},
+	{utc_media_camera_attr_get_flash_mode_positive, 44},
+	{utc_media_camera_attr_foreach_supported_af_mode_negative, 45},
+	{utc_media_camera_attr_foreach_supported_af_mode_positive, 46},
+	{utc_media_camera_attr_foreach_supported_exposure_mode_negative, 47},
+	{utc_media_camera_attr_foreach_supported_exposure_mode_positive, 48},
+	{utc_media_camera_attr_foreach_supported_iso_negative, 49},
+	{utc_media_camera_attr_foreach_supported_iso_positive, 50},
+	{utc_media_camera_attr_foreach_supported_whitebalance_negative, 51},
+	{utc_media_camera_attr_foreach_supported_whitebalance_positive, 52},
+	{utc_media_camera_attr_foreach_supported_effect_negative, 53},
+	{utc_media_camera_attr_foreach_supported_effect_positive, 54},
+	{utc_media_camera_attr_foreach_supported_scene_mode_negative, 55},
+	{utc_media_camera_attr_foreach_supported_scene_mode_positive, 56},
+	{utc_media_camera_attr_foreach_supported_flash_mode_negative, 57},
+	{utc_media_camera_attr_foreach_supported_flash_mode_positive, 58},
+	{utc_media_camera_attr_foreach_supported_fps_negative, 59},
+	{utc_media_camera_attr_foreach_supported_fps_positive, 60},
+	{utc_media_camera_attr_get_lens_orientation_negative, 61},
+	{utc_media_camera_attr_get_lens_orientation_positive, 62},	
+	{ NULL, 0 },
+};
+
+camera_h camera;
+
+static void startup(void)
+{
+	fprintf(stderr, "%s test\n", __func__);
+	/* start of TC */
+	int ret;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	if( ret != 0 )
+		dts_fail("camera_create", "Could not create camera"); 	
+}
+
+static void cleanup(void)
+{
+	/* end of TC */
+	camera_destroy(camera);
+}
+
+static void utc_media_camera_attr_set_preview_fps_negative(void)
+{
+	fprintf(stderr, "%s test\n", __func__);
+	int ret;
+	ret = camera_attr_set_preview_fps(camera, -1);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+}
+static void utc_media_camera_attr_set_preview_fps_positive(void)
+{
+	int ret;
+	ret = camera_attr_set_preview_fps(camera, CAMERA_ATTR_FPS_AUTO);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "CAMERA_ATTR_FPS_AUTO set is faild");
+}
+
+static void utc_media_camera_attr_set_image_quality_negative(void)
+{
+	int ret;
+	ret = camera_attr_set_image_quality(camera, -1);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed");
+
+}
+
+static void utc_media_camera_attr_set_image_quality_positive(void)
+{
+	int ret;
+	ret = camera_attr_set_image_quality(camera, 100);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set 100 is faild");
+
+}	
+
+static void utc_media_camera_attr_get_preview_fps_negative(void)
+{
+	int ret;
+	ret = camera_attr_get_preview_fps(camera, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+	
+}	
+
+static void utc_media_camera_attr_get_preview_fps_positive(void)
+{
+	int ret;
+	camera_attr_fps_e value;
+	ret = camera_attr_get_preview_fps(camera, &value);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "fail get preview fps");
+}	
+
+static void utc_media_camera_attr_get_image_quality_negative(void)
+{
+	int ret;
+	ret = camera_attr_get_image_quality(camera, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+
+}
+static void utc_media_camera_attr_get_image_quality_positive(void)
+{
+	int ret;
+	int value;
+	ret = camera_attr_get_image_quality(camera, &value);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "fail get image quality");
+}
+
+static void utc_media_camera_attr_set_zoom_negative(void)
+{
+	int ret;
+	ret = camera_attr_set_zoom(camera, -1);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed");
+
+}
+static void utc_media_camera_attr_set_zoom_positive(void)
+{
+	int ret;
+	int min,max;
+	ret = camera_attr_get_zoom_range(camera, &min, &max);
+	
+	if( ret != 0 )
+		dts_fail(__func__ , "Failed getting zoom range" );
+	
+	if( max == -1 )
+		dts_pass(__func__, "this target is not supported zoom");
+	
+	ret = camera_attr_set_zoom(camera,min);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set 10 is failed");
+}
+
+static void utc_media_camera_attr_set_af_mode_negative(void)
+{
+	int ret;
+	ret = camera_attr_set_af_mode(camera, -1);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed");
+
+}
+static void utc_media_camera_attr_set_af_mode_positive(void)
+{
+	int ret;
+	ret = camera_attr_set_af_mode(camera, CAMERA_ATTR_AF_NONE);
+	printf("camera_attr_set_af_mode ret=%x\n", ret);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set CAMERA_ATTR_AF_NONE is faild");
+
+}
+
+static void utc_media_camera_attr_set_exposure_mode_negative(void)
+{
+	int ret;
+	ret = camera_attr_set_exposure_mode(camera, -1);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed");
+}
+static void utc_media_camera_attr_set_exposure_mode_positive(void)
+{
+	int ret;
+	ret = camera_attr_set_exposure_mode(camera, CAMERA_ATTR_EXPOSURE_MODE_ALL);
+	printf("camera_attr_set_exposure_mode %x\n", ret);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set CAMERA_ATTR_EXPOSURE_MODE_ALL is faild");
+}
+
+static void utc_media_camera_attr_set_exposure_negative(void)
+{
+	int ret;
+	ret = camera_attr_set_exposure(camera, -1);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed");
+
+}
+static void utc_media_camera_attr_set_exposure_positive(void)
+{
+	int ret;
+	int min,max;
+	ret = camera_attr_get_exposure_range(camera, &min, &max);
+
+	if( ret != 0 )
+		dts_fail(__func__ , "Failed getting exposure range" );
+	
+	if( max == -1 )
+		dts_pass(__func__, "this target is not supproted exposure ");
+	
+	
+	ret = camera_attr_set_exposure(camera, min);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set 1 is faild");
+
+}
+
+static void utc_media_camera_attr_set_iso_negative(void)
+{
+	int ret;
+	ret = camera_attr_set_iso(camera, -1);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed");
+}
+static void utc_media_camera_attr_set_iso_positive(void)
+{
+	int ret;
+	ret = camera_attr_set_iso(camera, CAMERA_ATTR_ISO_AUTO);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "CAMERA_ATTR_ISO_AUTO set is faild");
+
+}
+
+static void utc_media_camera_attr_set_brightness_negative(void)
+{
+	int ret;
+	ret = camera_attr_set_brightness(camera, -1);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed");
+
+}
+static void utc_media_camera_attr_set_brightness_positive(void)
+{
+	int ret;
+	int min, max;
+	ret = camera_attr_get_brightness_range(camera, &min, &max);
+	if( ret != 0 )
+		dts_fail(__func__ , "Failed getting brightness range" );
+	
+	if( max == -1 )
+		dts_pass(__func__, "this target is not supported brightness ");	
+	ret = camera_attr_set_brightness(camera, min+1);
+	printf("camera_attr_set_brightness ret = %d, min = %d\n", ret, min);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set 1 is faild");
+
+}
+
+static void utc_media_camera_attr_set_contrast_negative(void)
+{
+	int ret;
+	ret = camera_attr_set_contrast(camera, -1);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed");
+}
+static void utc_media_camera_attr_set_contrast_positive(void)
+{
+	int ret;
+	int min, max;
+	ret = camera_attr_get_contrast_range(camera, &min, &max);
+	if( ret != 0 )
+		dts_fail(__func__ , "Failed getting contrast range" );
+	
+	if( max == -1 )
+		dts_pass(__func__, "this target is not supported contrast ");	
+	ret = camera_attr_set_contrast(camera, min);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set 1 is faild");
+}
+
+static void utc_media_camera_attr_set_whitebalance_negative(void)
+{
+	int ret;
+	ret = camera_attr_set_whitebalance(camera, -1);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed");
+}
+static void utc_media_camera_attr_set_whitebalance_positive(void)
+{
+	int ret;
+	ret = camera_attr_set_whitebalance(camera, CAMERA_ATTR_WHITE_BALANCE_AUTOMATIC);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set CAMERA_ATTR_WHITE_BALANCE_AUTOMATIC is faild");
+
+}
+
+static void utc_media_camera_attr_get_effect_negative(void)
+{
+	int ret;
+	ret = camera_attr_get_effect(camera, 0);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+
+}
+static void utc_media_camera_attr_get_effect_positive(void)
+{
+	int ret;
+	camera_attr_effect_mode_e value;
+	ret = camera_attr_get_effect(camera, &value);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild");
+
+}
+
+static void utc_media_camera_attr_get_scene_mode_negative(void)
+{
+	int ret;
+	ret = camera_attr_get_scene_mode(camera, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+
+}
+static void utc_media_camera_attr_get_scene_mode_positive(void)
+{
+	int ret;
+	camera_attr_scene_mode_e value;
+	ret = camera_attr_get_scene_mode(camera, &value);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild");
+
+}
+
+static void utc_media_camera_attr_is_enable_tag_negative(void)
+{
+	int ret;
+	ret = camera_attr_is_enabled_tag(camera, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+}
+static void utc_media_camera_attr_is_enable_tag_positive(void)
+{
+	int ret;
+	bool enable;
+	ret = camera_attr_is_enabled_tag(camera, &enable);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get enable tag is faild");
+}
+
+static void utc_media_camera_attr_get_tag_image_description_negative(void)
+{
+	int ret;
+	ret = camera_attr_get_tag_image_description(camera, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+}
+static void utc_media_camera_attr_get_tag_image_description_positive(void)
+{
+	int ret;
+	char *buffer;
+	ret = camera_attr_get_tag_image_description(camera, &buffer);
+	if( ret == 0)
+		free(buffer);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild");
+}
+
+static void utc_media_camera_attr_get_tag_orientation_negative(void)
+{
+	int ret;
+	ret = camera_attr_get_tag_orientation(camera, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+
+}
+static void utc_media_camera_attr_get_tag_orientation_positive(void)
+{
+	int ret;
+	camera_attr_tag_orientation_e value;
+	ret = camera_attr_get_tag_orientation(camera, &value);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild");
+}
+
+static void utc_media_camera_attr_get_tag_software_negative(void)
+{
+	int ret;
+	ret = camera_attr_get_tag_software(camera, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+}
+static void utc_media_camera_attr_get_tag_software_positive(void)
+{
+	int ret;
+	char *buffer;
+	ret = camera_attr_get_tag_software(camera, &buffer);
+	if(ret == 0 )
+		free(buffer);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild");
+}
+
+static void utc_media_camera_attr_get_geotag_negative(void)
+{
+	int ret;
+	ret = camera_attr_get_geotag(camera, NULL, NULL, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+
+}
+static void utc_media_camera_attr_get_geotag_positive(void)
+{
+	int ret;
+	double value1,value2, value3;
+	ret = camera_attr_get_geotag(camera, &value1, &value2, &value3);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild");
+
+}
+
+
+static void utc_media_camera_attr_get_flash_mode_negative(void)
+{
+	int ret;
+	ret = camera_attr_get_flash_mode(camera, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+
+}
+static void utc_media_camera_attr_get_flash_mode_positive(void)
+{
+	int ret;
+	camera_attr_flash_mode_e value;
+	ret = camera_attr_get_flash_mode(camera, &value);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild");
+
+}
+
+static void utc_media_camera_attr_foreach_supported_af_mode_negative(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_af_mode(camera, NULL, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+
+}
+
+bool _cb_af_mode(camera_attr_af_mode_e mode, void *user_data)
+{
+	return false;
+}
+
+static void utc_media_camera_attr_foreach_supported_af_mode_positive(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_af_mode(camera, _cb_af_mode, NULL);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "faild");
+}
+
+static void utc_media_camera_attr_foreach_supported_exposure_mode_negative(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_exposure_mode(camera, NULL, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+
+}
+
+bool _cb_exposure_mode(camera_attr_exposure_mode_e mode , void *user_data)
+{
+	return false;
+}
+
+static void utc_media_camera_attr_foreach_supported_exposure_mode_positive(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_exposure_mode(camera, _cb_exposure_mode, NULL);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_exposure_mode is failed");
+
+}
+
+static void utc_media_camera_attr_foreach_supported_iso_negative(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_iso(camera, NULL, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+}
+
+bool _cb_iso(camera_attr_iso_e iso , void *user_data)
+{
+	return false;
+}
+
+static void utc_media_camera_attr_foreach_supported_iso_positive(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_iso(camera, _cb_iso, NULL);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_exposure_mode is faild");
+}
+
+static void utc_media_camera_attr_foreach_supported_whitebalance_negative(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_whitebalance(camera, NULL, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+}
+
+bool _cb_whitebalance_cb(camera_attr_whitebalance_e wb , void *user_data)
+{
+	return false;
+}
+
+static void utc_media_camera_attr_foreach_supported_whitebalance_positive(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_whitebalance(camera, _cb_whitebalance_cb, NULL);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_whitebalance is faild");
+
+}
+
+static void utc_media_camera_attr_foreach_supported_effect_negative(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_effect(camera, NULL, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+
+}
+
+bool _cb_effect_cb(camera_attr_effect_mode_e effect , void *user_data)
+{
+	return false;
+}
+
+static void utc_media_camera_attr_foreach_supported_effect_positive(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_effect(camera, _cb_effect_cb, NULL);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_effect is faild");
+
+}
+
+static void utc_media_camera_attr_foreach_supported_scene_mode_negative(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_scene_mode(camera, NULL, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+
+}
+
+bool _cb_scene_mode_cb(camera_attr_scene_mode_e mode , void *user_data)
+{
+	return false;
+}
+
+static void utc_media_camera_attr_foreach_supported_scene_mode_positive(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_scene_mode(camera, _cb_scene_mode_cb, NULL);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_scene_mode is faild");
+
+}
+
+static void utc_media_camera_attr_foreach_supported_flash_mode_negative(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_flash_mode(camera, NULL, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+
+}
+
+bool _cb_flash_mode_cb(camera_attr_flash_mode_e mode,  void *user_data)
+{
+	return false;
+}
+
+static void utc_media_camera_attr_foreach_supported_flash_mode_positive(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_flash_mode(camera, _cb_flash_mode_cb, NULL);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_flash_mode is faild");
+
+}
+
+static void utc_media_camera_attr_foreach_supported_fps_negative(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_fps(camera, NULL, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+
+}
+
+bool _cb_fps_cb(camera_attr_fps_e fps, void *user_data)
+{
+	return false;
+}
+
+static void utc_media_camera_attr_foreach_supported_fps_positive(void)
+{
+	int ret;
+	ret = camera_attr_foreach_supported_fps(camera, _cb_fps_cb, NULL);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_fps is faild");
+
+}
+
+
+static void utc_media_camera_attr_get_lens_orientation_negative(void)
+{
+	int ret;
+	ret = camera_attr_get_lens_orientation(camera, NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+	
+}
+static void utc_media_camera_attr_get_lens_orientation_positive(void)
+{
+	int ret;
+	int rotate;
+	ret = camera_attr_get_lens_orientation(camera, &rotate);
+	dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_get_lens_orientation is faild");
+}
+
diff --git a/TC/testcase/utc_media_camera_lifecycle.c b/TC/testcase/utc_media_camera_lifecycle.c
new file mode 100755
index 0000000..f2ee9a7
--- /dev/null
+++ b/TC/testcase/utc_media_camera_lifecycle.c
@@ -0,0 +1,351 @@
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* 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 for the specific language governing permissions and
+* limitations under the License. 
+*/
+
+
+
+#include <tet_api.h>
+#include <media/camera.h>
+#include <stdio.h>
+#include <glib.h>
+#include <pthread.h>
+
+
+#define MY_ASSERT( fun , test , msg ) \
+{\
+	if( !test ) \
+		dts_fail(fun , msg ); \
+}		
+
+static GMainLoop *g_mainloop = NULL;
+static GThread *event_thread;
+	
+
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_media_camera_create_negative(void);
+static void utc_media_camera_create_positive(void);
+
+static void utc_media_camera_destroy_negative(void);
+static void utc_media_camera_destroy_positive(void);
+
+static void utc_media_camera_start_preview_negative(void);
+static void utc_media_camera_start_preview_positive(void);
+
+static void utc_media_camera_stop_preview_negative(void);
+static void utc_media_camera_stop_preview_positive(void);
+
+static void utc_media_camera_start_capture_negative(void);
+static void utc_media_camera_start_capture_positive(void);
+
+static void utc_media_camera_get_state_negative(void);
+static void utc_media_camera_get_state_positive(void);
+
+static void utc_media_camera_start_focusing_negative(void);
+static void utc_media_camera_start_focusing_positive(void);
+
+static void utc_media_camera_cancel_focusing_negative(void);
+static void utc_media_camera_cancel_focusing_positive(void);
+
+struct tet_testlist tet_testlist[] = {
+
+	{utc_media_camera_create_negative , 1},
+	{utc_media_camera_create_positive , 2},
+	{utc_media_camera_destroy_negative , 3},
+	{utc_media_camera_destroy_positive , 4},		
+	{utc_media_camera_start_preview_negative , 5},
+	{utc_media_camera_start_preview_positive , 6},
+	{utc_media_camera_stop_preview_negative , 7},
+	{utc_media_camera_stop_preview_positive , 8},
+	{utc_media_camera_get_state_negative , 9},	
+	{utc_media_camera_get_state_positive , 10},	
+	{utc_media_camera_start_focusing_negative ,11},	
+	{utc_media_camera_start_focusing_positive , 12},	
+	{utc_media_camera_cancel_focusing_negative , 13},	
+	{utc_media_camera_cancel_focusing_positive , 14},
+	{utc_media_camera_start_capture_negative , 15},
+	{utc_media_camera_start_capture_positive , 16},
+
+	{ NULL, 0 },
+};
+
+
+gpointer GmainThread(gpointer data){
+	g_mainloop = g_main_loop_new (NULL, 0);
+	g_main_loop_run (g_mainloop);
+	
+	return NULL;
+}
+
+
+static void startup(void)
+{
+	if( !g_thread_supported() )
+	{
+		g_thread_init(NULL);
+	}
+	
+	GError *gerr = NULL;
+	event_thread = g_thread_create(GmainThread, NULL, 1, &gerr);
+}
+
+static void cleanup(void)
+{
+	g_main_loop_quit (g_mainloop);
+	g_thread_join(event_thread);
+}
+
+static void utc_media_camera_create_negative(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	
+	int ret ;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, NULL);
+
+	MY_ASSERT(__func__ , ret != 0 , "NULL is not allowed");
+
+	dts_pass(__func__, "PASS");	
+}
+static void utc_media_camera_create_positive(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret ;
+	camera_h camera;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	
+	MY_ASSERT(__func__ , ret == 0 , "create fail");
+	
+	camera_destroy(camera);
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_media_camera_destroy_negative(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret;
+	ret = camera_destroy(NULL);
+	MY_ASSERT(__func__ , ret != 0 , "NULL is not allowed");
+	dts_pass(__func__, "PASS");	
+}
+static void utc_media_camera_destroy_positive(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret ;
+	camera_h camera;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	MY_ASSERT(__func__ , ret == 0 , "camera create fail");
+	ret = camera_destroy(camera);
+	MY_ASSERT(__func__ , ret == 0 , "camera destroy is faild");
+	
+	dts_pass(__func__, "PASS");		
+}
+
+static void utc_media_camera_start_preview_negative(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret ;
+	ret = camera_start_preview(NULL);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+}
+
+static void utc_media_camera_start_preview_positive(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret;
+	camera_h camera;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "camera create is faild");
+	ret = camera_start_preview(camera);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "camera start preview is faild");		
+	camera_stop_preview(camera);
+	camera_destroy(camera);	
+
+	dts_pass(__func__, "PASS");		
+}
+
+static void utc_media_camera_stop_preview_negative(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret;
+	camera_h camera;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "camera create is faild");
+
+	ret = camera_stop_preview(camera);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "invalid state");
+
+	camera_destroy(camera);	
+	
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_media_camera_stop_preview_positive(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret;
+	camera_h camera;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	ret = camera_start_preview(camera);
+	printf("------------ camera_start_preview %x\n", ret);
+	MY_ASSERT(__func__ , ret == CAMERA_ERROR_NONE, "camera start preview is faild");
+	
+	ret = camera_stop_preview(camera);
+	MY_ASSERT(__func__, ret ==  CAMERA_ERROR_NONE, "camera_stop_preview is faild");
+	
+	camera_destroy(camera);	
+	dts_pass(__func__, "PASS");
+}
+
+static void utc_media_camera_start_capture_negative(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+
+	int ret;
+	camera_h camera;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "camera create is faild");
+	ret = camera_start_capture(camera, NULL, NULL, NULL);
+	MY_ASSERT(__func__, ret !=CAMERA_ERROR_NONE, "invalid state");	
+	ret = camera_destroy(camera);	
+	printf("---------------utc_media_camera_start_capture_negative-------------camera_destroy ret = %x\n", ret);
+	dts_pass(__func__, "PASS");		
+}
+
+static void utc_media_camera_start_capture_positive(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	
+	int ret;
+	camera_h camera;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11,0);
+	ret = camera_start_preview(camera);
+	printf("------------ camera_start_preview %x\n", ret);	
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "camera start preview is faild");
+	ret = camera_start_capture(camera, NULL, NULL, NULL);
+	MY_ASSERT(__func__, ret==CAMERA_ERROR_NONE, "camera_start_capture is faild");
+	sleep(10);
+	camera_state_e state;
+	camera_get_state(camera, &state);
+	printf("----------camera state = %d\n", state);
+	ret = camera_start_preview(camera);
+	printf(" ---camera_start_preview %x\n", ret);
+	ret = camera_stop_preview(camera);	
+	printf(" ---camera_stop_preview %x\n", ret);	
+	ret = camera_destroy(camera);	
+	printf(" ---camera_destroy %x\n", ret);	
+	printf("---------------%s- end---------------------\n", __func__);
+	
+	dts_pass(__func__, "PASS");		
+}
+
+static void utc_media_camera_get_state_negative(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret;
+	camera_h camera;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);	
+	ret = camera_get_state(camera, NULL);
+	MY_ASSERT(__func__, ret!=CAMERA_ERROR_NONE, "invalid state");	
+	camera_destroy(camera);	
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_media_camera_get_state_positive(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret;
+	camera_h camera;
+	camera_state_e state;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);	
+	ret = camera_get_state(camera, &state);
+	MY_ASSERT(__func__, ret==CAMERA_ERROR_NONE, "camera_get_state fail");	
+	camera_destroy(camera);	
+	dts_pass(__func__, "PASS");		
+}
+
+static void utc_media_camera_start_focusing_negative(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret;
+	camera_h camera;
+	camera_create(CAMERA_DEVICE_CAMERA0, &camera);	
+	ret = camera_start_focusing(camera, false);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "invalid state");		
+	printf("-------------camera_start_focusing %x\n", ret);
+	ret = camera_destroy(camera);
+	printf("-------------camera_destroy %x\n", ret);	
+	dts_pass(__func__, "PASS");		
+
+}
+
+static void utc_media_camera_start_focusing_positive(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret;
+	camera_h camera;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);	
+	ret = camera_start_preview(camera);
+	printf("-------------------------- camera_start_preview ret = %x\n", ret);
+	
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "create camera fail");
+	ret = camera_start_focusing(camera, false);
+	printf("-------------------------- camera_start_focusing ret = %x\n", ret);	
+	MY_ASSERT(__func__, ret==CAMERA_ERROR_NONE, "fail focusing");
+	ret = camera_stop_preview(camera);
+	printf("--------- camera_stop_preview %x\n", ret);
+	ret = camera_destroy(camera);
+	printf("--------- camera_destroy %x\n", ret);	
+	dts_pass(__func__, "PASS");		
+}
+
+static void utc_media_camera_cancel_focusing_negative(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret;
+	camera_h camera;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);	
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "create camera fail");
+	ret = camera_cancel_focusing(camera);
+	printf("---- camera_cancel_focusing %x\n", ret);	
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "invalid state");
+	camera_destroy(camera);
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_media_camera_cancel_focusing_positive(void)
+{
+	fprintf(stderr, "--------------- %s - START --------------\n", __func__);
+	int ret;
+	camera_h camera;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);	
+	printf("------ 	camera_create %x\n", ret);	
+	ret = camera_start_preview(camera);
+	printf("------ 	camera_start_preview %x\n", ret);
+	ret = camera_start_focusing(camera, false);
+	printf("------ 	camera_start_focusing %x\n", ret);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "prepare fail");
+	
+	ret = camera_cancel_focusing(camera);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "cancel focusing fail");
+	camera_stop_preview(camera);
+	camera_destroy(camera);
+	dts_pass(__func__, "PASS");		
+}
diff --git a/TC/testcase/utc_media_camera_setting.c b/TC/testcase/utc_media_camera_setting.c
new file mode 100755
index 0000000..9543faa
--- /dev/null
+++ b/TC/testcase/utc_media_camera_setting.c
@@ -0,0 +1,753 @@
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* 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 for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+
+#include <tet_api.h>
+#include <media/camera.h>
+#include <stdio.h>
+#include <glib.h>
+#include <pthread.h>
+
+
+#define MY_ASSERT( fun , test , msg ) \
+{\
+	if( !test ) \
+		dts_fail(fun , msg ); \
+}		
+
+static GMainLoop *g_mainloop = NULL;
+	
+
+static void utc_camera_set_display_negative(void);
+static void utc_camera_set_display_positive(void);
+
+static void utc_camera_set_preview_resolution_negative(void);
+static void utc_camera_set_preview_resolution_positive(void);
+
+static void utc_camera_set_display_rotation_negative(void);
+static void utc_camera_set_display_rotation_positive(void);
+
+static void utc_camera_set_capture_resolution_negative(void);
+static void utc_camera_set_capture_resolution_positive(void);
+
+static void utc_camera_set_capture_format_negative(void);
+static void utc_camera_set_capture_format_positive(void);
+
+static void utc_camera_set_preview_format_negative(void);
+static void utc_camera_set_preview_format_positive(void);
+
+static void utc_camera_get_preview_resolution_negative(void);
+static void utc_camera_get_preview_resolution_positive(void);
+
+static void utc_camera_get_display_rotation_negative(void);
+static void utc_camera_get_display_rotation_positive(void);
+
+static void utc_camera_get_capture_resolution_negative(void);
+static void utc_camera_get_capture_resolution_positive(void);
+
+static void utc_camera_get_preview_format_negative(void);
+static void utc_camera_get_preview_format_positive(void);
+
+static void utc_camera_set_preview_cb_negative(void);
+static void utc_camera_set_preview_cb_positive(void);
+
+static void utc_camera_unset_preview_cb_negative(void);
+static void utc_camera_unset_preview_cb_positive(void);
+
+static void utc_camera_set_state_changed_cb_negative(void);
+static void utc_camera_set_state_changed_cb_positive(void);
+
+static void utc_camera_unset_state_changed_cb_negative(void);
+static void utc_camera_unset_state_changed_cb_positive(void);
+
+static void utc_camera_set_focus_changed_cb_negative(void);
+static void utc_camera_set_focus_changed_cb_positive(void);
+
+static void utc_camera_unset_focus_changed_cb_negative(void);
+static void utc_camera_unset_focus_changed_cb_positive(void);
+
+static void utc_camera_foreach_supported_preview_resolution_negative(void);
+static void utc_camera_foreach_supported_preview_resolution_positive(void);
+
+static void utc_camera_foreach_supported_capture_resolution_negative(void);
+static void utc_camera_foreach_supported_capture_resolution_positive(void);
+
+static void utc_camera_foreach_supported_capture_format_negative(void);
+static void utc_camera_foreach_supported_capture_format_positive(void);
+
+static void utc_camera_foreach_supported_preview_format_negative(void);
+static void utc_camera_foreach_supported_preview_format_positive(void);
+
+static void utc_camera_set_x11_display_visible_positive(void);
+static void utc_camera_set_x11_display_visible_negative(void);
+
+static void utc_camera_is_x11_display_visible_positive(void);
+static void utc_camera_is_x11_display_visible_negative(void);
+
+
+static void utc_camera_set_x11_display_mode_positive(void);
+static void utc_camera_set_x11_display_mode_negative(void);
+
+static void utc_camera_get_x11_display_mode_positive(void);
+static void utc_camera_get_x11_display_mode_negative(void);
+
+
+static void utc_camera_get_capture_format_positive(void);
+static void utc_camera_get_capture_format_negative(void);
+
+static void utc_camera_set_error_cb_positive(void);
+static void utc_camera_set_error_cb_negative(void);
+
+static void utc_camera_unset_error_cb_positive(void);
+static void utc_camera_unset_error_cb_negative(void);
+
+
+
+
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+struct tet_testlist tet_testlist[] = {
+	{utc_camera_set_display_negative , 1 },
+	{utc_camera_set_display_positive , 2 },
+
+	{utc_camera_set_preview_resolution_negative , 3 },
+	{utc_camera_set_preview_resolution_positive , 4 },
+
+	{utc_camera_set_display_rotation_negative , 5 },
+	{utc_camera_set_display_rotation_positive , 6 },
+
+	{utc_camera_set_capture_resolution_negative , 7 },
+	{utc_camera_set_capture_resolution_positive, 8 },
+
+	{utc_camera_set_capture_format_negative, 9 },
+	{utc_camera_set_capture_format_positive, 10 },
+
+	{utc_camera_set_preview_format_negative, 11 },
+	{utc_camera_set_preview_format_positive, 12 },
+
+	{utc_camera_get_preview_resolution_negative, 13 },
+	{utc_camera_get_preview_resolution_positive, 14 },
+
+	{utc_camera_get_display_rotation_negative, 15 },
+	{utc_camera_get_display_rotation_positive, 16 },
+
+	{utc_camera_get_capture_resolution_negative, 17 },
+	{utc_camera_get_capture_resolution_positive, 18 },
+
+	{utc_camera_get_preview_format_negative, 19 },
+	{utc_camera_get_preview_format_positive, 20 },
+
+	{utc_camera_set_preview_cb_negative, 21 },
+	{utc_camera_set_preview_cb_positive, 22 },
+
+	{utc_camera_unset_preview_cb_negative, 23 },
+	{utc_camera_unset_preview_cb_positive, 24 },
+
+	{utc_camera_set_state_changed_cb_negative, 29 },
+	{utc_camera_set_state_changed_cb_positive, 30 },
+
+	{utc_camera_unset_state_changed_cb_negative, 31 },
+	{utc_camera_unset_state_changed_cb_positive, 32 },
+
+	{utc_camera_set_focus_changed_cb_negative, 33 },
+	{utc_camera_set_focus_changed_cb_positive, 34 },
+
+	{utc_camera_unset_focus_changed_cb_negative, 35 },
+	{utc_camera_unset_focus_changed_cb_positive, 36 },
+
+	{utc_camera_foreach_supported_preview_resolution_negative, 41 },
+	{utc_camera_foreach_supported_preview_resolution_positive, 42 },
+
+	{utc_camera_foreach_supported_capture_resolution_negative, 43 },
+	{utc_camera_foreach_supported_capture_resolution_positive, 44 },
+
+	{utc_camera_foreach_supported_capture_format_negative, 45 },
+	{utc_camera_foreach_supported_capture_format_positive, 46 },
+
+	{utc_camera_foreach_supported_preview_format_negative, 47 },
+	{utc_camera_foreach_supported_preview_format_positive, 48 },
+
+	{ utc_camera_set_x11_display_visible_negative , 49 }, 	
+	{ utc_camera_set_x11_display_visible_positive , 50 },
+
+	{ utc_camera_is_x11_display_visible_negative , 51 }, 	
+	{ utc_camera_is_x11_display_visible_positive , 52 },
+
+	{ utc_camera_set_x11_display_mode_negative , 53 }, 	
+	{ utc_camera_set_x11_display_mode_positive , 54 },
+	
+	{ utc_camera_get_x11_display_mode_negative , 55 }, 	
+	{ utc_camera_get_x11_display_mode_positive , 56 },
+
+	{ utc_camera_get_capture_format_positive , 57 }, 	
+	{ utc_camera_get_capture_format_negative , 58 },
+
+	{ utc_camera_set_error_cb_positive , 59 }, 	
+	{ utc_camera_set_error_cb_negative , 60 },
+
+	{ utc_camera_unset_error_cb_positive , 61 }, 	
+	{ utc_camera_unset_error_cb_negative , 62 },
+
+	
+	{ NULL, 0 },
+};
+
+
+gpointer GmainThread(gpointer data){
+	g_mainloop = g_main_loop_new (NULL, 0);
+	g_main_loop_run (g_mainloop);
+	
+	return NULL;
+}
+
+camera_h camera;
+
+
+static void startup(void)
+{
+	fprintf(stderr, "%s test\n", __func__);
+	/* start of TC */
+	int ret;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	if( ret != 0 )
+		dts_fail("camera_create", "Could not create camera"); 	
+}
+
+static void cleanup(void)
+{
+	/* end of TC */
+	camera_destroy(camera);
+}
+
+
+static void utc_camera_set_display_negative(void)
+{
+	fprintf(stderr, "%s test\n", __func__);
+	int ret;
+	ret = camera_set_display(NULL, CAMERA_DISPLAY_TYPE_X11, 0);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+}
+static void utc_camera_set_display_positive(void)
+{
+	int ret;
+	ret = camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, 0);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE , "set display handle fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_set_preview_resolution_negative(void)
+{
+	int ret;
+	ret = camera_set_preview_resolution(NULL,0,  0);
+	dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed");
+}
+
+
+bool _preview_resolution_cb(int width, int height, void *user_data )
+{
+	int *resolution = (int*)user_data;
+	resolution[0] = width;
+	resolution[1] = height;
+	return false;
+}
+
+static void utc_camera_set_preview_resolution_positive(void)
+{
+	int ret;
+	int resolution[2];
+	
+	camera_foreach_supported_preview_resolution(camera, _preview_resolution_cb, resolution)	;
+	ret = camera_set_preview_resolution(camera,resolution[0],  resolution[1]);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE , "set preview resolution is faild");
+
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_set_display_rotation_negative(void)
+{
+	int ret;
+	ret = camera_set_x11_display_rotation(camera, -1);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE , "not allow -1");
+	dts_pass(__func__, "PASS");	
+}
+static void utc_camera_set_display_rotation_positive(void)
+{
+	int ret;
+	ret = camera_set_x11_display_rotation(camera, CAMERA_ROTATION_NONE);
+	MY_ASSERT(__func__, ret== CAMERA_ERROR_NONE , "camera_set_display_rotation fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_set_capture_resolution_negative(void)
+{
+	int ret;
+	ret = camera_set_capture_resolution(NULL, 0,0);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE , "not allow NULL");
+	dts_pass(__func__, "PASS");	
+}
+
+bool _capture_resolution_cb(int width, int height, void *user_data)
+{
+	int *resolution = (int*) user_data;
+	resolution[0] = width;
+	resolution[1] = height;
+	return false;
+}
+
+static void utc_camera_set_capture_resolution_positive(void)
+{
+	int ret;
+	int resolution[2];
+	
+	camera_foreach_supported_capture_resolution(camera, _capture_resolution_cb, resolution);
+	ret = camera_set_capture_resolution(camera, resolution[0],resolution[1]);
+	
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE , "camera_set_capture_resolution fail");
+	dts_pass(__func__, "PASS");	
+
+}
+static void utc_camera_set_capture_format_negative(void)
+{
+	int ret;
+	ret = camera_set_capture_format(camera, -1);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE , "not allow -1");
+
+	dts_pass(__func__, "PASS");	
+}
+
+bool _capture_format_cb(camera_pixel_format_e format , void *user_data)
+{
+	int *ret = (int*) user_data;
+	*ret = format;
+	return false;
+}
+
+static void utc_camera_set_capture_format_positive(void)
+{
+	int ret;
+	int value;
+	camera_foreach_supported_capture_format(camera, _capture_format_cb, &value);
+	ret = camera_set_capture_format(camera, value);
+	MY_ASSERT(__func__, ret== CAMERA_ERROR_NONE , "camera_set_capture_format fail");
+	
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_set_preview_format_negative(void)
+{
+	int ret ;
+	ret = camera_set_preview_format(camera, -1);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "-1 is not allowed");
+	dts_pass(__func__, "PASS");	
+}
+
+bool _preview_format_cb(camera_pixel_format_e format , void *user_data)
+{
+	camera_pixel_format_e * ret = (camera_pixel_format_e*)user_data;
+	*ret = format;
+	return false;
+}
+
+static void utc_camera_set_preview_format_positive(void)
+{
+	int ret;
+	camera_pixel_format_e format;
+	camera_foreach_supported_preview_format(camera, _preview_format_cb, &format);
+	ret = camera_set_preview_format(camera, format);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE,"set preview format fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_get_preview_resolution_negative(void)
+{
+	int ret ;
+	ret = camera_get_preview_resolution(NULL, NULL,NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+
+	dts_pass(__func__, "PASS");	
+}
+static void utc_camera_get_preview_resolution_positive(void)
+{
+	int ret;
+	int value1;
+	int value2;
+	ret = camera_get_preview_resolution(camera, &value1,&value2);
+	MY_ASSERT(__func__,ret == CAMERA_ERROR_NONE, "get preview resolution fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_get_display_rotation_negative(void)
+{
+	int ret ;
+	ret = camera_get_x11_display_rotation(NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+
+	dts_pass(__func__, "PASS");	
+
+}
+static void utc_camera_get_display_rotation_positive(void)
+{
+	int ret;
+	camera_rotation_e value;
+	ret = camera_get_x11_display_rotation(camera, &value);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "fail get display rotation");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_get_capture_resolution_negative(void)
+{
+	int ret ;
+	ret = camera_get_capture_resolution(NULL, NULL,NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+	dts_pass(__func__, "PASS");	
+}
+static void utc_camera_get_capture_resolution_positive(void)
+{
+	int ret;
+	int value1, value2;
+	ret = camera_get_capture_resolution(camera,&value1, &value2);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "get capture resolution fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_get_preview_format_negative(void)
+{
+	int ret ;
+	ret = camera_get_preview_format(NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+
+	dts_pass(__func__, "PASS");	
+}
+static void utc_camera_get_preview_format_positive(void)
+{
+	int ret;
+	int value;
+	ret=  camera_get_preview_format(camera, &value);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "get preview format fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_set_preview_cb_negative(void)
+{
+	int ret ;
+	ret = camera_set_preview_cb(NULL, NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+	dts_pass(__func__, "PASS");	
+}
+
+void _preview_cb(void* stream_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data)
+{
+}
+
+static void utc_camera_set_preview_cb_positive(void)
+{
+	int ret;
+	ret = camera_set_preview_cb(camera,_preview_cb,NULL);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "set preview cb fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_unset_preview_cb_negative(void)
+{
+	int ret ;
+	ret = camera_unset_preview_cb(NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_unset_preview_cb_positive(void)
+{
+	int ret;
+	ret = camera_unset_preview_cb(camera);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "unset preview cb fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_set_state_changed_cb_negative(void)
+{
+	int ret ;
+	ret = camera_set_state_changed_cb(NULL, NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+	dts_pass(__func__, "PASS");	
+	
+}
+
+void _changed_cb(camera_state_e previous , camera_state_e current , bool by_asm, void *user_data)
+{
+}
+
+static void utc_camera_set_state_changed_cb_positive(void)
+{
+	int ret;
+	ret = camera_set_state_changed_cb(camera, _changed_cb, NULL);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE , "set state change cb fail");
+	dts_pass(__func__, "PASS");	
+}
+static void utc_camera_unset_state_changed_cb_negative(void)
+{
+	int ret ;
+	ret = camera_unset_state_changed_cb(NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+	dts_pass(__func__, "PASS");	
+}
+static void utc_camera_unset_state_changed_cb_positive(void)
+{
+	int ret ;
+	ret = camera_unset_state_changed_cb(camera);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "camera_unset_state_changed_cb fail");
+
+	dts_pass(__func__, "PASS");	
+}
+static void utc_camera_set_focus_changed_cb_negative(void)
+{
+	int ret ;
+	ret = camera_set_focus_changed_cb(NULL, NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+	dts_pass(__func__, "PASS");	
+}
+
+void _focus_changed_cb(camera_focus_state_e state, void *user_data)
+{
+}
+
+static void utc_camera_set_focus_changed_cb_positive(void)
+{
+	int ret;
+	ret = camera_set_focus_changed_cb(camera, _focus_changed_cb, NULL);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "fail");
+
+	dts_pass(__func__, "PASS");	
+}
+static void utc_camera_unset_focus_changed_cb_negative(void)
+{
+	int ret ;
+	ret = camera_unset_focus_changed_cb(NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+	dts_pass(__func__, "PASS");	
+}
+static void utc_camera_unset_focus_changed_cb_positive(void)
+{
+	int ret ;
+	ret = camera_unset_focus_changed_cb(camera);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_foreach_supported_preview_resolution_negative(void)
+{
+	int ret ;
+	ret = camera_foreach_supported_preview_resolution(NULL, NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+	dts_pass(__func__, "PASS");	
+}
+
+bool _preview_resolution_cb2(int width, int height, void *user_data )
+{
+	return false;
+}
+
+static void utc_camera_foreach_supported_preview_resolution_positive(void)
+{
+	int ret ;
+	ret = camera_foreach_supported_preview_resolution(camera, _preview_resolution_cb2, NULL);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_foreach_supported_capture_resolution_negative(void)
+{
+	int ret ;
+	ret = camera_foreach_supported_capture_resolution(NULL, NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+	dts_pass(__func__, "PASS");	
+}
+
+bool _capture_resolution_cb2(int width, int height, void *user_data)
+{
+	return false;
+}
+
+static void utc_camera_foreach_supported_capture_resolution_positive(void)
+{
+	int ret ;
+	ret = camera_foreach_supported_capture_resolution(camera, _capture_resolution_cb2, NULL);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_foreach_supported_capture_format_negative(void)
+{
+	int ret ;
+	ret = camera_foreach_supported_capture_format(NULL, NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+	dts_pass(__func__, "PASS");	
+}
+
+bool _capture_format_cb2(camera_pixel_format_e format , void *user_data)
+{
+	return false;
+}
+
+static void utc_camera_foreach_supported_capture_format_positive(void)
+{
+	int ret ;
+	ret = camera_foreach_supported_capture_format(camera, _capture_format_cb2, NULL);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_foreach_supported_preview_format_negative(void)
+{
+	int ret ;
+	ret = camera_foreach_supported_preview_format(NULL, NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+	dts_pass(__func__, "PASS");	
+}
+
+bool _preview_format_cb2(camera_pixel_format_e format , void *user_data)
+{
+	return false;
+}
+
+static void utc_camera_foreach_supported_preview_format_positive(void)
+{
+	int ret ;
+	ret = camera_foreach_supported_preview_format(camera, _preview_format_cb2,NULL);	
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "fail");
+	dts_pass(__func__, "PASS");	
+}
+
+
+static void utc_camera_set_x11_display_visible_positive(void){
+	int ret;
+	ret = camera_set_x11_display_visible(camera, true);
+	MY_ASSERT(__func__, ret== CAMERA_ERROR_NONE , "camera_set_x11_display_visible fail");
+	dts_pass(__func__, "PASS");		
+}
+static void utc_camera_set_x11_display_visible_negative(void){
+	int ret;
+	ret = camera_set_x11_display_visible(NULL, 0);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE , "not allow NULL");
+	dts_pass(__func__, "PASS");		
+}
+
+static void utc_camera_is_x11_display_visible_positive(void){
+	int ret;
+	bool value;
+	ret = camera_is_x11_display_visible(camera, &value);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "fail camera_is_x11_display_visible");
+	dts_pass(__func__, "PASS");	
+	
+}
+static void utc_camera_is_x11_display_visible_negative(void){
+	int ret ;
+	ret = camera_is_x11_display_visible(NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+
+	dts_pass(__func__, "PASS");		
+}
+
+
+static void utc_camera_set_x11_display_mode_positive(void){
+	int ret;
+	ret = camera_set_x11_display_mode(camera, CAMERA_DISPLAY_MODE_LETTER_BOX);
+	MY_ASSERT(__func__, ret== CAMERA_ERROR_NONE , "camera_set_x11_display_mode fail");
+	dts_pass(__func__, "PASS");		
+	
+}
+static void utc_camera_set_x11_display_mode_negative(void){
+	int ret;
+	ret = camera_set_x11_display_mode(NULL, 0);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE , "not allow NULL");
+	dts_pass(__func__, "PASS");		
+}
+
+static void utc_camera_get_x11_display_mode_positive(void){
+	int ret;
+	camera_display_mode_e value;
+	ret = camera_get_x11_display_mode(camera, &value);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "fail camera_set_x11_display_mode");
+	dts_pass(__func__, "PASS");		
+}
+static void utc_camera_get_x11_display_mode_negative(void){
+	int ret ;
+	ret = camera_get_x11_display_mode(NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+
+	dts_pass(__func__, "PASS");			
+}
+
+
+
+static void utc_camera_get_capture_format_positive(void)
+{
+	int ret;
+	camera_pixel_format_e value;
+	ret = camera_get_capture_format(camera, &value);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "fail camera_get_capture_format");
+	dts_pass(__func__, "PASS");		
+}
+static void utc_camera_get_capture_format_negative(void)
+{
+	int ret ;
+	ret = camera_get_capture_format(NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "NULL is not allowed");
+	dts_pass(__func__, "PASS");			
+}
+
+
+
+void _error_cb(int error, camera_state_e current_state, void *user_data)
+{
+}
+
+static void utc_camera_set_error_cb_positive(void)
+{
+	int ret;
+	ret = camera_set_error_cb(camera, _error_cb, NULL);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_set_error_cb_negative(void)
+{
+	int ret;
+	ret = camera_set_error_cb(NULL, NULL, NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "fail");
+	dts_pass(__func__, "PASS");	
+}
+
+static void utc_camera_unset_error_cb_positive(void)
+{
+	int ret;
+	ret = camera_unset_error_cb(camera);
+	MY_ASSERT(__func__, ret == CAMERA_ERROR_NONE, "fail");
+	dts_pass(__func__, "PASS");	
+}
+static void utc_camera_unset_error_cb_negative(void)
+{
+	int ret;
+	ret = camera_unset_error_cb(NULL);
+	MY_ASSERT(__func__, ret != CAMERA_ERROR_NONE, "fail");
+	dts_pass(__func__, "PASS");	
+}
+
diff --git a/TC/testcase/utc_media_camera_working.c b/TC/testcase/utc_media_camera_working.c
new file mode 100755
index 0000000..3695c9f
--- /dev/null
+++ b/TC/testcase/utc_media_camera_working.c
@@ -0,0 +1,906 @@
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* 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 for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+
+#include <tet_api.h>
+#include <media/camera.h>
+#include <stdio.h>
+#include <glib.h>
+
+#define MY_ASSERT( fun , test , msg ) \
+{\
+	if( !test ) \
+		dts_fail(fun , msg ); \
+}		
+
+static GMainLoop *g_mainloop = NULL;
+static GThread *event_thread;
+int preview_win = 0;	
+
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_media_camera_attribute_test(void);
+static void utc_media_camera_preview_test(void);
+static void utc_media_camera_state_change_test(void);
+static void utc_media_camera_capture_test(void);
+static void utc_media_capture_resolution_test(void);
+
+struct tet_testlist tet_testlist[] = {
+	{ utc_media_camera_attribute_test , 1 },
+	{ utc_media_camera_preview_test, 2} ,
+	{ utc_media_camera_state_change_test , 3 },
+	{ utc_media_camera_capture_test , 4 },
+	{ utc_media_capture_resolution_test , 5 },
+	{ NULL, 0 },
+};
+
+
+gpointer GmainThread(gpointer data){
+	g_mainloop = g_main_loop_new (NULL, 0);
+	g_main_loop_run (g_mainloop);
+	
+	return NULL;
+}
+
+
+static void startup(void)
+{
+	if( !g_thread_supported() )
+	{
+		g_thread_init(NULL);
+	}
+	
+	GError *gerr = NULL;
+	event_thread = g_thread_create(GmainThread, NULL, 1, &gerr);
+}
+
+static void cleanup(void)
+{
+	g_main_loop_quit (g_mainloop);
+	g_thread_join(event_thread);
+}
+
+
+void state_cb(camera_state_e previous , camera_state_e current , int by_asm, void *user_data){
+	char *state_table[] ={
+			"CAMERA_STATE_NONE",				/**< camera is not created yet */
+			"CAMERA_STATE_CREATED",				/**< camera is created, but not initialized yet */
+			"CAMERA_STATE_PREVIEW",				/**< camera is prepared to capture (Preview) */
+			"CAMERA_STATE_CAPTURING",			/**< While capturing*/
+			"CAMERA_STATE_CAPTURED",			/**< camera is now recording */
+			"CAMERA_STATE_NUM",					/**< Number of camera states */
+		};
+	printf("%s\n", state_table[current]);
+}
+
+void capture_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data)
+{
+	char * filepath = (char*)user_data;
+	FILE* f = fopen(filepath, "w+");
+	bool ret;
+	if(f!=NULL && image_buffer !=NULL)
+	{
+		fwrite(image_buffer,1,  buffer_size, f);
+		printf("capture(%s) %dx%d, buffer_size=%d\n", filepath, width, height, buffer_size);
+		ret = TRUE;
+	}
+	else
+	{
+		ret = FALSE;
+	}
+	
+	fclose(f);
+}
+
+int capture_complete(void *user_data){
+	camera_h cam = (camera_h)user_data;
+	
+	printf("capture_complete!!\n");
+
+	camera_start_preview(cam);
+	
+	return 1;	
+}
+
+
+bool g_preview_fps_pass;
+bool _preview_fps_cb(camera_attr_fps_e fps, void *user_data){
+	int ret;
+	camera_attr_fps_e get_fps;
+	camera_h camera = (camera_h) user_data;
+	ret = camera_attr_set_preview_fps(camera, fps);
+	printf("-set preview fps %d\tret=%x\n", fps, ret);	
+	ret = camera_attr_get_preview_fps(camera, &get_fps);
+	printf("-get preview fps %d\tret=%x", get_fps, ret);	
+	
+	if(get_fps == fps)
+		printf("\t\t\tpass\n");
+	else{
+		printf("\t\t\tfail\n");
+		g_preview_fps_pass = false;
+		return false;
+	}		
+	return true;
+}
+
+
+int preview_fps_test(camera_h camera)
+{
+	g_preview_fps_pass = true;
+	printf("------------- PREVIEW FPS TEST -------------\n");
+	camera_attr_foreach_supported_fps(camera, _preview_fps_cb,(void*)camera);
+	printf("--------------------------------------------\n");	
+	if( g_preview_fps_pass ){
+		printf("PREVIEW FPS TEST PASS\n\n");
+		return 0;
+	}else{
+		printf("PREVIEW FPS TEST FAIL\n\n");
+		return -1;
+	}
+}
+
+int image_quality_test(camera_h camera){
+	int ret1;	
+	int ret2;
+	int i;
+	printf("------------- IMAGE QUALITY TEST -------------\n");
+	for( i =-10; i <= 110 ; i+=10){
+		int quality;
+		ret1 = camera_attr_set_image_quality(camera,i);
+		printf("-set image quality %d\tret=%x\n",i,ret1);
+		ret2 = camera_attr_get_image_quality(camera,&quality);
+		printf("-get image quality %d\tret=%x",quality,ret2);
+		
+		if( i >=0 && i <= 100){
+			if( quality == i ){
+				printf("\t\t\tpass\n");
+			}else
+			{
+				printf("\t\t\tfail\n");			
+				return -1;
+			}
+		}else{	//out of bound error
+			if( ret1 == 0){
+				printf("\t\t\tfail\n");
+				return -1;
+			}else{
+				printf("\t\t\tpass\n");
+			}
+		}
+		
+	}
+	printf("--------------------------------------------\n");	
+	printf("IMAGE QUALITY TEST PASS\n\n");
+	
+	return 0;
+}
+
+int zoom_test(camera_h camera){
+	int ret1 ;
+	int ret2 ;	
+	int i;
+	int min, max;
+	printf("------------- ZOOM TEST -------------\n");
+	camera_attr_get_zoom_range(camera, &min, &max);
+	if(max == -1 )
+		return 0;	
+	for( i = min ; i <= max; i+=5 ){
+		int zoom;
+		ret1 = camera_attr_set_zoom(camera, i);
+		printf("-set zoom %d\tret=%x\n",i, ret1);
+		ret2 = camera_attr_get_zoom(camera,&zoom);
+		printf("-get zoom %d\tret=%x",zoom, ret2);
+
+		if( i >=min && i <= max ){
+			if( i == zoom )
+				printf("\t\t\tpass\n");
+			else{
+				printf("\t\t\tfail\n");
+				return -1;
+			}	
+		}else{
+			if( ret1 == 0 ){
+				printf("\t\t\tfail\n");
+				return -1;
+			}else{
+				printf("\t\t\tpass\n");
+			}
+		}
+	}
+	printf("--------------------------------------------\n");	
+	printf("ZOOM TEST PASS\n\n");
+
+	camera_attr_set_zoom(camera, 10);	
+	return 0;
+}
+
+bool g_af_test_pass ;
+bool _af_mode_test_cb(camera_attr_af_mode_e mode, void *user_data){
+	camera_h camera = (camera_h) user_data;
+	int ret;
+	camera_attr_af_mode_e get_mode;
+	ret= camera_attr_set_af_mode(camera, mode);
+	printf("-set af mode %d\tret=%x\n", mode, ret);
+	ret= camera_attr_get_af_mode(camera, &get_mode);
+	printf("-get af mode %d\tret=%x", get_mode, ret);	
+	if( mode != get_mode ){
+		printf("\t\t\tFAIL\n");
+		g_af_test_pass= false;
+		return false;
+	}else
+		printf("\t\t\tPASS\n");
+	return true;
+}
+
+int af_mode_test(camera_h camera){
+	g_af_test_pass = true;
+	camera_attr_foreach_supported_af_mode(camera, _af_mode_test_cb, camera);
+	return g_af_test_pass ? 0 : -1;
+}
+
+bool g_exposure_mode_pass;
+bool _exposure_mode_test_cb(camera_attr_exposure_mode_e mode, void *user_data){
+	camera_h camera = (camera_h) user_data;
+	int ret;
+	camera_attr_exposure_mode_e get_mode;
+	
+	ret = camera_attr_set_exposure_mode(camera, mode);
+	printf("-set exposure mode %d\tret=%x\n", mode,ret);
+	ret = camera_attr_get_exposure_mode(camera,&get_mode);
+	printf("-get exposure mode %d\tret=%x\n", get_mode,ret);		
+	if( get_mode != mode ){
+		g_exposure_mode_pass = false;
+		return false;
+	}
+	return true;
+}
+
+int exposure_mode_test(camera_h camera){
+	g_exposure_mode_pass = true;
+	camera_attr_foreach_supported_exposure_mode(camera,_exposure_mode_test_cb, camera);
+	camera_attr_set_exposure_mode(camera, CAMERA_ATTR_EXPOSURE_MODE_ALL);
+	
+	return g_exposure_mode_pass ? 0 : -1;
+}
+
+int exposure_test(camera_h camera){
+	int i;
+	int ret1, ret2;
+	int default_value;
+	int min,max;
+	ret1 = camera_attr_get_exposure(camera, &default_value );	
+	camera_attr_get_exposure_range(camera, &min, &max);
+	printf("exposure range %d~%d\n", min, max);
+	if(max == -1 )
+		return 0;	
+	for( i = 1; i < 13 ; i++ ){
+		int value;
+		ret1 = camera_attr_set_exposure(camera, i );
+		printf("-set exposure %d\tret=%x\n",i,ret1);
+		ret2 = camera_attr_get_exposure(camera, &value);
+		printf("-get exposure %d\tret=%x\n",value,ret2);
+		if( i >= min && i <= max ){
+			if( value != i)
+				return -1;
+		}else{ // out of bound error
+			if( ret1 == 0 )
+				return -1;
+		}
+	}	
+	ret1 = camera_attr_set_exposure(camera, default_value );	
+	return 0;
+}
+
+bool g_iso_test_pass ;
+bool _iso_test_cb(camera_attr_iso_e iso, void *user_data){
+	camera_h camera = (camera_h) user_data;
+	int ret;
+	camera_attr_iso_e get_iso;
+	ret = camera_attr_set_iso(camera, iso);
+	printf("-set iso %d\tret=%x\n", iso, ret);
+	ret = camera_attr_get_iso(camera,&get_iso);
+	printf("-get iso %d\tret=%x\n", get_iso, ret);	
+	if( get_iso != iso ){
+		g_iso_test_pass = false;
+		return false;
+	}
+	return true;
+}
+
+int iso_test(camera_h camera){
+	g_iso_test_pass = true;
+	camera_attr_foreach_supported_iso(camera,_iso_test_cb, camera);
+	return g_iso_test_pass ? 0 : -1;
+}
+
+int brightness_test(camera_h camera){
+	int i;
+	int ret1,ret2;
+	int default_value;
+	int min,max;
+	ret1 = camera_attr_get_brightness(camera, &default_value );	
+	camera_attr_get_brightness_range(camera, &min, &max);
+	if(max == -1 )
+		return 0;	
+	for( i = 1; i < 13 ; i++ ){
+		int value;
+		ret1 = camera_attr_set_brightness(camera, i );
+		printf("-set brightness %d\tret=%x\n",i,ret1);
+		ret2 = camera_attr_get_brightness(camera, &value);
+		printf("-get brightness %d\tret=%x\n",value,ret2);
+
+		if( i >= min && i <= max ){
+			if( value != i)
+				return -1;
+		}else{ // out of bound error
+			if( ret1 == 0 )
+				return -1;
+		}
+		
+	}	
+	ret1 = camera_attr_set_brightness(camera, default_value );	
+	return 0;
+	
+}
+
+int contrast_test(camera_h camera){
+	int i;
+	int ret1,ret2;
+	int default_value;
+	int min,max;
+	ret1 = camera_attr_get_contrast (camera, &default_value );	
+	camera_attr_get_contrast_range(camera, &min, &max);
+	if(max == -1 )
+		return 0;
+	for( i = 1; i < 13 ; i++ ){
+		int value;
+		ret1 = camera_attr_set_contrast (camera, i );
+		printf("-set contrast %d\tret=%x\n",i,ret1);
+		ret2 = camera_attr_get_contrast (camera, &value);
+		printf("-get contrast %d\tret=%x\n",value,ret2);
+
+		if( i >= min && i <= max ){
+			if( value != i)
+				return -1;
+		}else{ // out of bound error
+			if( ret1 == 0 )
+				return -1;
+		}		
+	}	
+	ret1 = camera_attr_set_contrast (camera, default_value );	
+	return 0;	
+}
+
+bool _whitebalance_test_cb(camera_attr_whitebalance_e wb,  void *user_data){
+	camera_h camera = (camera_h) user_data;
+	int ret;
+	ret = camera_attr_set_whitebalance(camera, wb);
+	printf("-set whitebalance %d\tret=%x\n", wb,ret);
+	ret = camera_attr_get_whitebalance(camera,&wb);
+	printf("-get whitebalance %d\tret=%x\n", wb,ret);		
+	return true;	
+}
+
+
+int whitebalance_test(camera_h camera){
+	camera_attr_foreach_supported_whitebalance(camera, _whitebalance_test_cb ,camera);
+	return 0;
+}
+
+bool _effect_test_cb(camera_attr_effect_mode_e effect,  void *user_data){
+	camera_h camera = (camera_h) user_data;
+	int ret;
+	ret = camera_attr_set_effect(camera, effect);
+	printf("-set effect %d\tret=%x\n", effect,ret);
+	ret = camera_attr_get_effect(camera,&effect);
+	printf("-get effect %d\tret=%x\n", effect,ret);		
+	return true;
+}
+
+
+int effect_test(camera_h camera){
+	camera_attr_foreach_supported_effect(camera, _effect_test_cb, camera);
+	return 0;
+}
+
+
+bool _scene_mode_test_cb (camera_attr_scene_mode_e mode,  void *user_data){
+	camera_h camera = (camera_h) user_data;
+	int ret;
+	ret = camera_attr_set_scene_mode(camera, mode);
+	printf("-set scene %d\tret=%x\n", mode,ret);
+	ret = camera_attr_get_scene_mode(camera,&mode);
+	printf("-get scene %d\tret=%x\n", mode,ret);		
+	return true;
+}
+
+int scene_mode_test(camera_h camera){
+	camera_attr_foreach_supported_scene_mode(camera, _scene_mode_test_cb, camera);
+	return 0;
+}
+
+int tag_enable_test(camera_h camera){
+	int ret;
+	bool enable;
+	ret = camera_attr_enable_tag(camera, true);
+	printf("-set enable tag true\tret=%x\n",ret);
+	ret = camera_attr_is_enabled_tag(camera, &enable);
+	printf("-get enable tag %d\tret=%x\n",enable, ret);
+	return 0;
+}
+
+int tag_orientation_test(camera_h camera){
+	int ret;
+	camera_attr_tag_orientation_e orientation;
+	
+	ret = camera_attr_set_tag_orientation(camera, 1);
+	printf("-set tag orientation %d\tret=%x\n",1 ,ret);
+	ret= camera_attr_get_tag_orientation(camera, &orientation);
+	printf("-get tag orientation %d\tret=%x\n",orientation,ret);	
+
+	
+	ret |= camera_attr_set_tag_orientation(camera, 2 );
+	printf("-set tag orientation %d\tret=%x\n",2 ,ret);
+	ret |= camera_attr_get_tag_orientation(camera, &orientation);
+	printf("-get tag orientation %d\tret=%x\n",orientation,ret);		
+
+	ret |= camera_attr_set_tag_orientation(camera, 3 );
+	printf("-set tag orientation %d\tret=%x\n",3 ,ret);
+	ret |= camera_attr_get_tag_orientation(camera, &orientation);
+	printf("-get tag orientation %d\tret=%x\n",orientation,ret);		
+
+	ret |= camera_attr_set_tag_orientation(camera, 4 );
+	printf("-set tag orientation %d\tret=%x\n",4 ,ret);
+	ret |= camera_attr_get_tag_orientation(camera, &orientation);
+	printf("-get tag orientation %d\tret=%x\n",orientation,ret);		
+
+	ret |= camera_attr_set_tag_orientation(camera, 5  );
+	printf("-set tag orientation %d\tret=%x\n",5  ,ret);
+	ret |= camera_attr_get_tag_orientation(camera, &orientation);
+	printf("-get tag orientation %d\tret=%x\n",orientation,ret);		
+
+	ret |= camera_attr_set_tag_orientation(camera, 6 );
+	printf("-set tag orientation %d\tret=%x\n",6 ,ret);
+	ret |= camera_attr_get_tag_orientation(camera, &orientation);
+	printf("-get tag orientation %d\tret=%x\n",orientation,ret);		
+
+	ret |= camera_attr_set_tag_orientation(camera, 7  );
+	printf("-set tag orientation %d\tret=%x\n",7  ,ret);
+	ret |= camera_attr_get_tag_orientation(camera, &orientation);
+	printf("-get tag orientation %d\tret=%x\n",orientation,ret);		
+
+	ret |= camera_attr_set_tag_orientation(camera, 8  );
+	printf("-set tag orientation %d\tret=%x\n",8  ,ret);
+	ret |= camera_attr_get_tag_orientation(camera, &orientation);
+	printf("-get tag orientation %d\tret=%x\n",orientation,ret);		
+
+	return ret == 0 ? 0 : -1;
+	
+}
+
+int tag_image_description_test(camera_h camera){
+	char *buffer;
+	int ret;
+	ret = camera_attr_set_tag_image_description(camera, "hello capi");
+	printf("-set tag image description \"hello capi\"\tret=%x\n", ret);
+	ret = camera_attr_get_tag_image_description(camera, &buffer);
+	printf("-get tag image description \"%s\"\tret=%x\n", buffer, ret);
+	free(buffer);
+	ret = camera_attr_set_tag_image_description(camera, "12345678901234567890");
+	printf("-set tag image description \"12345678901234567890\"\tret=%x\n", ret);
+	ret = camera_attr_get_tag_image_description(camera, &buffer);
+	printf("-get tag image description \"%s\"\tret=%x\n", buffer, ret);
+	free(buffer);
+	return 0;
+}
+
+int tag_software_test(camera_h camera){
+	char *buffer;
+	int ret;
+	ret = camera_attr_set_tag_software(camera, "hello capi");
+	printf("-set tag software \"hello capi\"\tret=%x\n", ret);
+	ret = camera_attr_get_tag_software(camera, &buffer);
+	printf("-get tag software  \"%s\"\tret=%x\n", buffer, ret);
+	free(buffer);
+
+	ret = camera_attr_set_tag_software(camera, "12345678901234567890");
+	printf("-set tag software \"12345678901234567890\"\tret=%x\n", ret);
+	ret = camera_attr_get_tag_software(camera, &buffer);
+	printf("-get tag software \"%s\"\tret=%x\n", buffer, ret);
+	free(buffer);
+	return 0;	
+}
+
+
+bool _flash_mode_test_cb(camera_attr_flash_mode_e mode,  void *user_data){
+	camera_h camera = (camera_h) user_data;
+	int ret;
+	ret = camera_attr_set_flash_mode(camera, mode);
+	printf("-set flash mode %d\tret=%x\n", mode,ret);
+	ret = camera_attr_get_flash_mode(camera,&mode);
+	printf("-get flash mode %d\tret=%x\n", mode,ret);		
+	return true;
+}
+
+
+int flash_mode_test(camera_h camera){
+	camera_attr_foreach_supported_flash_mode(camera, _flash_mode_test_cb,camera);
+	return 0;
+}
+
+int gps_test(camera_h camera){
+	double lng = 1.12;
+	double lat = 1.13;
+	double alt = 1.14;
+	int ret;
+	ret = camera_attr_set_geotag(camera, lat, lng , alt );
+	if( ret != 0)
+		return -1;
+	ret = camera_attr_get_geotag(camera, &lat , &lng , &alt);
+	if( ret != 0 )
+		return -1;
+	return 0;
+}
+
+
+void utc_media_camera_attribute_test(void)
+{
+	int ret;
+	camera_h camera ;
+	int ret2;
+	camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
+	camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);	
+	printf("-----------------------create camera-----------------------------\n");
+
+	ret = preview_fps_test(camera);
+	printf("preview_fps_test %d\n", ret);	
+	ret += image_quality_test(camera);
+	printf("image_quality_test %d\n", ret);		
+	
+	ret2 = camera_start_preview(camera);
+	printf("--------------------------preview-started----------%x-------------------------\n", ret2);
+	ret += zoom_test(camera);
+	printf("zoom_test %d\n", ret);		
+	ret += af_mode_test(camera);
+	printf("af_mode_test %d\n", ret);	
+	ret += exposure_mode_test(camera);
+	printf("exposure_mode_test %d\n", ret);		
+	ret += exposure_test(camera);
+	printf("exposure_test %d\n", ret);		
+	ret += iso_test(camera);
+	printf("iso_test %d\n", ret);		
+	ret += brightness_test(camera);
+	printf("brightness_test %d\n", ret);		
+	ret += contrast_test(camera);
+	printf("contrast_test %d\n", ret);		
+	ret += whitebalance_test(camera);
+	printf("whitebalance_test %d\n", ret);		
+	ret += effect_test(camera);
+	printf("effect_test %d\n", ret);	
+	ret += scene_mode_test(camera);
+	printf("scene_mode_test %d\n", ret);	
+	ret += tag_enable_test(camera);
+	printf("tag_enable_test %d\n", ret);
+	ret += tag_orientation_test(camera);
+	printf("tag_orientation_test %d\n", ret);	
+	ret += tag_image_description_test(camera);
+	printf("tag_image_description_test %d\n", ret);	
+	ret += tag_software_test(camera);
+	printf("tag_software_test %d\n", ret);	
+	ret += flash_mode_test(camera);
+	printf("flash_mode_test %d\n", ret);	
+	ret += gps_test(camera);
+	printf("gps_test %d\n", ret);	
+	
+	camera_stop_preview(camera);
+	camera_destroy(camera);
+
+	MY_ASSERT(__func__, ret == 0 , "error attribute get set test");
+	dts_pass(__func__, "PASS");
+	
+}
+
+
+typedef struct {
+	camera_h camera;
+	camera_pixel_format_e in_format;
+	bool iscalled;
+	bool result;
+} camera_preview_test_s;
+
+ void _camera_preview_test_cb(void *stream_buffer, int buffer_size, int width, int height, camera_pixel_format_e format,  void *user_data){
+ 	camera_preview_test_s * data = (camera_preview_test_s*)user_data;
+	data->iscalled = true;
+	if( format == data->in_format )
+		data->result = true;
+
+}
+
+bool _preview_format_test_cb(camera_pixel_format_e format,  void *user_data){
+	int *table = (int*)user_data;
+	table[format] = 1;	
+	return true;
+}
+
+
+void utc_media_camera_preview_test(void)
+{
+	int ret;
+	camera_h camera ;
+	int i;
+	camera_preview_test_s preview_test_data;
+	int enable_preview_format[CAMERA_PIXEL_FORMAT_JPEG+1] = {0,};
+	
+	
+	camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
+	camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);	
+	camera_set_preview_cb(camera, 	 _camera_preview_test_cb	, &preview_test_data);
+
+	ret = camera_foreach_supported_preview_format(camera, _preview_format_test_cb,enable_preview_format);
+
+	printf("-----------------------PREVIEW FORMAT TEST-----------------------------\n");
+	
+	for(i =0; i<= CAMERA_PIXEL_FORMAT_JPEG ; i++){
+		if( enable_preview_format[i] ){
+			preview_test_data.in_format = i;
+			preview_test_data.camera = camera;
+			preview_test_data.iscalled = false;
+			preview_test_data.result = false;
+			camera_set_preview_format(camera, i);
+			printf("-------------PREVIEW FORMAT %d TEST--------------------\n", i);
+			camera_start_preview(camera);
+			sleep(1);
+			camera_stop_preview(camera);
+			if( preview_test_data.iscalled && preview_test_data.result ){
+				printf("PASS\n");
+			}else{
+				printf("FAIL\n");
+				camera_destroy(camera);
+				dts_fail("CAMERA_PREVIEW_TEST", "preview cb is not called");
+				return;
+			}
+			
+		}
+	}
+
+	camera_destroy(camera);
+
+	dts_pass(__func__,"PASS");
+	return;
+	
+	
+}
+
+
+typedef struct{
+	bool iscalled;
+	bool ispreviewed;
+	bool iscapturing;
+	bool iscaptured;
+	camera_state_e state;
+} state_change_data;
+
+void _state_change_test_cb(camera_state_e previous , camera_state_e current , bool by_asm,  void *user_data){
+	state_change_data * data = (state_change_data*)user_data;
+	data->iscalled = true;
+	if( current == CAMERA_STATE_PREVIEW )
+		data->ispreviewed = true;
+	if( current == CAMERA_STATE_CAPTURED )
+		data->iscaptured = true;
+	if( current == CAMERA_STATE_CAPTURING )
+		data->iscapturing = true;
+	data->state = current;
+}
+
+void _capture_test_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
+	
+}
+
+
+void utc_media_camera_state_change_test(void){
+	camera_h camera ;
+	state_change_data data;
+	bool ispass = true;
+	
+	camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
+	camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
+	camera_set_state_changed_cb(camera, _state_change_test_cb, &data);
+
+	printf("------------------- PREVIEW STATE Change test------------------\n");
+	data.iscalled = false;
+	data.state = 0;	
+	camera_start_preview(camera);
+	sleep(1);
+	if( data.iscalled && data.state == CAMERA_STATE_PREVIEW )
+		printf("PASS\n");
+	else{
+		printf("FAIL\n");
+		ispass = false;
+	}
+
+
+	printf("------------------- CREATED STATE Change test------------------\n");
+	
+	data.iscalled = false;
+	data.state = 0;
+	camera_stop_preview(camera);
+	sleep(1);
+	if( data.iscalled && data.state == CAMERA_STATE_CREATED)
+		printf("PASS\n");
+	else{
+		printf("FAIL\n");
+		ispass = false;
+	}
+
+
+	printf("------------------- CAPTURED STATE Change test------------------\n");
+
+	camera_start_preview(camera);
+	sleep(1);
+	data.iscalled = false;
+	data.state = 0;
+	data.iscaptured = false;
+	data.ispreviewed= false;	
+	data.iscapturing = false;	
+	camera_start_capture(camera, _capture_test_cb, NULL, NULL);
+	sleep(3);
+	if( data.iscalled &&  data.iscaptured && data.iscapturing && data.state == CAMERA_STATE_CAPTURED)
+		printf("PASS\n");
+	else{
+		printf("FAIL\n");
+		ispass = false;
+	}
+	
+	camera_start_preview(camera);
+	camera_stop_preview(camera);
+	camera_destroy(camera);
+	MY_ASSERT(__func__, ispass , "camera_state_change_test FAIL");
+	dts_pass(__func__, "PASS");
+	
+}
+
+void _capture_test2_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
+	int *iscalled = (int*)user_data;
+	*iscalled = 1;
+}
+
+void utc_media_camera_capture_test(void){
+	camera_h camera ;
+	int iscalled;
+	camera_state_e state ;
+	bool ispass = true;
+	int timeout = 5;
+
+	printf("---------------------CAPTURE Test -----------------\n");
+	
+	camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
+	camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);	
+	camera_start_preview(camera);
+	iscalled = 0;
+	camera_start_capture(camera, _capture_test2_cb,NULL,  &iscalled);
+	
+	while( timeout-- >0 && camera_get_state(camera, &state ) == 0 && state != CAMERA_STATE_CAPTURED)
+		sleep(1);
+	
+	if( iscalled == 1 )
+		printf("PASS\n");
+	else{
+		printf("FAIL\n");
+		ispass = false;
+	}
+
+	
+	camera_start_preview(camera);
+	camera_stop_preview(camera);
+	camera_destroy(camera);
+
+	MY_ASSERT(__func__, ispass,"capture test fail");
+	dts_pass(__func__, "PASS");
+
+	
+}
+
+
+typedef struct{
+	int width[100];
+	int height[100];
+	int count;
+} resolution_stack;
+
+
+bool capture_resolution_test_cb(int width, int height,  void *user_data){
+	resolution_stack *data = (resolution_stack*)user_data;
+	data->width[data->count] = width;
+	data->height[data->count] = height;
+	data->count++;
+
+	printf("%dx%d\n",width, height);
+	
+	return true;
+}
+
+typedef struct{
+	int expected_width;
+	int expected_height;
+	bool ispass;
+}preview_test_data;
+void _capture_test3_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
+	preview_test_data *data = (preview_test_data*)user_data;
+	if( data->expected_height == image->height && data->expected_width == image->width )
+		data->ispass = true;
+
+}
+
+
+void utc_media_capture_resolution_test(void){
+	camera_h camera ;
+	resolution_stack resolution_list;
+	int i;
+	camera_state_e state ;
+	int ret = 0;
+
+	camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
+	camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
+	resolution_list.count = 0;
+	camera_foreach_supported_capture_resolution(camera, capture_resolution_test_cb, &resolution_list);
+	//camera_set_state_changed_cb(camera, state_cb, NULL);
+
+	printf("-----------------CAPTURE RESOLUTION TEST---------------------\n");
+
+	for(i =0 ; i < resolution_list.count ; i++){
+		preview_test_data data;
+		data.ispass = false;
+		data.expected_width = resolution_list.width[i];
+		data.expected_height = resolution_list.height[i];
+		int timeout=5;
+
+		printf("-----------------CAPTURE RESOLUTION (%dx%d)---------------------\n",data.expected_width  ,data.expected_height);
+		
+		printf("resolution set test %x\n", (unsigned int)camera_set_capture_resolution(camera,data.expected_width  ,data.expected_height));
+
+		camera_start_preview(camera);
+		
+		camera_start_capture(camera, _capture_test3_cb, NULL , &data);
+		
+		while( timeout-- > 0 && camera_get_state(camera, &state ) == 0 && state != CAMERA_STATE_CAPTURED ){
+			sleep(1);
+		}
+
+		camera_start_preview(camera);
+		camera_stop_preview(camera);
+		if( !data.ispass ){
+			ret += -1;
+			printf("FAIL\n");
+		}else{
+			printf("PASS\n");		
+		}
+	}
+
+	MY_ASSERT(__func__,ret == 0, "capture resolution test fail");
+	dts_pass(__func__, "PASS");
+}
+
diff --git a/TC/tet_scen b/TC/tet_scen
new file mode 100755
index 0000000..03f029a
--- /dev/null
+++ b/TC/tet_scen
@@ -0,0 +1,7 @@
+all
+	^TEST
+##### Scenarios for TEST #####
+
+# Test scenario
+TEST
+	:include:/testcase/tslist
diff --git a/TC/tetbuild.cfg b/TC/tetbuild.cfg
new file mode 100644
index 0000000..f7eda55
--- /dev/null
+++ b/TC/tetbuild.cfg
@@ -0,0 +1,5 @@
+TET_OUTPUT_CAPTURE=True # capture option for build operation checking
+TET_BUILD_TOOL=make # build with using make command
+TET_BUILD_FILE=-f Makefile # execution file (Makefile) for build
+TET_API_COMPLIANT=True # use TET API in Test Case ?
+TET_PASS_TC_NAME=True # report passed TC name in Journal file?
diff --git a/TC/tetclean.cfg b/TC/tetclean.cfg
new file mode 100644
index 0000000..02d7030
--- /dev/null
+++ b/TC/tetclean.cfg
@@ -0,0 +1,5 @@
+TET_OUTPUT_CAPTURE=True # capture option
+TET_CLEAN_TOOL= make clean # clean tool
+TET_CLEAN_FILE= Makefile # file for clean
+TET_API_COMPLIANT=True # TET API useage 
+TET_PASS_TC_NAME=True # showing name , passed TC
diff --git a/TC/tetexec.cfg b/TC/tetexec.cfg
new file mode 100644
index 0000000..ef3e452
--- /dev/null
+++ b/TC/tetexec.cfg
@@ -0,0 +1,5 @@
+TET_OUTPUT_CAPTURE=True # capturing execution or not
+TET_EXEC_TOOL=  # ex) exec : execution tool set up/ Optional
+TET_EXEC_FILE=   # ex) exectool : execution file/ Optional
+TET_API_COMPLIANT=True # Test case or Tool usesTET API?
+TET_PASS_TC_NAME=True # showing Passed TC name ?
diff --git a/capi-media-camera.pc.in b/capi-media-camera.pc.in
index 5d02f8d..5d02f8d 100755..100644
--- a/capi-media-camera.pc.in
+++ b/capi-media-camera.pc.in
diff --git a/debian/README b/debian/README
deleted file mode 100755
index e69de29..0000000
--- a/debian/README
+++ /dev/null
diff --git a/debian/capi-media-camera-dev.install b/debian/capi-media-camera-dev.install
deleted file mode 100755
index 761a28b..0000000
--- a/debian/capi-media-camera-dev.install
+++ /dev/null
@@ -1,4 +0,0 @@
-/usr/include/*
-/usr/include/*/*
-/usr/lib/pkgconfig/*.pc
-
diff --git a/debian/capi-media-camera-dev.postinst b/debian/capi-media-camera-dev.postinst
deleted file mode 100755
index 1a24852..0000000
--- a/debian/capi-media-camera-dev.postinst
+++ /dev/null
@@ -1 +0,0 @@
-#!/bin/sh
diff --git a/debian/capi-media-camera.install b/debian/capi-media-camera.install
deleted file mode 100755
index 4a755a4..0000000
--- a/debian/capi-media-camera.install
+++ /dev/null
@@ -1 +0,0 @@
-/usr/lib/lib*.so*
diff --git a/debian/capi-media-camera.postinst b/debian/capi-media-camera.postinst
deleted file mode 100755
index 1a24852..0000000
--- a/debian/capi-media-camera.postinst
+++ /dev/null
@@ -1 +0,0 @@
-#!/bin/sh
diff --git a/debian/changelog b/debian/changelog
deleted file mode 100755
index af53b4f..0000000
--- a/debian/changelog
+++ /dev/null
@@ -1,13 +0,0 @@
-capi-media-camera (0.1.0-11) unstable; urgency=low
-
-  * update camrea API
-  * Git: slp-source.sec.samsung.net:slp/api/camera
-  * Tag: capi-media-camera_0.1.0-11
-
- -- Seungkeun Lee <sngn.lee@samsung.com>  Wed, 14 Mar 2012 11:38:20 +0900
-
-capi-media-camera (0.0.1-1) unstable; urgency=low
-
-  * Initial release.
-
- -- Seungkeun Lee <sngn.lee@samsung.com>  Wed, 07 Dec 2011 12:42:07 +0900
diff --git a/debian/compat b/debian/compat
deleted file mode 100755
index 7ed6ff8..0000000
--- a/debian/compat
+++ /dev/null
@@ -1 +0,0 @@
-5
diff --git a/debian/control b/debian/control
deleted file mode 100755
index e1e354b..0000000
--- a/debian/control
+++ /dev/null
@@ -1,22 +0,0 @@
-
-Source: capi-media-camera
-Section: libs
-Priority: extra
-Maintainer: Seungkeun Lee <sngn.lee@samsung.com>, Kangho Hur<kagho.hur@samsung.com>
-Build-Depends: debhelper (>= 5), dlog-dev, libmm-camcorder-dev, libmm-common-dev, libmm-session-dev, capi-base-common-dev
-
-Package: capi-media-camera
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}
-Description: A Camera library in Tizen Native API
-
-Package: capi-media-camera-dev
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, capi-media-camera (= ${Source-Version}), capi-base-common-dev
-Description: A Camera library in Tizen Native API (DEV)
-
-Package: capi-media-camera-dbg
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, capi-media-camera (= ${Source-Version})
-Description: A Camera library in Tizen Native API (DBG)
-
diff --git a/debian/rules b/debian/rules
deleted file mode 100755
index 1b8f351..0000000
--- a/debian/rules
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/usr/bin/make -f
-
-FULLVER ?= $(shell dpkg-parsechangelog | grep Version: | cut -d ' ' -f 2 | cut -d '-' -f 1)
-MAJORVER ?= $(shell echo $(FULLVER) | cut -d '.' -f 1)
-
-CFLAGS = -Wall -g
-
-ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
-	CFLAGS += -O0
-else
-	CFLAGS += -O2
-endif
-CMAKE_ROOT_DIR ?= $(CURDIR)
-CMAKE_BUILD_DIR ?= $(CURDIR)/cmake_build_tmp
-
-configure: configure-stamp
-configure-stamp:
-	dh_testdir
-	mkdir -p $(CMAKE_BUILD_DIR) && cd $(CMAKE_BUILD_DIR) && cmake .. -DFULLVER=${FULLVER} -DMAJORVER=${MAJORVER}
-	touch configure-stamp
-
-
-build: build-stamp
-build-stamp: configure-stamp 
-	dh_testdir
-	cd $(CMAKE_BUILD_DIR) && $(MAKE)
-	touch $@
-
-clean:
-	cd $(CMAKE_ROOT_DIR)
-	dh_testdir
-	dh_testroot
-	rm -f build-stamp configure-stamp
-	rm -f 
-	rm -rf $(CMAKE_BUILD_DIR)
-	dh_clean
-	
-install: build
-	dh_testdir
-	dh_testroot
-	dh_clean -k 
-	dh_installdirs
-
-	cd $(CMAKE_BUILD_DIR) && $(MAKE) DESTDIR=$(CURDIR)/debian/tmp install
-
-binary-indep: build install
-
-binary-arch: build install
-	dh_testdir
-	dh_testroot
-	dh_installchangelogs 
-	dh_installdocs
-	dh_installexamples
-	dh_install --sourcedir=debian/tmp
-	dh_installman
-	dh_link
-	dh_strip --dbg-package=capi-media-camera-dbg
-	dh_fixperms
-	dh_makeshlibs
-	dh_installdeb
-	dh_shlibdeps
-	dh_gencontrol
-	dh_md5sums
-	dh_builddeb
-
-binary: binary-indep binary-arch
-.PHONY: build clean binary-indep binary-arch binary install configure
-
diff --git a/include/camera.h b/include/camera.h
index 998249f..2212a07 100755
--- a/include/camera.h
+++ b/include/camera.h
@@ -53,6 +53,9 @@ typedef enum
     CAMERA_ERROR_DEVICE =            CAMERA_ERROR_CLASS | 0x04,    /**< Device error */
     CAMERA_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION,  /**< Internal error */
     CAMERA_ERROR_SOUND_POLICY =      CAMERA_ERROR_CLASS | 0x06,    /**< Blocked by Audio Session Manager */
+    CAMERA_ERROR_SECURITY_RESTRICTED = CAMERA_ERROR_CLASS | 0x07,    /**< Restricted by security system policy */
+    CAMERA_ERROR_DEVICE_BUSY = CAMERA_ERROR_CLASS | 0x08,    /**< The device is using in other applications or working some operation */
+    CAMERA_ERROR_DEVICE_NOT_FOUND = CAMERA_ERROR_CLASS | 0x09, /**< No camera device */
 } camera_error_e;
 
 
@@ -180,6 +183,43 @@ typedef enum
 	CAMERA_DISPLAY_MODE_CROPPED_FULL,	/**< Cropped full screen*/
 } camera_display_mode_e;
 
+/**
+ * @brief Enumerations of the camera policy.
+ */
+typedef enum
+{
+	CAMERA_POLICY_NONE = 0, /**< None */
+	CAMERA_POLICY_SOUND, /**< Sound policy */
+	CAMERA_POLICY_SECURITY /**< Security policy */
+} camera_policy_e;
+
+
+/**
+ * @brief Struct of the image data
+ */
+ typedef struct
+{
+	unsigned char *data;       				/**< The image buffer */
+	unsigned int size;            				/**< The size of buffer */
+	int width;                        			/**< The width of image */
+	int height;                      				/**< The height of image */
+	camera_pixel_format_e format; /**< The format of image pixel */
+}camera_image_data_s;
+
+
+/**
+ * @brief Struct of the face detection
+ */
+typedef struct
+{
+	int id;				/**< The id of each face */
+	int score;		/**< The confidence level for the detection of the face */
+	int x;				/**< The x coordinates of face */
+	int y;				/**< The y coordinates of face */
+	int width;		/**< The width of face */
+	int height;		/**< The height of face */
+}camera_detected_face_s;
+
 
 /**
  * @}
@@ -321,12 +361,12 @@ typedef enum
 typedef enum
 {
     CAMERA_ATTR_TAG_ORIENTATION_TOP_LEFT = 1,      /**< Row #0 is top, Column #0 is left */
-    CAMERA_ATTR_TAG_ORIENTATION_TOP_RIGHT = 2,     /**< Row #0 is top, Column #0 is right */
+    CAMERA_ATTR_TAG_ORIENTATION_TOP_RIGHT = 2,     /**< Row #0 is top, Column #0 is right (flipped) */
     CAMERA_ATTR_TAG_ORIENTATION_BOTTOM_RIGHT = 3,  /**< Row #0 is bottom, Column #0 is right */
-    CAMERA_ATTR_TAG_ORIENTATION_BOTTOM_LEFT = 4,   /**< Row #0 is bottom, Column #0 is left */
-    CAMERA_ATTR_TAG_ORIENTATION_LEFT_TOP = 5,      /**< Row #0 is left, Column #0 is top */
+    CAMERA_ATTR_TAG_ORIENTATION_BOTTOM_LEFT = 4,   /**< Row #0 is bottom, Column #0 is left (flipped) */
+    CAMERA_ATTR_TAG_ORIENTATION_LEFT_TOP = 5,      /**< Row #0 is left, Column #0 is top (flipped) */
     CAMERA_ATTR_TAG_ORIENTATION_RIGHT_TOP = 6,     /**< Row #0 is right, Column #0 is top */
-    CAMERA_ATTR_TAG_ORIENTATION_RIGHT_BOTTOM = 7,  /**< Row #0 is right, Column #0 is bottom */
+    CAMERA_ATTR_TAG_ORIENTATION_RIGHT_BOTTOM = 7,  /**< Row #0 is right, Column #0 is bottom (flipped) */
     CAMERA_ATTR_TAG_ORIENTATION_LEFT_BOTTOM = 8,   /**< Row #0 is left, Column #0 is bottom */
 } camera_attr_tag_orientation_e;
 
@@ -362,6 +402,26 @@ typedef enum
     CAMERA_ATTR_FPS_120 = 120 /**< 120 FPS */
 } camera_attr_fps_e;
 
+/**
+ * @brief Enumerations of the theater mode
+ */
+typedef enum
+{
+	CAMERA_ATTR_THEATER_MODE_DISABLE = 0, /**< Disable theater mode - External display show same image with device display. */
+	CAMERA_ATTR_THEATER_MODE_ENABLE = 2,  /**< Enable theater mode - Preview image is displayed on external display with full screen mode. But preview image is not shown on device display. */
+	CAMERA_ATTR_THEATER_MODE_CLONE = 1    /**< Clone mode - Preview image is displayed on external display with full screen mode. Also preview image is shown with UI on device display*/
+} camera_attr_theater_mode_e;
+
+/**
+ * @brief Enumerations of HDR capture mode
+ */
+typedef enum
+{
+	CAMERA_ATTR_HDR_MODE_DISABLE = 0,   /**< Disable HDR capture */
+	CAMERA_ATTR_HDR_MODE_ENABLE,          /**< Enable HDR capture */
+	CAMERA_ATTR_HDR_MODE_KEEP_ORIGINAL /**< Enable HDR capture and keep original image data */
+} camera_attr_hdr_mode_e;
+
 
 /**
  * @}
@@ -376,11 +436,9 @@ typedef enum
 /**
  * @brief	Called when the camera state changes.
  *
- * @remarks	When camera is used as a recorder then this callback function won't be called.
- *
  * @param[in] previous      The previous state of the camera
  * @param[in] current       The current state of the camera
- * @param[in] by_policy     @c true if the state is changed by sound policy, otherwise @c false
+ * @param[in] by_policy     @c true if the state is changed by policy, otherwise @c false
  * @param[in] user_data     The user data passed from the callback registration function
  * @pre camera_start_preview(), camera_start_capture() or camera_stop_preview()
  * will invoke this callback if you registers this callback unsing camera_set_state_changed_cb().
@@ -389,6 +447,18 @@ typedef enum
 typedef void (*camera_state_changed_cb)(camera_state_e previous, camera_state_e current,
         bool by_policy, void *user_data);
 
+/**
+ * @brief	Called when the camera interrupted by policy
+ *
+ * @param[in] policy     		The policy that interrupting the camera
+ * @param[in] previous      The previous state of the camera
+ * @param[in] current       The current state of the camera
+ * @param[in] user_data     The user data passed from the callback registration function
+ * @see	camera_set_interrupted_cb()
+ */
+typedef void (*camera_interrupted_cb)(camera_policy_e policy, camera_state_e previous, camera_state_e current, void *user_data);
+
+
 
 /**
  * @brief	Called when the camera focus state changes.
@@ -429,26 +499,23 @@ typedef void (*camera_focus_changed_cb)(camera_focus_state_e state, void *user_d
 typedef void (*camera_preview_cb)(void *stream_buffer, int buffer_size, int width, int height,
         camera_pixel_format_e format, void *user_data);
 
-
 /**
  * @brief	Called to get information about image data taken by the camera once per frame while capturing.
  *
  * @remarks This function is issued in the context of gstreamer (video source thread) so you should not directly invoke UI update code.
- * You must not call camera_stop_preview() within this callback.
+ * You must not call camera_start_preview() within this callback.
  *
- * @param[in] image_buffer   The reference pointer to captured data
- * @param[in] buffer_size    The length of stream buffer (in bytes)
- * @param[in] width          The width of frame resolution
- * @param[in] height         The height of frame resolution
- * @param[in] format         The camera pixel format
+ * @param[in] image     The image data of captured picture
+ * @param[in] postview  The image data of postvew
+ * @param[in] thumbnail The image data of thumbnail ( It could be NULL, if available thumbnail data is not existed. )
  * @param[in] user_data     The user data passed from the callback registration function
- * @pre	camera_start_capture() will invoke this callback function if you register this callback using camera_set_capturing_cb().
- * @see	camera_set_capturing_cb()
- * @see	camera_unset_capturing_cb()
+ * @pre	camera_start_capture() or camera_start_continuous_capture() will invoke this callback function if you register this callback using camera_start_capture() or camera_start_continuous_capture()
  * @see	camera_start_capture()
+ * @see	camera_start_continuous_capture()
+ * @see	camera_capture_completed_cb()
  */
-typedef void (*camera_capturing_cb)(void *image_buffer, int buffer_size, int width, int height,
-        camera_pixel_format_e format, void *user_data);
+typedef void (*camera_capturing_cb)(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data);
+
 
 
 /**
@@ -459,9 +526,9 @@ typedef void (*camera_capturing_cb)(void *image_buffer, int buffer_size, int wid
  *
  * @param[in] user_data     The user data passed from the callback registration function
  *
- * @pre	This callback function is invoked if you register this callback using camera_set_capture_completed_cb().
- * @see	camera_set_capture_completed_cb()
- * @see	camera_unset_capture_completed_cb()
+ * @pre	This callback function is invoked if you register this callback using camera_start_capture() or camera_start_continuous_capture().
+ * @see	camera_start_capture()
+ * @see	camera_start_continuous_capture()
  * @see	camera_capturing_cb()
  */
 typedef void (*camera_capture_completed_cb)(void *user_data);
@@ -470,8 +537,15 @@ typedef void (*camera_capture_completed_cb)(void *user_data);
 /**
  * @brief	Called when the error occurred.
  *
- * @remarks The callback is called when inform asynchronous operation error.
- * @param[in] error		The error message
+ * @remarks
+ * This callback inform critical error situation.\n
+ * When invoked this callback, user should release the resource and terminate application.\n
+ * These error code will be occurred\n
+ * #CAMERA_ERROR_DEVICE\n
+ * #CAMERA_ERROR_INVALID_OPERATION\n
+ * #CAMERA_ERROR_OUT_OF_MEMORY\n
+ *
+ * @param[in] error		The error code
  * @param[in] current_state	The current state of the camera
  * @param[in] user_data		The user data passed from the callback registration function
  *
@@ -479,7 +553,18 @@ typedef void (*camera_capture_completed_cb)(void *user_data);
  * @see	camera_set_error_cb()
  * @see	camera_unset_error_cb()
  */
-typedef void (*camera_error_cb)(int error, camera_state_e current_state, void *user_data);
+typedef void (*camera_error_cb)(camera_error_e error, camera_state_e current_state, void *user_data);
+
+/**
+ * @brief Called when face detected in the preview frame
+ *
+ * @param[in] faces The detected face array
+ * @param[in] count The length of array
+ * @param[in] user_data The user data passed from the callback registration function
+ *
+ * @see	camera_start_face_detection()
+ */
+typedef void (*camera_face_detected_cb)(camera_detected_face_s *faces, int count, void *user_data);
 
 /**
  * @}
@@ -601,6 +686,8 @@ int camera_destroy(camera_h camera);
  * @retval      #CAMERA_ERROR_INVALID_STATE Invalid state
  * @retval      #CAMERA_ERROR_SOUND_POLICY Sound policy error
  * @retval      #CAMERA_ERROR_INVALID_OPERATION Invalid operation
+ * @retval		#CAMERA_ERROR_DEVICE_BUSY The device is using in other applications or working some operation
+ * @retval		#CAMERA_ERROR_DEVICE_NOT_FOUND No camera device
  * @pre    The camera state should be #CAMERA_STATE_CREATED, or #CAMERA_STATE_CAPTURED.\n
  * You must set display handle. \n
  * If needed, modify preview fps(camera_attr_set_preview_fps()),
@@ -641,7 +728,7 @@ int camera_start_preview(camera_h camera);
 int camera_stop_preview(camera_h camera);
 
 /**
- * @brief Starts capturing of still images. (Image mode only)
+ * @brief Starts capturing of still images.
  *
  * @remarks  This function causes the transition of camera state from #CAMERA_STATE_CAPTURING to #CAMERA_STATE_CAPTURED automatically\n
  * and the corresponding callback function camera_capturing_cb() and camera_capture_completed_cb() will be invoked\n
@@ -650,6 +737,9 @@ int camera_stop_preview(camera_h camera);
  * You should restart camera's preview with calling camera_start_preview().
  *
  * @param[in]	camera	The handle to the camera
+ * @param[in] capturing_cb The callback for capturing data
+ * @param[in] completed_cb The callback for notification of completed
+ * @param[in] user_data The user data
  * @return      0 on success, otherwise a negative error value.
  * @retval      #CAMERA_ERROR_NONE Successful
  * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
@@ -662,8 +752,7 @@ int camera_stop_preview(camera_h camera);
  * @post   If it succeeds the camera state will be #CAMERA_STATE_CAPTURED.
  *
  * @see camera_start_preview()
- * @see camera_set_capturing_cb()
- * @see camera_set_capture_completed_cb()
+ * @see camera_start_continuous_capture();
  * @see camera_foreach_supported_capture_resolution()
  * @see camera_set_capture_resolution()
  * @see camera_get_capture_resolution()
@@ -673,7 +762,55 @@ int camera_stop_preview(camera_h camera);
  * @see camera_attr_set_image_quality()
  * @see camera_attr_get_image_quality()
  */
-int camera_start_capture(camera_h camera);
+int camera_start_capture(camera_h camera, camera_capturing_cb capturing_cb , camera_capture_completed_cb completed_cb , void *user_data);
+
+/**
+ * @brief Starts continuous capturing of still images.
+ *
+ * @remarks
+ * If not supported zero shutter lag. the capture resolution could be changed to the preview resolution.\n
+ * This function causes the transition of camera state from #CAMERA_STATE_CAPTURING to #CAMERA_STATE_CAPTURED automatically\n
+ * and the corresponding callback function camera_capturing_cb() and camera_capture_completed_cb() will be invoked\n
+ * Each Captured image will be delivered through camera_capturing_cb().\n
+ * You will be notified by camera_capture_completed_cb() callback when entire capture is completed.\n
+ * You should restart camera's preview with calling camera_start_preview().\n
+ *
+ * @param[in]	camera	The handle to the camera
+ * @param[in]	count	The number of still images
+ * @param[in] interval	The interval of capture ( millisecond )
+ * @param[in] capturing_cb The callback for capturing data
+ * @param[in] completed_cb The callback for notification of completed
+ * @param[in] user_data The user data
+ * @return      0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval      #CAMERA_ERROR_INVALID_STATE Invalid state
+ * @retval      #CAMERA_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @post   If it succeeds the camera state will be #CAMERA_STATE_CAPTURED.
+ *
+ * @see camera_start_preview()
+ * @see camera_start_capture();
+ * @see camera_stop_continuous_capture()
+ */
+int camera_start_continuous_capture(camera_h camera, int count, int interval, camera_capturing_cb capturing_cb, camera_capture_completed_cb completed_cb , void *user_data);
+
+/**
+ * @brief Abort continuous capturing.
+ *
+ * @remarks The camera state will be changed to the #CAMERA_STATE_CAPTURED state
+ * @param[in]	camera	The handle to the camera
+ * @return      0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval      #CAMERA_ERROR_INVALID_STATE Invalid state
+ * @retval      #CAMERA_ERROR_INVALID_OPERATION Invalid operation
+ * @pre    The camera state should be #CAMERA_STATE_PREVIEW
+ *
+ * @see camera_start_continuous_capture()
+ */
+int camera_stop_continuous_capture(camera_h camera);
+
 
 /**
  * @brief Gets the state of the camera.
@@ -694,7 +831,10 @@ int camera_get_state(camera_h camera, camera_state_e *state);
 /**
  * @brief Starts camera auto-focusing, Asynchronously
  *
+ * @remarks If continuous status is true, the camera continuously tries to focus
+ *
  * @param[in]	camera	The handle to the camera
+ * @param[in] continuous	The status of continuous focusing
  * @return      0 on success, otherwise a negative error value.
  * @retval      #CAMERA_ERROR_NONE Successful
  * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
@@ -708,7 +848,7 @@ int camera_get_state(camera_h camera, camera_state_e *state);
  * @see camera_focus_changed_cb()
  * @see camera_attr_set_af_mode()
  */
-int camera_start_focusing(camera_h camera);
+int camera_start_focusing(camera_h camera, bool continuous);
 
 /**
  * @brief Stops camera auto focusing.
@@ -781,6 +921,99 @@ int camera_set_preview_resolution(camera_h camera, int width, int height);
 int camera_get_preview_resolution(camera_h camera, int *width, int *height);
 
 /**
+ * @brief Gets the recommended preview resolution
+ *
+ * @remarks Depend on capture resolution aspect ratio and display resolution, the recommended preview resolution is determined.
+ *
+ * @param[in] camera	The handle to the camera
+ * @param[out] width	The preview width
+ * @param[out] height	The preview height
+ * @return	  0 on success, otherwise a negative error value.
+ * @retval    #CAMERA_ERROR_NONE Successful
+ * @retval    #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see	camera_set_preview_resolution()
+ * @see	camera_foreach_supported_preview_resolution()
+ */
+int camera_get_recommended_preview_resolution(camera_h camera, int *width, int *height);
+
+/**
+ * @brief Starts the face detection.
+ * @remarks
+ * This should be called after preview is started.\n
+ * The callback will invoked when face detected in preview frame.\n
+ * Internally starting continuous focus and focusing on detected face.\n
+ * When the face detection is running, camera_start_focusing(), camera_cancel_focusing(), camera_attr_set_af_mode(), 	camera_attr_set_af_area(), camera_attr_set_exposure_mode() and camera_attr_set_whitebalance() settings are ignored.\n
+ * If invoke camera_stop_preview(), face detection is stopped. and then resuming preview with camera_start_preview(), you should call this method again to resume face detection.
+ *
+ * @param[in] camera	The handle to the camera
+ * @param[in] callback  The callback for notify detected face
+ * @param[in] user_data   The user data to be passed to the callback function
+ *
+ * @return	  0 on success, otherwise a negative error value.
+ * @retval    #CAMERA_ERROR_NONE Successful
+ * @retval    #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval    #CAMERA_ERROR_INVALID_STATE Not preview state
+ * @retval    #CAMERA_ERROR_INVALID_OPERATION Not supported this feature
+ *
+ * @pre    The camera state must be #CAMERA_STATE_PREVIEW
+ *
+ * @see camera_stop_face_detection()
+ * @see camera_face_detected_cb()
+ * @see camera_is_supported_face_detection()
+ */
+int camera_start_face_detection(camera_h camera, camera_face_detected_cb callback, void * user_data);
+
+/**
+ * @brief Stops the face detection.
+ *
+ * @param[in] camera	The handle to the camera
+ * @return	  0 on success, otherwise a negative error value.
+ * @retval    #CAMERA_ERROR_NONE Successful
+ * @retval    #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @pre    This should be called after face detection was started.
+ *
+ * @see camera_start_face_detection()
+ * @see camera_is_supported_face_detection()
+ */
+int camera_stop_face_detection(camera_h camera);
+
+/**
+ * @brief Zooming on the detected face
+ *
+ * @remarks The face id is getting from camera_face_detected_cb().\n
+ *
+ * @param[in]	camera	The handle to the camera
+ * @param[in] face_id	The face id to zoom
+ *
+ * @return	  0 on success, otherwise a negative error value.
+ * @retval    #CAMERA_ERROR_NONE Successful
+ * @retval    #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval    #CAMERA_ERROR_INVALID_STATE face zoom was already enabled.
+ * @retval    #CAMERA_ERROR_INVALID_OPERATION Not supported this feature
+ *
+ * @pre This should be called after face detection was started.
+ *
+ * @see camera_cancel_face_zoom()
+ * @see camera_start_face_detection()
+ */
+int camera_face_zoom(camera_h camera, int face_id);
+
+/**
+ * @brief Cancel zooming on the face
+ *
+ * @param[in]	camera	The handle to the camera
+ *
+ * @retval    #CAMERA_ERROR_NONE Successful
+ * @retval    #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see camera_face_zoom()
+ * @see camera_start_face_detection()
+ */
+int camera_cancel_face_zoom(camera_h camera);
+
+/**
  * @}
  */
 
@@ -1126,6 +1359,18 @@ int camera_get_preview_format(camera_h camera, camera_pixel_format_e *format);
 int camera_foreach_supported_preview_format(camera_h camera,
         camera_supported_preview_format_cb callback, void *user_data);
 
+
+/**
+ * @biref Gets face detection feature supported state
+ * @ingroup CAPI_MEDIA_CAMERA_CAPABILITY_MODULE
+ * @param[in]	camera The handle to the camera
+ * @return true on supported, otherwise false
+ *
+ * @see camera_start_face_detection()
+ * @see camera_stop_face_detection()
+ */
+bool camera_is_supported_face_detection(camera_h camera);
+
 /**
  * @}
  */
@@ -1172,39 +1417,6 @@ int camera_set_preview_cb(camera_h camera, camera_preview_cb callback, void *use
 int camera_unset_preview_cb(camera_h camera);
 
 /**
- * @brief	Registers a callback function to be called when capturing.
- *
- * @remarks	registered callback is called on internal thread of camera so you should not directly invoke UI update code in callback.
- * You will be notified when sending a message finisheds and check whether is succeeds using this function.\n
- * This function should be called before capturing (see camera_start_capture()).
- *
- * @param[in] camera	The handle to the camera
- * @param[in] callback    The callback function to register
- * @param[in] user_data   The user data to be passed to the callback function
- * @return	    0 on success, otherwise a negative error value.
- * @retval      #CAMERA_ERROR_NONE Successful
- * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval      #CAMERA_ERROR_INVALID_STATE Invalid state
- *
- * @see	camera_start_capture()
- * @see	camera_unset_capturing_cb()
- * @see	camera_capturing_cb()
- */
-int camera_set_capturing_cb(camera_h camera, camera_capturing_cb callback, void *user_data);
-
-/**
- * @brief	Unregisters the callback function.
- *
- * @param[in]	camera	The handle to the camera
- * @return	    0 on success, otherwise a negative error value.
- * @retval      #CAMERA_ERROR_NONE Successful
- * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see camera_set_capturing_cb()
- */
-int camera_unset_capturing_cb(camera_h camera);
-
-/**
  * @brief	Registers a callback function to be called when camera state changes.
  *
  * @param[in] camera	The handle to the camera
@@ -1235,24 +1447,21 @@ int camera_set_state_changed_cb(camera_h camera, camera_state_changed_cb callbac
 int camera_unset_state_changed_cb(camera_h camera);
 
 /**
- * @brief	Registers a callback function to be called when auto-focus state changes.
+ * @brief	Registers a callback function to be called when camera interrupted by policy.
  *
  * @param[in] camera	The handle to the camera
- * @param[in] callback	The callback function to register
- * @param[in] user_data	The user data to be passed to the callback function
+ * @param[in] callback	  The callback function to register
+ * @param[in] user_data   The user data to be passed to the callback function
+ *
  * @return	  0 on success, otherwise a negative error value.
  * @retval    #CAMERA_ERROR_NONE Successful
  * @retval    #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
- * @post	This function will invoke camera_focus_changed_cb() when auto-focus state changes.
  *
- * @see	camera_start_focusing()
- * @see	camera_cancel_focusing()
- * @see	camera_unset_focus_changed_cb()
- * @see	camera_focus_changed_cb()
+ * @see camera_unset_interrupted_cb()
+ * @see	camera_interrupted_cb()
  */
-int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback,
-        void *user_data);
-
+int camera_set_interrupted_cb(camera_h camera, camera_interrupted_cb callback,
+	    void *user_data);
 
 /**
  * @brief	Unregisters the callback function.
@@ -1262,27 +1471,28 @@ int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callbac
  * @retval    #CAMERA_ERROR_NONE Successful
  * @retval    #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
  *
- * @see     camera_set_focus_changed_cb()
+ * @see     camera_set_interrupted_cb()
  */
-int camera_unset_focus_changed_cb(camera_h camera);
+int camera_unset_interrupted_cb(camera_h camera);
 
 
 /**
- * @brief	Registers a callback function to be called when capture completes.
+ * @brief	Registers a callback function to be called when auto-focus state changes.
  *
  * @param[in] camera	The handle to the camera
  * @param[in] callback	The callback function to register
- * @param[in] user_data The user data to be passed to the callback function
+ * @param[in] user_data	The user data to be passed to the callback function
  * @return	  0 on success, otherwise a negative error value.
  * @retval    #CAMERA_ERROR_NONE Successful
  * @retval    #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
- * @post	This function makes camera_capture_completed_cb() called when capturing completes.
+ * @post	This function will invoke camera_focus_changed_cb() when auto-focus state changes.
  *
- * @see camera_start_capture()
- * @see	camera_unset_capture_completed_cb()
- * @see	camera_capture_completed_cb()
+ * @see	camera_start_focusing()
+ * @see	camera_cancel_focusing()
+ * @see	camera_unset_focus_changed_cb()
+ * @see	camera_focus_changed_cb()
  */
-int camera_set_capture_completed_cb(camera_h camera, camera_capture_completed_cb callback,
+int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback,
         void *user_data);
 
 
@@ -1294,14 +1504,21 @@ int camera_set_capture_completed_cb(camera_h camera, camera_capture_completed_cb
  * @retval    #CAMERA_ERROR_NONE Successful
  * @retval    #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
  *
- * @see     camera_set_capture_completed_cb()
+ * @see     camera_set_focus_changed_cb()
  */
-int camera_unset_capture_completed_cb(camera_h camera);
-
+int camera_unset_focus_changed_cb(camera_h camera);
 
 /**
  * @brief	Registers a callback function to be called when an asynchronous operation error occurred.
  *
+ * @remarks
+ * This callback inform critical error situation.\n
+ * When invoked this callback, user should release the resource and terminate application.\n
+ * These error code will be occurred\n
+ * #CAMERA_ERROR_DEVICE\n
+ * #CAMERA_ERROR_INVALID_OPERATION\n
+ * #CAMERA_ERROR_OUT_OF_MEMORY\n
+ *
  * @param[in]	camera	The handle to the camera
  * @param[in]	callback	The callback function to register
  * @param[in]	user_data	The user data to be passed to the callback function
@@ -1617,6 +1834,44 @@ int camera_attr_set_af_mode(camera_h camera, camera_attr_af_mode_e mode);
 int camera_attr_get_af_mode(camera_h camera, camera_attr_af_mode_e *mode);
 
 /**
+ * @brief Sets auto focus area
+ *
+ * @remarks This API is invalid in CAMERA_ATTR_AF_NONE mode.\n
+ * The coordinates are mapped into preview area
+ *
+ * @param[in]	camera	The handle to the camera
+ * @param[in] x The x coordinates of focus area
+ * @param[in] y The y coordinates of focus area
+ *
+ * @return	  0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval      #CAMERA_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see camera_attr_set_af_mode()
+ * @see camera_attr_clear_af_area()
+ */
+int camera_attr_set_af_area(camera_h camera, int x, int y);
+
+/**
+ * @brief Clear the auto focus area.
+ *
+ * @remarks The focusing area set to the center area
+ *
+ * @param[in]	camera	The handle to the camera
+ *
+ * @return	  0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval      #CAMERA_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see camera_attr_set_af_mode()
+ * @see camera_attr_set_af_area()
+ *
+ */
+int camera_attr_clear_af_area(camera_h camera);
+
+/**
  * @}
  */
 
@@ -1822,6 +2077,36 @@ int camera_attr_foreach_supported_iso(camera_h camera, camera_attr_supported_iso
 
 
 /**
+ * @brief Sets the theater mode
+ *
+ * @remarks If you want to display preview image on external display with full screen mode, use this function.
+ *
+ * @param[in]	camera	The handle to the camera
+ * @param[in]	mode	The mode to change
+ * @return	    0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @pre		This function is valid only when external display was connected.
+ *
+ * @see	camera_attr_get_theater_mode()
+ */
+int camera_attr_set_theater_mode(camera_h camera, camera_attr_theater_mode_e mode);
+
+/**
+ * @brief Gets the theater mode
+ *
+ * @param[in]	camera	The handle to the camera
+ * @param[in]	mode	Currnet theater mode
+ * @return	    0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see	camera_attr_get_theater_mode()
+ */
+int camera_attr_get_theater_mode(camera_h camera, camera_attr_theater_mode_e *mode);
+
+
+/**
  * @brief Sets the brightness level.
  *
  *
@@ -2212,82 +2497,49 @@ int camera_attr_set_tag_software(camera_h camera, const char *software);
 int camera_attr_get_tag_software(camera_h camera, char **software);
 
 /**
- * @brief Sets the GPS latitude data in EXIF(Exchangeable image file format) tag.
+ * @brief Sets the geotag(GPS data) in EXIF(Exchangeable image file format) tag.
  *
- * @param[in]	camera	The handle to the camera
- * @param[in]   latitude    Latitude data
+ * @param[in]	camera The handle to the camera
+ * @param[in] latitude Latitude data
+ * @param[in] longitude Longitude data
+ * @param[in] altitude Altitude data
  * @return      0 on success, otherwise a negative error value.
  * @retval      #CAMERA_ERROR_NONE Successful
  * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
  *
- * @see         camera_attr_get_tag_latitude()
+ * @see         camera_attr_get_geotag()
+ * @see         camera_attr_remove_geotag()
  */
-int camera_attr_set_tag_latitude(camera_h camera, double latitude);
+int camera_attr_set_geotag(camera_h camera, double latitude , double longitude, double altitude);
 
 /**
- * @brief Gets the GPS latitude data in EXIF(Exchangeable image file format) tag.
+ * @brief Gets the geotag(GPS data) in EXIF(Exchangeable image file format) tag.
  *
  * @param[in]	camera	The handle to the camera
- * @param[out]  latitude    The latitude data
+ * @param[out] latitude Latitude data
+ * @param[out] longitude Longitude data
+ * @param[out] altitude Altitude data
  * @return      0 on success, otherwise a negative error value.
  * @retval      #CAMERA_ERROR_NONE Successful
  * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
  *
- * @see         camera_attr_set_tag_latitude()
+ * @see         camera_attr_set_geotag()
+ * @see         camera_attr_remove_geotag()
  */
-int camera_attr_get_tag_latitude(camera_h camera, double *latitude);
+int camera_attr_get_geotag(camera_h camera, double *latitude , double *longitude, double *altitude);
 
 /**
- * @brief Sets the GPS longitude data in EXIF(Exchangeable image file format) tag.
+ * @brief Remove the geotag(GPS data) in EXIF(Exchangeable image file format) tag.
  *
  * @param[in]	camera	The handle to the camera
- * @param[in]   longitude  The longitude data
  * @return      0 on success, otherwise a negative error value.
  * @retval      #CAMERA_ERROR_NONE Successful
  * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
  *
- * @see         camera_attr_get_tag_longitude()
+ * @see         camera_attr_set_geotag()
+ * @see         camera_attr_get_geotag()
  */
-int camera_attr_set_tag_longitude(camera_h camera, double longitude);
-
-/**
- * @brief Gets the GPS longitude data in EXIF(Exchangeable image file format) tag.
- *
- * @param[in]	camera	The handle to the camera
- * @param[out]  longitude  The longitude data
- * @return      0 on success, otherwise a negative error value.
- * @retval      #CAMERA_ERROR_NONE Successful
- * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see         camera_attr_set_tag_longitude()
- */
-int camera_attr_get_tag_longitude(camera_h camera, double *longitude);
-
-/**
- * @brief Sets the GPS altitude data in EXIF(Exchangeable image file format) tag.
- *
- * @param[in]	camera	The handle to the camera
- * @param[in]   altitude    The altitude data
- * @return      0 on success, otherwise a negative error value.
- * @retval      #CAMERA_ERROR_NONE Successful
- * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see         camera_attr_get_tag_altitude()
- */
-int camera_attr_set_tag_altitude(camera_h camera, double altitude);
-
-/**
- * @brief Gets the GPS altitude data in EXIF(Exchangeable image file format) tag.
- *
- * @param[in]	camera	The handle to the camera
- * @param[out]  altitude    The altitude data
- * @return      0 on success, otherwise a negative error value.
- * @retval      #CAMERA_ERROR_NONE Successful
- * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see  	    camera_attr_set_tag_altitude()
- */
-int camera_attr_get_tag_altitude(camera_h camera, double *altitude);
+int camera_attr_remove_geotag(camera_h camera);
 
 /**
  * @brief Sets the camera flash mode.
@@ -2430,6 +2682,183 @@ int camera_attr_set_stream_flip(camera_h camera , camera_flip_e flip);
 int camera_attr_get_stream_flip(camera_h camera , camera_flip_e *flip);
 
 
+
+/**
+ * @brief	Called when HDR capture process was updated
+ *
+ * @param[in] percent         The progress percent of HDR capture
+ * @param[in] user_data     The user data passed from the callback registration function
+ * @pre camera_start_capture() will invoke this callback if you register it using camera_attr_set_hdr_capture_progress_cb().
+ *
+ * @see camera_attr_get_hdr_mode()
+ * @see camera_attr_set_hdr_capture_progress_cb()
+ * @see camera_attr_unset_hdr_capture_progress_cb()
+ * @see camera_attr_is_supported_hdr_capture()
+ */
+typedef void (*camera_attr_hdr_progress_cb)(int percent, void *user_data);
+
+
+/**
+ * @brief Sets the mode of HDR(High dynamic range) capture.
+ * @remarks
+ * Taking multiple pictures at different exposure level and intelligently stitching them together so that we eventually arrive at a picture that is representative in both dark and bright areas.\n
+ * If this attribute is setting true. camera_attr_hdr_progress_cb is invoked when capture.\n
+ * If you set #CAMERA_ATTR_HDR_MODE_KEEP_ORIGINAL, the capturing callback is invoked twice. The first callback is delivering origin image data. The second callback is delivering improved image data.
+ *
+ * @param[in]	camera The handle to the camera
+ * @param[in]	mode The mode of HDR capture
+ * @return	    0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see camera_attr_get_hdr_mode()
+ * @see camera_attr_set_hdr_capture_progress_cb()
+ * @see camera_attr_unset_hdr_capture_progress_cb()
+ * @see camera_attr_is_supported_hdr_capture()
+ *
+ */
+int camera_attr_set_hdr_mode(camera_h camera, camera_attr_hdr_mode_e mode);
+
+/**
+ * @brief Gets the mode of HDR(High dynamic range) capture.
+ *
+ * @param[in]	camera The handle to the camera
+ * @param[out]	mode The mode of HDR capture
+ * @return	    0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see camera_attr_set_hdr_mode()
+ * @see camera_attr_set_hdr_capture_progress_cb()
+ * @see camera_attr_unset_hdr_capture_progress_cb()
+ * @see camera_attr_is_supported_hdr_capture()
+ *
+ */
+int camera_attr_get_hdr_mode(camera_h camera, camera_attr_hdr_mode_e *mode);
+
+__attribute__ ((deprecated)) int camera_attr_enable_hdr_capture(camera_h camera, bool enable);
+__attribute__ ((deprecated)) int camera_attr_is_enabled_hdr_capture(camera_h camera, bool *enabled);
+
+/**
+ * @brief	Registers a callback function to be called when HDR capture is progressing.
+ * @remarks This callback notify progress of HDR process.
+ *
+ * @param[in]	camera The handle to the camera
+ * @param[in] callback The callback function to invoke
+ * @param[in] user_data The user data passed to the callback registration function
+ * @return	    0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see camera_attr_set_hdr_mode()
+ * @see camera_attr_get_hdr_mode()
+ * @see camera_attr_unset_hdr_capture_progress_cb()
+ * @see camera_attr_is_supported_hdr_capture()
+ */
+int camera_attr_set_hdr_capture_progress_cb(camera_h camera, camera_attr_hdr_progress_cb callback, void* user_data);
+
+
+
+/**
+ * @brief	Unregisters the callback function.
+ *
+ * @param[in]	camera The handle to the camera
+ * @return	  0 on success, otherwise a negative error value.
+ * @retval    #CAMERA_ERROR_NONE Successful
+ * @retval    #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see camera_attr_set_hdr_mode()
+ * @see camera_attr_get_hdr_mode()
+ * @see camera_attr_set_hdr_capture_progress_cb()
+ * @see camera_attr_is_supported_hdr_capture() 
+ */
+int camera_attr_unset_hdr_capture_progress_cb(camera_h camera);
+
+/**
+ * @biref Gets HDR capture supported state
+ * @ingroup CAPI_MEDIA_CAMERA_CAPABILITY_MODULE
+ * @param[in]	camera The handle to the camera
+ * @return true on supported, otherwise false
+ *
+ * @see camera_attr_set_hdr_mode()
+ * @see camera_attr_get_hdr_mode()
+ * @see camera_attr_set_hdr_capture_progress_cb()
+ * @see camera_attr_unset_hdr_capture_progress_cb()
+ */
+bool camera_attr_is_supported_hdr_capture(camera_h camera);
+
+/**
+ * @brief Enable/Disable Anti-shake feature
+ * @remarks
+ * If enabling anti-shake, zero shutter lag is disabling
+ *
+ * @param[in]	camera The handle to the camera
+ * @param[in]	enable The state of anti-shake
+ * @return	    0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see camera_attr_is_enabled_anti_shake()
+ * @see camera_attr_is_supported_anti_shake()
+ *
+ */
+int camera_attr_enable_anti_shake(camera_h camera, bool enable);
+
+/**
+ * @brief Gets state of Anti-shake feature
+ *
+ * @param[in]	camera The handle to the camera
+ * @param[out]	enabled The state of anti-shake
+ * @return	    0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see camera_attr_enable_anti_shake()
+ * @see camera_attr_is_supported_anti_shake()
+ *
+ */
+int camera_attr_is_enabled_anti_shake(camera_h camera , bool *enabled);
+
+/**
+ * @biref Gets Anti-shake feature supported state
+ * @ingroup CAPI_MEDIA_CAMERA_CAPABILITY_MODULE
+ * @param[in]	camera The handle to the camera
+ * @return true on supported, otherwise false
+ *
+ * @see camera_attr_enable_anti_shake()
+ * @see camera_attr_is_enabled_anti_shake()
+ */
+bool camera_attr_is_supported_anti_shake(camera_h camera);
+
+/**
+ * @brief Enable/Disable auto contrast
+ *
+ * @param[in]	camera The handle to the camera
+ * @param[in]	enable The state of auto contrast
+ *
+ * @return	    0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see camera_attr_is_enabled_auto_contrast()
+ */
+int camera_attr_enable_auto_contrast(camera_h camera, bool enable);
+
+/**
+ * @brief Gets state of auto contrast
+ *
+ * @param[in]	camera The handle to the camera
+ * @param[out]	enabled The state of auto contrast
+ * @return	    0 on success, otherwise a negative error value.
+ * @retval      #CAMERA_ERROR_NONE Successful
+ * @retval      #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see camera_attr_enable_auto_contrast()
+ *
+ */
+int camera_attr_is_enabled_auto_contrast(camera_h camera, bool *enabled);
+
+
 /**
  * @}
  */
diff --git a/include/camera_private.h b/include/camera_private.h
index 9630da3..8038b80 100755
--- a/include/camera_private.h
+++ b/include/camera_private.h
@@ -27,35 +27,49 @@
 extern "C" {
 #endif
 
+#define MAX_DETECTED_FACE 20
+
 typedef enum {
 	_CAMERA_EVENT_TYPE_STATE_CHANGE,
-	_CAMERA_EVENT_TYPE_FOCUS_CHANGE,	
+	_CAMERA_EVENT_TYPE_FOCUS_CHANGE,
 	_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE,
 	_CAMERA_EVENT_TYPE_PREVIEW,
-	_CAMERA_EVENT_TYPE_CAPTURE,	
-	_CAMERA_EVENT_TYPE_ERROR,		
+	_CAMERA_EVENT_TYPE_CAPTURE,
+	_CAMERA_EVENT_TYPE_ERROR,
+	_CAMERA_EVENT_TYPE_HDR_PROGRESS,
+	_CAMERA_EVENT_TYPE_INTERRUPTED,
+	_CAMERA_EVENT_TYPE_FACE_DETECTION,
 	_CAMERA_EVENT_TYPE_NUM
 }_camera_event_e;
 
 typedef struct _camera_s{
 	MMHandleType mm_handle;
-	
+
 	void* user_cb[_CAMERA_EVENT_TYPE_NUM];
 	void* user_data[_CAMERA_EVENT_TYPE_NUM];
 	void* display_handle;
 	camera_display_type_e display_type;
 	int state;
-	
-} camera_s;
-
-typedef enum {
-	CAMERA_MODE_IMAGE = MM_CAMCORDER_MODE_IMAGE,				/**< Still image capture mode */
-	CAMERA_MODE_VIDEO = MM_CAMCORDER_MODE_VIDEO				/**< Video recording mode */
-} camera_mode_e;
-
 
+	MMMessageCallback relay_message_callback;
+	void* relay_user_data;
+	int capture_count;
+	int capture_width;
+	int capture_height;
+	bool is_continuous_shot_break;
+	bool is_capture_completed;
+	int current_capture_count;
+	int current_capture_complete_count;
+	bool capture_resolution_modified;
+	camera_detected_face_s faceinfo[MAX_DETECTED_FACE];
+	int num_of_faces;
+	bool hdr_keep_mode;
+	bool focus_area_valid;
+} camera_s;
 
-int __mm_camera_message_callback(int message, void *param, void *user_data);
+int _camera_get_mm_handle(camera_h camera , MMHandleType *handle);
+int _camera_set_relay_mm_message_callback(camera_h camera, MMMessageCallback callback, void *user_data);
+int __camera_start_continuous_focusing(camera_h camera);
 
 #ifdef __cplusplus
 }
diff --git a/packaging/capi-media-camera.spec b/packaging/capi-media-camera.spec
index b0f0ef1..cf1ccc0 100755
--- a/packaging/capi-media-camera.spec
+++ b/packaging/capi-media-camera.spec
@@ -1,8 +1,8 @@
 Name:       capi-media-camera
-Summary:    A Camera library in Tizen Native API
+Summary:    A Camera library in Tizen C API
 Version:    0.1.0
-Release:    1
-Group:      TO_BE/FILLED_IN
+Release:    30
+Group:      libs
 License:    Apache-2.0
 Source0:    %{name}-%{version}.tar.gz
 BuildRequires:  cmake
@@ -16,7 +16,7 @@ Requires(postun): /sbin/ldconfig
 
 
 %package devel
-Summary:  A Camera library in Tizen Native API (Development)
+Summary:  A Camera library in Tizen C API (Development)
 Group:    TO_BE/FILLED_IN
 Requires: %{name} = %{version}-%{release}
 
diff --git a/src/camera.c b/src/camera.c
index 581a00f..7809cfb 100755
--- a/src/camera.c
+++ b/src/camera.c
@@ -59,11 +59,17 @@ static int __convert_camera_error_code(const char* func, int code){
 			ret = CAMERA_ERROR_INVALID_STATE;
 			errorstr = "INVALID_STATE";
 			break;
-
-		case MM_ERROR_CAMCORDER_DEVICE :
 		case MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND :
-		case MM_ERROR_CAMCORDER_DEVICE_BUSY	:
+			ret = CAMERA_ERROR_DEVICE_NOT_FOUND;
+			errorstr = "DEVICE_NOT_FOUND";
+			break;
+		case MM_ERROR_CAMCORDER_DEVICE_BUSY :
 		case MM_ERROR_CAMCORDER_DEVICE_OPEN :
+		case MM_ERROR_CAMCORDER_CMD_IS_RUNNING :
+			ret = CAMERA_ERROR_DEVICE_BUSY;
+			errorstr = "DEVICE_BUSY";
+			break;
+		case MM_ERROR_CAMCORDER_DEVICE :
 		case MM_ERROR_CAMCORDER_DEVICE_IO :
 		case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT	:
 		case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE :
@@ -88,20 +94,18 @@ static int __convert_camera_error_code(const char* func, int code){
 		case MM_ERROR_CAMCORDER_INTERNAL :
 		case MM_ERROR_CAMCORDER_NOT_SUPPORTED :
 		case MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT :
-		case MM_ERROR_CAMCORDER_CMD_IS_RUNNING :	
 		case MM_ERROR_CAMCORDER_DSP_FAIL :
 		case MM_ERROR_CAMCORDER_AUDIO_EMPTY :
 		case MM_ERROR_CAMCORDER_CREATE_CONFIGURE :
 		case MM_ERROR_CAMCORDER_FILE_SIZE_OVER :
 		case MM_ERROR_CAMCORDER_DISPLAY_DEVICE_OFF :
-		case MM_ERROR_CAMCORDER_INVALID_CONDITION :			
+		case MM_ERROR_CAMCORDER_INVALID_CONDITION :
 			ret = CAMERA_ERROR_INVALID_OPERATION;
 			errorstr = "INVALID_OPERATION";
 			break;
-				
 
 		case MM_ERROR_CAMCORDER_RESOURCE_CREATION :
-		case MM_ERROR_COMMON_OUT_OF_MEMORY:	
+		case MM_ERROR_COMMON_OUT_OF_MEMORY:
 			ret = CAMERA_ERROR_OUT_OF_MEMORY;
 			errorstr = "OUT_OF_MEMORY";
 			break;
@@ -110,46 +114,86 @@ static int __convert_camera_error_code(const char* func, int code){
 			ret = CAMERA_ERROR_SOUND_POLICY;
 			errorstr = "ERROR_SOUND_POLICY";
 			break;
+		case MM_ERROR_POLICY_RESTRICTED:
+			ret = CAMERA_ERROR_SECURITY_RESTRICTED;
+			errorstr = "ERROR_RESTRICTED";
+			break;
 
 		default:
 			ret = CAMERA_ERROR_INVALID_OPERATION;
 			errorstr = "INVALID_OPERATION";
-		
 	}
-	
 	LOGE( "[%s] %s(0x%08x) : core frameworks error code(0x%08x)",func, errorstr, ret, code);
-	
 	return ret;
 }
 
 
 static gboolean __mm_videostream_callback(MMCamcorderVideoStreamDataType * stream, void *user_data){
-
 	if( user_data == NULL || stream == NULL)
 		return 0;
-		
+
 	camera_s * handle = (camera_s*)user_data;
-	if( handle->user_cb[_CAMERA_EVENT_TYPE_PREVIEW] )
-		((camera_preview_cb)handle->user_cb[_CAMERA_EVENT_TYPE_PREVIEW])(stream->data, stream->length, stream->width, stream->height, stream->format, handle->user_data[_CAMERA_EVENT_TYPE_PREVIEW]);
+	if( handle->user_cb[_CAMERA_EVENT_TYPE_PREVIEW] ){
+		int stream_format = stream->format;
+		if( stream_format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY )
+			stream_format = MM_PIXEL_FORMAT_UYVY;
+		((camera_preview_cb)handle->user_cb[_CAMERA_EVENT_TYPE_PREVIEW])(stream->data, stream->length, stream->width, stream->height, stream_format, handle->user_data[_CAMERA_EVENT_TYPE_PREVIEW]);
+	}
 	return 1;
 }
 static gboolean __mm_capture_callback(MMCamcorderCaptureDataType *frame, MMCamcorderCaptureDataType *thumbnail, void *user_data){
 	if( user_data == NULL || frame == NULL)
 		return 0;
-	
+
 	camera_s * handle = (camera_s*)user_data;
-	if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] )
-		((camera_capturing_cb)handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE])(frame->data, frame->length, frame->width, frame->height, frame->format, handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE]);
+	handle->current_capture_count++;
+	if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] ){
+		MMCamcorderCaptureDataType *scrnl = NULL;
+		int size = 0;
+		camera_image_data_s image = { NULL, 0, 0, 0, 0 };
+		camera_image_data_s thumb = { NULL, 0, 0, 0, 0 };
+		camera_image_data_s postview = { NULL, 0, 0, 0 };
+		if( frame ){
+			image.data = frame->data;
+			image.size = frame->length;
+			image.width = frame->width;
+			image.height = frame->height;
+			image.format = frame->format;
+		}
+
+		if( thumbnail ){
+			thumb.data = thumbnail->data;
+			thumb.size = thumbnail->length;
+			thumb.width = thumbnail->width;
+			thumb.height = thumbnail->height;
+			thumb.format = thumbnail->format;
+		}
+		mm_camcorder_get_attributes( handle->mm_handle, NULL, "captured-screennail", &scrnl, &size,NULL );
+		if( scrnl ){
+			postview.data = scrnl->data;
+			postview.size = scrnl->length;
+			postview.width = scrnl->width;
+			postview.height = scrnl->height;
+			postview.format = scrnl->format;
+		}
 
+		((camera_capturing_cb)handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE])(frame ? &image : NULL, thumbnail ? &thumb : NULL, scrnl ? &postview : NULL, handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE]);
+	}
+	// update captured state
+	if( handle->capture_count == 1 && handle->hdr_keep_mode ){
+		if( handle->current_capture_count == 2 )
+			handle->is_capture_completed = true;
+	}else if( handle->capture_count == handle->current_capture_count || handle->is_continuous_shot_break)
+		handle->is_capture_completed = true;
 	return 1;
 }
 
 static camera_state_e __camera_state_convert(MMCamcorderStateType mm_state)
 {
 	camera_state_e state = CAMERA_STATE_NONE;
-	
+
 	switch( mm_state ){
-		case MM_CAMCORDER_STATE_NONE:				
+		case MM_CAMCORDER_STATE_NONE:
 			state = CAMERA_STATE_NONE;
 			break;
 		case MM_CAMCORDER_STATE_NULL:
@@ -176,16 +220,18 @@ static camera_state_e __camera_state_convert(MMCamcorderStateType mm_state)
 	}
 
 	return state;
-	
 }
 
 
-int __mm_camera_message_callback(int message, void *param, void *user_data){
+static int __mm_camera_message_callback(int message, void *param, void *user_data){
 	if( user_data == NULL || param == NULL )
 		return 0;
-	
-	
+
 	camera_s * handle = (camera_s*)user_data;
+
+	if( handle->relay_message_callback )
+		handle->relay_message_callback(message, param, handle->relay_user_data);
+
 	MMMessageParamType *m = (MMMessageParamType*)param;
 	camera_state_e previous_state;
 
@@ -193,25 +239,33 @@ int __mm_camera_message_callback(int message, void *param, void *user_data){
 	switch(message){
 		case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
 		case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
-			if( m->state.previous < MM_CAMCORDER_STATE_NONE ||  m->state.previous > MM_CAMCORDER_STATE_PAUSED || m->state.code != 0 ){
+		case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY:
+			if( message == MM_MESSAGE_CAMCORDER_STATE_CHANGED && (m->state.previous < MM_CAMCORDER_STATE_NONE ||  m->state.previous > MM_CAMCORDER_STATE_PAUSED || m->state.code != 0) ){
 				LOGI( "Invalid state changed message");
 				break;
 			}
-			
+
 			previous_state = handle->state;
 			handle->state = __camera_state_convert(m->state.current );
-			
+			camera_policy_e policy = CAMERA_POLICY_NONE;
+			if(message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM )
+				policy = CAMERA_POLICY_SOUND;
+			else if( message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY )
+				policy = CAMERA_POLICY_SECURITY;
+
 			if( previous_state != handle->state && handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE] ){
-				((camera_state_changed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, message == MM_MESSAGE_CAMCORDER_STATE_CHANGED ? 0 : 1 , handle->user_data[_CAMERA_EVENT_TYPE_STATE_CHANGE]);
+				((camera_state_changed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, policy, handle->user_data[_CAMERA_EVENT_TYPE_STATE_CHANGE]);
 			}
 
 			// should change intermediate state MM_CAMCORDER_STATE_READY is not valid in capi , change to NULL state
-			if( message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM ){
+			if( policy != CAMERA_POLICY_NONE ){
+				if( previous_state != handle->state && handle->user_cb[_CAMERA_EVENT_TYPE_INTERRUPTED] )
+					((camera_interrupted_cb)handle->user_cb[_CAMERA_EVENT_TYPE_INTERRUPTED])(policy, previous_state, handle->state, handle->user_data[_CAMERA_EVENT_TYPE_INTERRUPTED]);
 				if( m->state.previous == MM_CAMCORDER_STATE_PREPARE && m->state.current == MM_CAMCORDER_STATE_READY ){
 					mm_camcorder_unrealize(handle->mm_handle);
 				}
 			}
-			
+
 			break;
 		case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED :
 			if( handle->user_cb[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] ){
@@ -223,16 +277,23 @@ int __mm_camera_message_callback(int message, void *param, void *user_data){
 			MMCamRecordingReport *report = (MMCamRecordingReport *)m ->data;
 			int mode;
 			 mm_camcorder_get_attributes(handle->mm_handle ,NULL,MMCAM_MODE, &mode, NULL);
-			 if( mode == MM_CAMCORDER_MODE_IMAGE){
-				//pseudo state change
-				previous_state = handle->state ;
-				handle->state = CAMERA_STATE_CAPTURED;
-				if( previous_state != handle->state && handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE] ){
-					((camera_state_changed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state,  0 , handle->user_data[_CAMERA_EVENT_TYPE_STATE_CHANGE]);
-				}
-				
-				if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] ){
-					((camera_capture_completed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE])(handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE]);
+			 if( mode == MM_CAMCORDER_MODE_IMAGE ){
+				handle->current_capture_complete_count = m->code;
+				if(  handle->capture_count == 1 || m->code == handle->capture_count ||(handle->is_continuous_shot_break && handle->state == CAMERA_STATE_CAPTURING) ){
+					//pseudo state change
+					previous_state = handle->state ;
+					handle->state = CAMERA_STATE_CAPTURED;
+					if( previous_state != handle->state && handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE] ){
+						((camera_state_changed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state,  0 , handle->user_data[_CAMERA_EVENT_TYPE_STATE_CHANGE]);
+					}
+					if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] ){
+						((camera_capture_completed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE])(handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE]);
+					}
+					// reset capturing callback , capture completed callback
+					handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+					handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+					handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+					handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
 				}
 			}else{
 				if( report != NULL && report->recording_filename ){
@@ -242,44 +303,130 @@ int __mm_camera_message_callback(int message, void *param, void *user_data){
 				if( report ){
 					free(report);
 					report = NULL;
-				}			
+				}
 			}
 			break;
 		}
+		case MM_MESSAGE_CAMCORDER_VIDEO_SNAPSHOT_CAPTURED:
+		{
+			if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] ){
+				((camera_capture_completed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE])(handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE]);
+			}
+			// reset capturing callback , capture completed callback
+			handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+			handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+			handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+			handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+			break;
+		}
 		case MM_MESSAGE_CAMCORDER_ERROR:
 		{
 			int errorcode = m->code;
-			errorcode = __convert_camera_error_code("NOTIFY", errorcode);
-			if( handle->user_cb[_CAMERA_EVENT_TYPE_ERROR] )
+			int camera_error = 0;
+			switch( errorcode ){
+				case MM_ERROR_CAMCORDER_DEVICE :
+				case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT :
+				case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE :
+				case MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG :
+					camera_error = CAMERA_ERROR_DEVICE;
+					break;
+				case MM_ERROR_CAMCORDER_GST_CORE :
+				case MM_ERROR_CAMCORDER_GST_LIBRARY :
+				case MM_ERROR_CAMCORDER_GST_RESOURCE :
+				case MM_ERROR_CAMCORDER_GST_STREAM :
+				case MM_ERROR_CAMCORDER_GST_NEGOTIATION :
+				case MM_ERROR_CAMCORDER_GST_FLOW_ERROR :
+				case MM_ERROR_CAMCORDER_ENCODER :
+				case MM_ERROR_CAMCORDER_ENCODER_BUFFER :
+				case MM_ERROR_CAMCORDER_ENCODER_WORKING :
+				case MM_ERROR_CAMCORDER_MNOTE_CREATION :
+				case MM_ERROR_CAMCORDER_MNOTE_ADD_ENTRY :
+				case MM_ERROR_CAMCORDER_INTERNAL :
+					camera_error = CAMERA_ERROR_INVALID_OPERATION;
+					break;
+				case MM_ERROR_CAMCORDER_LOW_MEMORY :
+				case MM_ERROR_CAMCORDER_MNOTE_MALLOC :
+					camera_error = CAMERA_ERROR_OUT_OF_MEMORY;
+					break;
+			}
+			if( camera_error != 0 && handle->user_cb[_CAMERA_EVENT_TYPE_ERROR] )
 				((camera_error_cb)handle->user_cb[_CAMERA_EVENT_TYPE_ERROR])(errorcode, handle->state , handle->user_data[_CAMERA_EVENT_TYPE_ERROR]);
-			
+
+			break;
+		}
+		case MM_MESSAGE_CAMCORDER_HDR_PROGRESS:
+		{
+			int percent = m->code;
+			if( handle->user_cb[_CAMERA_EVENT_TYPE_HDR_PROGRESS] )
+				((camera_attr_hdr_progress_cb)handle->user_cb[_CAMERA_EVENT_TYPE_HDR_PROGRESS])(percent, handle->user_data[_CAMERA_EVENT_TYPE_HDR_PROGRESS]);
+			break;
+		}
+		case MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO:
+		{
+			MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)(m->data);
+			if ( cam_fd_info ) {
+				camera_detected_face_s faces[cam_fd_info->num_of_faces];
+				handle->num_of_faces = cam_fd_info->num_of_faces > MAX_DETECTED_FACE ? MAX_DETECTED_FACE : cam_fd_info->num_of_faces;
+				int i;
+				for(i=0; i < handle->num_of_faces ; i++){
+					faces[i].id = cam_fd_info->face_info[i].id;
+					faces[i].score = cam_fd_info->face_info[i].score;
+					faces[i].x = cam_fd_info->face_info[i].rect.x;
+					faces[i].y = cam_fd_info->face_info[i].rect.y;
+					faces[i].width = cam_fd_info->face_info[i].rect.width;
+					faces[i].height = cam_fd_info->face_info[i].rect.height;
+					handle->faceinfo[i] = faces[i];	//cache face coordinate
+				}
+				if( handle->user_cb[_CAMERA_EVENT_TYPE_FACE_DETECTION] )
+					((camera_face_detected_cb)handle->user_cb[_CAMERA_EVENT_TYPE_FACE_DETECTION])(faces, handle->num_of_faces, handle->user_data[_CAMERA_EVENT_TYPE_FACE_DETECTION]);
+			}else{
+				handle->num_of_faces = 0;
+			}
 			break;
 		}
-			
-			
 	}
-	
+
 	return 1;
 }
 
+static int __capture_completed_event_cb(void *data){
+	camera_s *handle = (camera_s*)data;
+	if( handle->current_capture_count > 0 && handle->current_capture_count == handle->current_capture_complete_count && handle->state == CAMERA_STATE_CAPTURING ){
+		//pseudo state change
+		camera_state_e previous_state = handle->state;
+		handle->state = CAMERA_STATE_CAPTURED;
+		if( previous_state != handle->state && handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE] ){
+			((camera_state_changed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state,  0 , handle->user_data[_CAMERA_EVENT_TYPE_STATE_CHANGE]);
+		}
+		if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] ){
+			((camera_capture_completed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE])(handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE]);
+		}
+		// reset capturing callback , capture completed callback
+		handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+		handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+		handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+		handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+	}
+	return false;
+}
+
 int camera_create( camera_device_e device, camera_h* camera){
 
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-		
-	
- 	int ret;
+
+	int ret;
 	MMCamPreset info;
 	int preview_format;
 	int rotation;
-	
+
 	if( device == CAMERA_DEVICE_CAMERA1 )
 		info.videodev_type= MM_VIDEO_DEVICE_CAMERA1;
 	else
 		info.videodev_type= MM_VIDEO_DEVICE_CAMERA0;
-	
+
 	camera_s* handle = (camera_s*)malloc( sizeof(camera_s) );
 	if(handle==NULL){
 		LOGE("[%s] malloc fail",__func__);
@@ -295,39 +442,48 @@ int camera_create( camera_device_e device, camera_h* camera){
 
 	preview_format = MM_PIXEL_FORMAT_YUYV;
 	rotation = MM_DISPLAY_ROTATION_NONE;
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL, MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, &preview_format, MMCAM_RECOMMEND_DISPLAY_ROTATION, &rotation, NULL);
+	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+																MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, &preview_format,
+																MMCAM_RECOMMEND_DISPLAY_ROTATION, &rotation,
+																MMCAM_CAPTURE_WIDTH, &handle->capture_width,
+																MMCAM_CAPTURE_HEIGHT, &handle->capture_height,
+																NULL);
 
-	
 	char *error;
 	ret = mm_camcorder_set_attributes(handle->mm_handle, &error,
 																MMCAM_MODE , MM_CAMCORDER_MODE_IMAGE,
 																MMCAM_CAMERA_FORMAT,  preview_format,
 																MMCAM_IMAGE_ENCODER , MM_IMAGE_CODEC_JPEG,
-																MMCAM_CAPTURE_FORMAT,  MM_PIXEL_FORMAT_ENCODED ,
+																MMCAM_CAPTURE_FORMAT,  MM_PIXEL_FORMAT_ENCODED,
 																MMCAM_DISPLAY_SURFACE, MM_DISPLAY_SURFACE_NULL,
 																MMCAM_DISPLAY_ROTATION, rotation,
 																MMCAM_CAPTURE_COUNT, 1,
 																(void*)NULL);
 
 	handle->display_type = CAMERA_DISPLAY_TYPE_NONE;
-	
+
 	if( ret != MM_ERROR_NONE){
 		LOGE("[%s] mm_camcorder_set_attributes fail(%x, %s)",__func__, ret, error);
 		mm_camcorder_destroy(handle->mm_handle);
 		free(error);
 		free(handle);
 		return __convert_camera_error_code(__func__, ret);
-	}	
+	}
 
 	handle->state = CAMERA_STATE_CREATED;
+	handle->relay_message_callback = NULL;
+	handle->relay_user_data = NULL;
+	handle->capture_resolution_modified = false;
+	handle->hdr_keep_mode = false;
+	handle->focus_area_valid = false;
 	mm_camcorder_set_message_callback(handle->mm_handle, __mm_camera_message_callback, (void*)handle);
-		
-		
+
+
 	if( ret == MM_ERROR_NONE)
 		*camera = (camera_h)handle;
 
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
  int camera_destroy(camera_h camera){
@@ -335,12 +491,12 @@ int camera_create( camera_device_e device, camera_h* camera){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
- 	int ret;
+
+	int ret;
 	camera_s *handle = (camera_s*)camera;
-	
+
 	ret = mm_camcorder_destroy(handle->mm_handle);
-	
+
 	if( ret == MM_ERROR_NONE)
 		free(handle);
 
@@ -349,22 +505,25 @@ int camera_create( camera_device_e device, camera_h* camera){
 }
 
 int camera_start_preview(camera_h camera){
+	LOGE("%s - start", __func__);
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
 
-	
- 	int ret;
+
+	int ret;
 	camera_s *handle = (camera_s*)camera;
+	camera_state_e capi_state;
+	camera_get_state(camera, &capi_state);
 
-	if( handle->state == CAMERA_STATE_CAPTURED )
+	if( capi_state == CAMERA_STATE_CAPTURED )
 	{
 		ret = mm_camcorder_capture_stop(handle->mm_handle);
 		return __convert_camera_error_code(__func__, ret);
 	}
 
-	
+
 
 	//for receving MM_MESSAGE_CAMCORDER_CAPTURED evnet must be seted capture callback
 	mm_camcorder_set_video_capture_callback( handle->mm_handle, (mm_camcorder_video_capture_callback)__mm_capture_callback, (void*)handle);
@@ -375,20 +534,20 @@ int camera_start_preview(camera_h camera){
 		mm_camcorder_set_video_stream_callback( handle->mm_handle, (mm_camcorder_video_stream_callback)NULL, (void*)NULL);
 
 	MMCamcorderStateType state ;
-	mm_camcorder_get_state(handle->mm_handle, &state);	
+	mm_camcorder_get_state(handle->mm_handle, &state);
 	if( state != MM_CAMCORDER_STATE_READY){
-		ret = mm_camcorder_realize(handle->mm_handle);	
+		ret = mm_camcorder_realize(handle->mm_handle);
 		if( ret != MM_ERROR_NONE )
 			return __convert_camera_error_code(__func__, ret);
 	}
-	
+
 	ret = mm_camcorder_start(handle->mm_handle);
 
 	//start fail.
 	if( ret != MM_ERROR_NONE &&  state != MM_CAMCORDER_STATE_READY){
 		mm_camcorder_unrealize(handle->mm_handle);
 	}
-	
+
 	return __convert_camera_error_code(__func__, ret);
 }
 
@@ -398,28 +557,276 @@ int camera_stop_preview(camera_h camera){
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
 
-	
- 	int ret;
+
+	int ret;
 	camera_s *handle = (camera_s*)camera;
 	MMCamcorderStateType state ;
-	mm_camcorder_get_state(handle->mm_handle, &state);	
+	mm_camcorder_get_state(handle->mm_handle, &state);
 
 	if( state == MM_CAMCORDER_STATE_PREPARE ){
-		ret = mm_camcorder_stop(handle->mm_handle);	
+		ret = mm_camcorder_stop(handle->mm_handle);
 		if( ret != MM_ERROR_NONE)
-			return __convert_camera_error_code(__func__, ret);	
+			return __convert_camera_error_code(__func__, ret);
 	}
-	
+	camera_stop_face_detection(camera);
 	ret = mm_camcorder_unrealize(handle->mm_handle);
-	return __convert_camera_error_code(__func__, ret);	
+	return __convert_camera_error_code(__func__, ret);
+}
+
+int camera_start_capture(camera_h camera, camera_capturing_cb capturing_cb , camera_capture_completed_cb completed_cb , void *user_data){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+
+	camera_s * handle = (camera_s*)camera;
+	int ret;
+	MMCamcorderStateType state;
+	mm_camcorder_get_state(handle->mm_handle, &state);
+	if( state != MM_CAMCORDER_STATE_PREPARE && state != MM_CAMCORDER_STATE_RECORDING ){
+		LOGE( "[%s] INVALID_STATE(0x%08x)",__func__,CAMERA_ERROR_INVALID_STATE);
+		return CAMERA_ERROR_INVALID_STATE;
+	}
+
+	if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] != NULL || handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] != NULL )
+		return CAMERA_ERROR_INVALID_STATE;
+
+	if( handle->capture_resolution_modified ){
+		mm_camcorder_set_attributes(handle->mm_handle, NULL,
+															MMCAM_CAPTURE_WIDTH, handle->capture_width,
+															MMCAM_CAPTURE_HEIGHT, handle->capture_height,
+															NULL);
+		handle->capture_resolution_modified = false;
+	}
+	mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAPTURE_COUNT , 1,NULL);
+
+	handle->capture_count = 1;
+	handle->is_continuous_shot_break = false;
+	handle->current_capture_count = 0;
+	handle->current_capture_complete_count = 0;
+	handle->is_capture_completed = false;
+
+	handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)capturing_cb;
+	handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)user_data;
+	handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)completed_cb;
+	handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)user_data;
+	ret = mm_camcorder_capture_start(handle->mm_handle);
+	if( ret != 0 ){
+		handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+		handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+		handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+		handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+	}
+
+	return __convert_camera_error_code(__func__, ret);
+}
+
+int camera_start_continuous_capture(camera_h camera, int count, int interval, camera_capturing_cb capturing_cb, camera_capture_completed_cb completed_cb , void *user_data){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+
+	if( count < 2 || interval < 0 ){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+
+	camera_s * handle = (camera_s*)camera;
+
+	MMCamcorderStateType state;
+	mm_camcorder_get_state(handle->mm_handle, &state);
+	if( state != MM_CAMCORDER_STATE_PREPARE ){
+		LOGE( "[%s] INVALID_STATE(0x%08x)",__func__,CAMERA_ERROR_INVALID_STATE);
+		return CAMERA_ERROR_INVALID_STATE;
+	}
+
+	if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] != NULL || handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] != NULL )
+		return CAMERA_ERROR_INVALID_STATE;
+
+	int preview_width;
+	int preview_height;
+	int capture_width;
+	int capture_height;
+	int recormmend_preview_format;
+	bool supported_ZSL = false;
+
+	int ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+																MMCAM_CAPTURE_COUNT , count,
+																MMCAM_CAPTURE_INTERVAL, interval,
+																NULL);
+	if( ret != 0 ){
+		LOGE("[%s] (%x) error set continuous shot attribute", ret);
+		return __convert_camera_error_code(__func__, ret);
+	}
+	handle->capture_count = count;
+	handle->is_continuous_shot_break = false;
+	handle->current_capture_count = 0;
+	handle->current_capture_complete_count = 0;
+	handle->is_capture_completed = false;
+
+	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL, MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, &recormmend_preview_format,NULL);
+	if( recormmend_preview_format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY )
+		supported_ZSL = true;
+
+	if( ret != 0 ){
+		LOGE("[%s] (%x) error get continuous shot attribute", ret);
+	}
+
+	if( !supported_ZSL ){
+		mm_camcorder_get_attributes(handle->mm_handle, NULL,
+																	MMCAM_CAMERA_WIDTH, &preview_width,
+																	MMCAM_CAMERA_HEIGHT, &preview_height,
+																	MMCAM_CAPTURE_WIDTH, &capture_width,
+																	MMCAM_CAPTURE_HEIGHT, &capture_height,
+																	NULL);
+		if( preview_width != capture_width || preview_height != capture_height ){
+			mm_camcorder_set_attributes(handle->mm_handle, NULL,
+																		MMCAM_CAPTURE_WIDTH, preview_width,
+																		MMCAM_CAPTURE_HEIGHT, preview_height,
+																		NULL);
+			handle->capture_resolution_modified = true;
+		}
+	}
+
+	handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)capturing_cb;
+	handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)user_data;
+	handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)completed_cb;
+	handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)user_data;
+
+	ret = mm_camcorder_capture_start(handle->mm_handle);
+	if( ret != 0 ){
+		handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+		handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+		handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+		handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+	}
+
+	return __convert_camera_error_code(__func__,ret);
+
+}
+
+int camera_stop_continuous_capture(camera_h camera){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	camera_s *handle = (camera_s*)camera;
+	int ret;
+	camera_state_e state;
+	camera_get_state(camera, &state);
+	if( state != CAMERA_STATE_CAPTURING && handle->capture_count > 1 ){
+		LOGE( "[%s] INVALID_STATE(0x%08x)",__func__,CAMERA_ERROR_INVALID_STATE);
+		return CAMERA_ERROR_INVALID_STATE;
+	}
+
+	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, "capture-break-cont-shot", 1, NULL);
+	if( ret == 0){
+		handle->is_continuous_shot_break = true;
+		if( handle->current_capture_count > 0 )
+			handle->is_capture_completed = true;
+		g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, __capture_completed_event_cb, handle, NULL);
+	}
+
+	return __convert_camera_error_code(__func__,ret);
+}
+
+bool camera_is_supported_face_detection(camera_h camera){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return false;
+	}
+	int ret;
+	camera_s * handle = (camera_s*)camera;
+	MMCamAttrsInfo info;
+	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_DETECT_MODE , &info);
+	int i=0;
+	if( info.validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_ARRAY){
+		for( i =0; i < info.int_array.count ; i++){
+			if( info.int_array.array[i] == MM_CAMCORDER_DETECT_MODE_ON )
+				return true;
+		}
+	}
+	return false;
+}
+
+int camera_start_face_detection(camera_h camera, camera_face_detected_cb callback, void * user_data){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	camera_s * handle = (camera_s*)camera;
+	camera_state_e state = CAMERA_STATE_NONE;
+	int ret;
+	camera_get_state(camera, &state);
+	if( state != CAMERA_STATE_PREVIEW ){
+		LOGE( "[%s] INVALID_STATE(0x%08x)",__func__,CAMERA_ERROR_INVALID_STATE);
+		return CAMERA_ERROR_INVALID_STATE;
+	}
+	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_DETECT_MODE, MM_CAMCORDER_DETECT_MODE_ON, NULL);
+	if( ret == 0 ){
+		handle->user_cb[_CAMERA_EVENT_TYPE_FACE_DETECTION] = (void*)callback;
+		handle->user_data[_CAMERA_EVENT_TYPE_FACE_DETECTION] = (void*)user_data;
+		handle->num_of_faces = 0;
+	}
+	return __convert_camera_error_code(__func__,ret);
+}
+
+int camera_stop_face_detection(camera_h camera){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	camera_s * handle = (camera_s*)camera;
+	int ret;
+	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_DETECT_MODE, MM_CAMCORDER_DETECT_MODE_OFF, NULL);
+	handle->user_cb[_CAMERA_EVENT_TYPE_FACE_DETECTION] = NULL;
+	handle->user_data[_CAMERA_EVENT_TYPE_FACE_DETECTION] = NULL;
+	handle->num_of_faces = 0;
+	return __convert_camera_error_code(__func__,ret);
 }
 
-int camera_start_capture(camera_h camera){
+int camera_face_zoom(camera_h camera, int face_id){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	return mm_camcorder_capture_start(((camera_s*)camera)->mm_handle);
+	camera_s * handle = (camera_s*)camera;
+	int ret;
+	int find = -1;
+	int i;
+	int current_mode;
+
+	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FACE_ZOOM_MODE , &current_mode, NULL);
+
+	if( current_mode == MM_CAMCORDER_FACE_ZOOM_MODE_ON )
+		return CAMERA_ERROR_INVALID_STATE;
+
+	for( i = 0 ; i < handle->num_of_faces ; i++){
+		if( handle->faceinfo[i].id == face_id ){
+			find = i;
+			break;
+		}
+	}
+	if( find == -1 )
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_FACE_ZOOM_MODE, MM_CAMCORDER_FACE_ZOOM_MODE_ON,
+                                 MMCAM_CAMERA_FACE_ZOOM_X, handle->faceinfo[find].x+(handle->faceinfo[find].width>>1),
+                                 MMCAM_CAMERA_FACE_ZOOM_Y, handle->faceinfo[find].y+(handle->faceinfo[find].height>>1),
+                                 NULL);
+
+	return __convert_camera_error_code(__func__,ret);
+}
+
+int camera_cancel_face_zoom(camera_h camera){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	camera_s * handle = (camera_s*)camera;
+	int ret;
+	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_FACE_ZOOM_MODE, MM_CAMCORDER_FACE_ZOOM_MODE_OFF, NULL);
+	return __convert_camera_error_code(__func__,ret);
 }
 
 
@@ -432,32 +839,63 @@ int camera_get_state(camera_h camera, camera_state_e * state){
 	camera_s *handle = (camera_s*)camera;
 	camera_state_e capi_state;
 	MMCamcorderStateType mmstate ;
-	mm_camcorder_get_state(handle->mm_handle, &mmstate);	
+	mm_camcorder_get_state(handle->mm_handle, &mmstate);
 
 	capi_state = __camera_state_convert(mmstate);
 
-	if( handle->state == CAMERA_STATE_CAPTURED && mmstate == MM_CAMCORDER_STATE_CAPTURING )
+	if( ( handle->state == CAMERA_STATE_CAPTURED || handle->is_capture_completed ) && mmstate == MM_CAMCORDER_STATE_CAPTURING )
 		capi_state = CAMERA_STATE_CAPTURED;
 
 	*state = capi_state;
-	
 	return CAMERA_ERROR_NONE;
-	
 }
 
-int camera_start_focusing( camera_h camera ){
+int camera_start_focusing( camera_h camera, bool continuous ){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	return __convert_camera_error_code(__func__, mm_camcorder_start_focusing(((camera_s*)camera)->mm_handle));
+
+	if( continuous )
+		return __camera_start_continuous_focusing(camera);
+	else{
+		camera_s *handle = (camera_s*)camera;
+		mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_FOCUS_MODE, handle->focus_area_valid ? MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO : MM_CAMCORDER_FOCUS_MODE_AUTO, NULL);
+		return __convert_camera_error_code(__func__, mm_camcorder_start_focusing(((camera_s*)camera)->mm_handle));
+	}
 }
+
+int __camera_start_continuous_focusing(camera_h camera){
+	if( camera == NULL ){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	camera_s *handle = (camera_s*)camera;
+	int ret;
+	camera_attr_af_mode_e mode;
+	camera_attr_get_af_mode(camera, &mode);
+	if( mode == CAMERA_ATTR_AF_NONE ){
+		LOGE( "[%s] CAMERA_ERROR_INVALID_OPERATION(0x%08x) AF mode is CAMERA_ATTR_AF_NONE",__func__,CAMERA_ERROR_INVALID_OPERATION);
+		return CAMERA_ERROR_INVALID_OPERATION;
+	}
+	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE, MM_CAMCORDER_FOCUS_MODE_CONTINUOUS, NULL);
+	return __convert_camera_error_code(__func__, ret);
+}
+
 int camera_cancel_focusing( camera_h camera ){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	return __convert_camera_error_code(__func__, mm_camcorder_stop_focusing(((camera_s*)camera)->mm_handle));	
+	int ret;
+	camera_s *handle = (camera_s*)camera;
+	int mode;
+	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE , &mode, NULL);
+	if( mode == MM_CAMCORDER_FOCUS_MODE_CONTINUOUS ){
+		ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE, handle->focus_area_valid ? MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO : MM_CAMCORDER_FOCUS_MODE_AUTO, NULL);
+		return __convert_camera_error_code(__func__, ret);
+	}
+	return __convert_camera_error_code(__func__, mm_camcorder_stop_focusing(handle->mm_handle));
 }
 int camera_set_display(camera_h camera, camera_display_type_e type, camera_display_h display){
 	if( camera == NULL){
@@ -470,7 +908,9 @@ int camera_set_display(camera_h camera, camera_display_type_e type, camera_displ
 	handle->display_type = type;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL,
 		MMCAM_DISPLAY_DEVICE, MM_DISPLAY_DEVICE_MAINLCD,
-		MMCAM_DISPLAY_SURFACE  ,type,
+		MMCAM_DISPLAY_SURFACE  ,type, NULL );
+	if( ret == 0 && type != CAMERA_DISPLAY_TYPE_NONE)
+		ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL,
 		MMCAM_DISPLAY_HANDLE  , type == CAMERA_DISPLAY_TYPE_X11 ? &handle->display_handle : display , sizeof(display) ,
 		NULL);
 	return __convert_camera_error_code(__func__, ret);
@@ -485,7 +925,6 @@ int camera_set_preview_resolution(camera_h camera,  int width, int height){
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_WIDTH  , width ,MMCAM_CAMERA_HEIGHT ,height,  NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
 }
 int camera_set_x11_display_rotation(camera_h camera,  camera_rotation_e rotation){
 	if( camera == NULL){
@@ -495,7 +934,7 @@ int camera_set_x11_display_rotation(camera_h camera,  camera_rotation_e rotation
 
 	if( rotation < CAMERA_ROTATION_NONE || rotation > CAMERA_ROTATION_270 )
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 
@@ -507,10 +946,14 @@ int camera_set_capture_resolution(camera_h camera,  int width, int height){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
+	}
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAPTURE_WIDTH, width  ,MMCAM_CAPTURE_HEIGHT , height, NULL);
+	if( ret == 0 ){
+		handle->capture_width = width;
+		handle->capture_height = height;
+	}
 	return __convert_camera_error_code(__func__, ret);
 }
 
@@ -522,7 +965,7 @@ int camera_set_capture_format(camera_h camera, camera_pixel_format_e format){
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAPTURE_FORMAT, format , NULL);
-	return __convert_camera_error_code(__func__, ret);	
+	return __convert_camera_error_code(__func__, ret);
 }
 
 int camera_set_preview_format(camera_h camera, camera_pixel_format_e format){
@@ -532,8 +975,21 @@ int camera_set_preview_format(camera_h camera, camera_pixel_format_e format){
 	}
 	int ret;
 	camera_s * handle = (camera_s*)camera;
-	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FORMAT, format , NULL);
-	return __convert_camera_error_code(__func__, ret);	
+
+	if( format == CAMERA_PIXEL_FORMAT_UYVY ){
+		bool supported_ITLV_UYVY = false;
+		MMCamAttrsInfo supported_format;
+		ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_FORMAT , &supported_format);
+		int i;
+		for( i=0 ; i < supported_format.int_array.count ; i++){
+			if( supported_format.int_array.array[i] == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY )
+				supported_ITLV_UYVY = true;
+		}
+		ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FORMAT, supported_ITLV_UYVY ?  MM_PIXEL_FORMAT_ITLV_JPEG_UYVY : MM_PIXEL_FORMAT_UYVY , NULL);
+	}else
+		ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FORMAT, format , NULL);
+
+	return __convert_camera_error_code(__func__, ret);
 }
 
 int camera_get_preview_resolution(camera_h camera,  int *width, int *height){
@@ -546,7 +1002,7 @@ int camera_get_preview_resolution(camera_h camera,  int *width, int *height){
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_WIDTH , width,MMCAM_CAMERA_HEIGHT, height,  NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_get_x11_display_rotation( camera_h camera,  camera_rotation_e *rotation){
@@ -554,7 +1010,7 @@ int camera_get_x11_display_rotation( camera_h camera,  camera_rotation_e *rotati
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 
@@ -571,7 +1027,7 @@ int camera_set_x11_display_visible(camera_h camera, bool visible){
 	camera_s * handle = (camera_s*)camera;
 
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_DISPLAY_VISIBLE , visible, NULL);
-	return __convert_camera_error_code(__func__, ret);	
+	return __convert_camera_error_code(__func__, ret);
 }
 
 int camera_is_x11_display_visible(camera_h camera, bool* visible){
@@ -579,7 +1035,7 @@ int camera_is_x11_display_visible(camera_h camera, bool* visible){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	int result;
 	camera_s * handle = (camera_s*)camera;
@@ -587,7 +1043,7 @@ int camera_is_x11_display_visible(camera_h camera, bool* visible){
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_DISPLAY_VISIBLE , &result, NULL);
 	if( ret == 0)
 		*visible = result;
-	return __convert_camera_error_code(__func__, ret);	
+	return __convert_camera_error_code(__func__, ret);
 }
 
 int camera_set_x11_display_mode( camera_h camera , camera_display_mode_e ratio){
@@ -598,12 +1054,12 @@ int camera_set_x11_display_mode( camera_h camera , camera_display_mode_e ratio){
 
 	if( ratio < CAMERA_DISPLAY_MODE_LETTER_BOX || ratio > CAMERA_DISPLAY_MODE_CROPPED_FULL )
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_DISPLAY_GEOMETRY_METHOD , ratio, NULL);
-	return __convert_camera_error_code(__func__, ret);		
+	return __convert_camera_error_code(__func__, ret);
 }
 
 int camera_get_x11_display_mode( camera_h camera , camera_display_mode_e* ratio){
@@ -611,12 +1067,12 @@ int camera_get_x11_display_mode( camera_h camera , camera_display_mode_e* ratio)
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_DISPLAY_GEOMETRY_METHOD , ratio, NULL);
-	return __convert_camera_error_code(__func__, ret);		
+	return __convert_camera_error_code(__func__, ret);
 }
 
 
@@ -625,11 +1081,10 @@ int camera_get_capture_resolution(camera_h camera, int *width, int *height){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-
-	int ret;
 	camera_s * handle = (camera_s*)camera;
-	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAPTURE_WIDTH, width  ,MMCAM_CAPTURE_HEIGHT , height, NULL);
-	return __convert_camera_error_code(__func__, ret);
+	*width = handle->capture_width;
+	*height = handle->capture_height;
+	return CAMERA_ERROR_NONE;
 }
 
 int camera_get_capture_format(camera_h camera, camera_pixel_format_e *format){
@@ -637,11 +1092,11 @@ int camera_get_capture_format(camera_h camera, camera_pixel_format_e *format){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAPTURE_FORMAT, format , NULL);
-	return __convert_camera_error_code(__func__, ret);	
+	return __convert_camera_error_code(__func__, ret);
 }
 
 int camera_get_preview_format(camera_h camera, camera_pixel_format_e *format){
@@ -649,10 +1104,12 @@ int camera_get_preview_format(camera_h camera, camera_pixel_format_e *format){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FORMAT, format , NULL);
+	if( (MMPixelFormatType)*format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY )
+		*format = CAMERA_PIXEL_FORMAT_UYVY;
 	return __convert_camera_error_code(__func__, ret);	
 }
 
@@ -660,12 +1117,12 @@ int camera_set_preview_cb( camera_h camera, camera_preview_cb callback, void* us
 	if( camera == NULL || callback == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
-	
+	}
+
 	camera_s * handle = (camera_s*)camera;
 	handle->user_cb[_CAMERA_EVENT_TYPE_PREVIEW] = (void*)callback;
 	handle->user_data[_CAMERA_EVENT_TYPE_PREVIEW] = (void*)user_data;
-	return CAMERA_ERROR_NONE;	
+	return CAMERA_ERROR_NONE;
 }
 int camera_unset_preview_cb( camera_h camera){
 	if( camera == NULL){
@@ -675,41 +1132,19 @@ int camera_unset_preview_cb( camera_h camera){
 	camera_s * handle = (camera_s*)camera;
 	handle->user_cb[_CAMERA_EVENT_TYPE_PREVIEW] = (void*)NULL;
 	handle->user_data[_CAMERA_EVENT_TYPE_PREVIEW] = (void*)NULL;
-	return CAMERA_ERROR_NONE;		
-}
-int camera_set_capturing_cb( camera_h camera, camera_capturing_cb callback, void* user_data ){
-		
-	if( camera == NULL || callback == NULL){
-		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
-		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
-	
-	camera_s * handle = (camera_s*)camera;
-	handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)callback;
-	handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)user_data;
-	return CAMERA_ERROR_NONE;			
-}
-int camera_unset_capturing_cb( camera_h camera){
-	if( camera == NULL){
-		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
-		return CAMERA_ERROR_INVALID_PARAMETER;
-	}
-	
-	camera_s * handle = (camera_s*)camera;
-	handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)NULL;
-	handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)NULL;
-	return CAMERA_ERROR_NONE;				
+	return CAMERA_ERROR_NONE;
 }
+
 int camera_set_state_changed_cb(camera_h camera, camera_state_changed_cb callback, void* user_data){
 	if( camera == NULL || callback == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	camera_s * handle = (camera_s*)camera;
 	handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void*)callback;
 	handle->user_data[_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void*)user_data;
-	return CAMERA_ERROR_NONE;				
+	return CAMERA_ERROR_NONE;
 }
 int camera_unset_state_changed_cb(camera_h camera){
 	if( camera == NULL){
@@ -719,53 +1154,51 @@ int camera_unset_state_changed_cb(camera_h camera){
 	camera_s * handle = (camera_s*)camera;
 	handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void*)NULL;
 	handle->user_data[_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void*)NULL;
-	return CAMERA_ERROR_NONE;					
+	return CAMERA_ERROR_NONE;
 }
 
-int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback, void* user_data){
+int camera_set_interrupted_cb(camera_h camera, camera_interrupted_cb callback, void *user_data){
 	if( camera == NULL || callback == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
+
 	camera_s * handle = (camera_s*)camera;
-	handle->user_cb[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)callback;
-	handle->user_data[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)user_data;
+	handle->user_cb[_CAMERA_EVENT_TYPE_INTERRUPTED] = (void*)callback;
+	handle->user_data[_CAMERA_EVENT_TYPE_INTERRUPTED] = (void*)user_data;
 	return CAMERA_ERROR_NONE;
 }
-int camera_unset_focus_changed_cb(camera_h camera){
+
+int camera_unset_interrupted_cb(camera_h camera){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
 	camera_s * handle = (camera_s*)camera;
-	handle->user_cb[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)NULL;
-	handle->user_data[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)NULL;
-	return CAMERA_ERROR_NONE;	
+	handle->user_cb[_CAMERA_EVENT_TYPE_INTERRUPTED] = (void*)NULL;
+	handle->user_data[_CAMERA_EVENT_TYPE_INTERRUPTED] = (void*)NULL;
+	return CAMERA_ERROR_NONE;
 }
 
-int camera_set_capture_completed_cb(camera_h camera, camera_capture_completed_cb callback, void* user_data){
-		
+int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback, void* user_data){
 	if( camera == NULL || callback == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
 	camera_s * handle = (camera_s*)camera;
-	handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)callback;
-	handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)user_data;
+	handle->user_cb[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)callback;
+	handle->user_data[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)user_data;
 	return CAMERA_ERROR_NONE;
 }
-
-int camera_unset_capture_completed_cb(camera_h camera){
-		
+int camera_unset_focus_changed_cb(camera_h camera){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
 	camera_s * handle = (camera_s*)camera;
-	handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)NULL;
-	handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)NULL;
-	return CAMERA_ERROR_NONE;	
+	handle->user_cb[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)NULL;
+	handle->user_data[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)NULL;
+	return CAMERA_ERROR_NONE;
 }
 
 int camera_set_error_cb(camera_h camera, camera_error_cb callback, void *user_data){
@@ -773,7 +1206,7 @@ int camera_set_error_cb(camera_h camera, camera_error_cb callback, void *user_da
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	camera_s * handle = (camera_s*)camera;
 	handle->user_cb[_CAMERA_EVENT_TYPE_ERROR] = (void*)callback;
 	handle->user_data[_CAMERA_EVENT_TYPE_ERROR] = (void*)user_data;
@@ -789,25 +1222,25 @@ int camera_unset_error_cb(camera_h camera){
 	camera_s * handle = (camera_s*)camera;
 	handle->user_cb[_CAMERA_EVENT_TYPE_ERROR] = (void*)NULL;
 	handle->user_data[_CAMERA_EVENT_TYPE_ERROR] = (void*)NULL;
-	return CAMERA_ERROR_NONE;		
+	return CAMERA_ERROR_NONE;
 }
 
 int camera_foreach_supported_preview_resolution(camera_h camera, camera_supported_preview_resolution_cb foreach_cb , void *user_data){
 	if( camera == NULL || foreach_cb == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
-	
+	}
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	MMCamAttrsInfo preview_width;
-	MMCamAttrsInfo preview_height;	
+	MMCamAttrsInfo preview_height;
 	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_WIDTH , &preview_width);
 	ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_HEIGHT , &preview_height);
-		
+
 	if( ret != CAMERA_ERROR_NONE )
 		return __convert_camera_error_code(__func__, ret);
-	
+
 	int i;
 	for( i=0 ; i < preview_width.int_array.count ; i++)
 	{
@@ -815,23 +1248,23 @@ int camera_foreach_supported_preview_resolution(camera_h camera, camera_supporte
 			break;
 	}
 	return CAMERA_ERROR_NONE;
-	
+
 }
 int camera_foreach_supported_capture_resolution(camera_h camera, camera_supported_capture_resolution_cb foreach_cb , void *user_data){
 	if( camera == NULL || foreach_cb == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
+	}
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	MMCamAttrsInfo capture_width;
-	MMCamAttrsInfo capture_height;	
+	MMCamAttrsInfo capture_height;
 	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAPTURE_WIDTH , &capture_width);
 	ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAPTURE_HEIGHT , &capture_height);
-		
+
 	if( ret != CAMERA_ERROR_NONE )
 		return __convert_camera_error_code(__func__, ret);
-	
+
 	int i;
 	for( i=0 ; i < capture_width.int_array.count ; i++)
 	{
@@ -846,21 +1279,22 @@ int camera_foreach_supported_capture_format(camera_h camera, camera_supported_ca
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	MMCamAttrsInfo format;
 	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAPTURE_FORMAT , &format);
 
 	if( ret != CAMERA_ERROR_NONE )
-		return __convert_camera_error_code(__func__, ret);	
-	
+		return __convert_camera_error_code(__func__, ret);
+
 	int i;
 	for( i=0 ; i < format.int_array.count ; i++)
 	{
-		if ( !foreach_cb(format.int_array.array[i], user_data) )
-			break;
-	}	
+		if( format.int_array.array[i] != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY )
+			if ( !foreach_cb(format.int_array.array[i], user_data) )
+				break;
+	}
 	return CAMERA_ERROR_NONE;
 
 }
@@ -877,25 +1311,62 @@ int camera_foreach_supported_preview_format(camera_h camera, camera_supported_pr
 	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_FORMAT , &format);
 
 	if( ret != CAMERA_ERROR_NONE )
-		return __convert_camera_error_code(__func__, ret);	
-	
+		return __convert_camera_error_code(__func__, ret);
+
 	int i;
 	for( i=0 ; i < format.int_array.count ; i++)
 	{
-		if ( !foreach_cb(format.int_array.array[i], user_data) )
-			break;
-	}	
+		if( format.int_array.array[i] != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY /* || format.int_array.array[i] != MM_PIXEL_FORMAT_ITLV_JPEG_NV12 */)
+			if ( !foreach_cb(format.int_array.array[i], user_data) )
+				break;
+	}
 	return CAMERA_ERROR_NONE;
 
 }
 
 
+int camera_get_recommended_preview_resolution(camera_h camera, int *width, int *height){
+	if( camera == NULL ){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+
+	enum MMCamcorderPreviewType wide;
+	int capture_w, capture_h;
+	double ratio;
+	int ret;
+	camera_s * handle = (camera_s*)camera;
+
+	camera_get_capture_resolution(camera, &capture_w, &capture_h);
+	ratio = (double)capture_w/(double)capture_h;
+	if( ratio > 1.5 )
+		wide = MM_CAMCORDER_PREVIEW_TYPE_WIDE;
+	else
+		wide = MM_CAMCORDER_PREVIEW_TYPE_NORMAL;
+
+	MMCamAttrsInfo width_info, height_info;
+	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_RECOMMEND_CAMERA_WIDTH , &width_info);
+	ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_RECOMMEND_CAMERA_HEIGHT, &height_info);
+	if( ret != 0 )
+		return __convert_camera_error_code(__func__, ret);
+
+	if( width )
+		*width = width_info.int_array.array[wide];
+
+	if( height )
+		*height = height_info.int_array.array[wide];
+
+	return CAMERA_ERROR_NONE;
+}
+
+
+
 int camera_attr_get_lens_orientation(camera_h camera, int *angle) {
 	if( camera == NULL || angle == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	int rotation;
@@ -914,12 +1385,32 @@ int camera_attr_get_lens_orientation(camera_h camera, int *angle) {
 		case MM_DISPLAY_ROTATION_270:
 			*angle = 90;
 			break;
-	}	
-	
-	return __convert_camera_error_code(__func__, ret);	
+	}
+
+	return __convert_camera_error_code(__func__, ret);
 }
 
+int camera_attr_set_theater_mode(camera_h camera, camera_attr_theater_mode_e mode){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	int ret;
+	camera_s * handle = (camera_s*)camera;
+	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_DISPLAY_MODE, mode, NULL);
+	return __convert_camera_error_code(__func__, ret);
+}
 
+int camera_attr_get_theater_mode(camera_h camera, camera_attr_theater_mode_e *mode){
+	if( camera == NULL || mode == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	int ret;
+	camera_s * handle = (camera_s*)camera;
+	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_DISPLAY_MODE , mode, NULL);
+	return __convert_camera_error_code(__func__, ret);
+}
 
 int camera_attr_set_preview_fps(camera_h camera,  camera_attr_fps_e fps){
 	if( camera == NULL){
@@ -928,19 +1419,29 @@ int camera_attr_set_preview_fps(camera_h camera,  camera_attr_fps_e fps){
 	}
 	int ret;
 	camera_s * handle = (camera_s*)camera;
-	
-	if( fps == CAMERA_ATTR_FPS_AUTO )
-		ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FPS_AUTO  , 1, MMCAM_CAMERA_FPS, CAMERA_ATTR_FPS_60 , NULL);	
+
+	if( fps == CAMERA_ATTR_FPS_AUTO ){
+		MMCamAttrsInfo info;
+		ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_FPS , &info);
+		int maxfps = 0;
+		int i;
+		for( i=0 ; i < info.int_array.count ; i++)
+		{
+			if ( info.int_array.array[i] > maxfps && info.int_array.array[i] <= 60 )
+				maxfps = info.int_array.array[i];
+		}
+		ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FPS_AUTO  , 1, MMCAM_CAMERA_FPS, maxfps , NULL);
+	}
 	else
 		ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FPS_AUTO  , 0, MMCAM_CAMERA_FPS  , fps, NULL);
-	
+
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 
 int camera_attr_set_image_quality(camera_h camera,  int quality){
-		
+
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
@@ -961,27 +1462,27 @@ int camera_attr_get_preview_fps(camera_h camera,  camera_attr_fps_e *fps){
 	int mm_fps;
 	int is_auto;
 	camera_s * handle = (camera_s*)camera;
-	
+
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FPS , &mm_fps, MMCAM_CAMERA_FPS_AUTO , &is_auto, NULL);
 	if( is_auto )
 		*fps = CAMERA_ATTR_FPS_AUTO;
 	else
 		*fps = mm_fps;
-	
+
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 int camera_attr_get_image_quality(camera_h camera,  int *quality){
 	if( camera == NULL || quality == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_IMAGE_ENCODER_QUALITY   , quality, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 
@@ -994,8 +1495,9 @@ int camera_attr_set_zoom(camera_h camera,  int zoom){
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_DIGITAL_ZOOM  , zoom, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
+
 int camera_attr_set_af_mode(camera_h camera,  camera_attr_af_mode_e mode){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
@@ -1003,32 +1505,72 @@ int camera_attr_set_af_mode(camera_h camera,  camera_attr_af_mode_e mode){
 	}
 	int ret = CAMERA_ERROR_INVALID_PARAMETER;
 	camera_s * handle = (camera_s*)camera;
+	int focus_mode;
+	bool should_change_focus_mode = false;
+	mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE, &focus_mode, NULL);
+	if( focus_mode != MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO && focus_mode != MM_CAMCORDER_FOCUS_MODE_CONTINUOUS && focus_mode != MM_CAMCORDER_FOCUS_MODE_AUTO )
+		should_change_focus_mode = true;
+
+	if( mode != CAMERA_ATTR_AF_NONE && should_change_focus_mode ){
+		mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_FOCUS_MODE, MM_CAMCORDER_FOCUS_MODE_AUTO, NULL);
+	}
 
 	switch(mode){
 		case CAMERA_ATTR_AF_NONE:
-			ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE     , MM_CAMCORDER_FOCUS_MODE_NONE ,
-																														MMCAM_CAMERA_AF_SCAN_RANGE  , MM_CAMCORDER_AUTO_FOCUS_NORMAL , NULL);			
+			ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_FOCUS_MODE, MM_CAMCORDER_FOCUS_MODE_NONE,
+																														MMCAM_CAMERA_AF_SCAN_RANGE  , MM_CAMCORDER_AUTO_FOCUS_NORMAL, NULL);
 			break;
 		case CAMERA_ATTR_AF_NORMAL:
-			ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE  , MM_CAMCORDER_FOCUS_MODE_AUTO ,
-																														MMCAM_CAMERA_AF_SCAN_RANGE  , MM_CAMCORDER_AUTO_FOCUS_NORMAL , NULL);
+			ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_AF_SCAN_RANGE  , MM_CAMCORDER_AUTO_FOCUS_NORMAL, NULL);
 			break;
 		case CAMERA_ATTR_AF_MACRO:
-			ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE  , MM_CAMCORDER_FOCUS_MODE_AUTO ,
-																														MMCAM_CAMERA_AF_SCAN_RANGE  , MM_CAMCORDER_AUTO_FOCUS_MACRO  , NULL);						
+			ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_AF_SCAN_RANGE  , MM_CAMCORDER_AUTO_FOCUS_MACRO, NULL);
 			break;
 		case CAMERA_ATTR_AF_FULL:
-			ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE  , MM_CAMCORDER_FOCUS_MODE_AUTO ,
-																														MMCAM_CAMERA_AF_SCAN_RANGE  , MM_CAMCORDER_AUTO_FOCUS_FULL  , NULL);						
+			ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_AF_SCAN_RANGE  , MM_CAMCORDER_AUTO_FOCUS_FULL, NULL);
 			break;
-			
 		default:
 			return ret;
 	}
-	
+
 	return __convert_camera_error_code(__func__, ret);
 }
 
+int camera_attr_set_af_area(camera_h camera, int x, int y){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	int ret = CAMERA_ERROR_INVALID_PARAMETER;
+	camera_s * handle = (camera_s*)camera;
+	camera_attr_af_mode_e mode;
+	camera_attr_get_af_mode(camera, &mode);
+	if( mode == CAMERA_ATTR_AF_NONE ){
+		LOGE( "[%s] INVALID_OPERATION(0x%08x) AF mode is CAMERA_ATTR_AF_NONE",__func__,CAMERA_ERROR_INVALID_OPERATION);
+		return CAMERA_ERROR_INVALID_OPERATION;
+	}
+	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_AF_TOUCH_X, x,
+                                                                                                  MMCAM_CAMERA_AF_TOUCH_Y, y,
+																												NULL);
+	if( ret == 0 )
+		handle->focus_area_valid = true;
+	return __convert_camera_error_code(__func__, ret);
+}
+
+int camera_attr_clear_af_area(camera_h camera){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__, CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	camera_s * handle = (camera_s*)camera;
+	if( !handle->focus_area_valid ){
+		LOGE( "[%s] INVALID_OPERATION(0x%08x) AF area was not set",__func__,CAMERA_ERROR_INVALID_OPERATION);
+		return CAMERA_ERROR_INVALID_OPERATION;
+	}
+	handle->focus_area_valid = false;
+	return 0;
+}
+
 int camera_attr_set_exposure_mode(camera_h camera,  camera_attr_exposure_mode_e mode){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
@@ -1040,7 +1582,7 @@ int camera_attr_set_exposure_mode(camera_h camera,  camera_attr_exposure_mode_e
 									MM_CAMCORDER_AUTO_EXPOSURE_SPOT_1, //CAMCORDER_EXPOSURE_MODE_SPOT
 									MM_CAMCORDER_AUTO_EXPOSURE_CUSTOM_1,//CAMCORDER_EXPOSURE_MODE_CUSTOM
 		};
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_EXPOSURE_MODE  , maptable[abs(mode%5)], NULL);
@@ -1058,7 +1600,7 @@ int camera_attr_set_exposure(camera_h camera, int value){
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_EXPOSURE_VALUE  , value, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_set_iso(camera_h camera,  camera_attr_iso_e iso){
@@ -1069,7 +1611,7 @@ int camera_attr_set_iso(camera_h camera,  camera_attr_iso_e iso){
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_ISO  , iso, NULL);
-	return __convert_camera_error_code(__func__, ret);	
+	return __convert_camera_error_code(__func__, ret);
 }
 int camera_attr_set_brightness(camera_h camera,  int level){
 	if( camera == NULL){
@@ -1077,11 +1619,11 @@ int camera_attr_set_brightness(camera_h camera,  int level){
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
 	int ret;
-		
+
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_BRIGHTNESS  , level, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_set_contrast(camera_h camera,  int level){
@@ -1090,12 +1632,12 @@ int camera_attr_set_contrast(camera_h camera,  int level){
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
 	int ret;
-	
+
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_CONTRAST  , level, NULL);
 
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 int camera_attr_set_whitebalance(camera_h camera,  camera_attr_whitebalance_e wb){
 	if( camera == NULL){
@@ -1106,7 +1648,7 @@ int camera_attr_set_whitebalance(camera_h camera,  camera_attr_whitebalance_e wb
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_WB  , wb, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_set_effect(camera_h camera, camera_attr_effect_mode_e effect){
@@ -1134,7 +1676,7 @@ int camera_attr_set_effect(camera_h camera, camera_attr_effect_mode_e effect){
 		MM_CAMCORDER_COLOR_TONE_EMBOSS, //CAMCORDER_EFFECT_EMBOSS,			/**< Emboss */
 		MM_CAMCORDER_COLOR_TONE_OUTLINE, //CAMCORDER_EFFECT_OUTLINE,		/**< Outline */
 		MM_CAMCORDER_COLOR_TONE_SOLARIZATION_1, //CAMCORDER_EFFECT_SOLARIZATION,	/**< Solarization1 */
-		MM_CAMCORDER_COLOR_TONE_SKETCH_1, //CAMCORDER_EFFECT_SKETCH,		/**< Sketch1 */	
+		MM_CAMCORDER_COLOR_TONE_SKETCH_1, //CAMCORDER_EFFECT_SKETCH,		/**< Sketch1 */
 	};
 	int ret;
 	camera_s * handle = (camera_s*)camera;
@@ -1150,7 +1692,7 @@ int camera_attr_set_scene_mode(camera_h camera,  camera_attr_scene_mode_e mode){
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_SCENE_MODE  , mode, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 
@@ -1163,7 +1705,7 @@ int camera_attr_enable_tag(camera_h camera,  bool enable){
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_ENABLE  , enable, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_set_tag_image_description(camera_h camera,  const char *description){
@@ -1175,7 +1717,7 @@ int camera_attr_set_tag_image_description(camera_h camera,  const char *descript
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_IMAGE_DESCRIPTION    , description, strlen(description), NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_set_tag_orientation(camera_h camera,  camera_attr_tag_orientation_e orientation){
@@ -1187,7 +1729,7 @@ int camera_attr_set_tag_orientation(camera_h camera,  camera_attr_tag_orientatio
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_ORIENTATION  , orientation, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_set_tag_software(camera_h camera,  const char *software){
@@ -1199,44 +1741,35 @@ int camera_attr_set_tag_software(camera_h camera,  const char *software){
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_SOFTWARE   , software, strlen(software), NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
-}
 
-int camera_attr_set_tag_latitude(camera_h camera,  double latitude){
-	if( camera == NULL){
-		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
-		return CAMERA_ERROR_INVALID_PARAMETER;
-	}
-	int ret;
-	camera_s * handle = (camera_s*)camera;
-	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_LATITUDE  , latitude, NULL);
-	return __convert_camera_error_code(__func__, ret);
-	
 }
 
-int camera_attr_set_tag_longitude(camera_h camera,  double longtitude){
+int camera_attr_set_geotag(camera_h camera, double latitude , double longitude, double altitude){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
 	int ret;
 	camera_s * handle = (camera_s*)camera;
-	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_LONGITUDE  , longtitude, NULL);
+	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_GPS_ENABLE, 1,
+                                                                                                  MMCAM_TAG_LATITUDE, latitude,
+                                                                                                  MMCAM_TAG_LONGITUDE, longitude,
+                                                                                                  MMCAM_TAG_ALTITUDE, altitude,
+                                                                                                  NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
 }
 
-int camera_attr_set_tag_altitude(camera_h camera,  double altitude){
+int camera_attr_remove_geotag(camera_h camera){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
 	int ret;
 	camera_s * handle = (camera_s*)camera;
-	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_ALTITUDE  , altitude, NULL);
+	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_GPS_ENABLE, 0, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
 }
+
 int camera_attr_set_flash_mode(camera_h camera,  camera_attr_flash_mode_e mode){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
@@ -1245,7 +1778,7 @@ int camera_attr_set_flash_mode(camera_h camera,  camera_attr_flash_mode_e mode){
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_STROBE_MODE  , mode, NULL);
-	return __convert_camera_error_code(__func__, ret);	
+	return __convert_camera_error_code(__func__, ret);
 }
 
 
@@ -1253,20 +1786,20 @@ int camera_attr_get_zoom(camera_h camera,  int *zoom){
 	if( camera == NULL || zoom == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
-	
+	}
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_DIGITAL_ZOOM , zoom, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_get_zoom_range(camera_h camera , int *min , int *max){
 	if( camera == NULL || min == NULL || max == NULL ){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
+	}
 
 	int ret;
 	camera_s * handle = (camera_s*)camera;
@@ -1276,8 +1809,8 @@ int camera_attr_get_zoom_range(camera_h camera , int *min , int *max){
 		*min = ainfo.int_range.min;
 	if( max )
 		*max = ainfo.int_range.max;
-	
-	return __convert_camera_error_code(__func__, ret);	
+
+	return __convert_camera_error_code(__func__, ret);
 }
 
 
@@ -1286,7 +1819,7 @@ int camera_attr_get_af_mode( camera_h camera,  camera_attr_af_mode_e *mode){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	int focus_mode;
 	int af_range;
@@ -1301,13 +1834,14 @@ int camera_attr_get_af_mode( camera_h camera,  camera_attr_af_mode_e *mode){
 				*mode = CAMERA_ATTR_AF_NONE;
 				break;
 			case MM_CAMCORDER_FOCUS_MODE_AUTO:
+			case MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO:
+			case MM_CAMCORDER_FOCUS_MODE_CONTINUOUS:
 				switch ( af_range ){
 					case MM_CAMCORDER_AUTO_FOCUS_NONE :
-						*mode = CAMERA_ATTR_AF_NONE;
+						*mode = CAMERA_ATTR_AF_NORMAL;
 						break;
 					case MM_CAMCORDER_AUTO_FOCUS_NORMAL:
 						*mode = CAMERA_ATTR_AF_NORMAL;
-						
 						break;
 					case MM_CAMCORDER_AUTO_FOCUS_MACRO:
 						*mode = CAMERA_ATTR_AF_MACRO;
@@ -1317,13 +1851,10 @@ int camera_attr_get_af_mode( camera_h camera,  camera_attr_af_mode_e *mode){
 						break;
 				}
 				break;
-			case MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO:
-				*mode = CAMERA_ATTR_AF_NORMAL;
-				break;
 		}
-		
+
 	}
-	return __convert_camera_error_code(__func__, ret);	
+	return __convert_camera_error_code(__func__, ret);
 }
 
 int camera_attr_get_exposure_mode( camera_h camera,  camera_attr_exposure_mode_e *mode){
@@ -1331,7 +1862,7 @@ int camera_attr_get_exposure_mode( camera_h camera,  camera_attr_exposure_mode_e
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int maptable[] = {
 			CAMERA_ATTR_EXPOSURE_MODE_OFF,  //MM_CAMCORDER_AUTO_EXPOSURE_OFF
 			CAMERA_ATTR_EXPOSURE_MODE_ALL,  //MM_CAMCORDER_AUTO_EXPOSURE_ALL
@@ -1351,7 +1882,7 @@ int camera_attr_get_exposure_mode( camera_h camera,  camera_attr_exposure_mode_e
 		*mode = maptable[abs(exposure_mode%9)];
 	}
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_get_exposure(camera_h camera, int *value){
@@ -1359,11 +1890,11 @@ int camera_attr_get_exposure(camera_h camera, int *value){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_EXPOSURE_VALUE , value, NULL);
-	return __convert_camera_error_code(__func__, ret);	
+	return __convert_camera_error_code(__func__, ret);
 }
 
 
@@ -1371,7 +1902,7 @@ int camera_attr_get_exposure_range(camera_h camera, int *min, int *max){
 	if( camera == NULL || min == NULL || max == NULL ){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
+	}
 
 	int ret;
 	camera_s * handle = (camera_s*)camera;
@@ -1381,7 +1912,7 @@ int camera_attr_get_exposure_range(camera_h camera, int *min, int *max){
 		*min = ainfo.int_range.min;
 	if( max )
 		*max = ainfo.int_range.max;
-	
+
 	return __convert_camera_error_code(__func__, ret);
 }
 
@@ -1391,12 +1922,12 @@ int camera_attr_get_iso( camera_h camera,  camera_attr_iso_e *iso){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_ISO , iso, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_get_brightness(camera_h camera,  int *level){
@@ -1408,14 +1939,14 @@ int camera_attr_get_brightness(camera_h camera,  int *level){
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_BRIGHTNESS , level, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_get_brightness_range(camera_h camera, int *min, int *max){
 	if( camera == NULL || min == NULL || max == NULL ){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
+	}
 
 	int ret;
 	camera_s * handle = (camera_s*)camera;
@@ -1425,8 +1956,8 @@ int camera_attr_get_brightness_range(camera_h camera, int *min, int *max){
 		*min = ainfo.int_range.min;
 	if( max )
 		*max = ainfo.int_range.max;
-	
-	return __convert_camera_error_code(__func__, ret);	
+
+	return __convert_camera_error_code(__func__, ret);
 }
 
 
@@ -1435,8 +1966,8 @@ int camera_attr_get_contrast(camera_h camera,  int *level){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
-	
+
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_CONTRAST , level, NULL);
@@ -1447,7 +1978,7 @@ int camera_attr_get_contrast_range(camera_h camera, int *min , int *max){
 	if( camera == NULL || min == NULL || max == NULL ){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
+	}
 
 	int ret;
 	camera_s * handle = (camera_s*)camera;
@@ -1457,8 +1988,8 @@ int camera_attr_get_contrast_range(camera_h camera, int *min , int *max){
 		*min = ainfo.int_range.min;
 	if( max )
 		*max = ainfo.int_range.max;
-	
-	return __convert_camera_error_code(__func__, ret);		
+
+	return __convert_camera_error_code(__func__, ret);
 }
 
 
@@ -1467,21 +1998,21 @@ int camera_attr_get_whitebalance(camera_h camera,  camera_attr_whitebalance_e *w
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_WB , wb, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_get_effect(camera_h camera, camera_attr_effect_mode_e *effect){
-		
+
 	if( camera == NULL || effect == NULL ){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	int tone;
@@ -1511,7 +2042,7 @@ int camera_attr_get_effect(camera_h camera, camera_attr_effect_mode_e *effect){
 		case MM_CAMCORDER_COLOR_TONE_OUTLINE:
 		case MM_CAMCORDER_COLOR_TONE_SOLARIZATION_1:
 			*effect = tone;
-			break;			
+			break;
 		case MM_CAMCORDER_COLOR_TONE_SOLARIZATION_2:
 		case MM_CAMCORDER_COLOR_TONE_SOLARIZATION_3:
 		case MM_CAMCORDER_COLOR_TONE_SOLARIZATION_4:
@@ -1525,21 +2056,20 @@ int camera_attr_get_effect(camera_h camera, camera_attr_effect_mode_e *effect){
 			break;
 	}
 
-	return __convert_camera_error_code(__func__, ret);	
+	return __convert_camera_error_code(__func__, ret);
 }
 
 int camera_attr_get_scene_mode(camera_h camera,  camera_attr_scene_mode_e *mode){
-		
 	if( camera == NULL || mode == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_SCENE_MODE , mode, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 
@@ -1548,14 +2078,14 @@ int camera_attr_is_enabled_tag(camera_h camera,  bool *enable){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TAG_ENABLE , enable, NULL);
 
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_get_tag_image_description(camera_h camera,  char **description){
@@ -1563,7 +2093,7 @@ int camera_attr_get_tag_image_description(camera_h camera,  char **description){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	char *ndescription = NULL;
@@ -1575,30 +2105,30 @@ int camera_attr_get_tag_image_description(camera_h camera,  char **description){
 		else
 			*description = strdup("");
 	}
-	
+
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 
 int camera_attr_get_tag_orientation(camera_h camera,  camera_attr_tag_orientation_e *orientation){
-		
+
 	if( camera == NULL || orientation == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TAG_ORIENTATION , orientation, NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
+
 }
 int camera_attr_get_tag_software(camera_h camera,  char **software){
 	if( camera == NULL || software == NULL ){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	char *soft;
@@ -1610,53 +2140,29 @@ int camera_attr_get_tag_software(camera_h camera,  char **software){
 		else
 			*software = strdup("");
 	}
-	
 	return __convert_camera_error_code(__func__, ret);
-	
 }
 
-int camera_attr_get_tag_latitude(camera_h camera,  double *latitude){
-	if( camera == NULL || latitude == NULL){
+int camera_attr_get_geotag(camera_h camera, double *latitude , double *longitude, double *altitude){
+	if( camera == NULL || latitude == NULL || longitude == NULL || altitude == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
 	int ret;
 	camera_s * handle = (camera_s*)camera;
-	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TAG_LATITUDE , latitude, NULL);
+	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TAG_LATITUDE , latitude,
+                                                                                                  MMCAM_TAG_LONGITUDE, longitude,
+                                                                                                  MMCAM_TAG_ALTITUDE, altitude,
+                                                                                                  NULL);
 	return __convert_camera_error_code(__func__, ret);
-	
 }
 
-int camera_attr_get_tag_longitude(camera_h camera,  double *longtitude){
-	if( camera == NULL || longtitude == NULL){
-		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
-		return CAMERA_ERROR_INVALID_PARAMETER;
-	}
-	
-	int ret;
-	camera_s * handle = (camera_s*)camera;
-	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TAG_LONGITUDE  , longtitude, NULL);
-	return __convert_camera_error_code(__func__, ret);
-}
-
-int camera_attr_get_tag_altitude(camera_h camera,  double *altitude){
-	if( camera == NULL || altitude == NULL){
-		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
-		return CAMERA_ERROR_INVALID_PARAMETER;
-	}
-	
-	int ret;
-	camera_s * handle = (camera_s*)camera;
-	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TAG_ALTITUDE  , altitude, NULL);
-	return __convert_camera_error_code(__func__, ret);
-}
 int camera_attr_get_flash_mode(camera_h camera,  camera_attr_flash_mode_e *mode){
 	if( camera == NULL || mode == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_STROBE_MODE , mode, NULL);
@@ -1668,17 +2174,17 @@ int camera_attr_foreach_supported_af_mode( camera_h camera, camera_attr_supporte
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
-	
+
+
 	int ret;
 	int i;
 	camera_s * handle = (camera_s*)camera;
 	MMCamAttrsInfo af_range;
-	MMCamAttrsInfo focus_mode;	
-	
+	MMCamAttrsInfo focus_mode;
+
 	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_AF_SCAN_RANGE , &af_range);
-	ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_FOCUS_MODE , &focus_mode);	
-	
+	ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_FOCUS_MODE , &focus_mode);
+
 	if( ret != CAMERA_ERROR_NONE )
 		return __convert_camera_error_code(__func__, ret);
 
@@ -1688,11 +2194,10 @@ int camera_attr_foreach_supported_af_mode( camera_h camera, camera_attr_supporte
 			goto ENDCALLBACK;
 	}
 
-	
 	ENDCALLBACK:
 
 	return CAMERA_ERROR_NONE;
-	
+
 }
 
 int camera_attr_foreach_supported_exposure_mode(camera_h camera, camera_attr_supported_exposure_mode_cb foreach_cb , void *user_data){
@@ -1700,7 +2205,7 @@ int camera_attr_foreach_supported_exposure_mode(camera_h camera, camera_attr_sup
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int maptable[] = {
 			CAMERA_ATTR_EXPOSURE_MODE_OFF,  //MM_CAMCORDER_AUTO_EXPOSURE_OFF
 			CAMERA_ATTR_EXPOSURE_MODE_ALL,  //MM_CAMCORDER_AUTO_EXPOSURE_ALL
@@ -1718,7 +2223,7 @@ int camera_attr_foreach_supported_exposure_mode(camera_h camera, camera_attr_sup
 	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_EXPOSURE_MODE , &info);
 	if( ret != CAMERA_ERROR_NONE )
 		return __convert_camera_error_code(__func__, ret);
-	
+
 	int i;
 	for( i=0 ; i < info.int_array.count ; i++)
 	{
@@ -1728,56 +2233,56 @@ int camera_attr_foreach_supported_exposure_mode(camera_h camera, camera_attr_sup
 		}
 	}
 	return CAMERA_ERROR_NONE;
-	
+
 }
 int camera_attr_foreach_supported_iso( camera_h camera, camera_attr_supported_iso_cb foreach_cb , void *user_data){
 	if( camera == NULL || foreach_cb == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
+	}
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	MMCamAttrsInfo info;
 	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_ISO , &info);
 	if( ret != CAMERA_ERROR_NONE )
 		return __convert_camera_error_code(__func__, ret);
-	
+
 	int i;
 	for( i=0 ; i < info.int_array.count ; i++)
 	{
 		if ( !foreach_cb(info.int_array.array[i],user_data) )
 			break;
 	}
-	return CAMERA_ERROR_NONE;	
-	
+	return CAMERA_ERROR_NONE;
+
 }
 
 int camera_attr_foreach_supported_whitebalance(camera_h camera, camera_attr_supported_whitebalance_cb foreach_cb , void *user_data){
 	if( camera == NULL || foreach_cb == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
+	}
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	MMCamAttrsInfo info;
 	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_FILTER_WB , &info);
 	if( ret != CAMERA_ERROR_NONE )
 		return __convert_camera_error_code(__func__, ret);
-	
+
 	int i;
 	for( i=0 ; i < info.int_array.count ; i++)
 	{
 		if ( !foreach_cb(info.int_array.array[i],user_data)  )
 			break;
 	}
-	return CAMERA_ERROR_NONE;	
-	
+	return CAMERA_ERROR_NONE;
+
 }
 int camera_attr_foreach_supported_effect(camera_h camera, camera_attr_supported_effect_cb foreach_cb , void *user_data){
 	if( camera == NULL || foreach_cb == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}		
+	}
 	int maptable[] = {
 		CAMERA_ATTR_EFFECT_NONE, //MM_CAMCORDER_COLOR_TONE_NONE
 		CAMERA_ATTR_EFFECT_MONO, //MM_CAMCORDER_COLOR_TONE_MONO,
@@ -1801,7 +2306,7 @@ int camera_attr_foreach_supported_effect(camera_h camera, camera_attr_supported_
 		-1, //MM_CAMCORDER_COLOR_TONE_SOLARIZATION_2
 		-1 , //MM_CAMCORDER_COLOR_TONE_SOLARIZATION_3
 		-1, //MM_CAMCORDER_COLOR_TONE_SOLARIZATION_4
-		CAMERA_ATTR_EFFECT_SKETCH ,  //	MM_CAMCORDER_COLOR_TONE_SKETCH_1,/**< Sketch1 */	
+		CAMERA_ATTR_EFFECT_SKETCH ,  //	MM_CAMCORDER_COLOR_TONE_SKETCH_1,/**< Sketch1 */
 		-1, //MM_CAMCORDER_COLOR_TONE_SKETCH_2
 		-1, //MM_CAMCORDER_COLOR_TONE_SKETCH_3
 		-1 //MM_CAMCORDER_COLOR_TONE_SKETCH_4
@@ -1813,7 +2318,7 @@ int camera_attr_foreach_supported_effect(camera_h camera, camera_attr_supported_
 	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_FILTER_COLOR_TONE , &info);
 	if( ret != CAMERA_ERROR_NONE )
 		return __convert_camera_error_code(__func__, ret);
-	
+
 	int i;
 	for( i=0 ; i < info.int_array.count ; i++)
 	{
@@ -1822,29 +2327,29 @@ int camera_attr_foreach_supported_effect(camera_h camera, camera_attr_supported_
 				break;
 		}
 	}
-	return CAMERA_ERROR_NONE;	
-	
+	return CAMERA_ERROR_NONE;
+
 }
 int camera_attr_foreach_supported_scene_mode(camera_h camera, camera_attr_supported_scene_mode_cb foreach_cb , void *user_data){
 	if( camera == NULL || foreach_cb == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
 	}
-	
+
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	MMCamAttrsInfo info;
 	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_FILTER_SCENE_MODE  , &info);
 	if( ret != CAMERA_ERROR_NONE )
 		return __convert_camera_error_code(__func__, ret);
-	
+
 	int i;
 	for( i=0 ; i < info.int_array.count ; i++)
 	{
 		if ( !foreach_cb(info.int_array.array[i],user_data) )
 			break;
 	}
-	return CAMERA_ERROR_NONE;	
+	return CAMERA_ERROR_NONE;
 
 }
 
@@ -1859,28 +2364,28 @@ int camera_attr_foreach_supported_flash_mode(camera_h camera, camera_attr_suppor
 	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_STROBE_MODE  , &info);
 	if( ret != CAMERA_ERROR_NONE )
 		return __convert_camera_error_code(__func__, ret);
-	
+
 	int i;
 	for( i=0 ; i < info.int_array.count ; i++)
 	{
 		if ( !foreach_cb(info.int_array.array[i],user_data) )
 			break;
 	}
-	return CAMERA_ERROR_NONE;	
-	
+	return CAMERA_ERROR_NONE;
+
 }
 int camera_attr_foreach_supported_fps(camera_h camera, camera_attr_supported_fps_cb foreach_cb , void *user_data){
 	if( camera == NULL || foreach_cb == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
+	}
 	int ret;
 	camera_s * handle = (camera_s*)camera;
 	MMCamAttrsInfo info;
 	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_FPS , &info);
 	if( ret != CAMERA_ERROR_NONE )
 		return __convert_camera_error_code(__func__, ret);
-	
+
 	int i;
 	//if (foreach_cb(CAMERA_ATTR_FPS_AUTO, user_data) < 0 )
 	//	return CAMERA_ERROR_NONE;
@@ -1891,14 +2396,13 @@ int camera_attr_foreach_supported_fps(camera_h camera, camera_attr_supported_fps
 	}
 	return CAMERA_ERROR_NONE;
 
-	
 }
 
 int camera_attr_set_stream_rotation(camera_h camera , camera_rotation_e rotation){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
+	}
 
 	if( rotation < CAMERA_ROTATION_NONE || rotation > CAMERA_ROTATION_270 )
 		return CAMERA_ERROR_INVALID_PARAMETER;
@@ -1920,14 +2424,14 @@ int camera_attr_get_stream_rotation(camera_h camera , camera_rotation_e *rotatio
 	camera_s * handle = (camera_s*)camera;
 
 	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_ROTATION , rotation, NULL);
-	return __convert_camera_error_code(__func__, ret);	
+	return __convert_camera_error_code(__func__, ret);
 }
 
 int camera_attr_set_stream_flip(camera_h camera , camera_flip_e flip){
 	if( camera == NULL){
 		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
 		return CAMERA_ERROR_INVALID_PARAMETER;
-	}	
+	}
 
 	if( flip < CAMERA_FLIP_NONE || flip > CAMERA_FLIP_BOTH )
 		return CAMERA_ERROR_INVALID_PARAMETER;
@@ -1938,8 +2442,8 @@ int camera_attr_set_stream_flip(camera_h camera , camera_flip_e flip){
 	int hflip = 0;
 	vflip = (flip & CAMERA_FLIP_VERTICAL) == CAMERA_FLIP_VERTICAL;
 	hflip = (flip & CAMERA_FLIP_HORIZONTAL) == CAMERA_FLIP_HORIZONTAL;
-	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, "" , hflip  , "" , vflip , NULL);
-	return __convert_camera_error_code(__func__, ret);	
+	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FLIP_HORIZONTAL , hflip  , MMCAM_CAMERA_FLIP_VERTICAL, vflip , NULL);
+	return __convert_camera_error_code(__func__, ret);
 }
 
 int camera_attr_get_stream_flip(camera_h camera , camera_flip_e *flip){
@@ -1954,7 +2458,7 @@ int camera_attr_get_stream_flip(camera_h camera , camera_flip_e *flip){
 	int hflip = 0;
 	int result = 0;
 	char *error;
-	ret = mm_camcorder_get_attributes(handle->mm_handle ,&error, "" , &hflip  , "" , &vflip , NULL);
+	ret = mm_camcorder_get_attributes(handle->mm_handle ,&error, MMCAM_CAMERA_FLIP_HORIZONTAL , &hflip  , MMCAM_CAMERA_FLIP_VERTICAL, &vflip , NULL);
 
 	if( ret == 0){
 		if( vflip)
@@ -1963,6 +2467,209 @@ int camera_attr_get_stream_flip(camera_h camera , camera_flip_e *flip){
 			result = result | CAMERA_FLIP_HORIZONTAL;
 		*flip = result;
 	}
-	return __convert_camera_error_code(__func__, ret);	
+	return __convert_camera_error_code(__func__, ret);
+
+}
+
 
+int _camera_get_mm_handle(camera_h camera , MMHandleType *handle){
+	if( camera == NULL || handle == NULL ){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	camera_s *camera_handle = (camera_s*)camera;
+	*handle =  camera_handle->mm_handle;
+	return CAMERA_ERROR_NONE;
+}
+
+int _camera_set_relay_mm_message_callback(camera_h camera, MMMessageCallback callback, void *user_data){
+	if( camera == NULL ){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+
+	camera_s *handle = (camera_s*)camera;
+	handle->relay_message_callback = callback;
+	handle->relay_user_data = user_data;
+
+	return CAMERA_ERROR_NONE;
+}
+
+int camera_attr_set_hdr_mode(camera_h camera, camera_attr_hdr_mode_e mode){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	int ret;
+	camera_s * handle = (camera_s*)camera;
+	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_HDR_CAPTURE , mode, NULL);
+	if( ret == 0 ){
+		if( mode == CAMERA_ATTR_HDR_MODE_KEEP_ORIGINAL )
+			handle->hdr_keep_mode = true;
+		else
+			handle->hdr_keep_mode = false;
+	}
+	return __convert_camera_error_code(__func__, ret);
+}
+
+int camera_attr_get_hdr_mode(camera_h camera, camera_attr_hdr_mode_e *mode){
+	if( camera == NULL || mode == NULL ){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	int ret;
+	int result;
+	camera_s * handle = (camera_s*)camera;
+	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_HDR_CAPTURE , &result, NULL);
+	if( ret == 0 ){
+		*mode = result;
+	}
+	return __convert_camera_error_code(__func__, ret);
+}
+
+
+int camera_attr_enable_hdr_capture(camera_h camera, bool enable){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	int ret;
+	camera_s * handle = (camera_s*)camera;
+	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_HDR_CAPTURE , enable, NULL);
+	return __convert_camera_error_code(__func__, ret);
+}
+
+int camera_attr_is_enabled_hdr_capture(camera_h camera, bool *enabled){
+	if( camera == NULL || enabled == NULL ){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	int ret;
+	int result;
+	camera_s * handle = (camera_s*)camera;
+	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_HDR_CAPTURE , &result, NULL);
+	if( ret == 0 ){
+		if( result >= MM_CAMCORDER_HDR_ON )
+			*enabled = true;
+		else
+			*enabled = false;
+	}
+	return __convert_camera_error_code(__func__, ret);
+}
+
+bool camera_attr_is_supported_hdr_capture(camera_h camera){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return false;
+	}
+	int ret;
+	int i;
+	camera_s * handle = (camera_s*)camera;
+	MMCamAttrsInfo hdr_info;
+	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_HDR_CAPTURE , &hdr_info);
+	for (i = 0; i < hdr_info.int_array.count ; i++) {
+		if (hdr_info.int_array.array[i] >= MM_CAMCORDER_HDR_ON) {
+			return true;
+		}
+	}
+	return false;
+}
+
+int camera_attr_set_hdr_capture_progress_cb(camera_h camera, camera_attr_hdr_progress_cb callback, void* user_data){
+	if( camera == NULL || callback == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+
+	camera_s * handle = (camera_s*)camera;
+	handle->user_cb[_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void*)callback;
+	handle->user_data[_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void*)user_data;
+	return CAMERA_ERROR_NONE;
+}
+
+int camera_attr_unset_hdr_capture_progress_cb(camera_h camera){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	camera_s * handle = (camera_s*)camera;
+	handle->user_cb[_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void*)NULL;
+	handle->user_data[_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void*)NULL;
+	return CAMERA_ERROR_NONE;
+}
+
+int camera_attr_enable_anti_shake(camera_h camera, bool enable){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	int ret;
+	int mode = MM_CAMCORDER_AHS_OFF;
+	if( enable )
+		mode = MM_CAMCORDER_AHS_ON;
+
+	camera_s * handle = (camera_s*)camera;
+	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_ANTI_HANDSHAKE , mode, NULL);
+	return __convert_camera_error_code(__func__, ret);
+}
+
+int camera_attr_is_enabled_anti_shake(camera_h camera , bool *enabled){
+	if( camera == NULL || enabled == NULL ){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	int ret;
+	int mode = MM_CAMCORDER_AHS_OFF;
+	camera_s * handle = (camera_s*)camera;
+	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_ANTI_HANDSHAKE , &mode, NULL);
+	if( ret == 0 )
+		*enabled = mode;
+	return __convert_camera_error_code(__func__, ret);
+}
+
+bool camera_attr_is_supported_anti_shake(camera_h camera){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return false;
+	}
+	int i;
+	camera_s * handle = (camera_s*)camera;
+	MMCamAttrsInfo ash_info;
+	mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_ANTI_HANDSHAKE , &ash_info);
+
+	for( i=0 ; i < ash_info.int_array.count ; i++)
+	{
+		if ( ash_info.int_array.array[i] == MM_CAMCORDER_AHS_ON)
+			return true;
+	}
+	return false;
+}
+
+int camera_attr_enable_auto_contrast(camera_h camera, bool enable){
+	if( camera == NULL){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	int ret;
+	int mode = MM_CAMCORDER_WDR_OFF;
+	if( enable )
+		mode = MM_CAMCORDER_WDR_ON;
+
+	camera_s * handle = (camera_s*)camera;
+	ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL,  MMCAM_CAMERA_WDR  , mode, NULL);
+	return __convert_camera_error_code(__func__, ret);
+}
+
+int camera_attr_is_enabled_auto_contrast(camera_h camera, bool *enabled){
+	if( camera == NULL || enabled == NULL ){
+		LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+		return CAMERA_ERROR_INVALID_PARAMETER;
+	}
+	int ret;
+	int mode = MM_CAMCORDER_WDR_OFF;
+	camera_s * handle = (camera_s*)camera;
+	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_WDR , &mode, NULL);
+	if( ret == 0 )
+		*enabled = mode;
+	return __convert_camera_error_code(__func__, ret);
 }
diff --git a/tags b/tags
new file mode 100644
index 0000000..02a84e5
--- /dev/null
+++ b/tags
@@ -0,0 +1,652 @@
+!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_PROGRAM_AUTHOR	Darren Hiebert	/dhiebert@users.sourceforge.net/
+!_TAG_PROGRAM_NAME	Exuberant Ctags	//
+!_TAG_PROGRAM_URL	http://ctags.sourceforge.net	/official site/
+!_TAG_PROGRAM_VERSION	5.8	//
+-dbg-package	debian/rules	/^	dh_strip --dbg-package=capi-media-camera-dbg$/;"	m
+-sourcedir	debian/rules	/^	dh_install --sourcedir=debian\/tmp$/;"	m
+CAMERA_ATTR_AF_FULL	include/camera.h	/^    CAMERA_ATTR_AF_FULL,        \/**< auto-focus in full mode(all range scan, limited by dev spec) *\/$/;"	e	enum:__anon17
+CAMERA_ATTR_AF_MACRO	include/camera.h	/^    CAMERA_ATTR_AF_MACRO,       \/**< auto-focus in macro mode(close distance)  *\/$/;"	e	enum:__anon17
+CAMERA_ATTR_AF_NONE	include/camera.h	/^    CAMERA_ATTR_AF_NONE = 0,    \/**< auto-focus is not set *\/$/;"	e	enum:__anon17
+CAMERA_ATTR_AF_NORMAL	include/camera.h	/^    CAMERA_ATTR_AF_NORMAL,      \/**< auto-focus normally  *\/$/;"	e	enum:__anon17
+CAMERA_ATTR_EFFECT_ANTIQUE	include/camera.h	/^    CAMERA_ATTR_EFFECT_ANTIQUE,      \/**< Antique *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_AQUA	include/camera.h	/^    CAMERA_ATTR_EFFECT_AQUA,         \/**< Aqua *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_BLUE	include/camera.h	/^    CAMERA_ATTR_EFFECT_BLUE,         \/**< Blue *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_EMBOSS	include/camera.h	/^    CAMERA_ATTR_EFFECT_EMBOSS,       \/**< Emboss *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_GRAY	include/camera.h	/^    CAMERA_ATTR_EFFECT_GRAY,         \/**< Gray *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_GREEN	include/camera.h	/^    CAMERA_ATTR_EFFECT_GREEN,        \/**< Green *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_MONO	include/camera.h	/^    CAMERA_ATTR_EFFECT_MONO,         \/**< Mono *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_NEGATIVE	include/camera.h	/^    CAMERA_ATTR_EFFECT_NEGATIVE,     \/**< Negative *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_NONE	include/camera.h	/^    CAMERA_ATTR_EFFECT_NONE = 0,     \/**< None *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_ORANGE	include/camera.h	/^    CAMERA_ATTR_EFFECT_ORANGE,       \/**< Orange *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_OUTLINE	include/camera.h	/^    CAMERA_ATTR_EFFECT_OUTLINE,      \/**< Outline *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_PINK	include/camera.h	/^    CAMERA_ATTR_EFFECT_PINK,         \/**< Pink *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_PURPLE	include/camera.h	/^    CAMERA_ATTR_EFFECT_PURPLE,       \/**< Purple *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_RED	include/camera.h	/^    CAMERA_ATTR_EFFECT_RED,          \/**< Red *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_SEPIA	include/camera.h	/^    CAMERA_ATTR_EFFECT_SEPIA,        \/**< Sepia *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_SKETCH	include/camera.h	/^    CAMERA_ATTR_EFFECT_SKETCH,       \/**< Sketch *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_SOLARIZATION	include/camera.h	/^    CAMERA_ATTR_EFFECT_SOLARIZATION, \/**< Solarization *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_VIOLET	include/camera.h	/^    CAMERA_ATTR_EFFECT_VIOLET,       \/**< Violet *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_WARM	include/camera.h	/^    CAMERA_ATTR_EFFECT_WARM,         \/**< Warm *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EFFECT_YELLOW	include/camera.h	/^    CAMERA_ATTR_EFFECT_YELLOW,       \/**< Yellow *\/$/;"	e	enum:__anon14
+CAMERA_ATTR_EXPOSURE_MODE_ALL	include/camera.h	/^    CAMERA_ATTR_EXPOSURE_MODE_ALL,       \/**< All mode*\/$/;"	e	enum:__anon20
+CAMERA_ATTR_EXPOSURE_MODE_CENTER	include/camera.h	/^    CAMERA_ATTR_EXPOSURE_MODE_CENTER,    \/**< Center mode*\/$/;"	e	enum:__anon20
+CAMERA_ATTR_EXPOSURE_MODE_CUSTOM	include/camera.h	/^    CAMERA_ATTR_EXPOSURE_MODE_CUSTOM,    \/**< Custom mode*\/$/;"	e	enum:__anon20
+CAMERA_ATTR_EXPOSURE_MODE_OFF	include/camera.h	/^    CAMERA_ATTR_EXPOSURE_MODE_OFF = 0,   \/**< Off*\/$/;"	e	enum:__anon20
+CAMERA_ATTR_EXPOSURE_MODE_SPOT	include/camera.h	/^    CAMERA_ATTR_EXPOSURE_MODE_SPOT,      \/**< Spot mode*\/$/;"	e	enum:__anon20
+CAMERA_ATTR_FLASH_MODE_AUTO	include/camera.h	/^    CAMERA_ATTR_FLASH_MODE_AUTO,             \/**< Depending on intensity of light, strobe starts to flash. *\/$/;"	e	enum:__anon22
+CAMERA_ATTR_FLASH_MODE_FRONT_CURTAIN	include/camera.h	/^    CAMERA_ATTR_FLASH_MODE_FRONT_CURTAIN,    \/**< Front curtain synchronization. *\/$/;"	e	enum:__anon22
+CAMERA_ATTR_FLASH_MODE_OFF	include/camera.h	/^    CAMERA_ATTR_FLASH_MODE_OFF = 0,          \/**< Always off *\/$/;"	e	enum:__anon22
+CAMERA_ATTR_FLASH_MODE_ON	include/camera.h	/^    CAMERA_ATTR_FLASH_MODE_ON,               \/**< Always splashes *\/$/;"	e	enum:__anon22
+CAMERA_ATTR_FLASH_MODE_PERMANENT	include/camera.h	/^    CAMERA_ATTR_FLASH_MODE_PERMANENT,        \/**< keep turned on until turning off *\/$/;"	e	enum:__anon22
+CAMERA_ATTR_FLASH_MODE_REAR_CURTAIN	include/camera.h	/^    CAMERA_ATTR_FLASH_MODE_REAR_CURTAIN,     \/**< Rear curtain synchronization. *\/$/;"	e	enum:__anon22
+CAMERA_ATTR_FLASH_MODE_REDEYE_REDUCTION	include/camera.h	/^    CAMERA_ATTR_FLASH_MODE_REDEYE_REDUCTION, \/**< Red eye reduction. Multiple flash before capturing. *\/$/;"	e	enum:__anon22
+CAMERA_ATTR_FLASH_MODE_SLOW_SYNC	include/camera.h	/^    CAMERA_ATTR_FLASH_MODE_SLOW_SYNC,        \/**< Slow sync curtain synchronization*\/$/;"	e	enum:__anon22
+CAMERA_ATTR_FPS_120	include/camera.h	/^    CAMERA_ATTR_FPS_120 = 120 \/**< 120 FPS *\/$/;"	e	enum:__anon23
+CAMERA_ATTR_FPS_15	include/camera.h	/^    CAMERA_ATTR_FPS_15 = 15,  \/**< 15 FPS *\/$/;"	e	enum:__anon23
+CAMERA_ATTR_FPS_24	include/camera.h	/^    CAMERA_ATTR_FPS_24 = 24,  \/**< 24 FPS *\/$/;"	e	enum:__anon23
+CAMERA_ATTR_FPS_25	include/camera.h	/^    CAMERA_ATTR_FPS_25 = 25,  \/**< 25 FPS *\/$/;"	e	enum:__anon23
+CAMERA_ATTR_FPS_30	include/camera.h	/^    CAMERA_ATTR_FPS_30 = 30,  \/**< 30 FPS *\/$/;"	e	enum:__anon23
+CAMERA_ATTR_FPS_60	include/camera.h	/^    CAMERA_ATTR_FPS_60 = 60,  \/**< 60 FPS *\/$/;"	e	enum:__anon23
+CAMERA_ATTR_FPS_8	include/camera.h	/^    CAMERA_ATTR_FPS_8 = 8,    \/**< 8 FPS *\/$/;"	e	enum:__anon23
+CAMERA_ATTR_FPS_AUTO	include/camera.h	/^    CAMERA_ATTR_FPS_AUTO = 0, \/**< AUTO FPS *\/$/;"	e	enum:__anon23
+CAMERA_ATTR_ISO_100	include/camera.h	/^    CAMERA_ATTR_ISO_100,      \/**< ISO 100*\/$/;"	e	enum:__anon19
+CAMERA_ATTR_ISO_1600	include/camera.h	/^    CAMERA_ATTR_ISO_1600,     \/**< ISO 1600*\/$/;"	e	enum:__anon19
+CAMERA_ATTR_ISO_200	include/camera.h	/^    CAMERA_ATTR_ISO_200,      \/**< ISO 200*\/$/;"	e	enum:__anon19
+CAMERA_ATTR_ISO_3200	include/camera.h	/^    CAMERA_ATTR_ISO_3200,     \/**< ISO 3200*\/$/;"	e	enum:__anon19
+CAMERA_ATTR_ISO_400	include/camera.h	/^    CAMERA_ATTR_ISO_400,      \/**< ISO 400*\/$/;"	e	enum:__anon19
+CAMERA_ATTR_ISO_50	include/camera.h	/^    CAMERA_ATTR_ISO_50,       \/**< ISO 50*\/$/;"	e	enum:__anon19
+CAMERA_ATTR_ISO_800	include/camera.h	/^    CAMERA_ATTR_ISO_800,      \/**< ISO 800*\/$/;"	e	enum:__anon19
+CAMERA_ATTR_ISO_AUTO	include/camera.h	/^    CAMERA_ATTR_ISO_AUTO = 0, \/**< ISO auto mode*\/$/;"	e	enum:__anon19
+CAMERA_ATTR_SCENE_MODE_BACKLIGHT	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_BACKLIGHT,      \/**< Backlight *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_BEACH_N_INDOOR	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_BEACH_N_INDOOR, \/**< Beach & indoor *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_CANDLE_LIGHT	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_CANDLE_LIGHT,   \/**< Candle light *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_DUSK_N_DAWN	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_DUSK_N_DAWN,    \/**< Dusk & dawn *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_FALL_COLOR	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_FALL_COLOR,     \/**< Fall *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_FIREWORK	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_FIREWORK,       \/**< Firework *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_LANDSCAPE	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_LANDSCAPE,      \/**< Landscape *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_NIGHT_SCENE	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_NIGHT_SCENE,    \/**< Night scene *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_NORMAL	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_NORMAL = 0,     \/**< Normal *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_PARTY_N_INDOOR	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_PARTY_N_INDOOR, \/**< Party & indoor *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_PORTRAIT	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_PORTRAIT,       \/**< Portrait *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_SHOW_WINDOW	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_SHOW_WINDOW,    \/**< Show window *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_SPORTS	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_SPORTS,         \/**< Sports *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_SUNSET	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_SUNSET,         \/**< Sunset *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_SCENE_MODE_TEXT	include/camera.h	/^    CAMERA_ATTR_SCENE_MODE_TEXT,           \/**< Text *\/$/;"	e	enum:__anon16
+CAMERA_ATTR_TAG_ORIENTATION_BOTTOM_LEFT	include/camera.h	/^    CAMERA_ATTR_TAG_ORIENTATION_BOTTOM_LEFT = 4,   \/**< Row #0 is bottom, Column #0 is left *\/$/;"	e	enum:__anon21
+CAMERA_ATTR_TAG_ORIENTATION_BOTTOM_RIGHT	include/camera.h	/^    CAMERA_ATTR_TAG_ORIENTATION_BOTTOM_RIGHT = 3,  \/**< Row #0 is bottom, Column #0 is right *\/$/;"	e	enum:__anon21
+CAMERA_ATTR_TAG_ORIENTATION_LEFT_BOTTOM	include/camera.h	/^    CAMERA_ATTR_TAG_ORIENTATION_LEFT_BOTTOM = 8,   \/**< Row #0 is left, Column #0 is bottom *\/$/;"	e	enum:__anon21
+CAMERA_ATTR_TAG_ORIENTATION_LEFT_TOP	include/camera.h	/^    CAMERA_ATTR_TAG_ORIENTATION_LEFT_TOP = 5,      \/**< Row #0 is left, Column #0 is top *\/$/;"	e	enum:__anon21
+CAMERA_ATTR_TAG_ORIENTATION_RIGHT_BOTTOM	include/camera.h	/^    CAMERA_ATTR_TAG_ORIENTATION_RIGHT_BOTTOM = 7,  \/**< Row #0 is right, Column #0 is bottom *\/$/;"	e	enum:__anon21
+CAMERA_ATTR_TAG_ORIENTATION_RIGHT_TOP	include/camera.h	/^    CAMERA_ATTR_TAG_ORIENTATION_RIGHT_TOP = 6,     \/**< Row #0 is right, Column #0 is top *\/$/;"	e	enum:__anon21
+CAMERA_ATTR_TAG_ORIENTATION_TOP_LEFT	include/camera.h	/^    CAMERA_ATTR_TAG_ORIENTATION_TOP_LEFT = 1,      \/**< Row #0 is top, Column #0 is left *\/$/;"	e	enum:__anon21
+CAMERA_ATTR_TAG_ORIENTATION_TOP_RIGHT	include/camera.h	/^    CAMERA_ATTR_TAG_ORIENTATION_TOP_RIGHT = 2,     \/**< Row #0 is top, Column #0 is right *\/$/;"	e	enum:__anon21
+CAMERA_ATTR_WHITE_BALANCE_AUTOMATIC	include/camera.h	/^    CAMERA_ATTR_WHITE_BALANCE_AUTOMATIC,    \/**< Automatic *\/$/;"	e	enum:__anon15
+CAMERA_ATTR_WHITE_BALANCE_CLOUDY	include/camera.h	/^    CAMERA_ATTR_WHITE_BALANCE_CLOUDY,       \/**< Cloudy *\/$/;"	e	enum:__anon15
+CAMERA_ATTR_WHITE_BALANCE_CUSTOM	include/camera.h	/^    CAMERA_ATTR_WHITE_BALANCE_CUSTOM,       \/**< Custom *\/$/;"	e	enum:__anon15
+CAMERA_ATTR_WHITE_BALANCE_DAYLIGHT	include/camera.h	/^    CAMERA_ATTR_WHITE_BALANCE_DAYLIGHT,     \/**< Daylight *\/$/;"	e	enum:__anon15
+CAMERA_ATTR_WHITE_BALANCE_FLASH	include/camera.h	/^    CAMERA_ATTR_WHITE_BALANCE_FLASH,        \/**< Flash *\/$/;"	e	enum:__anon15
+CAMERA_ATTR_WHITE_BALANCE_FLUORESCENT	include/camera.h	/^    CAMERA_ATTR_WHITE_BALANCE_FLUORESCENT,  \/**< Fluorescent *\/$/;"	e	enum:__anon15
+CAMERA_ATTR_WHITE_BALANCE_HORIZON	include/camera.h	/^    CAMERA_ATTR_WHITE_BALANCE_HORIZON,      \/**< Horizon *\/$/;"	e	enum:__anon15
+CAMERA_ATTR_WHITE_BALANCE_INCANDESCENT	include/camera.h	/^    CAMERA_ATTR_WHITE_BALANCE_INCANDESCENT, \/**< Incandescent *\/$/;"	e	enum:__anon15
+CAMERA_ATTR_WHITE_BALANCE_NONE	include/camera.h	/^    CAMERA_ATTR_WHITE_BALANCE_NONE = 0,     \/**< None *\/$/;"	e	enum:__anon15
+CAMERA_ATTR_WHITE_BALANCE_SHADE	include/camera.h	/^    CAMERA_ATTR_WHITE_BALANCE_SHADE,        \/**< Shade *\/$/;"	e	enum:__anon15
+CAMERA_DEVICE_CAMERA0	include/camera.h	/^    CAMERA_DEVICE_CAMERA0 = 0, \/**< Primary camera *\/$/;"	e	enum:__anon9
+CAMERA_DEVICE_CAMERA1	include/camera.h	/^    CAMERA_DEVICE_CAMERA1      \/**< Secondary camera *\/$/;"	e	enum:__anon9
+CAMERA_DISPLAY_MODE_CROPPED_FULL	include/camera.h	/^	CAMERA_DISPLAY_MODE_CROPPED_FULL,	\/**< Cropped full screen*\/$/;"	e	enum:__anon13
+CAMERA_DISPLAY_MODE_FULL	include/camera.h	/^	CAMERA_DISPLAY_MODE_FULL,	\/**< full screen*\/$/;"	e	enum:__anon13
+CAMERA_DISPLAY_MODE_LETTER_BOX	include/camera.h	/^	CAMERA_DISPLAY_MODE_LETTER_BOX = 0,	\/**< Letter box*\/$/;"	e	enum:__anon13
+CAMERA_DISPLAY_MODE_ORIGIN_SIZE	include/camera.h	/^	CAMERA_DISPLAY_MODE_ORIGIN_SIZE,	\/**< Origin size*\/$/;"	e	enum:__anon13
+CAMERA_DISPLAY_ROTATION_180	include/camera.h	/^	CAMERA_DISPLAY_ROTATION_180,	\/**< 180 degree rotation *\/$/;"	e	enum:__anon12
+CAMERA_DISPLAY_ROTATION_270	include/camera.h	/^	CAMERA_DISPLAY_ROTATION_270,	\/**< 270 degree rotation *\/$/;"	e	enum:__anon12
+CAMERA_DISPLAY_ROTATION_90	include/camera.h	/^	CAMERA_DISPLAY_ROTATION_90,		\/**< 90 degree rotation *\/$/;"	e	enum:__anon12
+CAMERA_DISPLAY_ROTATION_NONE	include/camera.h	/^	CAMERA_DISPLAY_ROTATION_NONE,	\/**< No rotation of the display *\/$/;"	e	enum:__anon12
+CAMERA_DISPLAY_TYPE_EVAS	include/camera.h	/^  CAMERA_DISPLAY_TYPE_EVAS = 1,		\/**< Evas object surface display *\/$/;"	e	enum:__anon11
+CAMERA_DISPLAY_TYPE_NONE	include/camera.h	/^  CAMERA_DISPLAY_TYPE_NONE = 3		\/**< This disposes of buffers *\/$/;"	e	enum:__anon11
+CAMERA_DISPLAY_TYPE_X11	include/camera.h	/^  CAMERA_DISPLAY_TYPE_X11 = 0,		\/**< X surface display *\/$/;"	e	enum:__anon11
+CAMERA_ERROR_CLASS	include/camera.h	35;"	d
+CAMERA_ERROR_DEVICE	include/camera.h	/^    CAMERA_ERROR_DEVICE =            CAMERA_ERROR_CLASS | 0x04,    \/**< Device error *\/$/;"	e	enum:__anon7
+CAMERA_ERROR_INVALID_OPERATION	include/camera.h	/^    CAMERA_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION,  \/**< Internal error *\/$/;"	e	enum:__anon7
+CAMERA_ERROR_INVALID_PARAMETER	include/camera.h	/^    CAMERA_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER,  \/**< Invalid parameter *\/$/;"	e	enum:__anon7
+CAMERA_ERROR_INVALID_STATE	include/camera.h	/^    CAMERA_ERROR_INVALID_STATE =     CAMERA_ERROR_CLASS | 0x02,    \/**< Invalid state *\/$/;"	e	enum:__anon7
+CAMERA_ERROR_NONE	include/camera.h	/^    CAMERA_ERROR_NONE =              TIZEN_ERROR_OK,		\/**< Successful *\/$/;"	e	enum:__anon7
+CAMERA_ERROR_OUT_OF_MEMORY	include/camera.h	/^    CAMERA_ERROR_OUT_OF_MEMORY =     TIZEN_ERROR_OUT_OF_MEMORY,      \/**< Out of memory *\/$/;"	e	enum:__anon7
+CAMERA_ERROR_SOUND_POLICY	include/camera.h	/^    CAMERA_ERROR_SOUND_POLICY =      CAMERA_ERROR_CLASS | 0x06,    \/**< Blocked by Audio Session Manager *\/$/;"	e	enum:__anon7
+CAMERA_FOCUS_STATE_FAILED	include/camera.h	/^    CAMERA_FOCUS_STATE_FAILED,       \/**< Focus failed*\/$/;"	e	enum:__anon18
+CAMERA_FOCUS_STATE_FOCUSED	include/camera.h	/^    CAMERA_FOCUS_STATE_FOCUSED,      \/**< Focus success*\/$/;"	e	enum:__anon18
+CAMERA_FOCUS_STATE_ONGOING	include/camera.h	/^    CAMERA_FOCUS_STATE_ONGOING,      \/**< Focus in progress*\/$/;"	e	enum:__anon18
+CAMERA_FOCUS_STATE_RELEASED	include/camera.h	/^    CAMERA_FOCUS_STATE_RELEASED = 0, \/**< Focus released.*\/$/;"	e	enum:__anon18
+CAMERA_MODE_IMAGE	include/camera_private.h	/^	CAMERA_MODE_IMAGE = MM_CAMCORDER_MODE_IMAGE,				\/**< Still image capture mode *\/$/;"	e	enum:__anon6
+CAMERA_MODE_VIDEO	include/camera_private.h	/^	CAMERA_MODE_VIDEO = MM_CAMCORDER_MODE_VIDEO				\/**< Video recording mode *\/$/;"	e	enum:__anon6
+CAMERA_PIXEL_FORMAT_422P	include/camera.h	/^	CAMERA_PIXEL_FORMAT_422P,           \/**< YUV422(Y:U:V) planar pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_ARGB	include/camera.h	/^	CAMERA_PIXEL_FORMAT_ARGB,           \/**< ARGB pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_I420	include/camera.h	/^	CAMERA_PIXEL_FORMAT_I420,           \/**< I420 pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_INVALID	include/camera.h	/^	CAMERA_PIXEL_FORMAT_INVALID	= -1,  \/**< Invalid pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_JPEG	include/camera.h	/^	CAMERA_PIXEL_FORMAT_JPEG,           \/**< Encoded pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_NV12	include/camera.h	/^	CAMERA_PIXEL_FORMAT_NV12,           \/**< NV12 pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_NV12T	include/camera.h	/^	CAMERA_PIXEL_FORMAT_NV12T,          \/**< NV12 Tiled pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_NV16	include/camera.h	/^	CAMERA_PIXEL_FORMAT_NV16,           \/**< NV16 pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_NV21	include/camera.h	/^	CAMERA_PIXEL_FORMAT_NV21,           \/**< NV21 pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_RGB565	include/camera.h	/^	CAMERA_PIXEL_FORMAT_RGB565,         \/**< RGB565 pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_RGB888	include/camera.h	/^	CAMERA_PIXEL_FORMAT_RGB888,         \/**< RGB888 pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_RGBA	include/camera.h	/^	CAMERA_PIXEL_FORMAT_RGBA,           \/**< RGBA pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_UYVY	include/camera.h	/^	CAMERA_PIXEL_FORMAT_UYVY,           \/**< UYVY pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_YUYV	include/camera.h	/^	CAMERA_PIXEL_FORMAT_YUYV,           \/**< YUYV(YUY2) pixel format *\/$/;"	e	enum:__anon10
+CAMERA_PIXEL_FORMAT_YV12	include/camera.h	/^	CAMERA_PIXEL_FORMAT_YV12,           \/**< YV12 pixel format *\/$/;"	e	enum:__anon10
+CAMERA_STATE_CAPTURED	include/camera.h	/^    CAMERA_STATE_CAPTURED    \/**< After capturing *\/$/;"	e	enum:__anon8
+CAMERA_STATE_CAPTURING	include/camera.h	/^    CAMERA_STATE_CAPTURING,  \/**< While capturing *\/$/;"	e	enum:__anon8
+CAMERA_STATE_CREATED	include/camera.h	/^    CAMERA_STATE_CREATED,    \/**< Created, but not initialized yet *\/$/;"	e	enum:__anon8
+CAMERA_STATE_NONE	include/camera.h	/^    CAMERA_STATE_NONE,       \/**< Before create *\/$/;"	e	enum:__anon8
+CAMERA_STATE_PREVIEW	include/camera.h	/^    CAMERA_STATE_PREVIEW,    \/**< Preview *\/$/;"	e	enum:__anon8
+CC	TC/testcase/Makefile	/^CC ?= gcc$/;"	m
+CFLAGS	TC/testcase/Makefile	/^CFLAGS = -I. `pkg-config --cflags $(PKGS)`$/;"	m
+CFLAGS	debian/rules	/^CFLAGS = -Wall -g$/;"	m
+CMAKE_BUILD_DIR	debian/rules	/^CMAKE_BUILD_DIR ?= $(CURDIR)\/cmake_build_tmp$/;"	m
+CMAKE_ROOT_DIR	debian/rules	/^CMAKE_ROOT_DIR ?= $(CURDIR)$/;"	m
+DLOG_D	src/camera.c	37;"	d	file:
+DLOG_I	src/camera.c	36;"	d	file:
+DLOG_V	src/camera.c	35;"	d	file:
+GET_DISPLAY	include/camera.h	140;"	d
+GmainThread	TC/testcase/utc_media_camera_lifecycle.c	/^gpointer GmainThread(gpointer data){$/;"	f
+GmainThread	TC/testcase/utc_media_camera_setting.c	/^gpointer GmainThread(gpointer data){$/;"	f
+GmainThread	TC/testcase/utc_media_camera_working.c	/^gpointer GmainThread(gpointer data){$/;"	f
+LDFLAGS	TC/testcase/Makefile	/^LDFLAGS = `pkg-config --libs $(PKGS)`$/;"	m
+LOG_TAG	src/camera.c	32;"	d	file:
+LOG_TAG	src/camera.c	34;"	d	file:
+MY_ASSERT	TC/testcase/utc_media_camera_attr.c	22;"	d	file:
+MY_ASSERT	TC/testcase/utc_media_camera_lifecycle.c	25;"	d	file:
+MY_ASSERT	TC/testcase/utc_media_camera_setting.c	26;"	d	file:
+MY_ASSERT	TC/testcase/utc_media_camera_working.c	23;"	d	file:
+PKGS	TC/testcase/Makefile	/^PKGS = capi-media-camera dlog glib-2.0$/;"	m
+TCS	TC/testcase/Makefile	/^TCS = utc_media_camera_attr \\$/;"	m
+_CAMERA_EVENT_TYPE_CAPTURE	include/camera_private.h	/^	_CAMERA_EVENT_TYPE_CAPTURE,	$/;"	e	enum:__anon5
+_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE	include/camera_private.h	/^	_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE,$/;"	e	enum:__anon5
+_CAMERA_EVENT_TYPE_ERROR	include/camera_private.h	/^	_CAMERA_EVENT_TYPE_ERROR,		$/;"	e	enum:__anon5
+_CAMERA_EVENT_TYPE_FOCUS_CHANGE	include/camera_private.h	/^	_CAMERA_EVENT_TYPE_FOCUS_CHANGE,	$/;"	e	enum:__anon5
+_CAMERA_EVENT_TYPE_NUM	include/camera_private.h	/^	_CAMERA_EVENT_TYPE_NUM$/;"	e	enum:__anon5
+_CAMERA_EVENT_TYPE_PREVIEW	include/camera_private.h	/^	_CAMERA_EVENT_TYPE_PREVIEW,$/;"	e	enum:__anon5
+_CAMERA_EVENT_TYPE_STATE_CHANGE	include/camera_private.h	/^	_CAMERA_EVENT_TYPE_STATE_CHANGE,$/;"	e	enum:__anon5
+__TIZEN_MULTIMEDIA_CAMERA_H__	include/camera.h	26;"	d
+__TIZEN_MULTIMEDIA_CAMERA_PRIVATE_H__	include/camera_private.h	27;"	d
+_af_mode_test_cb	TC/testcase/utc_media_camera_working.c	/^bool _af_mode_test_cb(camera_attr_af_mode_e mode, void *user_data){$/;"	f
+_af_mode_test_cb	test/multimedia_camera_test.c	/^bool _af_mode_test_cb(camera_attr_af_mode_e mode, void *user_data){$/;"	f
+_camera_event_e	include/camera_private.h	/^}_camera_event_e;$/;"	t	typeref:enum:__anon5
+_camera_preview_test_cb	TC/testcase/utc_media_camera_working.c	/^ void _camera_preview_test_cb(void *stream_buffer, int buffer_size, int width, int height, camera_pixel_format_e format,  void *user_data){$/;"	f
+_camera_preview_test_cb	test/multimedia_camera_test.c	/^ void _camera_preview_test_cb(void *stream_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data){$/;"	f
+_camera_s	include/camera_private.h	/^typedef struct _camera_s{$/;"	s
+_camera_state_convert	src/camera.c	/^camera_state_e _camera_state_convert(MMCamcorderStateType mm_state)$/;"	f
+_capture_completed_cb	TC/testcase/utc_media_camera_setting.c	/^void _capture_completed_cb(void *user_data)$/;"	f
+_capture_format_cb	TC/testcase/utc_media_camera_setting.c	/^bool _capture_format_cb(camera_pixel_format_e format , void *user_data)$/;"	f
+_capture_format_cb2	TC/testcase/utc_media_camera_setting.c	/^bool _capture_format_cb2(camera_pixel_format_e format , void *user_data)$/;"	f
+_capture_resolution_cb	TC/testcase/utc_media_camera_setting.c	/^bool _capture_resolution_cb(int width, int height, void *user_data)$/;"	f
+_capture_resolution_cb2	TC/testcase/utc_media_camera_setting.c	/^bool _capture_resolution_cb2(int width, int height, void *user_data)$/;"	f
+_capture_test2_cb	TC/testcase/utc_media_camera_working.c	/^void _capture_test2_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format,  void *user_data){$/;"	f
+_capture_test2_cb	test/multimedia_camera_test.c	/^void _capture_test2_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data){$/;"	f
+_capture_test3_cb	TC/testcase/utc_media_camera_working.c	/^void _capture_test3_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format,  void *user_data){$/;"	f
+_capture_test3_cb	test/multimedia_camera_test.c	/^void _capture_test3_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data){$/;"	f
+_capture_test_cb	TC/testcase/utc_media_camera_working.c	/^void _capture_test_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format,  void *user_data){$/;"	f
+_capture_test_cb	test/multimedia_camera_test.c	/^void _capture_test_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data){$/;"	f
+_capturing_cb	TC/testcase/utc_media_camera_setting.c	/^void _capturing_cb(void* image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format , void *user_data)$/;"	f
+_cb_af_mode	TC/testcase/utc_media_camera_attr.c	/^bool _cb_af_mode(camera_attr_af_mode_e mode, void *user_data)$/;"	f
+_cb_effect_cb	TC/testcase/utc_media_camera_attr.c	/^bool _cb_effect_cb(camera_attr_effect_mode_e effect , void *user_data)$/;"	f
+_cb_exposure_mode	TC/testcase/utc_media_camera_attr.c	/^bool _cb_exposure_mode(camera_attr_exposure_mode_e mode , void *user_data)$/;"	f
+_cb_flash_mode_cb	TC/testcase/utc_media_camera_attr.c	/^bool _cb_flash_mode_cb(camera_attr_flash_mode_e mode,  void *user_data)$/;"	f
+_cb_fps_cb	TC/testcase/utc_media_camera_attr.c	/^bool _cb_fps_cb(camera_attr_fps_e fps, void *user_data)$/;"	f
+_cb_iso	TC/testcase/utc_media_camera_attr.c	/^bool _cb_iso(camera_attr_iso_e iso , void *user_data)$/;"	f
+_cb_scene_mode_cb	TC/testcase/utc_media_camera_attr.c	/^bool _cb_scene_mode_cb(camera_attr_scene_mode_e mode , void *user_data)$/;"	f
+_cb_whitebalance_cb	TC/testcase/utc_media_camera_attr.c	/^bool _cb_whitebalance_cb(camera_attr_whitebalance_e wb , void *user_data)$/;"	f
+_changed_cb	TC/testcase/utc_media_camera_setting.c	/^void _changed_cb(camera_state_e previous , camera_state_e current , bool by_asm, void *user_data)$/;"	f
+_convert_camera_error_code	src/camera.c	/^int _convert_camera_error_code(int code){$/;"	f
+_effect_test_cb	TC/testcase/utc_media_camera_working.c	/^bool _effect_test_cb(camera_attr_effect_mode_e effect,  void *user_data){$/;"	f
+_effect_test_cb	test/multimedia_camera_test.c	/^bool _effect_test_cb(camera_attr_effect_mode_e effect, void *user_data){$/;"	f
+_error_cb	TC/testcase/utc_media_camera_setting.c	/^void _error_cb(int error, camera_state_e current_state, void *user_data)$/;"	f
+_exposure_mode_test_cb	TC/testcase/utc_media_camera_working.c	/^bool _exposure_mode_test_cb(camera_attr_exposure_mode_e mode, void *user_data){$/;"	f
+_exposure_mode_test_cb	test/multimedia_camera_test.c	/^bool _exposure_mode_test_cb(camera_attr_exposure_mode_e mode, void *user_data){$/;"	f
+_flash_mode_test_cb	TC/testcase/utc_media_camera_working.c	/^bool _flash_mode_test_cb(camera_attr_flash_mode_e mode,  void *user_data){$/;"	f
+_flash_mode_test_cb	test/multimedia_camera_test.c	/^bool _flash_mode_test_cb(camera_attr_flash_mode_e mode, void *user_data){$/;"	f
+_focus_changed_cb	TC/testcase/utc_media_camera_setting.c	/^void _focus_changed_cb(camera_focus_state_e state, void *user_data)$/;"	f
+_focus_changed_cb2	test/multimedia_camera_test.c	/^void _focus_changed_cb2(camera_focus_state_e state, void *user_data){$/;"	f
+_iso_test_cb	TC/testcase/utc_media_camera_working.c	/^bool _iso_test_cb(camera_attr_iso_e iso, void *user_data){$/;"	f
+_iso_test_cb	test/multimedia_camera_test.c	/^bool _iso_test_cb(camera_attr_iso_e iso, void *user_data){$/;"	f
+_preview_cb	TC/testcase/utc_media_camera_setting.c	/^void _preview_cb(void* stream_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data)$/;"	f
+_preview_format_cb	TC/testcase/utc_media_camera_setting.c	/^bool _preview_format_cb(camera_pixel_format_e format , void *user_data)$/;"	f
+_preview_format_cb2	TC/testcase/utc_media_camera_setting.c	/^bool _preview_format_cb2(camera_pixel_format_e format , void *user_data)$/;"	f
+_preview_format_test_cb	TC/testcase/utc_media_camera_working.c	/^bool _preview_format_test_cb(camera_pixel_format_e format,  void *user_data){$/;"	f
+_preview_format_test_cb	test/multimedia_camera_test.c	/^bool _preview_format_test_cb(camera_pixel_format_e format, void *user_data){$/;"	f
+_preview_fps_cb	TC/testcase/utc_media_camera_working.c	/^bool _preview_fps_cb(camera_attr_fps_e fps, void *user_data){$/;"	f
+_preview_fps_cb	test/multimedia_camera_test.c	/^bool _preview_fps_cb(camera_attr_fps_e fps, void *user_data){$/;"	f
+_preview_resolution_cb	TC/testcase/utc_media_camera_setting.c	/^bool _preview_resolution_cb(int width, int height, void *user_data )$/;"	f
+_preview_resolution_cb2	TC/testcase/utc_media_camera_setting.c	/^bool _preview_resolution_cb2(int width, int height, void *user_data )$/;"	f
+_scene_mode_test_cb	TC/testcase/utc_media_camera_working.c	/^bool _scene_mode_test_cb (camera_attr_scene_mode_e mode,  void *user_data){$/;"	f
+_scene_mode_test_cb	test/multimedia_camera_test.c	/^bool _scene_mode_test_cb (camera_attr_scene_mode_e mode, void *user_data){$/;"	f
+_state_change_test_cb	TC/testcase/utc_media_camera_working.c	/^void _state_change_test_cb(camera_state_e previous , camera_state_e current , bool by_asm,  void *user_data){$/;"	f
+_state_change_test_cb	test/multimedia_camera_test.c	/^void _state_change_test_cb(camera_state_e previous , camera_state_e current , bool by_asm, void *user_data){$/;"	f
+_whitebalance_test_cb	TC/testcase/utc_media_camera_working.c	/^bool _whitebalance_test_cb(camera_attr_whitebalance_e wb,  void *user_data){$/;"	f
+_whitebalance_test_cb	test/multimedia_camera_test.c	/^bool _whitebalance_test_cb(camera_attr_whitebalance_e wb, void *user_data){$/;"	f
+af_mode_test	TC/testcase/utc_media_camera_working.c	/^int af_mode_test(camera_h camera){$/;"	f
+af_mode_test	test/multimedia_camera_test.c	/^int af_mode_test(camera_h camera){$/;"	f
+appdata	test/multimedia_camera_test.c	/^}appdata;$/;"	t	typeref:struct:__anon24	file:
+brightness_test	TC/testcase/utc_media_camera_working.c	/^int brightness_test(camera_h camera){$/;"	f
+brightness_test	test/multimedia_camera_test.c	/^int brightness_test(camera_h camera){$/;"	f
+camera	TC/testcase/utc_media_camera_attr.c	/^camera_h camera;$/;"	v
+camera	TC/testcase/utc_media_camera_setting.c	/^camera_h camera;$/;"	v
+camera	TC/testcase/utc_media_camera_working.c	/^	camera_h camera;$/;"	m	struct:__anon1	file:
+camera	test/multimedia_camera_test.c	/^	camera_h camera;$/;"	m	struct:__anon25	file:
+camera_attr_af_mode_e	include/camera.h	/^} camera_attr_af_mode_e;$/;"	t	typeref:enum:__anon17
+camera_attr_effect_mode_e	include/camera.h	/^} camera_attr_effect_mode_e;$/;"	t	typeref:enum:__anon14
+camera_attr_enable_tag	src/camera.c	/^int camera_attr_enable_tag(camera_h camera,  bool enable){$/;"	f
+camera_attr_exposure_mode_e	include/camera.h	/^} camera_attr_exposure_mode_e;$/;"	t	typeref:enum:__anon20
+camera_attr_flash_mode_e	include/camera.h	/^} camera_attr_flash_mode_e;$/;"	t	typeref:enum:__anon22
+camera_attr_foreach_supported_af_mode	src/camera.c	/^int camera_attr_foreach_supported_af_mode( camera_h camera, camera_attr_supported_af_mode_cb foreach_cb , void *user_data){$/;"	f
+camera_attr_foreach_supported_effect	src/camera.c	/^int camera_attr_foreach_supported_effect(camera_h camera, camera_attr_supported_effect_cb foreach_cb , void *user_data){$/;"	f
+camera_attr_foreach_supported_exposure_mode	src/camera.c	/^int camera_attr_foreach_supported_exposure_mode(camera_h camera, camera_attr_supported_exposure_mode_cb foreach_cb , void *user_data){$/;"	f
+camera_attr_foreach_supported_flash_mode	src/camera.c	/^int camera_attr_foreach_supported_flash_mode(camera_h camera, camera_attr_supported_flash_mode_cb foreach_cb , void *user_data){$/;"	f
+camera_attr_foreach_supported_fps	src/camera.c	/^int camera_attr_foreach_supported_fps(camera_h camera, camera_attr_supported_fps_cb foreach_cb , void *user_data){$/;"	f
+camera_attr_foreach_supported_iso	src/camera.c	/^int camera_attr_foreach_supported_iso( camera_h camera, camera_attr_supported_iso_cb foreach_cb , void *user_data){$/;"	f
+camera_attr_foreach_supported_scene_mode	src/camera.c	/^int camera_attr_foreach_supported_scene_mode(camera_h camera, camera_attr_supported_scene_mode_cb foreach_cb , void *user_data){$/;"	f
+camera_attr_foreach_supported_whitebalance	src/camera.c	/^int camera_attr_foreach_supported_whitebalance(camera_h camera, camera_attr_supported_whitebalance_cb foreach_cb , void *user_data){$/;"	f
+camera_attr_fps_e	include/camera.h	/^} camera_attr_fps_e;$/;"	t	typeref:enum:__anon23
+camera_attr_get_af_mode	src/camera.c	/^int camera_attr_get_af_mode( camera_h camera,  camera_attr_af_mode_e *mode){$/;"	f
+camera_attr_get_brightness	src/camera.c	/^int camera_attr_get_brightness(camera_h camera,  int *level){$/;"	f
+camera_attr_get_contrast	src/camera.c	/^int camera_attr_get_contrast(camera_h camera,  int *level){$/;"	f
+camera_attr_get_effect	src/camera.c	/^int camera_attr_get_effect(camera_h camera, camera_attr_effect_mode_e *effect){$/;"	f
+camera_attr_get_exposure	src/camera.c	/^int camera_attr_get_exposure(camera_h camera, int *value){$/;"	f
+camera_attr_get_exposure_mode	src/camera.c	/^int camera_attr_get_exposure_mode( camera_h camera,  camera_attr_exposure_mode_e *mode){$/;"	f
+camera_attr_get_flash_mode	src/camera.c	/^int camera_attr_get_flash_mode(camera_h camera,  camera_attr_flash_mode_e *mode){$/;"	f
+camera_attr_get_hue	src/camera.c	/^int camera_attr_get_hue(camera_h camera,  int *level){$/;"	f
+camera_attr_get_image_quality	src/camera.c	/^int camera_attr_get_image_quality(camera_h camera,  int *quality){$/;"	f
+camera_attr_get_iso	src/camera.c	/^int camera_attr_get_iso( camera_h camera,  camera_attr_iso_e *iso){$/;"	f
+camera_attr_get_lens_orientation	src/camera.c	/^int camera_attr_get_lens_orientation(camera_h camera, int *angle) {$/;"	f
+camera_attr_get_preview_fps	src/camera.c	/^int camera_attr_get_preview_fps(camera_h camera,  camera_attr_fps_e *fps){$/;"	f
+camera_attr_get_saturation	src/camera.c	/^int camera_attr_get_saturation(camera_h camera,  int *level){$/;"	f
+camera_attr_get_scene_mode	src/camera.c	/^int camera_attr_get_scene_mode(camera_h camera,  camera_attr_scene_mode_e *mode){$/;"	f
+camera_attr_get_sharpness	src/camera.c	/^int camera_attr_get_sharpness(camera_h camera,  int *level){$/;"	f
+camera_attr_get_tag_altitude	src/camera.c	/^int camera_attr_get_tag_altitude(camera_h camera,  double *altitude){$/;"	f
+camera_attr_get_tag_image_description	src/camera.c	/^int camera_attr_get_tag_image_description(camera_h camera,  char **description){$/;"	f
+camera_attr_get_tag_latitude	src/camera.c	/^int camera_attr_get_tag_latitude(camera_h camera,  double *latitude){$/;"	f
+camera_attr_get_tag_longitude	src/camera.c	/^int camera_attr_get_tag_longitude(camera_h camera,  double *longtitude){$/;"	f
+camera_attr_get_tag_orientation	src/camera.c	/^int camera_attr_get_tag_orientation(camera_h camera,  camera_attr_tag_orientation_e *orientation){$/;"	f
+camera_attr_get_tag_software	src/camera.c	/^int camera_attr_get_tag_software(camera_h camera,  char **software){$/;"	f
+camera_attr_get_whitebalance	src/camera.c	/^int camera_attr_get_whitebalance(camera_h camera,  camera_attr_whitebalance_e *wb){$/;"	f
+camera_attr_get_zoom	src/camera.c	/^int camera_attr_get_zoom(camera_h camera,  int *zoom){$/;"	f
+camera_attr_is_enabled_tag	src/camera.c	/^int camera_attr_is_enabled_tag(camera_h camera,  bool *enable){$/;"	f
+camera_attr_iso_e	include/camera.h	/^} camera_attr_iso_e;$/;"	t	typeref:enum:__anon19
+camera_attr_scene_mode_e	include/camera.h	/^} camera_attr_scene_mode_e;$/;"	t	typeref:enum:__anon16
+camera_attr_set_af_mode	src/camera.c	/^int camera_attr_set_af_mode(camera_h camera,  camera_attr_af_mode_e mode){$/;"	f
+camera_attr_set_af_touch	src/camera.c	/^int camera_attr_set_af_touch(camera_h camera,  int x , int y, int width, int height ){$/;"	f
+camera_attr_set_brightness	src/camera.c	/^int camera_attr_set_brightness(camera_h camera,  int level){$/;"	f
+camera_attr_set_contrast	src/camera.c	/^int camera_attr_set_contrast(camera_h camera,  int level){$/;"	f
+camera_attr_set_effect	src/camera.c	/^int camera_attr_set_effect(camera_h camera, camera_attr_effect_mode_e effect){$/;"	f
+camera_attr_set_exposure	src/camera.c	/^int camera_attr_set_exposure(camera_h camera, int value){$/;"	f
+camera_attr_set_exposure_mode	src/camera.c	/^int camera_attr_set_exposure_mode(camera_h camera,  camera_attr_exposure_mode_e mode){$/;"	f
+camera_attr_set_flash_mode	src/camera.c	/^int camera_attr_set_flash_mode(camera_h camera,  camera_attr_flash_mode_e mode){$/;"	f
+camera_attr_set_hue	src/camera.c	/^int camera_attr_set_hue(camera_h camera,  int level){$/;"	f
+camera_attr_set_image_quality	src/camera.c	/^int camera_attr_set_image_quality(camera_h camera,  int quality){$/;"	f
+camera_attr_set_iso	src/camera.c	/^int camera_attr_set_iso(camera_h camera,  camera_attr_iso_e iso){$/;"	f
+camera_attr_set_preview_fps	src/camera.c	/^int camera_attr_set_preview_fps(camera_h camera,  camera_attr_fps_e fps){$/;"	f
+camera_attr_set_saturation	src/camera.c	/^int camera_attr_set_saturation(camera_h camera,  int level){$/;"	f
+camera_attr_set_scene_mode	src/camera.c	/^int camera_attr_set_scene_mode(camera_h camera,  camera_attr_scene_mode_e mode){$/;"	f
+camera_attr_set_sharpness	src/camera.c	/^int camera_attr_set_sharpness(camera_h camera,  int level){$/;"	f
+camera_attr_set_tag_altitude	src/camera.c	/^int camera_attr_set_tag_altitude(camera_h camera,  double altitude){$/;"	f
+camera_attr_set_tag_image_description	src/camera.c	/^int camera_attr_set_tag_image_description(camera_h camera,  const char *description){$/;"	f
+camera_attr_set_tag_latitude	src/camera.c	/^int camera_attr_set_tag_latitude(camera_h camera,  double latitude){$/;"	f
+camera_attr_set_tag_longitude	src/camera.c	/^int camera_attr_set_tag_longitude(camera_h camera,  double longtitude){$/;"	f
+camera_attr_set_tag_orientation	src/camera.c	/^int camera_attr_set_tag_orientation(camera_h camera,  camera_attr_tag_orientation_e orientation){$/;"	f
+camera_attr_set_tag_software	src/camera.c	/^int camera_attr_set_tag_software(camera_h camera,  const char *software){$/;"	f
+camera_attr_set_whitebalance	src/camera.c	/^int camera_attr_set_whitebalance(camera_h camera,  camera_attr_whitebalance_e wb){$/;"	f
+camera_attr_set_zoom	src/camera.c	/^int camera_attr_set_zoom(camera_h camera,  int zoom){$/;"	f
+camera_attr_supported_af_mode_cb	include/camera.h	/^typedef bool (*camera_attr_supported_af_mode_cb)(camera_attr_af_mode_e mode, void *user_data);$/;"	t
+camera_attr_supported_effect_cb	include/camera.h	/^typedef bool (*camera_attr_supported_effect_cb)(camera_attr_effect_mode_e effect,$/;"	t
+camera_attr_supported_exposure_mode_cb	include/camera.h	/^typedef bool (*camera_attr_supported_exposure_mode_cb)(camera_attr_exposure_mode_e mode,$/;"	t
+camera_attr_supported_flash_mode_cb	include/camera.h	/^typedef bool (*camera_attr_supported_flash_mode_cb)(camera_attr_flash_mode_e mode,$/;"	t
+camera_attr_supported_fps_cb	include/camera.h	/^typedef bool (*camera_attr_supported_fps_cb)(camera_attr_fps_e fps, void *user_data);$/;"	t
+camera_attr_supported_iso_cb	include/camera.h	/^typedef bool (*camera_attr_supported_iso_cb)(camera_attr_iso_e iso, void *user_data);$/;"	t
+camera_attr_supported_scene_mode_cb	include/camera.h	/^typedef bool (*camera_attr_supported_scene_mode_cb)(camera_attr_scene_mode_e mode,$/;"	t
+camera_attr_supported_whitebalance_cb	include/camera.h	/^typedef bool (*camera_attr_supported_whitebalance_cb)(camera_attr_whitebalance_e wb,$/;"	t
+camera_attr_tag_orientation_e	include/camera.h	/^} camera_attr_tag_orientation_e;$/;"	t	typeref:enum:__anon21
+camera_attr_whitebalance_e	include/camera.h	/^} camera_attr_whitebalance_e;$/;"	t	typeref:enum:__anon15
+camera_attribute_test	test/multimedia_camera_test.c	/^int camera_attribute_test(){$/;"	f
+camera_cancel_focusing	src/camera.c	/^int camera_cancel_focusing( camera_h camera ){$/;"	f
+camera_capture_completed_cb	include/camera.h	/^typedef void (*camera_capture_completed_cb)(void *user_data);$/;"	t
+camera_capturing_cb	include/camera.h	/^typedef void (*camera_capturing_cb)(void *image_buffer, int buffer_size, int width, int height,$/;"	t
+camera_create	src/camera.c	/^int camera_create( camera_device_e device, camera_h* camera){$/;"	f
+camera_destroy	src/camera.c	/^ int camera_destroy(camera_h camera){$/;"	f
+camera_device_e	include/camera.h	/^} camera_device_e;$/;"	t	typeref:enum:__anon9
+camera_display_h	include/camera.h	/^typedef void *camera_display_h;$/;"	t
+camera_display_mode_e	include/camera.h	/^} camera_display_mode_e;$/;"	t	typeref:enum:__anon13
+camera_display_rotation_e	include/camera.h	/^} camera_display_rotation_e;$/;"	t	typeref:enum:__anon12
+camera_display_type_e	include/camera.h	/^} camera_display_type_e;$/;"	t	typeref:enum:__anon11
+camera_error_cb	include/camera.h	/^typedef void (*camera_error_cb)(int error, camera_state_e current_state, void *user_data);$/;"	t
+camera_error_e	include/camera.h	/^} camera_error_e;$/;"	t	typeref:enum:__anon7
+camera_focus_changed_cb	include/camera.h	/^typedef void (*camera_focus_changed_cb)(camera_focus_state_e state, void *user_data);$/;"	t
+camera_focus_state_e	include/camera.h	/^} camera_focus_state_e;$/;"	t	typeref:enum:__anon18
+camera_foreach_supported_capture_format	src/camera.c	/^int camera_foreach_supported_capture_format(camera_h camera, camera_supported_capture_format_cb foreach_cb , void *user_data){$/;"	f
+camera_foreach_supported_capture_resolution	src/camera.c	/^int camera_foreach_supported_capture_resolution(camera_h camera, camera_supported_capture_resolution_cb foreach_cb , void *user_data){$/;"	f
+camera_foreach_supported_preview_format	src/camera.c	/^int camera_foreach_supported_preview_format(camera_h camera, camera_supported_preview_format_cb foreach_cb , void *user_data){$/;"	f
+camera_foreach_supported_preview_resolution	src/camera.c	/^int camera_foreach_supported_preview_resolution(camera_h camera, camera_supported_preview_resolution_cb foreach_cb , void *user_data){$/;"	f
+camera_get_capture_format	src/camera.c	/^int camera_get_capture_format(camera_h camera, camera_pixel_format_e *format){$/;"	f
+camera_get_capture_resolution	src/camera.c	/^int camera_get_capture_resolution(camera_h camera, int *width, int *height){$/;"	f
+camera_get_preview_format	src/camera.c	/^int camera_get_preview_format(camera_h camera, camera_pixel_format_e *format){$/;"	f
+camera_get_preview_resolution	src/camera.c	/^int camera_get_preview_resolution(camera_h camera,  int *width, int *height){$/;"	f
+camera_get_state	src/camera.c	/^int camera_get_state(camera_h camera, camera_state_e * state){$/;"	f
+camera_get_x11_display_mode	src/camera.c	/^int camera_get_x11_display_mode( camera_h camera , camera_display_mode_e* ratio){$/;"	f
+camera_get_x11_display_rotation	src/camera.c	/^int camera_get_x11_display_rotation( camera_h camera,  camera_display_rotation_e *rotation){$/;"	f
+camera_h	include/camera.h	/^typedef struct camera_s *camera_h;$/;"	t	typeref:struct:camera_s
+camera_is_x11_display_visible	src/camera.c	/^int camera_is_x11_display_visible(camera_h camera, bool* visible){$/;"	f
+camera_lens_rotation_test	test/multimedia_camera_test.c	/^void camera_lens_rotation_test(){$/;"	f
+camera_mode_e	include/camera_private.h	/^} camera_mode_e;$/;"	t	typeref:enum:__anon6
+camera_pixel_format_e	include/camera.h	/^} camera_pixel_format_e;$/;"	t	typeref:enum:__anon10
+camera_preview_cb	include/camera.h	/^typedef void (*camera_preview_cb)(void *stream_buffer, int buffer_size, int width, int height,$/;"	t
+camera_preview_test	test/multimedia_camera_test.c	/^int camera_preview_test(){$/;"	f
+camera_preview_test_s	TC/testcase/utc_media_camera_working.c	/^} camera_preview_test_s;$/;"	t	typeref:struct:__anon1	file:
+camera_preview_test_s	test/multimedia_camera_test.c	/^} camera_preview_test_s;$/;"	t	typeref:struct:__anon25	file:
+camera_s	include/camera_private.h	/^} camera_s;$/;"	t	typeref:struct:_camera_s
+camera_set_capture_completed_cb	src/camera.c	/^int camera_set_capture_completed_cb(camera_h camera, camera_capture_completed_cb callback, void* user_data){$/;"	f
+camera_set_capture_format	src/camera.c	/^int camera_set_capture_format(camera_h camera, camera_pixel_format_e format){$/;"	f
+camera_set_capture_resolution	src/camera.c	/^int camera_set_capture_resolution(camera_h camera,  int width, int height){$/;"	f
+camera_set_capturing_cb	src/camera.c	/^int camera_set_capturing_cb( camera_h camera, camera_capturing_cb callback, void* user_data ){$/;"	f
+camera_set_display	src/camera.c	/^int camera_set_display(camera_h camera, camera_display_type_e type, camera_display_h display){$/;"	f
+camera_set_error_cb	src/camera.c	/^int camera_set_error_cb(camera_h camera, camera_error_cb callback, void *user_data){$/;"	f
+camera_set_focus_changed_cb	src/camera.c	/^int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback, void* user_data){$/;"	f
+camera_set_mode	src/camera.c	/^int camera_set_mode(camera_h camera, camera_mode_e mode ){$/;"	f
+camera_set_preview_cb	src/camera.c	/^int camera_set_preview_cb( camera_h camera, camera_preview_cb callback, void* user_data ){$/;"	f
+camera_set_preview_format	src/camera.c	/^int camera_set_preview_format(camera_h camera, camera_pixel_format_e format){$/;"	f
+camera_set_preview_resolution	src/camera.c	/^int camera_set_preview_resolution(camera_h camera,  int width, int height){$/;"	f
+camera_set_state_changed_cb	src/camera.c	/^int camera_set_state_changed_cb(camera_h camera, camera_state_changed_cb callback, void* user_data){$/;"	f
+camera_set_x11_display_mode	src/camera.c	/^int camera_set_x11_display_mode( camera_h camera , camera_display_mode_e ratio){$/;"	f
+camera_set_x11_display_rotation	src/camera.c	/^int camera_set_x11_display_rotation(camera_h camera,  camera_display_rotation_e rotation){$/;"	f
+camera_set_x11_display_visible	src/camera.c	/^int camera_set_x11_display_visible(camera_h camera, bool visible){$/;"	f
+camera_start_capture	src/camera.c	/^int camera_start_capture(camera_h camera){$/;"	f
+camera_start_focusing	src/camera.c	/^int camera_start_focusing( camera_h camera ){$/;"	f
+camera_start_preview	src/camera.c	/^int camera_start_preview(camera_h camera){$/;"	f
+camera_state_change_test	test/multimedia_camera_test.c	/^int camera_state_change_test(){$/;"	f
+camera_state_changed_cb	include/camera.h	/^typedef void (*camera_state_changed_cb)(camera_state_e previous, camera_state_e current,$/;"	t
+camera_state_e	include/camera.h	/^} camera_state_e;$/;"	t	typeref:enum:__anon8
+camera_stop_preview	src/camera.c	/^int camera_stop_preview(camera_h camera){$/;"	f
+camera_supported_capture_format_cb	include/camera.h	/^typedef bool (*camera_supported_capture_format_cb)(camera_pixel_format_e format,$/;"	t
+camera_supported_capture_resolution_cb	include/camera.h	/^typedef bool (*camera_supported_capture_resolution_cb)(int width, int height, void *user_data);$/;"	t
+camera_supported_preview_format_cb	include/camera.h	/^typedef bool (*camera_supported_preview_format_cb)(camera_pixel_format_e format,$/;"	t
+camera_supported_preview_resolution_cb	include/camera.h	/^typedef bool (*camera_supported_preview_resolution_cb)(int width, int height, void *user_data);$/;"	t
+camera_test	test/multimedia_camera_test.c	/^int camera_test(){$/;"	f
+camera_unset_capture_completed_cb	src/camera.c	/^int camera_unset_capture_completed_cb(camera_h camera){$/;"	f
+camera_unset_capturing_cb	src/camera.c	/^int camera_unset_capturing_cb( camera_h camera){$/;"	f
+camera_unset_error_cb	src/camera.c	/^int camera_unset_error_cb(camera_h camera){$/;"	f
+camera_unset_focus_changed_cb	src/camera.c	/^int camera_unset_focus_changed_cb(camera_h camera){$/;"	f
+camera_unset_preview_cb	src/camera.c	/^int camera_unset_preview_cb( camera_h camera){$/;"	f
+camera_unset_state_changed_cb	src/camera.c	/^int camera_unset_state_changed_cb(camera_h camera){$/;"	f
+capture_cb	TC/testcase/utc_media_camera_working.c	/^void capture_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data)$/;"	f
+capture_complete	TC/testcase/utc_media_camera_working.c	/^int capture_complete(void *user_data){$/;"	f
+capture_complete	test/multimedia_camera_test.c	/^int capture_complete(void *user_data){$/;"	f
+capture_resolution_test	test/multimedia_camera_test.c	/^int capture_resolution_test(){$/;"	f
+capture_resolution_test_cb	TC/testcase/utc_media_camera_working.c	/^bool capture_resolution_test_cb(int width, int height,  void *user_data){$/;"	f
+capture_resolution_test_cb	test/multimedia_camera_test.c	/^bool capture_resolution_test_cb(int width, int height, void *user_data){$/;"	f
+capture_test	test/multimedia_camera_test.c	/^int capture_test(){$/;"	f
+capturing_cb	test/multimedia_camera_test.c	/^void capturing_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data)$/;"	f
+cleanup	TC/testcase/utc_media_camera_attr.c	/^static void cleanup(void)$/;"	f	file:
+cleanup	TC/testcase/utc_media_camera_lifecycle.c	/^static void cleanup(void)$/;"	f	file:
+cleanup	TC/testcase/utc_media_camera_setting.c	/^static void cleanup(void)$/;"	f	file:
+cleanup	TC/testcase/utc_media_camera_working.c	/^static void cleanup(void)$/;"	f	file:
+contrast_test	TC/testcase/utc_media_camera_working.c	/^int contrast_test(camera_h camera){$/;"	f
+contrast_test	test/multimedia_camera_test.c	/^int contrast_test(camera_h camera){$/;"	f
+count	TC/testcase/utc_media_camera_working.c	/^	int count;$/;"	m	struct:__anon3	file:
+count	test/multimedia_camera_test.c	/^	int count;$/;"	m	struct:__anon27	file:
+display_handle	include/camera_private.h	/^	void* display_handle;$/;"	m	struct:_camera_s
+display_type	include/camera_private.h	/^	camera_display_type_e display_type;$/;"	m	struct:_camera_s
+effect_test	TC/testcase/utc_media_camera_working.c	/^int effect_test(camera_h camera){$/;"	f
+effect_test	test/multimedia_camera_test.c	/^int effect_test(camera_h camera){$/;"	f
+event_thread	TC/testcase/utc_media_camera_lifecycle.c	/^static GThread *event_thread;$/;"	v	file:
+event_thread	TC/testcase/utc_media_camera_working.c	/^static GThread *event_thread;$/;"	v	file:
+expected_height	TC/testcase/utc_media_camera_working.c	/^	int expected_height;$/;"	m	struct:__anon4	file:
+expected_height	test/multimedia_camera_test.c	/^	int expected_height;$/;"	m	struct:__anon28	file:
+expected_width	TC/testcase/utc_media_camera_working.c	/^	int expected_width;$/;"	m	struct:__anon4	file:
+expected_width	test/multimedia_camera_test.c	/^	int expected_width;$/;"	m	struct:__anon28	file:
+exposure_mode_test	TC/testcase/utc_media_camera_working.c	/^int exposure_mode_test(camera_h camera){$/;"	f
+exposure_mode_test	test/multimedia_camera_test.c	/^int exposure_mode_test(camera_h camera){$/;"	f
+exposure_test	TC/testcase/utc_media_camera_working.c	/^int exposure_test(camera_h camera){$/;"	f
+exposure_test	test/multimedia_camera_test.c	/^int exposure_test(camera_h camera){$/;"	f
+flash_mode_test	TC/testcase/utc_media_camera_working.c	/^int flash_mode_test(camera_h camera){$/;"	f
+flash_mode_test	test/multimedia_camera_test.c	/^int flash_mode_test(camera_h camera){$/;"	f
+focus_test	test/multimedia_camera_test.c	/^void focus_test(){$/;"	f
+g_af_test_pass	TC/testcase/utc_media_camera_working.c	/^bool g_af_test_pass ; $/;"	v
+g_af_test_pass	test/multimedia_camera_test.c	/^bool g_af_test_pass ; $/;"	v
+g_exposure_mode_pass	TC/testcase/utc_media_camera_working.c	/^bool g_exposure_mode_pass;$/;"	v
+g_exposure_mode_pass	test/multimedia_camera_test.c	/^bool g_exposure_mode_pass;$/;"	v
+g_iso_test_pass	TC/testcase/utc_media_camera_working.c	/^bool g_iso_test_pass ;$/;"	v
+g_iso_test_pass	test/multimedia_camera_test.c	/^bool g_iso_test_pass ;$/;"	v
+g_mainloop	TC/testcase/utc_media_camera_lifecycle.c	/^static GMainLoop *g_mainloop = NULL;$/;"	v	file:
+g_mainloop	TC/testcase/utc_media_camera_setting.c	/^static GMainLoop *g_mainloop = NULL;$/;"	v	file:
+g_mainloop	TC/testcase/utc_media_camera_working.c	/^static GMainLoop *g_mainloop = NULL;$/;"	v	file:
+g_preview_fps_pass	TC/testcase/utc_media_camera_working.c	/^bool g_preview_fps_pass;$/;"	v
+g_preview_fps_pass	test/multimedia_camera_test.c	/^bool g_preview_fps_pass;$/;"	v
+gps_test	TC/testcase/utc_media_camera_working.c	/^int gps_test(camera_h camera){$/;"	f
+gps_test	test/multimedia_camera_test.c	/^int gps_test(camera_h camera){$/;"	f
+height	TC/testcase/utc_media_camera_working.c	/^	int height[100];$/;"	m	struct:__anon3	file:
+height	test/multimedia_camera_test.c	/^	int height[100];$/;"	m	struct:__anon27	file:
+image_quality_test	TC/testcase/utc_media_camera_working.c	/^int image_quality_test(camera_h camera){$/;"	f
+image_quality_test	test/multimedia_camera_test.c	/^int image_quality_test(camera_h camera){$/;"	f
+img	test/multimedia_camera_test.c	/^Evas_Object* img;$/;"	v
+in_format	TC/testcase/utc_media_camera_working.c	/^	camera_pixel_format_e in_format;$/;"	m	struct:__anon1	file:
+in_format	test/multimedia_camera_test.c	/^	camera_pixel_format_e in_format;$/;"	m	struct:__anon25	file:
+iscalled	TC/testcase/utc_media_camera_working.c	/^	bool iscalled;$/;"	m	struct:__anon1	file:
+iscalled	TC/testcase/utc_media_camera_working.c	/^	bool iscalled;$/;"	m	struct:__anon2	file:
+iscalled	test/multimedia_camera_test.c	/^	bool iscalled;$/;"	m	struct:__anon25	file:
+iscalled	test/multimedia_camera_test.c	/^	bool iscalled;$/;"	m	struct:__anon26	file:
+iscaptured	TC/testcase/utc_media_camera_working.c	/^	bool iscaptured;$/;"	m	struct:__anon2	file:
+iscaptured	test/multimedia_camera_test.c	/^	bool iscaptured;$/;"	m	struct:__anon26	file:
+iscapturing	TC/testcase/utc_media_camera_working.c	/^	bool iscapturing;$/;"	m	struct:__anon2	file:
+iscapturing	test/multimedia_camera_test.c	/^	bool iscapturing;$/;"	m	struct:__anon26	file:
+iso_test	TC/testcase/utc_media_camera_working.c	/^int iso_test(camera_h camera){$/;"	f
+iso_test	test/multimedia_camera_test.c	/^int iso_test(camera_h camera){$/;"	f
+ispass	TC/testcase/utc_media_camera_working.c	/^	bool ispass;$/;"	m	struct:__anon4	file:
+ispass	test/multimedia_camera_test.c	/^	bool ispass;$/;"	m	struct:__anon28	file:
+ispreviewed	TC/testcase/utc_media_camera_working.c	/^	bool ispreviewed;$/;"	m	struct:__anon2	file:
+ispreviewed	test/multimedia_camera_test.c	/^	bool ispreviewed;$/;"	m	struct:__anon26	file:
+mEvasWindow	test/multimedia_camera_test.c	/^Evas_Object* mEvasWindow;$/;"	v
+main	test/multimedia_camera_test.c	/^int main(int argc, char ** argv)$/;"	f
+mm_capture_callback	src/camera.c	/^gboolean mm_capture_callback(MMCamcorderCaptureDataType *frame, MMCamcorderCaptureDataType *thumbnail, void *user_data){$/;"	f
+mm_handle	include/camera_private.h	/^	MMHandleType mm_handle;$/;"	m	struct:_camera_s
+mm_message_callback	src/camera.c	/^int mm_message_callback(int message, void *param, void *user_data){$/;"	f
+mm_videostream_callback	src/camera.c	/^gboolean mm_videostream_callback(MMCamcorderVideoStreamDataType * stream, void *user_data){$/;"	f
+preview_fps_test	TC/testcase/utc_media_camera_working.c	/^int preview_fps_test(camera_h camera)$/;"	f
+preview_fps_test	test/multimedia_camera_test.c	/^int preview_fps_test(camera_h camera)$/;"	f
+preview_resolution_cb	test/multimedia_camera_test.c	/^bool preview_resolution_cb(int width, int height, void *user_data)$/;"	f
+preview_test	test/multimedia_camera_test.c	/^void preview_test(){$/;"	f
+preview_test_data	TC/testcase/utc_media_camera_working.c	/^}preview_test_data;$/;"	t	typeref:struct:__anon4	file:
+preview_test_data	test/multimedia_camera_test.c	/^}preview_test_data;$/;"	t	typeref:struct:__anon28	file:
+preview_win	TC/testcase/utc_media_camera_working.c	/^int preview_win = 0;	$/;"	v
+preview_win	test/multimedia_camera_test.c	/^Ecore_X_Window preview_win;$/;"	v
+resolution_stack	TC/testcase/utc_media_camera_working.c	/^} resolution_stack;$/;"	t	typeref:struct:__anon3	file:
+resolution_stack	test/multimedia_camera_test.c	/^} resolution_stack;$/;"	t	typeref:struct:__anon27	file:
+result	TC/testcase/utc_media_camera_working.c	/^	bool result;$/;"	m	struct:__anon1	file:
+result	test/multimedia_camera_test.c	/^	bool result;$/;"	m	struct:__anon25	file:
+rotation_test	test/multimedia_camera_test.c	/^void rotation_test(){$/;"	f
+scene_mode_test	TC/testcase/utc_media_camera_working.c	/^int scene_mode_test(camera_h camera){$/;"	f
+scene_mode_test	test/multimedia_camera_test.c	/^int scene_mode_test(camera_h camera){$/;"	f
+startup	TC/testcase/utc_media_camera_attr.c	/^static void startup(void)$/;"	f	file:
+startup	TC/testcase/utc_media_camera_lifecycle.c	/^static void startup(void)$/;"	f	file:
+startup	TC/testcase/utc_media_camera_setting.c	/^static void startup(void)$/;"	f	file:
+startup	TC/testcase/utc_media_camera_working.c	/^static void startup(void)$/;"	f	file:
+state	TC/testcase/utc_media_camera_working.c	/^	camera_state_e state;$/;"	m	struct:__anon2	file:
+state	include/camera_private.h	/^	int state;$/;"	m	struct:_camera_s
+state	test/multimedia_camera_test.c	/^	camera_state_e state;$/;"	m	struct:__anon26	file:
+state_cb	TC/testcase/utc_media_camera_working.c	/^void state_cb(camera_state_e previous , camera_state_e current , int by_asm, void *user_data){$/;"	f
+state_cb	test/multimedia_camera_test.c	/^void state_cb(camera_state_e previous , camera_state_e current , int by_asm, const void *user_data){$/;"	f
+state_change_data	TC/testcase/utc_media_camera_working.c	/^} state_change_data;$/;"	t	typeref:struct:__anon2	file:
+state_change_data	test/multimedia_camera_test.c	/^} state_change_data;$/;"	t	typeref:struct:__anon26	file:
+stillshot_test	test/multimedia_camera_test.c	/^int stillshot_test(){$/;"	f
+tag_enable_test	TC/testcase/utc_media_camera_working.c	/^int tag_enable_test(camera_h camera){$/;"	f
+tag_enable_test	test/multimedia_camera_test.c	/^int tag_enable_test(camera_h camera){$/;"	f
+tag_image_description_test	TC/testcase/utc_media_camera_working.c	/^int tag_image_description_test(camera_h camera){$/;"	f
+tag_image_description_test	test/multimedia_camera_test.c	/^int tag_image_description_test(camera_h camera){$/;"	f
+tag_orientation_test	TC/testcase/utc_media_camera_working.c	/^int tag_orientation_test(camera_h camera){$/;"	f
+tag_orientation_test	test/multimedia_camera_test.c	/^int tag_orientation_test(camera_h camera){$/;"	f
+tag_software_test	TC/testcase/utc_media_camera_working.c	/^int tag_software_test(camera_h camera){$/;"	f
+tag_software_test	test/multimedia_camera_test.c	/^int tag_software_test(camera_h camera){$/;"	f
+test_main	test/multimedia_camera_test.c	/^void* test_main(void *arg){$/;"	f
+tet_cleanup	TC/testcase/utc_media_camera_attr.c	/^void (*tet_cleanup)(void) = cleanup;$/;"	v
+tet_cleanup	TC/testcase/utc_media_camera_lifecycle.c	/^void (*tet_cleanup)(void) = cleanup;$/;"	v
+tet_cleanup	TC/testcase/utc_media_camera_setting.c	/^void (*tet_cleanup)(void) = cleanup;$/;"	v
+tet_cleanup	TC/testcase/utc_media_camera_working.c	/^void (*tet_cleanup)(void) = cleanup;$/;"	v
+tet_startup	TC/testcase/utc_media_camera_attr.c	/^void (*tet_startup)(void) = startup;$/;"	v
+tet_startup	TC/testcase/utc_media_camera_lifecycle.c	/^void (*tet_startup)(void) = startup;$/;"	v
+tet_startup	TC/testcase/utc_media_camera_setting.c	/^void (*tet_startup)(void) = startup;$/;"	v
+tet_startup	TC/testcase/utc_media_camera_working.c	/^void (*tet_startup)(void) = startup;$/;"	v
+tet_testlist	TC/testcase/utc_media_camera_attr.c	/^struct tet_testlist tet_testlist[] = {$/;"	v	typeref:struct:tet_testlist
+tet_testlist	TC/testcase/utc_media_camera_lifecycle.c	/^struct tet_testlist tet_testlist[] = {$/;"	v	typeref:struct:tet_testlist
+tet_testlist	TC/testcase/utc_media_camera_setting.c	/^struct tet_testlist tet_testlist[] = {$/;"	v	typeref:struct:tet_testlist
+tet_testlist	TC/testcase/utc_media_camera_working.c	/^struct tet_testlist tet_testlist[] = {$/;"	v	typeref:struct:tet_testlist
+user_cb	include/camera_private.h	/^	void* user_cb[_CAMERA_EVENT_TYPE_NUM];$/;"	m	struct:_camera_s
+user_data	include/camera_private.h	/^	void* user_data[_CAMERA_EVENT_TYPE_NUM];$/;"	m	struct:_camera_s
+utc_camera_foreach_supported_capture_format_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_foreach_supported_capture_format_negative(void)$/;"	f	file:
+utc_camera_foreach_supported_capture_format_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_foreach_supported_capture_format_positive(void)$/;"	f	file:
+utc_camera_foreach_supported_capture_resolution_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_foreach_supported_capture_resolution_negative(void)$/;"	f	file:
+utc_camera_foreach_supported_capture_resolution_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_foreach_supported_capture_resolution_positive(void)$/;"	f	file:
+utc_camera_foreach_supported_preview_format_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_foreach_supported_preview_format_negative(void)$/;"	f	file:
+utc_camera_foreach_supported_preview_format_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_foreach_supported_preview_format_positive(void)$/;"	f	file:
+utc_camera_foreach_supported_preview_resolution_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_foreach_supported_preview_resolution_negative(void)$/;"	f	file:
+utc_camera_foreach_supported_preview_resolution_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_foreach_supported_preview_resolution_positive(void)$/;"	f	file:
+utc_camera_get_capture_format_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_get_capture_format_negative(void)$/;"	f	file:
+utc_camera_get_capture_format_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_get_capture_format_positive(void)$/;"	f	file:
+utc_camera_get_capture_resolution_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_get_capture_resolution_negative(void)$/;"	f	file:
+utc_camera_get_capture_resolution_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_get_capture_resolution_positive(void)$/;"	f	file:
+utc_camera_get_display_rotation_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_get_display_rotation_negative(void)$/;"	f	file:
+utc_camera_get_display_rotation_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_get_display_rotation_positive(void)$/;"	f	file:
+utc_camera_get_preview_format_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_get_preview_format_negative(void)$/;"	f	file:
+utc_camera_get_preview_format_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_get_preview_format_positive(void)$/;"	f	file:
+utc_camera_get_preview_resolution_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_get_preview_resolution_negative(void)$/;"	f	file:
+utc_camera_get_preview_resolution_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_get_preview_resolution_positive(void)$/;"	f	file:
+utc_camera_get_x11_display_mode_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_get_x11_display_mode_negative(void){$/;"	f	file:
+utc_camera_get_x11_display_mode_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_get_x11_display_mode_positive(void){$/;"	f	file:
+utc_camera_is_x11_display_visible_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_is_x11_display_visible_negative(void){$/;"	f	file:
+utc_camera_is_x11_display_visible_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_is_x11_display_visible_positive(void){$/;"	f	file:
+utc_camera_set_capture_completed_cb_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_capture_completed_cb_negative(void)$/;"	f	file:
+utc_camera_set_capture_completed_cb_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_capture_completed_cb_positive(void)$/;"	f	file:
+utc_camera_set_capture_format_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_capture_format_negative(void)$/;"	f	file:
+utc_camera_set_capture_format_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_capture_format_positive(void)$/;"	f	file:
+utc_camera_set_capture_resolution_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_capture_resolution_negative(void)$/;"	f	file:
+utc_camera_set_capture_resolution_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_capture_resolution_positive(void)$/;"	f	file:
+utc_camera_set_capturing_cb_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_capturing_cb_negative(void)$/;"	f	file:
+utc_camera_set_capturing_cb_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_capturing_cb_positive(void)$/;"	f	file:
+utc_camera_set_display_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_display_negative(void)$/;"	f	file:
+utc_camera_set_display_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_display_positive(void)$/;"	f	file:
+utc_camera_set_display_rotation_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_display_rotation_negative(void)$/;"	f	file:
+utc_camera_set_display_rotation_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_display_rotation_positive(void)$/;"	f	file:
+utc_camera_set_error_cb_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_error_cb_negative(void)$/;"	f	file:
+utc_camera_set_error_cb_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_error_cb_positive(void)$/;"	f	file:
+utc_camera_set_focus_changed_cb_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_focus_changed_cb_negative(void)$/;"	f	file:
+utc_camera_set_focus_changed_cb_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_focus_changed_cb_positive(void)$/;"	f	file:
+utc_camera_set_preview_cb_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_preview_cb_negative(void)$/;"	f	file:
+utc_camera_set_preview_cb_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_preview_cb_positive(void)$/;"	f	file:
+utc_camera_set_preview_format_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_preview_format_negative(void)$/;"	f	file:
+utc_camera_set_preview_format_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_preview_format_positive(void)$/;"	f	file:
+utc_camera_set_preview_resolution_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_preview_resolution_negative(void)$/;"	f	file:
+utc_camera_set_preview_resolution_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_preview_resolution_positive(void)$/;"	f	file:
+utc_camera_set_state_changed_cb_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_state_changed_cb_negative(void)$/;"	f	file:
+utc_camera_set_state_changed_cb_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_state_changed_cb_positive(void)$/;"	f	file:
+utc_camera_set_x11_display_mode_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_x11_display_mode_negative(void){$/;"	f	file:
+utc_camera_set_x11_display_mode_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_x11_display_mode_positive(void){$/;"	f	file:
+utc_camera_set_x11_display_visible_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_x11_display_visible_negative(void){$/;"	f	file:
+utc_camera_set_x11_display_visible_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_set_x11_display_visible_positive(void){$/;"	f	file:
+utc_camera_unset_capture_completed_cb_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_unset_capture_completed_cb_negative(void)$/;"	f	file:
+utc_camera_unset_capture_completed_cb_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_unset_capture_completed_cb_positive(void)$/;"	f	file:
+utc_camera_unset_capturing_cb_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_unset_capturing_cb_negative(void)$/;"	f	file:
+utc_camera_unset_capturing_cb_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_unset_capturing_cb_positive(void)$/;"	f	file:
+utc_camera_unset_error_cb_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_unset_error_cb_negative(void)$/;"	f	file:
+utc_camera_unset_error_cb_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_unset_error_cb_positive(void)$/;"	f	file:
+utc_camera_unset_focus_changed_cb_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_unset_focus_changed_cb_negative(void)$/;"	f	file:
+utc_camera_unset_focus_changed_cb_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_unset_focus_changed_cb_positive(void)$/;"	f	file:
+utc_camera_unset_preview_cb_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_unset_preview_cb_negative(void)$/;"	f	file:
+utc_camera_unset_preview_cb_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_unset_preview_cb_positive(void)$/;"	f	file:
+utc_camera_unset_state_changed_cb_negative	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_unset_state_changed_cb_negative(void)$/;"	f	file:
+utc_camera_unset_state_changed_cb_positive	TC/testcase/utc_media_camera_setting.c	/^static void utc_camera_unset_state_changed_cb_positive(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_af_mode_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_af_mode_negative(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_af_mode_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_af_mode_positive(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_effect_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_effect_negative(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_effect_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_effect_positive(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_exposure_mode_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_exposure_mode_negative(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_exposure_mode_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_exposure_mode_positive(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_flash_mode_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_flash_mode_negative(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_flash_mode_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_flash_mode_positive(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_fps_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_fps_negative(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_fps_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_fps_positive(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_iso_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_iso_negative(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_iso_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_iso_positive(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_scene_mode_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_scene_mode_negative(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_scene_mode_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_scene_mode_positive(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_whitebalance_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_whitebalance_negative(void)$/;"	f	file:
+utc_media_camera_attr_foreach_supported_whitebalance_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_foreach_supported_whitebalance_positive(void)$/;"	f	file:
+utc_media_camera_attr_get_effect_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_effect_negative(void)$/;"	f	file:
+utc_media_camera_attr_get_effect_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_effect_positive(void)$/;"	f	file:
+utc_media_camera_attr_get_flash_mode_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_flash_mode_negative(void)$/;"	f	file:
+utc_media_camera_attr_get_flash_mode_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_flash_mode_positive(void)$/;"	f	file:
+utc_media_camera_attr_get_image_quality_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_image_quality_negative(void)$/;"	f	file:
+utc_media_camera_attr_get_image_quality_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_image_quality_positive(void)$/;"	f	file:
+utc_media_camera_attr_get_lens_orientation_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_lens_orientation_negative(void)$/;"	f	file:
+utc_media_camera_attr_get_lens_orientation_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_lens_orientation_positive(void)$/;"	f	file:
+utc_media_camera_attr_get_preview_fps_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_preview_fps_negative(void)$/;"	f	file:
+utc_media_camera_attr_get_preview_fps_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_preview_fps_positive(void)$/;"	f	file:
+utc_media_camera_attr_get_scene_mode_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_scene_mode_negative(void)$/;"	f	file:
+utc_media_camera_attr_get_scene_mode_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_scene_mode_positive(void)$/;"	f	file:
+utc_media_camera_attr_get_tag_altitude_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_tag_altitude_negative(void)$/;"	f	file:
+utc_media_camera_attr_get_tag_altitude_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_tag_altitude_positive(void)$/;"	f	file:
+utc_media_camera_attr_get_tag_image_description_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_tag_image_description_negative(void)$/;"	f	file:
+utc_media_camera_attr_get_tag_image_description_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_tag_image_description_positive(void)$/;"	f	file:
+utc_media_camera_attr_get_tag_latitude_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_tag_latitude_negative(void)$/;"	f	file:
+utc_media_camera_attr_get_tag_latitude_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_tag_latitude_positive(void)$/;"	f	file:
+utc_media_camera_attr_get_tag_longitude_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_tag_longitude_negative(void)$/;"	f	file:
+utc_media_camera_attr_get_tag_longitude_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_tag_longitude_positive(void)$/;"	f	file:
+utc_media_camera_attr_get_tag_orientation_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_tag_orientation_negative(void)$/;"	f	file:
+utc_media_camera_attr_get_tag_orientation_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_tag_orientation_positive(void)$/;"	f	file:
+utc_media_camera_attr_get_tag_software_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_tag_software_negative(void)$/;"	f	file:
+utc_media_camera_attr_get_tag_software_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_get_tag_software_positive(void)$/;"	f	file:
+utc_media_camera_attr_is_enable_tag_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_is_enable_tag_negative(void)$/;"	f	file:
+utc_media_camera_attr_is_enable_tag_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_is_enable_tag_positive(void)$/;"	f	file:
+utc_media_camera_attr_set_af_mode_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_af_mode_negative(void)$/;"	f	file:
+utc_media_camera_attr_set_af_mode_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_af_mode_positive(void)$/;"	f	file:
+utc_media_camera_attr_set_brightness_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_brightness_negative(void)$/;"	f	file:
+utc_media_camera_attr_set_brightness_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_brightness_positive(void)$/;"	f	file:
+utc_media_camera_attr_set_contrast_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_contrast_negative(void)$/;"	f	file:
+utc_media_camera_attr_set_contrast_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_contrast_positive(void)$/;"	f	file:
+utc_media_camera_attr_set_exposure_mode_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_exposure_mode_negative(void)$/;"	f	file:
+utc_media_camera_attr_set_exposure_mode_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_exposure_mode_positive(void)$/;"	f	file:
+utc_media_camera_attr_set_exposure_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_exposure_negative(void)$/;"	f	file:
+utc_media_camera_attr_set_exposure_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_exposure_positive(void)$/;"	f	file:
+utc_media_camera_attr_set_image_quality_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_image_quality_negative(void)$/;"	f	file:
+utc_media_camera_attr_set_image_quality_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_image_quality_positive(void)$/;"	f	file:
+utc_media_camera_attr_set_iso_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_iso_negative(void)$/;"	f	file:
+utc_media_camera_attr_set_iso_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_iso_positive(void)$/;"	f	file:
+utc_media_camera_attr_set_preview_fps_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_preview_fps_negative(void)$/;"	f	file:
+utc_media_camera_attr_set_preview_fps_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_preview_fps_positive(void)$/;"	f	file:
+utc_media_camera_attr_set_whitebalance_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_whitebalance_negative(void)$/;"	f	file:
+utc_media_camera_attr_set_whitebalance_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_whitebalance_positive(void)$/;"	f	file:
+utc_media_camera_attr_set_zoom_negative	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_zoom_negative(void)$/;"	f	file:
+utc_media_camera_attr_set_zoom_positive	TC/testcase/utc_media_camera_attr.c	/^static void utc_media_camera_attr_set_zoom_positive(void)$/;"	f	file:
+utc_media_camera_attribute_test	TC/testcase/utc_media_camera_working.c	/^void utc_media_camera_attribute_test(void)$/;"	f
+utc_media_camera_cancel_focusing_negative	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_cancel_focusing_negative(void)$/;"	f	file:
+utc_media_camera_cancel_focusing_positive	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_cancel_focusing_positive(void)$/;"	f	file:
+utc_media_camera_capture_test	TC/testcase/utc_media_camera_working.c	/^void utc_media_camera_capture_test(void){$/;"	f
+utc_media_camera_create_negative	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_create_negative(void)$/;"	f	file:
+utc_media_camera_create_positive	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_create_positive(void)$/;"	f	file:
+utc_media_camera_destroy_negative	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_destroy_negative(void)$/;"	f	file:
+utc_media_camera_destroy_positive	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_destroy_positive(void)$/;"	f	file:
+utc_media_camera_get_state_negative	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_get_state_negative(void)$/;"	f	file:
+utc_media_camera_get_state_positive	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_get_state_positive(void)$/;"	f	file:
+utc_media_camera_preview_test	TC/testcase/utc_media_camera_working.c	/^void utc_media_camera_preview_test(void)$/;"	f
+utc_media_camera_start_capture_negative	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_start_capture_negative(void)$/;"	f	file:
+utc_media_camera_start_capture_positive	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_start_capture_positive(void)$/;"	f	file:
+utc_media_camera_start_focusing_negative	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_start_focusing_negative(void)$/;"	f	file:
+utc_media_camera_start_focusing_positive	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_start_focusing_positive(void)$/;"	f	file:
+utc_media_camera_start_preview_negative	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_start_preview_negative(void)$/;"	f	file:
+utc_media_camera_start_preview_positive	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_start_preview_positive(void)$/;"	f	file:
+utc_media_camera_state_change_test	TC/testcase/utc_media_camera_working.c	/^void utc_media_camera_state_change_test(void){$/;"	f
+utc_media_camera_stop_preview_negative	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_stop_preview_negative(void)$/;"	f	file:
+utc_media_camera_stop_preview_positive	TC/testcase/utc_media_camera_lifecycle.c	/^static void utc_media_camera_stop_preview_positive(void)$/;"	f	file:
+utc_media_capture_resolution_test	TC/testcase/utc_media_camera_working.c	/^void utc_media_capture_resolution_test(void){$/;"	f
+whitebalance_test	TC/testcase/utc_media_camera_working.c	/^int whitebalance_test(camera_h camera){$/;"	f
+whitebalance_test	test/multimedia_camera_test.c	/^int whitebalance_test(camera_h camera){$/;"	f
+width	TC/testcase/utc_media_camera_working.c	/^	int width[100];$/;"	m	struct:__anon3	file:
+width	test/multimedia_camera_test.c	/^	int width[100];$/;"	m	struct:__anon27	file:
+win	test/multimedia_camera_test.c	/^	Evas_Object* win;$/;"	m	struct:__anon24	file:
+zoom_test	TC/testcase/utc_media_camera_working.c	/^int zoom_test(camera_h camera){$/;"	f
+zoom_test	test/multimedia_camera_test.c	/^int zoom_test(camera_h camera){$/;"	f
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 421664d..73c466c 100755..100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,7 +1,7 @@
 SET(fw_test "${fw_name}-test")
 
 INCLUDE(FindPkgConfig)
-pkg_check_modules(${fw_test} REQUIRED mm-camcorder appcore-efl elementary evas ecore edje ecore-x)
+pkg_check_modules(${fw_test} REQUIRED mm-camcorder elementary evas ecore edje ecore-x)
 FOREACH(flag ${${fw_test}_CFLAGS})
     SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
     MESSAGE(${flag})
diff --git a/test/multimedia_camera_test.c b/test/multimedia_camera_test.c
index d9cf40c..47ffb1e 100755
--- a/test/multimedia_camera_test.c
+++ b/test/multimedia_camera_test.c
@@ -49,15 +49,15 @@ void state_cb(camera_state_e previous , camera_state_e current , int by_asm, con
 }
 
 
-void capturing_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data)
+void capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data)
 {
 	char * filepath = (char*)user_data;
 	FILE* f = fopen(filepath, "w+");
 	bool ret;
-	if(f!=NULL && image_buffer !=NULL)
+	if(f!=NULL && image !=NULL)
 	{
-		fwrite(image_buffer,1,  buffer_size, f);
-		printf("capture(%s) %dx%d, buffer_size=%d\n", filepath, width, height, buffer_size);
+		fwrite(image->data,1,  image->size, f);
+		printf("capture(%s) %dx%d, buffer_size=%d\n", filepath, image->width, image->height, image->size);
 		ret = TRUE;
 	}
 	else
@@ -80,9 +80,8 @@ int capture_complete(void *user_data){
 
 int stillshot_test(){
 	camera_h camera;
-	camera_create(CAMERA_DEVICE_CAMERA1, &camera);
+	camera_create(CAMERA_DEVICE_CAMERA0, &camera);
 	camera_attr_set_image_quality(camera, 100);
-	camera_set_capturing_cb(camera, capturing_cb, "/mnt/nfs/test.jpg");
 	camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
 	camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
 	camera_attr_set_tag_orientation(camera,6);
@@ -91,10 +90,10 @@ int stillshot_test(){
 	camera_set_capture_format(camera, CAMERA_PIXEL_FORMAT_JPEG);
 	
 	camera_start_preview(camera);
-	camera_start_focusing(camera);
+	camera_start_focusing(camera, false);
 
 	sleep(1);
-	camera_start_capture(camera);
+	camera_start_capture(camera, capturing_cb, NULL, "/mnt/nfs/test.jpg");
 	sleep(1);
 	camera_start_preview(camera);
 	camera_stop_preview(camera);
@@ -178,16 +177,19 @@ int zoom_test(camera_h camera){
 	int ret1 ;
 	int ret2 ;	
 	int i;
+	int min, max;
 	printf("------------- ZOOM TEST -------------\n");
-	
-	for( i = 0 ; i <= 40 ; i+=5 ){
+	camera_attr_get_zoom_range(camera, &min, &max);
+	if(max == -1 )
+		return 0;
+	for( i = min ; i <= max; i+=5 ){
 		int zoom;
 		ret1 = camera_attr_set_zoom(camera, i);
 		printf("-set zoom %d\tret=%x\n",i, ret1);
 		ret2 = camera_attr_get_zoom(camera,&zoom);
 		printf("-get zoom %d\tret=%x",zoom, ret2);
 
-		if( i >=10 && i <= 30 ){
+		if( i >=min && i <= max ){
 			if( i == zoom )
 				printf("\t\t\tpass\n");
 			else{
@@ -245,9 +247,11 @@ bool _exposure_mode_test_cb(camera_attr_exposure_mode_e mode, void *user_data){
 	ret = camera_attr_get_exposure_mode(camera,&get_mode);
 	printf("-get exposure mode %d\tret=%x\n", get_mode,ret);		
 	if( get_mode != mode ){
+		printf("\t\t\tFAIL\n");
 		g_exposure_mode_pass = false;
 		return false;
-	}
+	}else
+		printf("\t\t\tPASS\n");
 	return true;
 }
 
@@ -255,7 +259,6 @@ int exposure_mode_test(camera_h camera){
 	g_exposure_mode_pass = true;
 	camera_attr_foreach_supported_exposure_mode(camera,_exposure_mode_test_cb, camera);
 	camera_attr_set_exposure_mode(camera, CAMERA_ATTR_EXPOSURE_MODE_ALL);
-	
 	return g_exposure_mode_pass ? 0 : -1;
 }
 
@@ -263,14 +266,19 @@ int exposure_test(camera_h camera){
 	int i;
 	int ret1, ret2;
 	int default_value;
+	int min,max;
 	ret1 = camera_attr_get_exposure(camera, &default_value );	
-	for( i = 0; i < 13 ; i++ ){
+	camera_attr_get_exposure_range(camera, &min, &max);
+	printf("exposure range %d~%d\n", min, max);
+	if(max == -1 )
+		return 0;
+	for( i = 1; i < 13 ; i++ ){
 		int value;
 		ret1 = camera_attr_set_exposure(camera, i );
 		printf("-set exposure %d\tret=%x\n",i,ret1);
 		ret2 = camera_attr_get_exposure(camera, &value);
 		printf("-get exposure %d\tret=%x\n",value,ret2);
-		if( i >= 1 && i <= 7 ){
+		if( i >= min && i <= max ){
 			if( value != i)
 				return -1;
 		}else{ // out of bound error
@@ -308,15 +316,19 @@ int brightness_test(camera_h camera){
 	int i;
 	int ret1,ret2;
 	int default_value;
+	int min,max;
 	ret1 = camera_attr_get_brightness(camera, &default_value );	
-	for( i = 0; i < 13 ; i++ ){
+	camera_attr_get_brightness_range(camera, &min, &max);
+	if(max == -1 )
+		return 0;
+	for( i = 1; i < 13 ; i++ ){
 		int value;
 		ret1 = camera_attr_set_brightness(camera, i );
 		printf("-set brightness %d\tret=%x\n",i,ret1);
 		ret2 = camera_attr_get_brightness(camera, &value);
 		printf("-get brightness %d\tret=%x\n",value,ret2);
 
-		if( i >= 1 && i <= 7 ){
+		if( i >= min && i <= max ){
 			if( value != i)
 				return -1;
 		}else{ // out of bound error
@@ -334,15 +346,19 @@ int contrast_test(camera_h camera){
 	int i;
 	int ret1,ret2;
 	int default_value;
+	int min,max;
 	ret1 = camera_attr_get_contrast (camera, &default_value );	
-	for( i = 0; i < 13 ; i++ ){
+	camera_attr_get_contrast_range(camera, &min, &max);
+	if(max == -1 )
+		return 0;
+	for( i = 1; i < 13 ; i++ ){
 		int value;
 		ret1 = camera_attr_set_contrast (camera, i );
 		printf("-set contrast %d\tret=%x\n",i,ret1);
 		ret2 = camera_attr_get_contrast (camera, &value);
 		printf("-get contrast %d\tret=%x\n",value,ret2);
 
-		if( i >= 1 && i <= 7 ){
+		if( i >= min && i <= max ){
 			if( value != i)
 				return -1;
 		}else{ // out of bound error
@@ -512,24 +528,18 @@ int flash_mode_test(camera_h camera){
 }
 
 int gps_test(camera_h camera){
-	double value;
+	double lng = 1.12;
+	double lat = 1.13;
+	double alt = 1.14;
 	int ret;
-	ret = camera_attr_set_tag_longitude(camera, 1.12);
-	printf("-set tag longitude 1.12\tret=%x\n",ret);
-	ret = camera_attr_get_tag_longitude(camera, &value);
-	printf("-get tag longitude %g\tret=%x\n",value, ret);
-
-	ret = camera_attr_set_tag_latitude(camera, 1.13);
-	printf("-set tag latitude 1.13\tret=%x\n", ret);
-	ret = camera_attr_get_tag_latitude(camera, &value);
-	printf("-get tag latitude %g\tret=%x\n",value, ret);
-	
-	ret = camera_attr_set_tag_altitude(camera, 1.15);
-	printf("-set tag altitude 1.15\tret=%x\n",ret);
-	ret = camera_attr_get_tag_altitude(camera, &value);
-	printf("-get tag altitude %g\tret=%x\n",value, ret);
-	
+	ret = camera_attr_set_geotag(camera, lat, lng , alt );
+	if( ret != 0)
+		return -1;
+	ret = camera_attr_get_geotag(camera, &lat , &lng , &alt);
+	if( ret != 0 )
+		return -1;
 	return 0;
+
 }
 int camera_attribute_test(){
 	int ret;
@@ -594,6 +604,7 @@ int camera_preview_test(){
 	int ret;
 	camera_h camera ;
 	int i;
+	int timeout = 0;
 	camera_preview_test_s preview_test_data;
 	int enable_preview_format[CAMERA_PIXEL_FORMAT_JPEG+1] = {0,};
 	
@@ -609,6 +620,7 @@ int camera_preview_test(){
 	
 	for(i =0; i<= CAMERA_PIXEL_FORMAT_JPEG ; i++){
 		if( enable_preview_format[i] ){
+			timeout = 5;
 			preview_test_data.in_format = i;
 			preview_test_data.camera = camera;
 			preview_test_data.iscalled = false;
@@ -616,11 +628,14 @@ int camera_preview_test(){
 			camera_set_preview_format(camera, i);
 			printf("-------------PREVIEW FORMAT %d TEST--------------------\n", i);
 			camera_start_preview(camera);
-			sleep(1);
+			while( preview_test_data.iscalled==false && timeout-- > 5 )
+				sleep(1);
+
 			camera_stop_preview(camera);
 			if( preview_test_data.iscalled && preview_test_data.result ){
 				printf("PASS\n");
 			}else{
+				printf("preview_test_data.result = %d\n", preview_test_data.result);
 				printf("FAIL\n");
 				camera_destroy(camera);
 				return -1;
@@ -656,7 +671,8 @@ void _state_change_test_cb(camera_state_e previous , camera_state_e current , bo
 	data->state = current;
 }
 
-void _capture_test_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data){
+void _capture_test_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
+	printf("capture callback\n");
 }
 
 
@@ -664,18 +680,18 @@ int camera_state_change_test(){
 	camera_h camera ;
 	state_change_data data;
 	bool ispass = true;
+	int ret=0;
 	
 	camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
 	camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
 	camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
 	camera_set_state_changed_cb(camera, _state_change_test_cb, &data);
-	camera_set_capturing_cb(camera,_capture_test_cb, NULL);
-
 
 	printf("------------------- PREVIEW STATE Change test------------------\n");
 	data.iscalled = false;
-	data.state = 0;	
-	camera_start_preview(camera);
+	data.state = 0;
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview ret = %x\n", ret);
 	sleep(1);
 	if( data.iscalled && data.state == CAMERA_STATE_PREVIEW )
 		printf("PASS\n");
@@ -689,7 +705,8 @@ int camera_state_change_test(){
 	
 	data.iscalled = false;
 	data.state = 0;
-	camera_stop_preview(camera);
+	ret = camera_stop_preview(camera);
+	printf("camera_stop_preview ret = %x\n", ret);
 	sleep(1);
 	if( data.iscalled && data.state == CAMERA_STATE_CREATED)
 		printf("PASS\n");
@@ -701,14 +718,16 @@ int camera_state_change_test(){
 
 	printf("------------------- CAPTURED STATE Change test------------------\n");
 
-	camera_start_preview(camera);
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview ret = %x\n", ret);
 	sleep(1);
 	data.iscalled = false;
 	data.state = 0;
 	data.iscaptured = false;
 	data.ispreviewed= false;	
 	data.iscapturing = false;	
-	camera_start_capture(camera);
+	ret = camera_start_capture(camera, _capture_test_cb, NULL, NULL);
+	printf("camera_start_capture ret = %x\n", ret);
 	sleep(3);
 	if( data.iscalled &&  data.iscaptured && data.iscapturing && data.state == CAMERA_STATE_CAPTURED)
 		printf("PASS\n");
@@ -717,14 +736,18 @@ int camera_state_change_test(){
 		ispass = false;
 	}
 	
-	camera_start_preview(camera);
-	camera_stop_preview(camera);
-	camera_destroy(camera);
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview ret = %x\n", ret);
+	ret = camera_stop_preview(camera);
+	printf("camera_stop_preview ret = %x\n", ret);
+	ret = camera_destroy(camera);
+	printf("camera_destroy ret = %x\n", ret);
+
 	return ispass ? 0: -1;
 	
 }
 
-void _capture_test2_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data){
+void _capture_test2_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
 	int *iscalled = (int*)user_data;
 	*iscalled = 1;
 }
@@ -741,10 +764,9 @@ int capture_test(){
 	camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
 	camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
 	camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);	
-	camera_set_capturing_cb(camera,_capture_test2_cb, &iscalled);
 	camera_start_preview(camera);
 	iscalled = 0;
-	camera_start_capture(camera);
+	camera_start_capture(camera, _capture_test2_cb, NULL,  &iscalled);
 
 	while( camera_get_state(camera, &state ) == 0 && state != CAMERA_STATE_CAPTURED && timeout-- > 0 )
 		sleep(1);
@@ -788,9 +810,9 @@ typedef struct{
 	int expected_height;
 	bool ispass;
 }preview_test_data;
-void _capture_test3_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data){
+void _capture_test3_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
 	preview_test_data *data = (preview_test_data*)user_data;
-	if( data->expected_height == height && data->expected_width == width )
+	if( data->expected_height == image->height && data->expected_width == image->width )
 		data->ispass = true;
 }
 
@@ -822,10 +844,9 @@ int capture_resolution_test(){
 		
 		printf("resolution set test %x\n", (unsigned int)camera_set_capture_resolution(camera,data.expected_width  ,data.expected_height));
 
-		camera_set_capturing_cb(camera, _capture_test3_cb , &data);
 		camera_start_preview(camera);
 		
-		camera_start_capture(camera);
+		camera_start_capture(camera, _capture_test3_cb , NULL,  &data);
 		
 		while( camera_get_state(camera, &state ) == 0 && state != CAMERA_STATE_CAPTURED && timeout-- > 0){
 			sleep(1);
@@ -907,15 +928,15 @@ void focus_test(){
 
 	sleep(3);
 	printf("start focusing\n");
-	camera_start_focusing(camera);
+	camera_start_focusing(camera, false);
 	
 	sleep(3);
 	printf("start focusing2\n");
-	camera_start_focusing(camera);
+	camera_start_focusing(camera, false);
 	sleep(3);
 
 	printf("start focusing3\n");
-	camera_start_focusing(camera);
+	camera_start_focusing(camera, false);
 	printf("cancel focusing\n");
 	camera_cancel_focusing(camera);
 
@@ -989,21 +1010,445 @@ void rotation_flip_test(){
 	
 }
 
+
+
+typedef struct{
+	camera_h camera;
+	int count;
+	bool completed;
+}conti_test_data;
+
+void conti_capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
+	conti_test_data *test_data = (conti_test_data*)user_data;
+	printf("capture callback!!%d\n", test_data->count++);
+	if( test_data->count == 5 )
+		camera_stop_continuous_capture(test_data->camera);
+}
+
+void _capture_completed_cb(void *user_data){
+	conti_test_data *test_data = (conti_test_data*)user_data;
+	test_data->completed = true;
+	printf("capture completed\n");
+}
+
+int continuous_capture_test(){
+	printf("--------------continuous capture test--------------------\n");
+	camera_h camera;
+	conti_test_data test_data;
+	int timeout =30;
+	int ret;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	printf("camera_create %x\n", ret);
+	ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	printf("camera_set_display %x\n", ret);
+	ret = camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
+	printf("camera_set_x11_display_rotation %x\n", ret);
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview %x\n", ret);
+
+	test_data.camera = camera;
+	test_data.count = 0;
+	test_data.completed = false;
+	ret = camera_start_continuous_capture(camera, 10, 10, conti_capturing_cb, _capture_completed_cb, &test_data);
+	printf("camera_start_continuous_capture ret = %x\n", ret);
+	if( ret != 0 ){
+		printf("fail conti capture\n");
+		camera_stop_preview(camera);
+		camera_destroy(camera);
+		return -1;
+	}
+
+	while( test_data.completed == false && timeout-- > 0 )
+		sleep(1);
+
+	camera_start_preview(camera);
+
+	if( test_data.count != 5|| test_data.completed == false ){
+		camera_stop_preview(camera);
+		camera_destroy(camera);
+		return -1;
+	}
+
+
+	test_data.camera = camera;
+	test_data.count = 0;
+	test_data.completed = false;
+	timeout = 30;
+
+	ret = camera_start_continuous_capture(camera, 10, 1000, conti_capturing_cb, _capture_completed_cb, &test_data);
+
+	if( ret != 0 ){
+		printf("fail conti capture\n");
+		camera_stop_preview(camera);
+		camera_destroy(camera);
+		return -1;
+	}
+
+	sleep(2);
+	camera_stop_continuous_capture(camera);
+
+	while( test_data.completed == false && timeout-- > 0 )
+		sleep(1);
+
+	camera_start_preview(camera);
+	camera_stop_preview(camera);
+	camera_destroy(camera);
+
+	printf("total capture count = %d\n", test_data.count);
+	if( test_data.completed == false)
+		return -1;
+	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);
+	}
+}
+
+
+int face_detection_test(){
+	printf("--------------face_detection_test--------------------\n");
+	camera_h camera;
+	int ret;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	printf("camera_create %x\n", ret);
+	ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	printf("camera_set_display %x\n", ret);
+	ret = camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
+	printf("camera_set_x11_display_rotation %x\n", ret);
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview %x\n", ret);
+	if( camera_is_supported_face_detection(camera) ){
+		ret = camera_start_face_detection(camera, _face_detected, NULL);
+		printf("camera_start_face_detection %x\n", ret);
+	}else
+	{
+		printf("not supported face detection\n");
+	}
+	return 0;
+}
+
+int face_count ;
+void _face_detected2(camera_detected_face_s *faces, int count, void *user_data){
+	face_count = count;
+	printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n-------------------------------------------\n");
+	int i;
+	for( i = 0 ; i < count ; i++ ){
+		printf("%d) %dx%d \n", faces[i].id, faces[i].x , faces[i].y);
+	}
+}
+
+
+int face_zoom_test(){
+	printf("--------------face_zoom_test--------------------\n");
+	camera_h camera;
+	int ret;
+	ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	printf("camera_create %x\n", ret);
+	ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	printf("camera_set_display %x\n", ret);
+	ret = camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
+	printf("camera_set_x11_display_rotation %x\n", ret);
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview %x\n", ret);
+	if( camera_is_supported_face_detection(camera) ){
+		ret = camera_start_face_detection(camera, _face_detected2, NULL);
+		printf("camera_start_face_detection %x\n", ret);
+	}else
+	{
+		printf("not supported face detection\n");
+	}
+	while(1){
+		char select[255];
+		//printf("current faces %d\n", face_count);
+		//printf("x is zoom cancel\n");
+		//printf("select face>");
+		gets(select);
+		if( select[0] == 'x' ){
+			camera_cancel_face_zoom(camera);
+		}else if( select[0] != '\0'){
+			int face = select[0] - '0';
+			//printf("input : <%s>\n", select);
+			if( face >= 0 ){
+				//printf("select %d\n", face);
+				camera_face_zoom(camera, face);
+			}
+		}
+	}
+	return 0;
+}
+
+char *table[] = {
+"CAMERA_PIXEL_FORMAT_NV12",           /**< NV12 pixel format */
+"CAMERA_PIXEL_FORMAT_NV12T",          /**< NV12 Tiled pixel format */
+"CAMERA_PIXEL_FORMAT_NV16",           /**< NV16 pixel format */
+"CAMERA_PIXEL_FORMAT_NV21",           /**< NV21 pixel format */
+"CAMERA_PIXEL_FORMAT_YUYV",           /**< YUYV(YUY2) pixel format */
+"CAMERA_PIXEL_FORMAT_UYVY",           /**< UYVY pixel format */
+"CAMERA_PIXEL_FORMAT_422P",           /**< YUV422(Y:U:V) planar pixel format */
+"CAMERA_PIXEL_FORMAT_I420",           /**< I420 pixel format */
+"CAMERA_PIXEL_FORMAT_YV12",           /**< YV12 pixel format */
+"CAMERA_PIXEL_FORMAT_RGB565",         /**< RGB565 pixel format */
+"CAMERA_PIXEL_FORMAT_RGB888",         /**< RGB888 pixel format */
+"CAMERA_PIXEL_FORMAT_RGBA",           /**< RGBA pixel format */
+"CAMERA_PIXEL_FORMAT_ARGB",           /**< ARGB pixel format */
+"CAMERA_PIXEL_FORMAT_JPEG"           /**< Encoded pixel format */
+};
+
+
+bool supported_preview_format_test(camera_pixel_format_e format,void *user_data){
+	printf("%s\n", table[format]);
+	return true;
+}
+
+int preview_format_test(){
+	camera_h camera;
+	camera_pixel_format_e format;
+	camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	printf("----------CAMERA_DEVICE_CAMERA0 -----------------\n");
+	camera_foreach_supported_preview_format(camera, supported_preview_format_test, NULL);
+	camera_get_preview_format(camera, &format);
+	printf("default - %s\n", table[format]);
+
+	camera_destroy(camera);
+	camera_create(CAMERA_DEVICE_CAMERA1, &camera);
+	printf("----------CAMERA_DEVICE_CAMERA1 -----------------\n");
+	camera_foreach_supported_preview_format(camera, supported_preview_format_test, NULL);
+	camera_get_preview_format(camera, &format);
+	printf("default - %s\n", table[format]);
+	camera_destroy(camera);
+
+	return 0;
+
+}
+
+void _hdr_progress_cb(int percent, void *user_data){
+	printf("percent = %d\n", percent);
+}
+
+void _hdr_capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
+	printf("hdr capturing!\n");
+}
+
+void _hdr_capture_completed_cb(void *user_data){
+	printf("hdr capture complete\n");
+}
+
+
+
+int hdr_capture_test(){
+	camera_h camera;
+	int ret;
+	camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	if( !camera_attr_is_supported_hdr_capture(camera) ){
+		printf("Not supported HDR Capture\n");
+		return 0;
+	}
+
+	camera_attr_set_hdr_capture_progress_cb(camera, _hdr_progress_cb, NULL);
+	camera_attr_set_hdr_mode(camera, CAMERA_ATTR_HDR_MODE_KEEP_ORIGINAL);
+	ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	camera_start_preview(camera);
+	camera_start_capture(camera, _hdr_capturing_cb , _hdr_capture_completed_cb , NULL);
+
+	return 0;
+}
+
+Eina_Bool captured_event_check5(void *data){
+	printf("!!!captured_event_check5\n");
+	camera_h camera = (camera_h)data;
+	camera_start_capture(camera, _hdr_capturing_cb , _hdr_capture_completed_cb , NULL);
+	camera_state_e state;
+	camera_get_state(camera,&state);
+	while( state == CAMERA_STATE_CAPTURING ){
+		//printf("current state = %d\n", state);
+		usleep(10000);
+		camera_get_state(camera,&state);
+	}
+	printf("current state = %d\n", state);
+	camera_start_preview(camera);
+	camera_stop_preview(camera);
+	camera_destroy(camera);
+
+	return false;
+}
+
+
+int hdr_capture_test2(){
+	camera_h camera;
+	int ret;
+	camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	if( !camera_attr_is_supported_hdr_capture(camera) ){
+		printf("Not supported HDR Capture\n");
+		return 0;
+	}
+
+	camera_attr_set_hdr_capture_progress_cb(camera, _hdr_progress_cb, NULL);
+	camera_attr_set_hdr_mode(camera, CAMERA_ATTR_HDR_MODE_KEEP_ORIGINAL);
+	ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	camera_start_preview(camera);
+	ecore_idler_add(captured_event_check5, camera);
+
+	return 0;
+}
+
+
+void _captured_check_capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
+	printf("capturing!\n");
+}
+
+void _captured_check_capture_completed_cb(void *user_data){
+	printf("capture complete\n");
+}
+
+Eina_Bool captured_event_check4(void *data){
+	printf("!!!HDR captured event check4\n");
+	camera_h camera;
+	int ret;
+	camera_state_e state;
+
+	ret= camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview ret = %d\n", ret);
+	camera_attr_set_hdr_mode(camera, CAMERA_ATTR_HDR_MODE_KEEP_ORIGINAL);
+	camera_start_capture(camera, _captured_check_capturing_cb , _captured_check_capture_completed_cb , NULL);
+	printf("camera_start_capture ret = %d\n", ret);
+	camera_get_state(camera,&state);
+	while( state == CAMERA_STATE_CAPTURING ){
+		//printf("current state = %d\n", state);
+		usleep(10000);
+		camera_get_state(camera,&state);
+	}
+	printf("current state = %d\n", state);
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview ret = %d\n", ret);
+	ret = camera_stop_preview(camera);
+	printf("camera_stop_preview ret = %d\n", ret);
+	ret = camera_destroy(camera);
+	printf("camera_destroy ret = %d\n", ret);
+	return false;
+}
+
+Eina_Bool captured_event_check3(void *data){
+	printf("!!!continuous break captured event check3\n");
+	camera_h camera;
+	int ret;
+	camera_state_e state;
+
+	ret= camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	printf("camera_create ret = %d\n", ret);
+	ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview ret = %d\n", ret);
+	ret = camera_start_continuous_capture(camera, 5 , 1000, _captured_check_capturing_cb, _captured_check_capture_completed_cb, NULL);
+	printf("camera_start_continuous_capture ret = %d\n", ret);
+	camera_get_state(camera,&state);
+	int count = 0;
+	while( state == CAMERA_STATE_CAPTURING ){
+		//printf("current state = %d\n", state);
+		usleep(10000);
+		count++;
+		if( count == 10)
+			camera_stop_continuous_capture(camera);
+		camera_get_state(camera,&state);
+	}
+	printf("current state = %d\n", state);
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview ret = %d\n", ret);
+	ret = camera_stop_preview(camera);
+	printf("camera_stop_preview ret = %d\n", ret);
+	ret = camera_destroy(camera);
+	printf("camera_destroy ret = %d\n", ret);
+	ecore_idler_add(captured_event_check4, NULL);
+	return false;
+}
+
+Eina_Bool captured_event_check2(void *data){
+	printf("!!!continuous shot captured event check2\n");
+	camera_h camera;
+	int ret;
+	camera_state_e state;
+
+	ret= camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	printf("camera_create ret = %d\n", ret);
+	ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview ret = %d\n", ret);
+	ret = camera_start_continuous_capture(camera, 5 , 1000, _captured_check_capturing_cb, _captured_check_capture_completed_cb, NULL);
+	printf("camera_start_continuous_capture ret = %d\n", ret);
+	camera_get_state(camera,&state);
+	while( state == CAMERA_STATE_CAPTURING ){
+		//printf("current state = %d\n", state);
+		usleep(10000);
+		camera_get_state(camera,&state);
+	}
+	printf("current state = %d\n", state);
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview ret = %d\n", ret);
+	ret = camera_stop_preview(camera);
+	printf("camera_stop_preview ret = %d\n", ret);
+	ret = camera_destroy(camera);
+	printf("camera_destroy ret = %d\n", ret);
+	ecore_idler_add(captured_event_check3, NULL);
+	return false;
+}
+
+
+Eina_Bool captured_event_check(void *data){
+	printf("!!!Normal captured event check\n");
+	camera_h camera;
+	camera_state_e state;
+
+	int ret;
+	ret= camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+	ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview ret = %d\n", ret);
+	camera_start_capture(camera, _captured_check_capturing_cb , _captured_check_capture_completed_cb , NULL);
+	printf("camera_start_capture ret = %d\n", ret);
+	camera_get_state(camera,&state);
+	while( state == CAMERA_STATE_CAPTURING ){
+		//printf("current state = %d\n", state);
+		usleep(10000);
+		camera_get_state(camera,&state);
+	}
+	printf("current state = %d\n", state);
+	ret = camera_start_preview(camera);
+	printf("camera_start_preview ret = %d\n", ret);
+	ret = camera_stop_preview(camera);
+	printf("camera_stop_preview ret = %d\n", ret);
+	ret = camera_destroy(camera);
+	printf("camera_destroy ret = %d\n", ret);
+
+	ecore_idler_add(captured_event_check2, NULL);
+	return false;
+}
+
 int camera_test(){
-	
+
 	int ret=0;
-	/*
-	ret = camera_attribute_test();
-	ret += camera_preview_test();
-	ret += camera_state_change_test();
-	ret += capture_test();
-	ret += capture_resolution_test();
-	ret += stillshot_test();
-	camera_lens_rotation_test();
-
-	contrast_test2();
-	*/
-	rotation_flip_test();
+
+	//ret = camera_attribute_test();
+	//ret += camera_preview_test();
+	//ret += camera_state_change_test();
+	//ret += capture_test();
+	//ret += capture_resolution_test();
+	//ret += stillshot_test();
+	//camera_lens_rotation_test();
+	//contrast_test2();
+	//rotation_flip_test();
+	//ret += continuous_capture_test();
+	//ret = face_detection_test();
+	//face_zoom_test();
+	//preview_format_test();
+	//hdr_capture_test();
+	//hdr_capture_test();
+	hdr_capture_test2();
 
 	return ret;
 }
@@ -1050,14 +1495,13 @@ int main(int argc, char ** argv)
 
 	evas_object_image_fill_set(img, 0, 0, w, h);
 
-	evas_object_show(img);	
+	evas_object_show(img);
 
 	pthread_t gloop_thread;
 
 	pthread_create(&gloop_thread, NULL, test_main,  NULL);
 
-	//ecore_timer_add(0.01, video_window_update, NULL);
-
+	//ecore_idler_add(captured_event_check, NULL);
 
 	elm_run();
 	elm_shutdown();