2.0 init

Change-Id: Ic2e7bdadbaefd1e5dd222f8f9197e4bf9b6601ab

diff --git a/TC/_export_env.sh b/TC/_export_env.sh
new file mode 100755 (executable)
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 (executable)
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 (executable)
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 (executable)
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 (file)
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 (executable)
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 (executable)
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 (file)
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 (executable)
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 (executable)
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 (executable)
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 (executable)
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 (executable)
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 (file)
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 (file)
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 (file)
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
old mode 100755 (executable)
new mode 100644 (file)

diff --git a/debian/README b/debian/README
deleted file mode 100755 (executable)
index e69de29..0000000

diff --git a/debian/capi-media-camera-dev.install b/debian/capi-media-camera-dev.install
deleted file mode 100755 (executable)
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 (executable)
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 (executable)
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 (executable)
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 (executable)
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 (executable)
index 7ed6ff8..0000000
--- a/debian/compat
+++ /dev/null
@@ -1 +0,0 @@
-5

diff --git a/debian/control b/debian/control
deleted file mode 100755 (executable)
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 (executable)
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 998249f54a0651905c70fd355c1d5c1731980daf..2212a0769fedef75e09ad72aa5b4d7e0fad09287 100755 (executable)
--- 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_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;
 
 
 } camera_error_e;
 
 


@@ -180,6 +183,43 @@ typedef enum
        CAMERA_DISPLAY_MODE_CROPPED_FULL,       /**< Cropped full screen*/
 } camera_display_mode_e;
 
        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 */
 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_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_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;
 
     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;
 
     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.
  *
 /**
  * @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] 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().
  * @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);
 
 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.
 
 /**
  * @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);
 
 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.
 /**
  * @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
  * @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_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
  *
  *
  * @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);
  * @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.
  *
 /**
  * @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
  *
  * @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()
  */
  * @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_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()),
  * @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);
 
 /**
 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
  *
  * @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
  * 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
  * @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()
  * @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()
  * @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()
  */
  * @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.
 
 /**
  * @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
  *
 /**
  * @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]  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
  * @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()
  */
  * @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.
 
 /**
  * @brief Stops camera auto focusing.


@@ -780,6 +920,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);
 
  */
 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);
 
 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);
+

 /**
  * @}
  */
 /**
  * @}
  */


@@ -1171,39 +1416,6 @@ int camera_set_preview_cb(camera_h camera, camera_preview_cb callback, void *use
  */
 int camera_unset_preview_cb(camera_h camera);
 
  */
 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.
  *
 /**
  * @brief      Registers a callback function to be called when camera state changes.
  *


@@ -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);
 
 /**
 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] 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
  * @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.
 
 /**
  * @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
  *
  * @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] 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
  * @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);
 
 
         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
  *
  * @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.
  *
 
 /**
  * @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
  * @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


@@ -1616,6 +1833,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);
 
  */
 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);
+

 /**
  * @}
  */
 /**
  * @}
  */


@@ -1821,6 +2076,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.
  *
 /**
  * @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);
 
 /**
 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
  *
  * @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[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
  *
  * @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]  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
  *
  * @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.
 
 /**
  * @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);
 
 
 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 9630da3b857ffafa163a31488c46ae8a904d2c8f..8038b80e1617fd1d18825d0bbb7c87e63d6f2743 100755 (executable)
--- a/include/camera_private.h
+++ b/include/camera_private.h
@@ -27,35 +27,49 @@
 extern "C" {
 #endif
 
 extern "C" {
 #endif
 

+#define MAX_DETECTED_FACE 20
+

 typedef enum {
        _CAMERA_EVENT_TYPE_STATE_CHANGE,
 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_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;
        _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;
        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
 }
 
 #ifdef __cplusplus
 }

diff --git a/packaging/capi-media-camera.spec b/packaging/capi-media-camera.spec
index b0f0ef1f54875325fcfd582fcdc02e940d293ce6..cf1ccc01b022c283c7903022f1697e57ba8faf16 100755 (executable)
--- a/packaging/capi-media-camera.spec
+++ b/packaging/capi-media-camera.spec
@@ -1,8 +1,8 @@
 Name:       capi-media-camera
 Name:       capi-media-camera

-Summary:    A Camera library in Tizen Native API
+Summary:    A Camera library in Tizen C API

 Version:    0.1.0
 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
 License:    Apache-2.0
 Source0:    %{name}-%{version}.tar.gz
 BuildRequires:  cmake


@@ -16,7 +16,7 @@ Requires(postun): /sbin/ldconfig
 
 
 %package devel
 
 
 %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}
 
 Group:    TO_BE/FILLED_IN
 Requires: %{name} = %{version}-%{release}
 

diff --git a/src/camera.c b/src/camera.c
index 581a00f18118794497835f66e574d785889c7dad..7809cfb63004601805683f54be414e933c8c46d6 100755 (executable)
--- 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;
                        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_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_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 :
                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_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_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;
                        ret = CAMERA_ERROR_INVALID_OPERATION;
                        errorstr = "INVALID_OPERATION";
                        break;

-                               

 
                case MM_ERROR_CAMCORDER_RESOURCE_CREATION :
 
                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;
                        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;
                        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";
 
                default:
                        ret = CAMERA_ERROR_INVALID_OPERATION;
                        errorstr = "INVALID_OPERATION";

-               

        }
        }

-       

        LOGE( "[%s] %s(0x%08x) : core frameworks error code(0x%08x)",func, errorstr, ret, code);
        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){
        return ret;
 }
 
 
 static gboolean __mm_videostream_callback(MMCamcorderVideoStreamDataType * stream, void *user_data){

-

        if( user_data == NULL || stream == NULL)
                return 0;
        if( user_data == NULL || stream == NULL)
                return 0;

-               
+

        camera_s * handle = (camera_s*)user_data;
        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;
        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;
        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;
        return 1;
 }
 
 static camera_state_e __camera_state_convert(MMCamcorderStateType mm_state)
 {
        camera_state_e state = CAMERA_STATE_NONE;

-       
+

        switch( mm_state ){
        switch( mm_state ){

-               case MM_CAMCORDER_STATE_NONE:                           
+               case MM_CAMCORDER_STATE_NONE:

                        state = CAMERA_STATE_NONE;
                        break;
                case MM_CAMCORDER_STATE_NULL:
                        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;
        }
 
        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;
        if( user_data == NULL || param == NULL )
                return 0;

-       
-       
+

        camera_s * handle = (camera_s*)user_data;
        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;
 
        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:
        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;
                        }
                                LOGI( "Invalid state changed message");
                                break;
                        }

-                       
+

                        previous_state = handle->state;
                        handle->state = __camera_state_convert(m->state.current );
                        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] ){
                        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
                        }
 
                        // 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);
                                }
                        }
                                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] ){
                        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);
                        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 ){
                                }
                        }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;
                                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;
                        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]);
                                ((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;
                }
                        break;
                }

-                       
-                       

        }
        }

-       
+

        return 1;
 }
 
        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 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;
        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;
        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__);
        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;
 
        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,
        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;
                                                                                                                                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);
        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->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);
        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);
        if( ret == MM_ERROR_NONE)
                *camera = (camera_h)handle;
 
        return __convert_camera_error_code(__func__, ret);

-       
+

 }
 
  int camera_destroy(camera_h camera){
 }
 
  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;
        }
                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_s *handle = (camera_s*)camera;

-       
+

        ret = mm_camcorder_destroy(handle->mm_handle);
        ret = mm_camcorder_destroy(handle->mm_handle);

-       
+

        if( ret == MM_ERROR_NONE)
                free(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){
 }
 
 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;
        }
 
        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_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);
        }
 
        {
                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);
 
        //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_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){
        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);
        }
                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);
        }
        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);
 }
 
        return __convert_camera_error_code(__func__, ret);
 }
 


@@ -398,28 +557,276 @@ int camera_stop_preview(camera_h camera){
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
 
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
 

-       
-       int ret;
+
+       int ret;

        camera_s *handle = (camera_s*)camera;
        MMCamcorderStateType state ;
        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 ){
 
        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)
                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);
        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_capture(camera_h camera){
+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( 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);
+
+       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_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;
+       }
+       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 ;
        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);
 
 
        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;
                capi_state = CAMERA_STATE_CAPTURED;
 
        *state = capi_state;

-       

        return CAMERA_ERROR_NONE;
        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;
        }
        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;
        }
 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){
 }
 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,
        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);
                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);
        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){
 }
 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;
 
        if( rotation < CAMERA_ROTATION_NONE || rotation > CAMERA_ROTATION_270 )
                return CAMERA_ERROR_INVALID_PARAMETER;

-       
+

        int ret;
        camera_s * handle = (camera_s*)camera;
 
        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;
        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);
        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);
 }
 
        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);
        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){
 }
 
 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;
        }
        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){
 }
 
 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);
        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){
 }
 
 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;
        }
                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 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);
        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){
 }
 
 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;
        }
                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;
        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;
        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){
 }
 
 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;
 
        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);
        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){
 }
 
 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;
        }
                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);
        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;
        }
                LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }

-
-       int ret;

        camera_s * handle = (camera_s*)camera;
        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){
 }
 
 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;
        }
                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);
        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){
 }
 
 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;
        }
                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);
        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);      
 }
 
        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;
        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;
        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){
 }
 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;
        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;
        }
 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;
        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){
 }
 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;
        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;
        }
        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;
        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;
 }
        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;
        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;
        }
        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;
        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;
 }
        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;
        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){
 }
 
 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;
        }
                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;
        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;
        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 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;
        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);
        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);
        if( ret != CAMERA_ERROR_NONE )
                return __convert_camera_error_code(__func__, ret);

-       
+

        int i;
        for( i=0 ; i < preview_width.int_array.count ; i++)
        {
        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;
                        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 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;
        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);
        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);
        if( ret != CAMERA_ERROR_NONE )
                return __convert_camera_error_code(__func__, ret);

-       
+

        int i;
        for( i=0 ; i < capture_width.int_array.count ; i++)
        {
        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;
        }
                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 )
        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++)
        {
        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;
 
 }
        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 )
        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++)
        {
        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;
 
 }
 
 
        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 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;
        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;
                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){
 
 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;
        }
        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);
        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);
        return __convert_camera_error_code(__func__, ret);

-       
+

 }
 
 
 int camera_attr_set_image_quality(camera_h camera,  int quality){
 }
 
 
 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;
        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;
        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;
        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);
        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 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);
        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);
        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);
 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 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:
 
        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:
                        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:
                        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:
                        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;
                        break;

-                       

                default:
                        return ret;
        }
                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);
 }
 
        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);
 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
                };
                                                                        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);
        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);
        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){
 }
 
 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);
        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){
 }
 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;
                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);
        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){
 }
 
 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;
                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);
        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){
 }
 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);
        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){
 }
 
 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_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;
        };
        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);
        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);
        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){
 }
 
 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);
        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){
 }
 
 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);
        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){
 }
 
 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);
        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;
        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);
        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;
        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);
        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);
 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);
        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;
        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 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 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;
 
        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;
                *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;
        }
                LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }

-       
+

        int ret;
        int focus_mode;
        int af_range;
        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:
                                *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 :
                                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_NORMAL:
                                                *mode = CAMERA_ATTR_AF_NORMAL;

-                                               

                                                break;
                                        case MM_CAMCORDER_AUTO_FOCUS_MACRO:
                                                *mode = CAMERA_ATTR_AF_MACRO;
                                                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;
                                                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){
 }
 
 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;
        }
                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
        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);
                *mode = maptable[abs(exposure_mode%9)];
        }
        return __convert_camera_error_code(__func__, ret);

-       
+

 }
 
 int camera_attr_get_exposure(camera_h camera, int *value){
 }
 
 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;
        }
                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);
        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;
        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;
 
        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;
                *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);
 }
 


@@ -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;
        }
                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 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){
 }
 
 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);
        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 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;
 
        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;
                *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;
        }
                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);
        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;
        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;
 
        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;
                *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;
        }
                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 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){
 }
 
 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;
        }
        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;
        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;
                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:
                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;
        }
 
                        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){
 }
 
 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;
        }
        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);
        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;
        }
                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 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){
 }
 
 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;
        }
                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;
        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("");
        }
                else
                        *description = strdup("");
        }

-       
+

        return __convert_camera_error_code(__func__, ret);
        return __convert_camera_error_code(__func__, ret);

-       
+

 }
 
 int camera_attr_get_tag_orientation(camera_h camera,  camera_attr_tag_orientation_e *orientation){
 }
 
 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;
        }
        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 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 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;
        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("");
        }
                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){
-               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);

        return __convert_camera_error_code(__func__, ret);
        return __convert_camera_error_code(__func__, ret);

-       

 }
 
 }
 

-int camera_attr_get_tag_longitude(camera_h camera,  double *longtitude){
-       if( camera == NULL || longtitude == 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;
        }
                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 ret;
        camera_s * handle = (camera_s*)camera;

-       ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TAG_LONGITUDE  , longtitude, 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);
 }
 
        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 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);
        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;
        }
                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;
        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_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);
 
        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;
        }
 
                        goto ENDCALLBACK;
        }
 

-       

        ENDCALLBACK:
 
        return CAMERA_ERROR_NONE;
        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){
 }
 
 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;
        }
                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
        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);
        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++)
        {
        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;
                }
        }
        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 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 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;
        }
        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 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 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;
        }
        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 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,
        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
                -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
                -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);
        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++)
        {
        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;
                }
        }
                                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 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 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;
        }
        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);
        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;
        }
        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 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 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;
        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;
 
        }
        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;
 }
 
 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;
 
        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);
        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;
 }
 
 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;
 
        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;
        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){
 }
 
 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;
        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)
 
        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;
        }
                        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 (file)
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
old mode 100755 (executable)
new mode 100644 (file)
index 421664d..73c466c
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,7 +1,7 @@
 SET(fw_test "${fw_name}-test")
 
 INCLUDE(FindPkgConfig)
 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})
 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 d9cf40cf769e0344e65f090acc6cacdd687dbe67..47ffb1eacd8f3b8c6843045746139f3af9f3f7ca 100755 (executable)
--- 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;
 {
        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
                ret = TRUE;
        }
        else


@@ -80,9 +80,8 @@ int capture_complete(void *user_data){
 
 int stillshot_test(){
        camera_h camera;
 
 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_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);
        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_set_capture_format(camera, CAMERA_PIXEL_FORMAT_JPEG);
        
        camera_start_preview(camera);

-       camera_start_focusing(camera);
+       camera_start_focusing(camera, false);

 
        sleep(1);
 
        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);
        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 ret1 ;
        int ret2 ;      
        int i;

+       int min, max;

        printf("------------- ZOOM TEST -------------\n");
        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);
 
                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{
                        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 ){
        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;
                g_exposure_mode_pass = false;
                return false;

-       }
+       }else
+               printf("\t\t\tPASS\n");

        return true;
 }
 
        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);
        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;
 }
 
        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 i;
        int ret1, ret2;
        int default_value;

+       int min,max;

        ret1 = camera_attr_get_exposure(camera, &default_value );       
        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);
                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
                        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 i;
        int ret1,ret2;
        int default_value;

+       int min,max;

        ret1 = camera_attr_get_brightness(camera, &default_value );     
        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);
 
                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
                        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 i;
        int ret1,ret2;
        int default_value;

+       int min,max;

        ret1 = camera_attr_get_contrast (camera, &default_value );      
        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);
 
                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
                        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){
 }
 
 int gps_test(camera_h camera){

-       double value;
+       double lng = 1.12;
+       double lat = 1.13;
+       double alt = 1.14;

        int ret;
        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;
        return 0;

+

 }
 int camera_attribute_test(){
        int ret;
 }
 int camera_attribute_test(){
        int ret;


@@ -594,6 +604,7 @@ int camera_preview_test(){
        int ret;
        camera_h camera ;
        int i;
        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,};
        
        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] ){
        
        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;
                        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);
                        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{
                        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;
                                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;
 }
 
        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;
        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_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;
 
        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");
        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;
        
        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");
        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");
 
 
        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;       
        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");
        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;
        }
        
                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;
        
 }
 
        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;
 }
        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_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_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);
 
        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;
        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;
        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;
 }
 
                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));
 
                
                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_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);
                
                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");
 
        sleep(3);
        printf("start focusing\n");

-       camera_start_focusing(camera);
+       camera_start_focusing(camera, false);

        
        sleep(3);
        printf("start focusing2\n");
        
        sleep(3);
        printf("start focusing2\n");

-       camera_start_focusing(camera);
+       camera_start_focusing(camera, false);

        sleep(3);
 
        printf("start focusing3\n");
        sleep(3);
 
        printf("start focusing3\n");

-       camera_start_focusing(camera);
+       camera_start_focusing(camera, false);

        printf("cancel focusing\n");
        camera_cancel_focusing(camera);
 
        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 camera_test(){

-       
+

        int ret=0;
        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;
 }
 
        return ret;
 }


@@ -1050,14 +1495,13 @@ int main(int argc, char ** argv)
 
        evas_object_image_fill_set(img, 0, 0, w, h);
 
 
        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);
 
 
        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();
 
        elm_run();
        elm_shutdown();