--- /dev/null
+#!/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
--- /dev/null
+#!/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
--- /dev/null
+#!/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
--- /dev/null
+#!/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
--- /dev/null
+CAPI_PROJECT_ROOT=/home/abyss/capi
+TET_INSTALL_HOST_PATH=/home/abyss/TETware
+TET_INSTALL_TARGET_PATH=/mnt/nfs/TETware
--- /dev/null
+#!/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
--- /dev/null
+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)
--- /dev/null
+/testcase/utc_media_camera_attr
+/testcase/utc_media_camera_lifecycle
+/testcase/utc_media_camera_setting
+/testcase/utc_media_camera_working
+
--- /dev/null
+/*
+* 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");
+}
+
--- /dev/null
+/*
+* 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");
+}
--- /dev/null
+/*
+* 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");
+}
+
--- /dev/null
+/*
+* 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");
+}
+
--- /dev/null
+all
+ ^TEST
+##### Scenarios for TEST #####
+
+# Test scenario
+TEST
+ :include:/testcase/tslist
--- /dev/null
+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?
--- /dev/null
+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
--- /dev/null
+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 ?
+++ /dev/null
-/usr/include/*
-/usr/include/*/*
-/usr/lib/pkgconfig/*.pc
-
+++ /dev/null
-/usr/lib/lib*.so*
+++ /dev/null
-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
+++ /dev/null
-
-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)
-
+++ /dev/null
-#!/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
-
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_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;
+
/**
* @}
typedef enum
{
CAMERA_ATTR_TAG_ORIENTATION_TOP_LEFT = 1, /**< Row #0 is top, Column #0 is left */
- CAMERA_ATTR_TAG_ORIENTATION_TOP_RIGHT = 2, /**< Row #0 is top, Column #0 is right */
+ CAMERA_ATTR_TAG_ORIENTATION_TOP_RIGHT = 2, /**< Row #0 is top, Column #0 is right (flipped) */
CAMERA_ATTR_TAG_ORIENTATION_BOTTOM_RIGHT = 3, /**< Row #0 is bottom, Column #0 is right */
- CAMERA_ATTR_TAG_ORIENTATION_BOTTOM_LEFT = 4, /**< Row #0 is bottom, Column #0 is left */
- CAMERA_ATTR_TAG_ORIENTATION_LEFT_TOP = 5, /**< Row #0 is left, Column #0 is top */
+ CAMERA_ATTR_TAG_ORIENTATION_BOTTOM_LEFT = 4, /**< Row #0 is bottom, Column #0 is left (flipped) */
+ CAMERA_ATTR_TAG_ORIENTATION_LEFT_TOP = 5, /**< Row #0 is left, Column #0 is top (flipped) */
CAMERA_ATTR_TAG_ORIENTATION_RIGHT_TOP = 6, /**< Row #0 is right, Column #0 is top */
- CAMERA_ATTR_TAG_ORIENTATION_RIGHT_BOTTOM = 7, /**< Row #0 is right, Column #0 is bottom */
+ CAMERA_ATTR_TAG_ORIENTATION_RIGHT_BOTTOM = 7, /**< Row #0 is right, Column #0 is bottom (flipped) */
CAMERA_ATTR_TAG_ORIENTATION_LEFT_BOTTOM = 8, /**< Row #0 is left, Column #0 is bottom */
} camera_attr_tag_orientation_e;
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;
+
/**
* @}
/**
* @brief Called when the camera state changes.
*
- * @remarks When camera is used as a recorder then this callback function won't be called.
- *
* @param[in] previous The previous state of the camera
* @param[in] current The current state of the camera
- * @param[in] by_policy @c true if the state is changed by sound policy, otherwise @c false
+ * @param[in] by_policy @c true if the state is changed by policy, otherwise @c false
* @param[in] user_data The user data passed from the callback registration function
* @pre camera_start_preview(), camera_start_capture() or camera_stop_preview()
* will invoke this callback if you registers this callback unsing camera_set_state_changed_cb().
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.
typedef void (*camera_preview_cb)(void *stream_buffer, int buffer_size, int width, int height,
camera_pixel_format_e format, void *user_data);
-
/**
* @brief Called to get information about image data taken by the camera once per frame while capturing.
*
* @remarks This function is issued in the context of gstreamer (video source thread) so you should not directly invoke UI update code.
- * You must not call camera_stop_preview() within this callback.
+ * You must not call camera_start_preview() within this callback.
*
- * @param[in] image_buffer The reference pointer to captured data
- * @param[in] buffer_size The length of stream buffer (in bytes)
- * @param[in] width The width of frame resolution
- * @param[in] height The height of frame resolution
- * @param[in] format The camera pixel format
+ * @param[in] image The image data of captured picture
+ * @param[in] postview The image data of postvew
+ * @param[in] thumbnail The image data of thumbnail ( It could be NULL, if available thumbnail data is not existed. )
* @param[in] user_data The user data passed from the callback registration function
- * @pre camera_start_capture() will invoke this callback function if you register this callback using camera_set_capturing_cb().
- * @see camera_set_capturing_cb()
- * @see camera_unset_capturing_cb()
+ * @pre camera_start_capture() or camera_start_continuous_capture() will invoke this callback function if you register this callback using camera_start_capture() or camera_start_continuous_capture()
* @see camera_start_capture()
+ * @see camera_start_continuous_capture()
+ * @see camera_capture_completed_cb()
*/
-typedef void (*camera_capturing_cb)(void *image_buffer, int buffer_size, int width, int height,
- camera_pixel_format_e format, void *user_data);
+typedef void (*camera_capturing_cb)(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data);
+
/**
*
* @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);
/**
* @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
*
* @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);
/**
* @}
* @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()),
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
* 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
* @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_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 Starts camera auto-focusing, Asynchronously
*
+ * @remarks If continuous status is true, the camera continuously tries to focus
+ *
* @param[in] camera The handle to the camera
+ * @param[in] continuous The status of continuous focusing
* @return 0 on success, otherwise a negative error value.
* @retval #CAMERA_ERROR_NONE Successful
* @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
* @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.
*/
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);
+
/**
* @}
*/
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);
+
/**
* @}
*/
*/
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.
*
int camera_unset_state_changed_cb(camera_h camera);
/**
- * @brief Registers a callback function to be called when auto-focus state changes.
+ * @brief Registers a callback function to be called when camera interrupted by policy.
*
* @param[in] camera The handle to the camera
- * @param[in] callback The callback function to register
- * @param[in] user_data The user data to be passed to the callback function
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ *
* @return 0 on success, otherwise a negative error value.
* @retval #CAMERA_ERROR_NONE Successful
* @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
- * @post This function will invoke camera_focus_changed_cb() when auto-focus state changes.
*
- * @see camera_start_focusing()
- * @see camera_cancel_focusing()
- * @see camera_unset_focus_changed_cb()
- * @see camera_focus_changed_cb()
+ * @see camera_unset_interrupted_cb()
+ * @see camera_interrupted_cb()
*/
-int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback,
- void *user_data);
-
+int camera_set_interrupted_cb(camera_h camera, camera_interrupted_cb callback,
+ void *user_data);
/**
* @brief Unregisters the callback function.
* @retval #CAMERA_ERROR_NONE Successful
* @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
*
- * @see camera_set_focus_changed_cb()
+ * @see camera_set_interrupted_cb()
*/
-int camera_unset_focus_changed_cb(camera_h camera);
+int camera_unset_interrupted_cb(camera_h camera);
/**
- * @brief Registers a callback function to be called when capture completes.
+ * @brief Registers a callback function to be called when auto-focus state changes.
*
* @param[in] camera The handle to the camera
* @param[in] callback The callback function to register
- * @param[in] user_data The user data to be passed to the callback function
+ * @param[in] user_data The user data to be passed to the callback function
* @return 0 on success, otherwise a negative error value.
* @retval #CAMERA_ERROR_NONE Successful
* @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
- * @post This function makes camera_capture_completed_cb() called when capturing completes.
+ * @post This function will invoke camera_focus_changed_cb() when auto-focus state changes.
*
- * @see camera_start_capture()
- * @see camera_unset_capture_completed_cb()
- * @see camera_capture_completed_cb()
+ * @see camera_start_focusing()
+ * @see camera_cancel_focusing()
+ * @see camera_unset_focus_changed_cb()
+ * @see camera_focus_changed_cb()
*/
-int camera_set_capture_completed_cb(camera_h camera, camera_capture_completed_cb callback,
+int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback,
void *user_data);
* @retval #CAMERA_ERROR_NONE Successful
* @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
*
- * @see camera_set_capture_completed_cb()
+ * @see camera_set_focus_changed_cb()
*/
-int camera_unset_capture_completed_cb(camera_h camera);
-
+int camera_unset_focus_changed_cb(camera_h camera);
/**
* @brief Registers a callback function to be called when an asynchronous operation error occurred.
*
+ * @remarks
+ * This callback inform critical error situation.\n
+ * When invoked this callback, user should release the resource and terminate application.\n
+ * These error code will be occurred\n
+ * #CAMERA_ERROR_DEVICE\n
+ * #CAMERA_ERROR_INVALID_OPERATION\n
+ * #CAMERA_ERROR_OUT_OF_MEMORY\n
+ *
* @param[in] camera The handle to the camera
* @param[in] callback The callback function to register
* @param[in] user_data The user data to be passed to the callback function
*/
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);
+
/**
* @}
*/
*/
+/**
+ * @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.
*
int camera_attr_get_tag_software(camera_h camera, char **software);
/**
- * @brief Sets the GPS latitude data in EXIF(Exchangeable image file format) tag.
+ * @brief Sets the geotag(GPS data) in EXIF(Exchangeable image file format) tag.
*
- * @param[in] camera The handle to the camera
- * @param[in] latitude Latitude data
+ * @param[in] camera The handle to the camera
+ * @param[in] latitude Latitude data
+ * @param[in] longitude Longitude data
+ * @param[in] altitude Altitude data
* @return 0 on success, otherwise a negative error value.
* @retval #CAMERA_ERROR_NONE Successful
* @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
*
- * @see camera_attr_get_tag_latitude()
+ * @see camera_attr_get_geotag()
+ * @see camera_attr_remove_geotag()
*/
-int camera_attr_set_tag_latitude(camera_h camera, double latitude);
+int camera_attr_set_geotag(camera_h camera, double latitude , double longitude, double altitude);
/**
- * @brief Gets the GPS latitude data in EXIF(Exchangeable image file format) tag.
+ * @brief Gets the geotag(GPS data) in EXIF(Exchangeable image file format) tag.
*
* @param[in] camera The handle to the camera
- * @param[out] latitude The latitude data
+ * @param[out] latitude Latitude data
+ * @param[out] longitude Longitude data
+ * @param[out] altitude Altitude data
* @return 0 on success, otherwise a negative error value.
* @retval #CAMERA_ERROR_NONE Successful
* @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
*
- * @see camera_attr_set_tag_latitude()
+ * @see camera_attr_set_geotag()
+ * @see camera_attr_remove_geotag()
*/
-int camera_attr_get_tag_latitude(camera_h camera, double *latitude);
+int camera_attr_get_geotag(camera_h camera, double *latitude , double *longitude, double *altitude);
/**
- * @brief Sets the GPS longitude data in EXIF(Exchangeable image file format) tag.
+ * @brief Remove the geotag(GPS data) in EXIF(Exchangeable image file format) tag.
*
* @param[in] camera The handle to the camera
- * @param[in] longitude The longitude data
* @return 0 on success, otherwise a negative error value.
* @retval #CAMERA_ERROR_NONE Successful
* @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
*
- * @see camera_attr_get_tag_longitude()
+ * @see camera_attr_set_geotag()
+ * @see camera_attr_get_geotag()
*/
-int camera_attr_set_tag_longitude(camera_h camera, double longitude);
-
-/**
- * @brief Gets the GPS longitude data in EXIF(Exchangeable image file format) tag.
- *
- * @param[in] camera The handle to the camera
- * @param[out] longitude The longitude data
- * @return 0 on success, otherwise a negative error value.
- * @retval #CAMERA_ERROR_NONE Successful
- * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see camera_attr_set_tag_longitude()
- */
-int camera_attr_get_tag_longitude(camera_h camera, double *longitude);
-
-/**
- * @brief Sets the GPS altitude data in EXIF(Exchangeable image file format) tag.
- *
- * @param[in] camera The handle to the camera
- * @param[in] altitude The altitude data
- * @return 0 on success, otherwise a negative error value.
- * @retval #CAMERA_ERROR_NONE Successful
- * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see camera_attr_get_tag_altitude()
- */
-int camera_attr_set_tag_altitude(camera_h camera, double altitude);
-
-/**
- * @brief Gets the GPS altitude data in EXIF(Exchangeable image file format) tag.
- *
- * @param[in] camera The handle to the camera
- * @param[out] altitude The altitude data
- * @return 0 on success, otherwise a negative error value.
- * @retval #CAMERA_ERROR_NONE Successful
- * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @see camera_attr_set_tag_altitude()
- */
-int camera_attr_get_tag_altitude(camera_h camera, double *altitude);
+int camera_attr_remove_geotag(camera_h camera);
/**
* @brief Sets the camera flash mode.
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);
+
+
/**
* @}
*/
extern "C" {
#endif
+#define MAX_DETECTED_FACE 20
+
typedef enum {
_CAMERA_EVENT_TYPE_STATE_CHANGE,
- _CAMERA_EVENT_TYPE_FOCUS_CHANGE,
+ _CAMERA_EVENT_TYPE_FOCUS_CHANGE,
_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE,
_CAMERA_EVENT_TYPE_PREVIEW,
- _CAMERA_EVENT_TYPE_CAPTURE,
- _CAMERA_EVENT_TYPE_ERROR,
+ _CAMERA_EVENT_TYPE_CAPTURE,
+ _CAMERA_EVENT_TYPE_ERROR,
+ _CAMERA_EVENT_TYPE_HDR_PROGRESS,
+ _CAMERA_EVENT_TYPE_INTERRUPTED,
+ _CAMERA_EVENT_TYPE_FACE_DETECTION,
_CAMERA_EVENT_TYPE_NUM
}_camera_event_e;
typedef struct _camera_s{
MMHandleType mm_handle;
-
+
void* user_cb[_CAMERA_EVENT_TYPE_NUM];
void* user_data[_CAMERA_EVENT_TYPE_NUM];
void* display_handle;
camera_display_type_e display_type;
int state;
-
-} camera_s;
-
-typedef enum {
- CAMERA_MODE_IMAGE = MM_CAMCORDER_MODE_IMAGE, /**< Still image capture mode */
- CAMERA_MODE_VIDEO = MM_CAMCORDER_MODE_VIDEO /**< Video recording mode */
-} camera_mode_e;
-
+ MMMessageCallback relay_message_callback;
+ void* relay_user_data;
+ int capture_count;
+ int capture_width;
+ int capture_height;
+ bool is_continuous_shot_break;
+ bool is_capture_completed;
+ int current_capture_count;
+ int current_capture_complete_count;
+ bool capture_resolution_modified;
+ camera_detected_face_s faceinfo[MAX_DETECTED_FACE];
+ int num_of_faces;
+ bool hdr_keep_mode;
+ bool focus_area_valid;
+} camera_s;
-int __mm_camera_message_callback(int message, void *param, void *user_data);
+int _camera_get_mm_handle(camera_h camera , MMHandleType *handle);
+int _camera_set_relay_mm_message_callback(camera_h camera, MMMessageCallback callback, void *user_data);
+int __camera_start_continuous_focusing(camera_h camera);
#ifdef __cplusplus
}
Name: capi-media-camera
-Summary: A Camera library in Tizen Native API
+Summary: A Camera library in Tizen C API
Version: 0.1.0
-Release: 1
-Group: TO_BE/FILLED_IN
+Release: 30
+Group: libs
License: Apache-2.0
Source0: %{name}-%{version}.tar.gz
BuildRequires: cmake
%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}
ret = CAMERA_ERROR_INVALID_STATE;
errorstr = "INVALID_STATE";
break;
-
- case MM_ERROR_CAMCORDER_DEVICE :
case MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND :
- case MM_ERROR_CAMCORDER_DEVICE_BUSY :
+ ret = CAMERA_ERROR_DEVICE_NOT_FOUND;
+ errorstr = "DEVICE_NOT_FOUND";
+ break;
+ case MM_ERROR_CAMCORDER_DEVICE_BUSY :
case MM_ERROR_CAMCORDER_DEVICE_OPEN :
+ case MM_ERROR_CAMCORDER_CMD_IS_RUNNING :
+ ret = CAMERA_ERROR_DEVICE_BUSY;
+ errorstr = "DEVICE_BUSY";
+ break;
+ case MM_ERROR_CAMCORDER_DEVICE :
case MM_ERROR_CAMCORDER_DEVICE_IO :
case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT :
case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE :
case MM_ERROR_CAMCORDER_INTERNAL :
case MM_ERROR_CAMCORDER_NOT_SUPPORTED :
case MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT :
- case MM_ERROR_CAMCORDER_CMD_IS_RUNNING :
case MM_ERROR_CAMCORDER_DSP_FAIL :
case MM_ERROR_CAMCORDER_AUDIO_EMPTY :
case MM_ERROR_CAMCORDER_CREATE_CONFIGURE :
case MM_ERROR_CAMCORDER_FILE_SIZE_OVER :
case MM_ERROR_CAMCORDER_DISPLAY_DEVICE_OFF :
- case MM_ERROR_CAMCORDER_INVALID_CONDITION :
+ case MM_ERROR_CAMCORDER_INVALID_CONDITION :
ret = CAMERA_ERROR_INVALID_OPERATION;
errorstr = "INVALID_OPERATION";
break;
-
case MM_ERROR_CAMCORDER_RESOURCE_CREATION :
- case MM_ERROR_COMMON_OUT_OF_MEMORY:
+ case MM_ERROR_COMMON_OUT_OF_MEMORY:
ret = CAMERA_ERROR_OUT_OF_MEMORY;
errorstr = "OUT_OF_MEMORY";
break;
ret = CAMERA_ERROR_SOUND_POLICY;
errorstr = "ERROR_SOUND_POLICY";
break;
+ case MM_ERROR_POLICY_RESTRICTED:
+ ret = CAMERA_ERROR_SECURITY_RESTRICTED;
+ errorstr = "ERROR_RESTRICTED";
+ break;
default:
ret = CAMERA_ERROR_INVALID_OPERATION;
errorstr = "INVALID_OPERATION";
-
}
-
LOGE( "[%s] %s(0x%08x) : core frameworks error code(0x%08x)",func, errorstr, ret, code);
-
return ret;
}
static gboolean __mm_videostream_callback(MMCamcorderVideoStreamDataType * stream, void *user_data){
-
if( user_data == NULL || stream == NULL)
return 0;
-
+
camera_s * handle = (camera_s*)user_data;
- if( handle->user_cb[_CAMERA_EVENT_TYPE_PREVIEW] )
- ((camera_preview_cb)handle->user_cb[_CAMERA_EVENT_TYPE_PREVIEW])(stream->data, stream->length, stream->width, stream->height, stream->format, handle->user_data[_CAMERA_EVENT_TYPE_PREVIEW]);
+ if( handle->user_cb[_CAMERA_EVENT_TYPE_PREVIEW] ){
+ int stream_format = stream->format;
+ if( stream_format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY )
+ stream_format = MM_PIXEL_FORMAT_UYVY;
+ ((camera_preview_cb)handle->user_cb[_CAMERA_EVENT_TYPE_PREVIEW])(stream->data, stream->length, stream->width, stream->height, stream_format, handle->user_data[_CAMERA_EVENT_TYPE_PREVIEW]);
+ }
return 1;
}
static gboolean __mm_capture_callback(MMCamcorderCaptureDataType *frame, MMCamcorderCaptureDataType *thumbnail, void *user_data){
if( user_data == NULL || frame == NULL)
return 0;
-
+
camera_s * handle = (camera_s*)user_data;
- if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] )
- ((camera_capturing_cb)handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE])(frame->data, frame->length, frame->width, frame->height, frame->format, handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE]);
+ handle->current_capture_count++;
+ if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] ){
+ MMCamcorderCaptureDataType *scrnl = NULL;
+ int size = 0;
+ camera_image_data_s image = { NULL, 0, 0, 0, 0 };
+ camera_image_data_s thumb = { NULL, 0, 0, 0, 0 };
+ camera_image_data_s postview = { NULL, 0, 0, 0 };
+ if( frame ){
+ image.data = frame->data;
+ image.size = frame->length;
+ image.width = frame->width;
+ image.height = frame->height;
+ image.format = frame->format;
+ }
+ if( thumbnail ){
+ thumb.data = thumbnail->data;
+ thumb.size = thumbnail->length;
+ thumb.width = thumbnail->width;
+ thumb.height = thumbnail->height;
+ thumb.format = thumbnail->format;
+ }
+ mm_camcorder_get_attributes( handle->mm_handle, NULL, "captured-screennail", &scrnl, &size,NULL );
+ if( scrnl ){
+ postview.data = scrnl->data;
+ postview.size = scrnl->length;
+ postview.width = scrnl->width;
+ postview.height = scrnl->height;
+ postview.format = scrnl->format;
+ }
+
+ ((camera_capturing_cb)handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE])(frame ? &image : NULL, thumbnail ? &thumb : NULL, scrnl ? &postview : NULL, handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE]);
+ }
+ // update captured state
+ if( handle->capture_count == 1 && handle->hdr_keep_mode ){
+ if( handle->current_capture_count == 2 )
+ handle->is_capture_completed = true;
+ }else if( handle->capture_count == handle->current_capture_count || handle->is_continuous_shot_break)
+ handle->is_capture_completed = true;
return 1;
}
static camera_state_e __camera_state_convert(MMCamcorderStateType mm_state)
{
camera_state_e state = CAMERA_STATE_NONE;
-
+
switch( mm_state ){
- case MM_CAMCORDER_STATE_NONE:
+ case MM_CAMCORDER_STATE_NONE:
state = CAMERA_STATE_NONE;
break;
case MM_CAMCORDER_STATE_NULL:
}
return state;
-
}
-int __mm_camera_message_callback(int message, void *param, void *user_data){
+static int __mm_camera_message_callback(int message, void *param, void *user_data){
if( user_data == NULL || param == NULL )
return 0;
-
-
+
camera_s * handle = (camera_s*)user_data;
+
+ if( handle->relay_message_callback )
+ handle->relay_message_callback(message, param, handle->relay_user_data);
+
MMMessageParamType *m = (MMMessageParamType*)param;
camera_state_e previous_state;
switch(message){
case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
- if( m->state.previous < MM_CAMCORDER_STATE_NONE || m->state.previous > MM_CAMCORDER_STATE_PAUSED || m->state.code != 0 ){
+ case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY:
+ if( message == MM_MESSAGE_CAMCORDER_STATE_CHANGED && (m->state.previous < MM_CAMCORDER_STATE_NONE || m->state.previous > MM_CAMCORDER_STATE_PAUSED || m->state.code != 0) ){
LOGI( "Invalid state changed message");
break;
}
-
+
previous_state = handle->state;
handle->state = __camera_state_convert(m->state.current );
-
+ camera_policy_e policy = CAMERA_POLICY_NONE;
+ if(message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM )
+ policy = CAMERA_POLICY_SOUND;
+ else if( message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY )
+ policy = CAMERA_POLICY_SECURITY;
+
if( previous_state != handle->state && handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE] ){
- ((camera_state_changed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, message == MM_MESSAGE_CAMCORDER_STATE_CHANGED ? 0 : 1 , handle->user_data[_CAMERA_EVENT_TYPE_STATE_CHANGE]);
+ ((camera_state_changed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, policy, handle->user_data[_CAMERA_EVENT_TYPE_STATE_CHANGE]);
}
// should change intermediate state MM_CAMCORDER_STATE_READY is not valid in capi , change to NULL state
- if( message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM ){
+ if( policy != CAMERA_POLICY_NONE ){
+ if( previous_state != handle->state && handle->user_cb[_CAMERA_EVENT_TYPE_INTERRUPTED] )
+ ((camera_interrupted_cb)handle->user_cb[_CAMERA_EVENT_TYPE_INTERRUPTED])(policy, previous_state, handle->state, handle->user_data[_CAMERA_EVENT_TYPE_INTERRUPTED]);
if( m->state.previous == MM_CAMCORDER_STATE_PREPARE && m->state.current == MM_CAMCORDER_STATE_READY ){
mm_camcorder_unrealize(handle->mm_handle);
}
}
-
+
break;
case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED :
if( handle->user_cb[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] ){
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 ){
if( report ){
free(report);
report = NULL;
- }
+ }
+ }
+ break;
+ }
+ case MM_MESSAGE_CAMCORDER_VIDEO_SNAPSHOT_CAPTURED:
+ {
+ if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] ){
+ ((camera_capture_completed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE])(handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE]);
}
+ // reset capturing callback , capture completed callback
+ handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+ handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+ handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+ handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
break;
}
case MM_MESSAGE_CAMCORDER_ERROR:
{
int errorcode = m->code;
- errorcode = __convert_camera_error_code("NOTIFY", errorcode);
- if( handle->user_cb[_CAMERA_EVENT_TYPE_ERROR] )
+ int camera_error = 0;
+ switch( errorcode ){
+ case MM_ERROR_CAMCORDER_DEVICE :
+ case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT :
+ case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE :
+ case MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG :
+ camera_error = CAMERA_ERROR_DEVICE;
+ break;
+ case MM_ERROR_CAMCORDER_GST_CORE :
+ case MM_ERROR_CAMCORDER_GST_LIBRARY :
+ case MM_ERROR_CAMCORDER_GST_RESOURCE :
+ case MM_ERROR_CAMCORDER_GST_STREAM :
+ case MM_ERROR_CAMCORDER_GST_NEGOTIATION :
+ case MM_ERROR_CAMCORDER_GST_FLOW_ERROR :
+ case MM_ERROR_CAMCORDER_ENCODER :
+ case MM_ERROR_CAMCORDER_ENCODER_BUFFER :
+ case MM_ERROR_CAMCORDER_ENCODER_WORKING :
+ case MM_ERROR_CAMCORDER_MNOTE_CREATION :
+ case MM_ERROR_CAMCORDER_MNOTE_ADD_ENTRY :
+ case MM_ERROR_CAMCORDER_INTERNAL :
+ camera_error = CAMERA_ERROR_INVALID_OPERATION;
+ break;
+ case MM_ERROR_CAMCORDER_LOW_MEMORY :
+ case MM_ERROR_CAMCORDER_MNOTE_MALLOC :
+ camera_error = CAMERA_ERROR_OUT_OF_MEMORY;
+ break;
+ }
+ if( camera_error != 0 && handle->user_cb[_CAMERA_EVENT_TYPE_ERROR] )
((camera_error_cb)handle->user_cb[_CAMERA_EVENT_TYPE_ERROR])(errorcode, handle->state , handle->user_data[_CAMERA_EVENT_TYPE_ERROR]);
-
+
+ break;
+ }
+ case MM_MESSAGE_CAMCORDER_HDR_PROGRESS:
+ {
+ int percent = m->code;
+ if( handle->user_cb[_CAMERA_EVENT_TYPE_HDR_PROGRESS] )
+ ((camera_attr_hdr_progress_cb)handle->user_cb[_CAMERA_EVENT_TYPE_HDR_PROGRESS])(percent, handle->user_data[_CAMERA_EVENT_TYPE_HDR_PROGRESS]);
+ break;
+ }
+ case MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO:
+ {
+ MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)(m->data);
+ if ( cam_fd_info ) {
+ camera_detected_face_s faces[cam_fd_info->num_of_faces];
+ handle->num_of_faces = cam_fd_info->num_of_faces > MAX_DETECTED_FACE ? MAX_DETECTED_FACE : cam_fd_info->num_of_faces;
+ int i;
+ for(i=0; i < handle->num_of_faces ; i++){
+ faces[i].id = cam_fd_info->face_info[i].id;
+ faces[i].score = cam_fd_info->face_info[i].score;
+ faces[i].x = cam_fd_info->face_info[i].rect.x;
+ faces[i].y = cam_fd_info->face_info[i].rect.y;
+ faces[i].width = cam_fd_info->face_info[i].rect.width;
+ faces[i].height = cam_fd_info->face_info[i].rect.height;
+ handle->faceinfo[i] = faces[i]; //cache face coordinate
+ }
+ if( handle->user_cb[_CAMERA_EVENT_TYPE_FACE_DETECTION] )
+ ((camera_face_detected_cb)handle->user_cb[_CAMERA_EVENT_TYPE_FACE_DETECTION])(faces, handle->num_of_faces, handle->user_data[_CAMERA_EVENT_TYPE_FACE_DETECTION]);
+ }else{
+ handle->num_of_faces = 0;
+ }
break;
}
-
-
}
-
+
return 1;
}
+static int __capture_completed_event_cb(void *data){
+ camera_s *handle = (camera_s*)data;
+ if( handle->current_capture_count > 0 && handle->current_capture_count == handle->current_capture_complete_count && handle->state == CAMERA_STATE_CAPTURING ){
+ //pseudo state change
+ camera_state_e previous_state = handle->state;
+ handle->state = CAMERA_STATE_CAPTURED;
+ if( previous_state != handle->state && handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE] ){
+ ((camera_state_changed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, 0 , handle->user_data[_CAMERA_EVENT_TYPE_STATE_CHANGE]);
+ }
+ if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] ){
+ ((camera_capture_completed_cb)handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE])(handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE]);
+ }
+ // reset capturing callback , capture completed callback
+ handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+ handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+ handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+ handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+ }
+ return false;
+}
+
int camera_create( camera_device_e device, camera_h* camera){
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
-
- int ret;
+
+ int ret;
MMCamPreset info;
int preview_format;
int rotation;
-
+
if( device == CAMERA_DEVICE_CAMERA1 )
info.videodev_type= MM_VIDEO_DEVICE_CAMERA1;
else
info.videodev_type= MM_VIDEO_DEVICE_CAMERA0;
-
+
camera_s* handle = (camera_s*)malloc( sizeof(camera_s) );
if(handle==NULL){
LOGE("[%s] malloc fail",__func__);
preview_format = MM_PIXEL_FORMAT_YUYV;
rotation = MM_DISPLAY_ROTATION_NONE;
- ret = mm_camcorder_get_attributes(handle->mm_handle, NULL, MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, &preview_format, MMCAM_RECOMMEND_DISPLAY_ROTATION, &rotation, NULL);
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, &preview_format,
+ MMCAM_RECOMMEND_DISPLAY_ROTATION, &rotation,
+ MMCAM_CAPTURE_WIDTH, &handle->capture_width,
+ MMCAM_CAPTURE_HEIGHT, &handle->capture_height,
+ NULL);
-
char *error;
ret = mm_camcorder_set_attributes(handle->mm_handle, &error,
MMCAM_MODE , MM_CAMCORDER_MODE_IMAGE,
MMCAM_CAMERA_FORMAT, preview_format,
MMCAM_IMAGE_ENCODER , MM_IMAGE_CODEC_JPEG,
- MMCAM_CAPTURE_FORMAT, MM_PIXEL_FORMAT_ENCODED ,
+ MMCAM_CAPTURE_FORMAT, MM_PIXEL_FORMAT_ENCODED,
MMCAM_DISPLAY_SURFACE, MM_DISPLAY_SURFACE_NULL,
MMCAM_DISPLAY_ROTATION, rotation,
MMCAM_CAPTURE_COUNT, 1,
(void*)NULL);
handle->display_type = CAMERA_DISPLAY_TYPE_NONE;
-
+
if( ret != MM_ERROR_NONE){
LOGE("[%s] mm_camcorder_set_attributes fail(%x, %s)",__func__, ret, error);
mm_camcorder_destroy(handle->mm_handle);
free(error);
free(handle);
return __convert_camera_error_code(__func__, ret);
- }
+ }
handle->state = CAMERA_STATE_CREATED;
+ handle->relay_message_callback = NULL;
+ handle->relay_user_data = NULL;
+ handle->capture_resolution_modified = false;
+ handle->hdr_keep_mode = false;
+ handle->focus_area_valid = false;
mm_camcorder_set_message_callback(handle->mm_handle, __mm_camera_message_callback, (void*)handle);
-
-
+
+
if( ret == MM_ERROR_NONE)
*camera = (camera_h)handle;
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_destroy(camera_h camera){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
- int ret;
+
+ int ret;
camera_s *handle = (camera_s*)camera;
-
+
ret = mm_camcorder_destroy(handle->mm_handle);
-
+
if( ret == MM_ERROR_NONE)
free(handle);
}
int camera_start_preview(camera_h camera){
+ LOGE("%s - start", __func__);
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
- int ret;
+
+ int ret;
camera_s *handle = (camera_s*)camera;
+ camera_state_e capi_state;
+ camera_get_state(camera, &capi_state);
- if( handle->state == CAMERA_STATE_CAPTURED )
+ if( capi_state == CAMERA_STATE_CAPTURED )
{
ret = mm_camcorder_capture_stop(handle->mm_handle);
return __convert_camera_error_code(__func__, ret);
}
-
+
//for receving MM_MESSAGE_CAMCORDER_CAPTURED evnet must be seted capture callback
mm_camcorder_set_video_capture_callback( handle->mm_handle, (mm_camcorder_video_capture_callback)__mm_capture_callback, (void*)handle);
mm_camcorder_set_video_stream_callback( handle->mm_handle, (mm_camcorder_video_stream_callback)NULL, (void*)NULL);
MMCamcorderStateType state ;
- mm_camcorder_get_state(handle->mm_handle, &state);
+ mm_camcorder_get_state(handle->mm_handle, &state);
if( state != MM_CAMCORDER_STATE_READY){
- ret = mm_camcorder_realize(handle->mm_handle);
+ ret = mm_camcorder_realize(handle->mm_handle);
if( ret != MM_ERROR_NONE )
return __convert_camera_error_code(__func__, ret);
}
-
+
ret = mm_camcorder_start(handle->mm_handle);
//start fail.
if( ret != MM_ERROR_NONE && state != MM_CAMCORDER_STATE_READY){
mm_camcorder_unrealize(handle->mm_handle);
}
-
+
return __convert_camera_error_code(__func__, ret);
}
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
- int ret;
+
+ int ret;
camera_s *handle = (camera_s*)camera;
MMCamcorderStateType state ;
- mm_camcorder_get_state(handle->mm_handle, &state);
+ mm_camcorder_get_state(handle->mm_handle, &state);
if( state == MM_CAMCORDER_STATE_PREPARE ){
- ret = mm_camcorder_stop(handle->mm_handle);
+ ret = mm_camcorder_stop(handle->mm_handle);
if( ret != MM_ERROR_NONE)
- return __convert_camera_error_code(__func__, ret);
+ return __convert_camera_error_code(__func__, ret);
}
-
+ camera_stop_face_detection(camera);
ret = mm_camcorder_unrealize(handle->mm_handle);
- return __convert_camera_error_code(__func__, ret);
+ return __convert_camera_error_code(__func__, ret);
+}
+
+int camera_start_capture(camera_h camera, camera_capturing_cb capturing_cb , camera_capture_completed_cb completed_cb , void *user_data){
+ if( camera == NULL){
+ LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+ return CAMERA_ERROR_INVALID_PARAMETER;
+ }
+
+ camera_s * handle = (camera_s*)camera;
+ int ret;
+ MMCamcorderStateType state;
+ mm_camcorder_get_state(handle->mm_handle, &state);
+ if( state != MM_CAMCORDER_STATE_PREPARE && state != MM_CAMCORDER_STATE_RECORDING ){
+ LOGE( "[%s] INVALID_STATE(0x%08x)",__func__,CAMERA_ERROR_INVALID_STATE);
+ return CAMERA_ERROR_INVALID_STATE;
+ }
+
+ if( handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] != NULL || handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] != NULL )
+ return CAMERA_ERROR_INVALID_STATE;
+
+ if( handle->capture_resolution_modified ){
+ mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_CAPTURE_WIDTH, handle->capture_width,
+ MMCAM_CAPTURE_HEIGHT, handle->capture_height,
+ NULL);
+ handle->capture_resolution_modified = false;
+ }
+ mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAPTURE_COUNT , 1,NULL);
+
+ handle->capture_count = 1;
+ handle->is_continuous_shot_break = false;
+ handle->current_capture_count = 0;
+ handle->current_capture_complete_count = 0;
+ handle->is_capture_completed = false;
+
+ handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)capturing_cb;
+ handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)user_data;
+ handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)completed_cb;
+ handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)user_data;
+ ret = mm_camcorder_capture_start(handle->mm_handle);
+ if( ret != 0 ){
+ handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+ handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = NULL;
+ handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+ handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = NULL;
+ }
+
+ return __convert_camera_error_code(__func__, ret);
}
-int camera_start_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;
}
- 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 , ¤t_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);
}
camera_s *handle = (camera_s*)camera;
camera_state_e capi_state;
MMCamcorderStateType mmstate ;
- mm_camcorder_get_state(handle->mm_handle, &mmstate);
+ mm_camcorder_get_state(handle->mm_handle, &mmstate);
capi_state = __camera_state_convert(mmstate);
- if( handle->state == CAMERA_STATE_CAPTURED && mmstate == MM_CAMCORDER_STATE_CAPTURING )
+ if( ( handle->state == CAMERA_STATE_CAPTURED || handle->is_capture_completed ) && mmstate == MM_CAMCORDER_STATE_CAPTURING )
capi_state = CAMERA_STATE_CAPTURED;
*state = capi_state;
-
return CAMERA_ERROR_NONE;
-
}
-int camera_start_focusing( camera_h camera ){
+int camera_start_focusing( camera_h camera, bool continuous ){
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
- return __convert_camera_error_code(__func__, mm_camcorder_start_focusing(((camera_s*)camera)->mm_handle));
+
+ if( continuous )
+ return __camera_start_continuous_focusing(camera);
+ else{
+ camera_s *handle = (camera_s*)camera;
+ mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_FOCUS_MODE, handle->focus_area_valid ? MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO : MM_CAMCORDER_FOCUS_MODE_AUTO, NULL);
+ return __convert_camera_error_code(__func__, mm_camcorder_start_focusing(((camera_s*)camera)->mm_handle));
+ }
+}
+
+int __camera_start_continuous_focusing(camera_h camera){
+ if( camera == NULL ){
+ LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+ return CAMERA_ERROR_INVALID_PARAMETER;
+ }
+ camera_s *handle = (camera_s*)camera;
+ int ret;
+ camera_attr_af_mode_e mode;
+ camera_attr_get_af_mode(camera, &mode);
+ if( mode == CAMERA_ATTR_AF_NONE ){
+ LOGE( "[%s] CAMERA_ERROR_INVALID_OPERATION(0x%08x) AF mode is CAMERA_ATTR_AF_NONE",__func__,CAMERA_ERROR_INVALID_OPERATION);
+ return CAMERA_ERROR_INVALID_OPERATION;
+ }
+ ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE, MM_CAMCORDER_FOCUS_MODE_CONTINUOUS, NULL);
+ return __convert_camera_error_code(__func__, ret);
}
+
int camera_cancel_focusing( camera_h camera ){
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
- return __convert_camera_error_code(__func__, mm_camcorder_stop_focusing(((camera_s*)camera)->mm_handle));
+ int ret;
+ camera_s *handle = (camera_s*)camera;
+ int mode;
+ ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE , &mode, NULL);
+ if( mode == MM_CAMCORDER_FOCUS_MODE_CONTINUOUS ){
+ ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE, handle->focus_area_valid ? MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO : MM_CAMCORDER_FOCUS_MODE_AUTO, NULL);
+ return __convert_camera_error_code(__func__, ret);
+ }
+ return __convert_camera_error_code(__func__, mm_camcorder_stop_focusing(handle->mm_handle));
}
int camera_set_display(camera_h camera, camera_display_type_e type, camera_display_h display){
if( camera == NULL){
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);
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){
if( rotation < CAMERA_ROTATION_NONE || rotation > CAMERA_ROTATION_270 )
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_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);
}
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 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){
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){
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_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){
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_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){
if( ratio < CAMERA_DISPLAY_MODE_LETTER_BOX || ratio > CAMERA_DISPLAY_MODE_CROPPED_FULL )
return CAMERA_ERROR_INVALID_PARAMETER;
-
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_DISPLAY_GEOMETRY_METHOD , ratio, NULL);
- return __convert_camera_error_code(__func__, ret);
+ return __convert_camera_error_code(__func__, ret);
}
int camera_get_x11_display_mode( camera_h camera , camera_display_mode_e* ratio){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_DISPLAY_GEOMETRY_METHOD , ratio, NULL);
- return __convert_camera_error_code(__func__, ret);
+ return __convert_camera_error_code(__func__, ret);
}
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
- int ret;
camera_s * handle = (camera_s*)camera;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAPTURE_WIDTH, width ,MMCAM_CAPTURE_HEIGHT , height, NULL);
- return __convert_camera_error_code(__func__, ret);
+ *width = handle->capture_width;
+ *height = handle->capture_height;
+ return CAMERA_ERROR_NONE;
}
int camera_get_capture_format(camera_h camera, camera_pixel_format_e *format){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAPTURE_FORMAT, format , NULL);
- return __convert_camera_error_code(__func__, ret);
+ return __convert_camera_error_code(__func__, ret);
}
int camera_get_preview_format(camera_h camera, camera_pixel_format_e *format){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FORMAT, format , NULL);
+ if( (MMPixelFormatType)*format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY )
+ *format = CAMERA_PIXEL_FORMAT_UYVY;
return __convert_camera_error_code(__func__, ret);
}
if( camera == NULL || callback == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
- }
-
+ }
+
camera_s * handle = (camera_s*)camera;
handle->user_cb[_CAMERA_EVENT_TYPE_PREVIEW] = (void*)callback;
handle->user_data[_CAMERA_EVENT_TYPE_PREVIEW] = (void*)user_data;
- return CAMERA_ERROR_NONE;
+ return CAMERA_ERROR_NONE;
}
int camera_unset_preview_cb( camera_h camera){
if( camera == NULL){
camera_s * handle = (camera_s*)camera;
handle->user_cb[_CAMERA_EVENT_TYPE_PREVIEW] = (void*)NULL;
handle->user_data[_CAMERA_EVENT_TYPE_PREVIEW] = (void*)NULL;
- return CAMERA_ERROR_NONE;
-}
-int camera_set_capturing_cb( camera_h camera, camera_capturing_cb callback, void* user_data ){
-
- if( camera == NULL || callback == NULL){
- LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
- return CAMERA_ERROR_INVALID_PARAMETER;
- }
-
- camera_s * handle = (camera_s*)camera;
- handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)callback;
- handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)user_data;
- return CAMERA_ERROR_NONE;
-}
-int camera_unset_capturing_cb( camera_h camera){
- if( camera == NULL){
- LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
- return CAMERA_ERROR_INVALID_PARAMETER;
- }
-
- camera_s * handle = (camera_s*)camera;
- handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)NULL;
- handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE] = (void*)NULL;
- return CAMERA_ERROR_NONE;
+ return CAMERA_ERROR_NONE;
}
+
int camera_set_state_changed_cb(camera_h camera, camera_state_changed_cb callback, void* user_data){
if( camera == NULL || callback == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
camera_s * handle = (camera_s*)camera;
handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void*)callback;
handle->user_data[_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void*)user_data;
- return CAMERA_ERROR_NONE;
+ return CAMERA_ERROR_NONE;
}
int camera_unset_state_changed_cb(camera_h camera){
if( camera == NULL){
camera_s * handle = (camera_s*)camera;
handle->user_cb[_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void*)NULL;
handle->user_data[_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void*)NULL;
- return CAMERA_ERROR_NONE;
+ return CAMERA_ERROR_NONE;
}
-int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback, void* user_data){
+int camera_set_interrupted_cb(camera_h camera, camera_interrupted_cb callback, void *user_data){
if( camera == NULL || callback == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
+
camera_s * handle = (camera_s*)camera;
- handle->user_cb[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)callback;
- handle->user_data[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)user_data;
+ handle->user_cb[_CAMERA_EVENT_TYPE_INTERRUPTED] = (void*)callback;
+ handle->user_data[_CAMERA_EVENT_TYPE_INTERRUPTED] = (void*)user_data;
return CAMERA_ERROR_NONE;
}
-int camera_unset_focus_changed_cb(camera_h camera){
+
+int camera_unset_interrupted_cb(camera_h camera){
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
camera_s * handle = (camera_s*)camera;
- handle->user_cb[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)NULL;
- handle->user_data[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)NULL;
- return CAMERA_ERROR_NONE;
+ handle->user_cb[_CAMERA_EVENT_TYPE_INTERRUPTED] = (void*)NULL;
+ handle->user_data[_CAMERA_EVENT_TYPE_INTERRUPTED] = (void*)NULL;
+ return CAMERA_ERROR_NONE;
}
-int camera_set_capture_completed_cb(camera_h camera, camera_capture_completed_cb callback, void* user_data){
-
+int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback, void* user_data){
if( camera == NULL || callback == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
camera_s * handle = (camera_s*)camera;
- handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)callback;
- handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)user_data;
+ handle->user_cb[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)callback;
+ handle->user_data[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)user_data;
return CAMERA_ERROR_NONE;
}
-
-int camera_unset_capture_completed_cb(camera_h camera){
-
+int camera_unset_focus_changed_cb(camera_h camera){
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
camera_s * handle = (camera_s*)camera;
- handle->user_cb[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)NULL;
- handle->user_data[_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = (void*)NULL;
- return CAMERA_ERROR_NONE;
+ handle->user_cb[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)NULL;
+ handle->user_data[_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void*)NULL;
+ return CAMERA_ERROR_NONE;
}
int camera_set_error_cb(camera_h camera, camera_error_cb callback, void *user_data){
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*)NULL;
handle->user_data[_CAMERA_EVENT_TYPE_ERROR] = (void*)NULL;
- return CAMERA_ERROR_NONE;
+ return CAMERA_ERROR_NONE;
}
int camera_foreach_supported_preview_resolution(camera_h camera, camera_supported_preview_resolution_cb foreach_cb , void *user_data){
if( camera == NULL || foreach_cb == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
- }
-
+ }
+
int ret;
camera_s * handle = (camera_s*)camera;
MMCamAttrsInfo preview_width;
- MMCamAttrsInfo preview_height;
+ MMCamAttrsInfo preview_height;
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_WIDTH , &preview_width);
ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_HEIGHT , &preview_height);
-
+
if( ret != CAMERA_ERROR_NONE )
return __convert_camera_error_code(__func__, ret);
-
+
int i;
for( i=0 ; i < preview_width.int_array.count ; i++)
{
break;
}
return CAMERA_ERROR_NONE;
-
+
}
int camera_foreach_supported_capture_resolution(camera_h camera, camera_supported_capture_resolution_cb foreach_cb , void *user_data){
if( camera == NULL || foreach_cb == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
- }
+ }
int ret;
camera_s * handle = (camera_s*)camera;
MMCamAttrsInfo capture_width;
- MMCamAttrsInfo capture_height;
+ MMCamAttrsInfo capture_height;
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAPTURE_WIDTH , &capture_width);
ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAPTURE_HEIGHT , &capture_height);
-
+
if( ret != CAMERA_ERROR_NONE )
return __convert_camera_error_code(__func__, ret);
-
+
int i;
for( i=0 ; i < capture_width.int_array.count ; i++)
{
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
MMCamAttrsInfo format;
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAPTURE_FORMAT , &format);
if( ret != CAMERA_ERROR_NONE )
- return __convert_camera_error_code(__func__, ret);
-
+ return __convert_camera_error_code(__func__, ret);
+
int i;
for( i=0 ; i < format.int_array.count ; i++)
{
- if ( !foreach_cb(format.int_array.array[i], user_data) )
- break;
- }
+ if( format.int_array.array[i] != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY )
+ if ( !foreach_cb(format.int_array.array[i], user_data) )
+ break;
+ }
return CAMERA_ERROR_NONE;
}
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_FORMAT , &format);
if( ret != CAMERA_ERROR_NONE )
- return __convert_camera_error_code(__func__, ret);
-
+ return __convert_camera_error_code(__func__, ret);
+
int i;
for( i=0 ; i < format.int_array.count ; i++)
{
- if ( !foreach_cb(format.int_array.array[i], user_data) )
- break;
- }
+ if( format.int_array.array[i] != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY /* || format.int_array.array[i] != MM_PIXEL_FORMAT_ITLV_JPEG_NV12 */)
+ if ( !foreach_cb(format.int_array.array[i], user_data) )
+ break;
+ }
return CAMERA_ERROR_NONE;
}
+int camera_get_recommended_preview_resolution(camera_h camera, int *width, int *height){
+ if( camera == NULL ){
+ LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+ return CAMERA_ERROR_INVALID_PARAMETER;
+ }
+
+ enum MMCamcorderPreviewType wide;
+ int capture_w, capture_h;
+ double ratio;
+ int ret;
+ camera_s * handle = (camera_s*)camera;
+
+ camera_get_capture_resolution(camera, &capture_w, &capture_h);
+ ratio = (double)capture_w/(double)capture_h;
+ if( ratio > 1.5 )
+ wide = MM_CAMCORDER_PREVIEW_TYPE_WIDE;
+ else
+ wide = MM_CAMCORDER_PREVIEW_TYPE_NORMAL;
+
+ MMCamAttrsInfo width_info, height_info;
+ ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_RECOMMEND_CAMERA_WIDTH , &width_info);
+ ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_RECOMMEND_CAMERA_HEIGHT, &height_info);
+ if( ret != 0 )
+ return __convert_camera_error_code(__func__, ret);
+
+ if( width )
+ *width = width_info.int_array.array[wide];
+
+ if( height )
+ *height = height_info.int_array.array[wide];
+
+ return CAMERA_ERROR_NONE;
+}
+
+
+
int camera_attr_get_lens_orientation(camera_h camera, int *angle) {
if( camera == NULL || angle == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
int rotation;
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 ret;
camera_s * handle = (camera_s*)camera;
-
- if( fps == CAMERA_ATTR_FPS_AUTO )
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FPS_AUTO , 1, MMCAM_CAMERA_FPS, CAMERA_ATTR_FPS_60 , NULL);
+
+ if( fps == CAMERA_ATTR_FPS_AUTO ){
+ MMCamAttrsInfo info;
+ ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_FPS , &info);
+ int maxfps = 0;
+ int i;
+ for( i=0 ; i < info.int_array.count ; i++)
+ {
+ if ( info.int_array.array[i] > maxfps && info.int_array.array[i] <= 60 )
+ maxfps = info.int_array.array[i];
+ }
+ ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FPS_AUTO , 1, MMCAM_CAMERA_FPS, maxfps , NULL);
+ }
else
ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FPS_AUTO , 0, MMCAM_CAMERA_FPS , fps, NULL);
-
+
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_set_image_quality(camera_h camera, int quality){
-
+
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
int mm_fps;
int is_auto;
camera_s * handle = (camera_s*)camera;
-
+
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FPS , &mm_fps, MMCAM_CAMERA_FPS_AUTO , &is_auto, NULL);
if( is_auto )
*fps = CAMERA_ATTR_FPS_AUTO;
else
*fps = mm_fps;
-
+
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_get_image_quality(camera_h camera, int *quality){
if( camera == NULL || quality == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_IMAGE_ENCODER_QUALITY , quality, NULL);
return __convert_camera_error_code(__func__, ret);
-
+
}
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 ret = CAMERA_ERROR_INVALID_PARAMETER;
camera_s * handle = (camera_s*)camera;
+ int focus_mode;
+ bool should_change_focus_mode = false;
+ mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE, &focus_mode, NULL);
+ if( focus_mode != MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO && focus_mode != MM_CAMCORDER_FOCUS_MODE_CONTINUOUS && focus_mode != MM_CAMCORDER_FOCUS_MODE_AUTO )
+ should_change_focus_mode = true;
+
+ if( mode != CAMERA_ATTR_AF_NONE && should_change_focus_mode ){
+ mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_FOCUS_MODE, MM_CAMCORDER_FOCUS_MODE_AUTO, NULL);
+ }
switch(mode){
case CAMERA_ATTR_AF_NONE:
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE , MM_CAMCORDER_FOCUS_MODE_NONE ,
- MMCAM_CAMERA_AF_SCAN_RANGE , MM_CAMCORDER_AUTO_FOCUS_NORMAL , NULL);
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_FOCUS_MODE, MM_CAMCORDER_FOCUS_MODE_NONE,
+ MMCAM_CAMERA_AF_SCAN_RANGE , MM_CAMCORDER_AUTO_FOCUS_NORMAL, NULL);
break;
case CAMERA_ATTR_AF_NORMAL:
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE , MM_CAMCORDER_FOCUS_MODE_AUTO ,
- MMCAM_CAMERA_AF_SCAN_RANGE , MM_CAMCORDER_AUTO_FOCUS_NORMAL , NULL);
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_AF_SCAN_RANGE , MM_CAMCORDER_AUTO_FOCUS_NORMAL, NULL);
break;
case CAMERA_ATTR_AF_MACRO:
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE , MM_CAMCORDER_FOCUS_MODE_AUTO ,
- MMCAM_CAMERA_AF_SCAN_RANGE , MM_CAMCORDER_AUTO_FOCUS_MACRO , NULL);
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_AF_SCAN_RANGE , MM_CAMCORDER_AUTO_FOCUS_MACRO, NULL);
break;
case CAMERA_ATTR_AF_FULL:
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_FOCUS_MODE , MM_CAMCORDER_FOCUS_MODE_AUTO ,
- MMCAM_CAMERA_AF_SCAN_RANGE , MM_CAMCORDER_AUTO_FOCUS_FULL , NULL);
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_AF_SCAN_RANGE , MM_CAMCORDER_AUTO_FOCUS_FULL, NULL);
break;
-
default:
return ret;
}
-
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+int camera_attr_set_af_area(camera_h camera, int x, int y){
+ if( camera == NULL){
+ LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
+ return CAMERA_ERROR_INVALID_PARAMETER;
+ }
+ int ret = CAMERA_ERROR_INVALID_PARAMETER;
+ camera_s * handle = (camera_s*)camera;
+ camera_attr_af_mode_e mode;
+ camera_attr_get_af_mode(camera, &mode);
+ if( mode == CAMERA_ATTR_AF_NONE ){
+ LOGE( "[%s] INVALID_OPERATION(0x%08x) AF mode is CAMERA_ATTR_AF_NONE",__func__,CAMERA_ERROR_INVALID_OPERATION);
+ return CAMERA_ERROR_INVALID_OPERATION;
+ }
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_AF_TOUCH_X, x,
+ MMCAM_CAMERA_AF_TOUCH_Y, y,
+ NULL);
+ if( ret == 0 )
+ handle->focus_area_valid = true;
return __convert_camera_error_code(__func__, ret);
}
+int camera_attr_clear_af_area(camera_h camera){
+ if( camera == NULL){
+ LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__, CAMERA_ERROR_INVALID_PARAMETER);
+ return CAMERA_ERROR_INVALID_PARAMETER;
+ }
+ camera_s * handle = (camera_s*)camera;
+ if( !handle->focus_area_valid ){
+ LOGE( "[%s] INVALID_OPERATION(0x%08x) AF area was not set",__func__,CAMERA_ERROR_INVALID_OPERATION);
+ return CAMERA_ERROR_INVALID_OPERATION;
+ }
+ handle->focus_area_valid = false;
+ return 0;
+}
+
int camera_attr_set_exposure_mode(camera_h camera, camera_attr_exposure_mode_e mode){
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
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);
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 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){
return CAMERA_ERROR_INVALID_PARAMETER;
}
int ret;
-
+
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_BRIGHTNESS , level, NULL);
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_set_contrast(camera_h camera, int level){
return CAMERA_ERROR_INVALID_PARAMETER;
}
int ret;
-
+
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_CONTRAST , level, NULL);
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_set_whitebalance(camera_h camera, camera_attr_whitebalance_e wb){
if( camera == NULL){
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){
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;
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_TAG_ENABLE , enable, NULL);
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_set_tag_image_description(camera_h camera, const char *description){
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){
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){
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_SOFTWARE , software, strlen(software), NULL);
return __convert_camera_error_code(__func__, ret);
-
-}
-int camera_attr_set_tag_latitude(camera_h camera, double latitude){
- if( camera == NULL){
- LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
- return CAMERA_ERROR_INVALID_PARAMETER;
- }
- int ret;
- camera_s * handle = (camera_s*)camera;
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_LATITUDE , latitude, NULL);
- return __convert_camera_error_code(__func__, ret);
-
}
-int camera_attr_set_tag_longitude(camera_h camera, double longtitude){
+int camera_attr_set_geotag(camera_h camera, double latitude , double longitude, double altitude){
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
int ret;
camera_s * handle = (camera_s*)camera;
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_LONGITUDE , longtitude, NULL);
+ ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_GPS_ENABLE, 1,
+ MMCAM_TAG_LATITUDE, latitude,
+ MMCAM_TAG_LONGITUDE, longitude,
+ MMCAM_TAG_ALTITUDE, altitude,
+ NULL);
return __convert_camera_error_code(__func__, ret);
-
}
-int camera_attr_set_tag_altitude(camera_h camera, double altitude){
+int camera_attr_remove_geotag(camera_h camera){
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
int ret;
camera_s * handle = (camera_s*)camera;
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_ALTITUDE , altitude, NULL);
+ ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_GPS_ENABLE, 0, NULL);
return __convert_camera_error_code(__func__, ret);
-
}
+
int camera_attr_set_flash_mode(camera_h camera, camera_attr_flash_mode_e mode){
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
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);
}
if( camera == NULL || zoom == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
- }
-
+ }
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_DIGITAL_ZOOM , zoom, NULL);
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_get_zoom_range(camera_h camera , int *min , int *max){
if( camera == NULL || min == NULL || max == NULL ){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
- }
+ }
int ret;
camera_s * handle = (camera_s*)camera;
*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);
}
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
int focus_mode;
int af_range;
*mode = CAMERA_ATTR_AF_NONE;
break;
case MM_CAMCORDER_FOCUS_MODE_AUTO:
+ case MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO:
+ case MM_CAMCORDER_FOCUS_MODE_CONTINUOUS:
switch ( af_range ){
case MM_CAMCORDER_AUTO_FOCUS_NONE :
- *mode = CAMERA_ATTR_AF_NONE;
+ *mode = CAMERA_ATTR_AF_NORMAL;
break;
case MM_CAMCORDER_AUTO_FOCUS_NORMAL:
*mode = CAMERA_ATTR_AF_NORMAL;
-
break;
case MM_CAMCORDER_AUTO_FOCUS_MACRO:
*mode = CAMERA_ATTR_AF_MACRO;
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){
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
*mode = maptable[abs(exposure_mode%9)];
}
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_get_exposure(camera_h camera, int *value){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_EXPOSURE_VALUE , value, NULL);
- return __convert_camera_error_code(__func__, ret);
+ return __convert_camera_error_code(__func__, ret);
}
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;
*min = ainfo.int_range.min;
if( max )
*max = ainfo.int_range.max;
-
+
return __convert_camera_error_code(__func__, ret);
}
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_ISO , iso, NULL);
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_get_brightness(camera_h camera, int *level){
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_BRIGHTNESS , level, NULL);
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_get_brightness_range(camera_h camera, int *min, int *max){
if( camera == NULL || min == NULL || max == NULL ){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
- }
+ }
int ret;
camera_s * handle = (camera_s*)camera;
*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);
}
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);
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;
*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);
}
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_WB , wb, NULL);
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_get_effect(camera_h camera, camera_attr_effect_mode_e *effect){
-
+
if( camera == NULL || effect == NULL ){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
int tone;
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:
break;
}
- return __convert_camera_error_code(__func__, ret);
+ return __convert_camera_error_code(__func__, ret);
}
int camera_attr_get_scene_mode(camera_h camera, camera_attr_scene_mode_e *mode){
-
if( camera == NULL || mode == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_FILTER_SCENE_MODE , mode, NULL);
return __convert_camera_error_code(__func__, ret);
-
+
}
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TAG_ENABLE , enable, NULL);
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_get_tag_image_description(camera_h camera, char **description){
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;
else
*description = strdup("");
}
-
+
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_get_tag_orientation(camera_h camera, camera_attr_tag_orientation_e *orientation){
-
+
if( camera == NULL || orientation == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TAG_ORIENTATION , orientation, NULL);
return __convert_camera_error_code(__func__, ret);
-
+
}
int camera_attr_get_tag_software(camera_h camera, char **software){
if( camera == NULL || software == NULL ){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
char *soft;
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);
-
}
-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;
}
-
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);
}
-int camera_attr_get_tag_altitude(camera_h camera, double *altitude){
- if( camera == NULL || altitude == NULL){
- LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
- return CAMERA_ERROR_INVALID_PARAMETER;
- }
-
- int ret;
- camera_s * handle = (camera_s*)camera;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TAG_ALTITUDE , altitude, NULL);
- return __convert_camera_error_code(__func__, ret);
-}
int camera_attr_get_flash_mode(camera_h camera, camera_attr_flash_mode_e *mode){
if( camera == NULL || mode == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_STROBE_MODE , mode, NULL);
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
-
+
+
int ret;
int i;
camera_s * handle = (camera_s*)camera;
MMCamAttrsInfo af_range;
- MMCamAttrsInfo focus_mode;
-
+ MMCamAttrsInfo focus_mode;
+
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_AF_SCAN_RANGE , &af_range);
- ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_FOCUS_MODE , &focus_mode);
-
+ ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_FOCUS_MODE , &focus_mode);
+
if( ret != CAMERA_ERROR_NONE )
return __convert_camera_error_code(__func__, ret);
goto ENDCALLBACK;
}
-
ENDCALLBACK:
return CAMERA_ERROR_NONE;
-
+
}
int camera_attr_foreach_supported_exposure_mode(camera_h camera, camera_attr_supported_exposure_mode_cb foreach_cb , void *user_data){
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
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++)
{
}
}
return CAMERA_ERROR_NONE;
-
+
}
int camera_attr_foreach_supported_iso( camera_h camera, camera_attr_supported_iso_cb foreach_cb , void *user_data){
if( camera == NULL || foreach_cb == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
- }
+ }
int ret;
camera_s * handle = (camera_s*)camera;
MMCamAttrsInfo info;
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_ISO , &info);
if( ret != CAMERA_ERROR_NONE )
return __convert_camera_error_code(__func__, ret);
-
+
int i;
for( i=0 ; i < info.int_array.count ; i++)
{
if ( !foreach_cb(info.int_array.array[i],user_data) )
break;
}
- return CAMERA_ERROR_NONE;
-
+ return CAMERA_ERROR_NONE;
+
}
int camera_attr_foreach_supported_whitebalance(camera_h camera, camera_attr_supported_whitebalance_cb foreach_cb , void *user_data){
if( camera == NULL || foreach_cb == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
- }
+ }
int ret;
camera_s * handle = (camera_s*)camera;
MMCamAttrsInfo info;
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_FILTER_WB , &info);
if( ret != CAMERA_ERROR_NONE )
return __convert_camera_error_code(__func__, ret);
-
+
int i;
for( i=0 ; i < info.int_array.count ; i++)
{
if ( !foreach_cb(info.int_array.array[i],user_data) )
break;
}
- return CAMERA_ERROR_NONE;
-
+ return CAMERA_ERROR_NONE;
+
}
int camera_attr_foreach_supported_effect(camera_h camera, camera_attr_supported_effect_cb foreach_cb , void *user_data){
if( camera == NULL || foreach_cb == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
- }
+ }
int maptable[] = {
CAMERA_ATTR_EFFECT_NONE, //MM_CAMCORDER_COLOR_TONE_NONE
CAMERA_ATTR_EFFECT_MONO, //MM_CAMCORDER_COLOR_TONE_MONO,
-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
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++)
{
break;
}
}
- return CAMERA_ERROR_NONE;
-
+ return CAMERA_ERROR_NONE;
+
}
int camera_attr_foreach_supported_scene_mode(camera_h camera, camera_attr_supported_scene_mode_cb foreach_cb , void *user_data){
if( camera == NULL || foreach_cb == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
}
-
+
int ret;
camera_s * handle = (camera_s*)camera;
MMCamAttrsInfo info;
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_FILTER_SCENE_MODE , &info);
if( ret != CAMERA_ERROR_NONE )
return __convert_camera_error_code(__func__, ret);
-
+
int i;
for( i=0 ; i < info.int_array.count ; i++)
{
if ( !foreach_cb(info.int_array.array[i],user_data) )
break;
}
- return CAMERA_ERROR_NONE;
+ return CAMERA_ERROR_NONE;
}
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_STROBE_MODE , &info);
if( ret != CAMERA_ERROR_NONE )
return __convert_camera_error_code(__func__, ret);
-
+
int i;
for( i=0 ; i < info.int_array.count ; i++)
{
if ( !foreach_cb(info.int_array.array[i],user_data) )
break;
}
- return CAMERA_ERROR_NONE;
-
+ return CAMERA_ERROR_NONE;
+
}
int camera_attr_foreach_supported_fps(camera_h camera, camera_attr_supported_fps_cb foreach_cb , void *user_data){
if( camera == NULL || foreach_cb == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
- }
+ }
int ret;
camera_s * handle = (camera_s*)camera;
MMCamAttrsInfo info;
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_FPS , &info);
if( ret != CAMERA_ERROR_NONE )
return __convert_camera_error_code(__func__, ret);
-
+
int i;
//if (foreach_cb(CAMERA_ATTR_FPS_AUTO, user_data) < 0 )
// return CAMERA_ERROR_NONE;
}
return CAMERA_ERROR_NONE;
-
}
int camera_attr_set_stream_rotation(camera_h camera , camera_rotation_e rotation){
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
- }
+ }
if( rotation < CAMERA_ROTATION_NONE || rotation > CAMERA_ROTATION_270 )
return CAMERA_ERROR_INVALID_PARAMETER;
camera_s * handle = (camera_s*)camera;
ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_CAMERA_ROTATION , rotation, NULL);
- return __convert_camera_error_code(__func__, ret);
+ return __convert_camera_error_code(__func__, ret);
}
int camera_attr_set_stream_flip(camera_h camera , camera_flip_e flip){
if( camera == NULL){
LOGE( "[%s] INVALID_PARAMETER(0x%08x)",__func__,CAMERA_ERROR_INVALID_PARAMETER);
return CAMERA_ERROR_INVALID_PARAMETER;
- }
+ }
if( flip < CAMERA_FLIP_NONE || flip > CAMERA_FLIP_BOTH )
return CAMERA_ERROR_INVALID_PARAMETER;
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 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)
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);
}
--- /dev/null
+!_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
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})
}
-void capturing_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data)
+void capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data)
{
char * filepath = (char*)user_data;
FILE* f = fopen(filepath, "w+");
bool ret;
- if(f!=NULL && image_buffer !=NULL)
+ if(f!=NULL && image !=NULL)
{
- fwrite(image_buffer,1, buffer_size, f);
- printf("capture(%s) %dx%d, buffer_size=%d\n", filepath, width, height, buffer_size);
+ fwrite(image->data,1, image->size, f);
+ printf("capture(%s) %dx%d, buffer_size=%d\n", filepath, image->width, image->height, image->size);
ret = TRUE;
}
else
int stillshot_test(){
camera_h camera;
- camera_create(CAMERA_DEVICE_CAMERA1, &camera);
+ camera_create(CAMERA_DEVICE_CAMERA0, &camera);
camera_attr_set_image_quality(camera, 100);
- camera_set_capturing_cb(camera, capturing_cb, "/mnt/nfs/test.jpg");
camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
camera_attr_set_tag_orientation(camera,6);
camera_set_capture_format(camera, CAMERA_PIXEL_FORMAT_JPEG);
camera_start_preview(camera);
- camera_start_focusing(camera);
+ camera_start_focusing(camera, false);
sleep(1);
- camera_start_capture(camera);
+ camera_start_capture(camera, capturing_cb, NULL, "/mnt/nfs/test.jpg");
sleep(1);
camera_start_preview(camera);
camera_stop_preview(camera);
int ret1 ;
int ret2 ;
int i;
+ int min, max;
printf("------------- ZOOM TEST -------------\n");
-
- for( i = 0 ; i <= 40 ; i+=5 ){
+ camera_attr_get_zoom_range(camera, &min, &max);
+ if(max == -1 )
+ return 0;
+ for( i = min ; i <= max; i+=5 ){
int zoom;
ret1 = camera_attr_set_zoom(camera, i);
printf("-set zoom %d\tret=%x\n",i, ret1);
ret2 = camera_attr_get_zoom(camera,&zoom);
printf("-get zoom %d\tret=%x",zoom, ret2);
- if( i >=10 && i <= 30 ){
+ if( i >=min && i <= max ){
if( i == zoom )
printf("\t\t\tpass\n");
else{
ret = camera_attr_get_exposure_mode(camera,&get_mode);
printf("-get exposure mode %d\tret=%x\n", get_mode,ret);
if( get_mode != mode ){
+ printf("\t\t\tFAIL\n");
g_exposure_mode_pass = false;
return false;
- }
+ }else
+ printf("\t\t\tPASS\n");
return true;
}
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 i;
int ret1, ret2;
int default_value;
+ int min,max;
ret1 = camera_attr_get_exposure(camera, &default_value );
- for( i = 0; i < 13 ; i++ ){
+ camera_attr_get_exposure_range(camera, &min, &max);
+ printf("exposure range %d~%d\n", min, max);
+ if(max == -1 )
+ return 0;
+ for( i = 1; i < 13 ; i++ ){
int value;
ret1 = camera_attr_set_exposure(camera, i );
printf("-set exposure %d\tret=%x\n",i,ret1);
ret2 = camera_attr_get_exposure(camera, &value);
printf("-get exposure %d\tret=%x\n",value,ret2);
- if( i >= 1 && i <= 7 ){
+ if( i >= min && i <= max ){
if( value != i)
return -1;
}else{ // out of bound error
int i;
int ret1,ret2;
int default_value;
+ int min,max;
ret1 = camera_attr_get_brightness(camera, &default_value );
- for( i = 0; i < 13 ; i++ ){
+ camera_attr_get_brightness_range(camera, &min, &max);
+ if(max == -1 )
+ return 0;
+ for( i = 1; i < 13 ; i++ ){
int value;
ret1 = camera_attr_set_brightness(camera, i );
printf("-set brightness %d\tret=%x\n",i,ret1);
ret2 = camera_attr_get_brightness(camera, &value);
printf("-get brightness %d\tret=%x\n",value,ret2);
- if( i >= 1 && i <= 7 ){
+ if( i >= min && i <= max ){
if( value != i)
return -1;
}else{ // out of bound error
int i;
int ret1,ret2;
int default_value;
+ int min,max;
ret1 = camera_attr_get_contrast (camera, &default_value );
- for( i = 0; i < 13 ; i++ ){
+ camera_attr_get_contrast_range(camera, &min, &max);
+ if(max == -1 )
+ return 0;
+ for( i = 1; i < 13 ; i++ ){
int value;
ret1 = camera_attr_set_contrast (camera, i );
printf("-set contrast %d\tret=%x\n",i,ret1);
ret2 = camera_attr_get_contrast (camera, &value);
printf("-get contrast %d\tret=%x\n",value,ret2);
- if( i >= 1 && i <= 7 ){
+ if( i >= min && i <= max ){
if( value != i)
return -1;
}else{ // out of bound error
}
int gps_test(camera_h camera){
- double value;
+ double lng = 1.12;
+ double lat = 1.13;
+ double alt = 1.14;
int ret;
- ret = camera_attr_set_tag_longitude(camera, 1.12);
- printf("-set tag longitude 1.12\tret=%x\n",ret);
- ret = camera_attr_get_tag_longitude(camera, &value);
- printf("-get tag longitude %g\tret=%x\n",value, ret);
-
- ret = camera_attr_set_tag_latitude(camera, 1.13);
- printf("-set tag latitude 1.13\tret=%x\n", ret);
- ret = camera_attr_get_tag_latitude(camera, &value);
- printf("-get tag latitude %g\tret=%x\n",value, ret);
-
- ret = camera_attr_set_tag_altitude(camera, 1.15);
- printf("-set tag altitude 1.15\tret=%x\n",ret);
- ret = camera_attr_get_tag_altitude(camera, &value);
- printf("-get tag altitude %g\tret=%x\n",value, ret);
-
+ ret = camera_attr_set_geotag(camera, lat, lng , alt );
+ if( ret != 0)
+ return -1;
+ ret = camera_attr_get_geotag(camera, &lat , &lng , &alt);
+ if( ret != 0 )
+ return -1;
return 0;
+
}
int camera_attribute_test(){
int ret;
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,};
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;
camera_set_preview_format(camera, i);
printf("-------------PREVIEW FORMAT %d TEST--------------------\n", i);
camera_start_preview(camera);
- sleep(1);
+ while( preview_test_data.iscalled==false && timeout-- > 5 )
+ sleep(1);
+
camera_stop_preview(camera);
if( preview_test_data.iscalled && preview_test_data.result ){
printf("PASS\n");
}else{
+ printf("preview_test_data.result = %d\n", preview_test_data.result);
printf("FAIL\n");
camera_destroy(camera);
return -1;
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");
}
camera_h camera ;
state_change_data data;
bool ispass = true;
+ int ret=0;
camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
camera_set_state_changed_cb(camera, _state_change_test_cb, &data);
- camera_set_capturing_cb(camera,_capture_test_cb, NULL);
-
printf("------------------- PREVIEW STATE Change test------------------\n");
data.iscalled = false;
- data.state = 0;
- camera_start_preview(camera);
+ data.state = 0;
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview ret = %x\n", ret);
sleep(1);
if( data.iscalled && data.state == CAMERA_STATE_PREVIEW )
printf("PASS\n");
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");
printf("------------------- CAPTURED STATE Change test------------------\n");
- camera_start_preview(camera);
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview ret = %x\n", ret);
sleep(1);
data.iscalled = false;
data.state = 0;
data.iscaptured = false;
data.ispreviewed= false;
data.iscapturing = false;
- camera_start_capture(camera);
+ ret = camera_start_capture(camera, _capture_test_cb, NULL, NULL);
+ printf("camera_start_capture ret = %x\n", ret);
sleep(3);
if( data.iscalled && data.iscaptured && data.iscapturing && data.state == CAMERA_STATE_CAPTURED)
printf("PASS\n");
ispass = false;
}
- camera_start_preview(camera);
- camera_stop_preview(camera);
- camera_destroy(camera);
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview ret = %x\n", ret);
+ ret = camera_stop_preview(camera);
+ printf("camera_stop_preview ret = %x\n", ret);
+ ret = camera_destroy(camera);
+ printf("camera_destroy ret = %x\n", ret);
+
return ispass ? 0: -1;
}
-void _capture_test2_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data){
+void _capture_test2_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
int *iscalled = (int*)user_data;
*iscalled = 1;
}
camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
- camera_set_capturing_cb(camera,_capture_test2_cb, &iscalled);
camera_start_preview(camera);
iscalled = 0;
- camera_start_capture(camera);
+ camera_start_capture(camera, _capture_test2_cb, NULL, &iscalled);
while( camera_get_state(camera, &state ) == 0 && state != CAMERA_STATE_CAPTURED && timeout-- > 0 )
sleep(1);
int expected_height;
bool ispass;
}preview_test_data;
-void _capture_test3_cb(void *image_buffer, int buffer_size, int width, int height, camera_pixel_format_e format, void *user_data){
+void _capture_test3_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
preview_test_data *data = (preview_test_data*)user_data;
- if( data->expected_height == height && data->expected_width == width )
+ if( data->expected_height == image->height && data->expected_width == image->width )
data->ispass = true;
}
printf("resolution set test %x\n", (unsigned int)camera_set_capture_resolution(camera,data.expected_width ,data.expected_height));
- camera_set_capturing_cb(camera, _capture_test3_cb , &data);
camera_start_preview(camera);
- camera_start_capture(camera);
+ camera_start_capture(camera, _capture_test3_cb , NULL, &data);
while( camera_get_state(camera, &state ) == 0 && state != CAMERA_STATE_CAPTURED && timeout-- > 0){
sleep(1);
sleep(3);
printf("start focusing\n");
- camera_start_focusing(camera);
+ camera_start_focusing(camera, false);
sleep(3);
printf("start focusing2\n");
- camera_start_focusing(camera);
+ camera_start_focusing(camera, false);
sleep(3);
printf("start focusing3\n");
- camera_start_focusing(camera);
+ camera_start_focusing(camera, false);
printf("cancel focusing\n");
camera_cancel_focusing(camera);
}
+
+
+typedef struct{
+ camera_h camera;
+ int count;
+ bool completed;
+}conti_test_data;
+
+void conti_capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
+ conti_test_data *test_data = (conti_test_data*)user_data;
+ printf("capture callback!!%d\n", test_data->count++);
+ if( test_data->count == 5 )
+ camera_stop_continuous_capture(test_data->camera);
+}
+
+void _capture_completed_cb(void *user_data){
+ conti_test_data *test_data = (conti_test_data*)user_data;
+ test_data->completed = true;
+ printf("capture completed\n");
+}
+
+int continuous_capture_test(){
+ printf("--------------continuous capture test--------------------\n");
+ camera_h camera;
+ conti_test_data test_data;
+ int timeout =30;
+ int ret;
+ ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ printf("camera_create %x\n", ret);
+ ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+ printf("camera_set_display %x\n", ret);
+ ret = camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
+ printf("camera_set_x11_display_rotation %x\n", ret);
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview %x\n", ret);
+
+ test_data.camera = camera;
+ test_data.count = 0;
+ test_data.completed = false;
+ ret = camera_start_continuous_capture(camera, 10, 10, conti_capturing_cb, _capture_completed_cb, &test_data);
+ printf("camera_start_continuous_capture ret = %x\n", ret);
+ if( ret != 0 ){
+ printf("fail conti capture\n");
+ camera_stop_preview(camera);
+ camera_destroy(camera);
+ return -1;
+ }
+
+ while( test_data.completed == false && timeout-- > 0 )
+ sleep(1);
+
+ camera_start_preview(camera);
+
+ if( test_data.count != 5|| test_data.completed == false ){
+ camera_stop_preview(camera);
+ camera_destroy(camera);
+ return -1;
+ }
+
+
+ test_data.camera = camera;
+ test_data.count = 0;
+ test_data.completed = false;
+ timeout = 30;
+
+ ret = camera_start_continuous_capture(camera, 10, 1000, conti_capturing_cb, _capture_completed_cb, &test_data);
+
+ if( ret != 0 ){
+ printf("fail conti capture\n");
+ camera_stop_preview(camera);
+ camera_destroy(camera);
+ return -1;
+ }
+
+ sleep(2);
+ camera_stop_continuous_capture(camera);
+
+ while( test_data.completed == false && timeout-- > 0 )
+ sleep(1);
+
+ camera_start_preview(camera);
+ camera_stop_preview(camera);
+ camera_destroy(camera);
+
+ printf("total capture count = %d\n", test_data.count);
+ if( test_data.completed == false)
+ return -1;
+ return 0;
+}
+
+
+void _face_detected(camera_detected_face_s *faces, int count, void *user_data){
+ printf("face detected!!\n");
+ int i;
+ for(i = 0 ; i < count ; i++){
+ printf("%d) - %dx%d\n", faces[i].id, faces[i].x, faces[i].y);
+ }
+}
+
+
+int face_detection_test(){
+ printf("--------------face_detection_test--------------------\n");
+ camera_h camera;
+ int ret;
+ ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ printf("camera_create %x\n", ret);
+ ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+ printf("camera_set_display %x\n", ret);
+ ret = camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
+ printf("camera_set_x11_display_rotation %x\n", ret);
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview %x\n", ret);
+ if( camera_is_supported_face_detection(camera) ){
+ ret = camera_start_face_detection(camera, _face_detected, NULL);
+ printf("camera_start_face_detection %x\n", ret);
+ }else
+ {
+ printf("not supported face detection\n");
+ }
+ return 0;
+}
+
+int face_count ;
+void _face_detected2(camera_detected_face_s *faces, int count, void *user_data){
+ face_count = count;
+ printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n-------------------------------------------\n");
+ int i;
+ for( i = 0 ; i < count ; i++ ){
+ printf("%d) %dx%d \n", faces[i].id, faces[i].x , faces[i].y);
+ }
+}
+
+
+int face_zoom_test(){
+ printf("--------------face_zoom_test--------------------\n");
+ camera_h camera;
+ int ret;
+ ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ printf("camera_create %x\n", ret);
+ ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+ printf("camera_set_display %x\n", ret);
+ ret = camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
+ printf("camera_set_x11_display_rotation %x\n", ret);
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview %x\n", ret);
+ if( camera_is_supported_face_detection(camera) ){
+ ret = camera_start_face_detection(camera, _face_detected2, NULL);
+ printf("camera_start_face_detection %x\n", ret);
+ }else
+ {
+ printf("not supported face detection\n");
+ }
+ while(1){
+ char select[255];
+ //printf("current faces %d\n", face_count);
+ //printf("x is zoom cancel\n");
+ //printf("select face>");
+ gets(select);
+ if( select[0] == 'x' ){
+ camera_cancel_face_zoom(camera);
+ }else if( select[0] != '\0'){
+ int face = select[0] - '0';
+ //printf("input : <%s>\n", select);
+ if( face >= 0 ){
+ //printf("select %d\n", face);
+ camera_face_zoom(camera, face);
+ }
+ }
+ }
+ return 0;
+}
+
+char *table[] = {
+"CAMERA_PIXEL_FORMAT_NV12", /**< NV12 pixel format */
+"CAMERA_PIXEL_FORMAT_NV12T", /**< NV12 Tiled pixel format */
+"CAMERA_PIXEL_FORMAT_NV16", /**< NV16 pixel format */
+"CAMERA_PIXEL_FORMAT_NV21", /**< NV21 pixel format */
+"CAMERA_PIXEL_FORMAT_YUYV", /**< YUYV(YUY2) pixel format */
+"CAMERA_PIXEL_FORMAT_UYVY", /**< UYVY pixel format */
+"CAMERA_PIXEL_FORMAT_422P", /**< YUV422(Y:U:V) planar pixel format */
+"CAMERA_PIXEL_FORMAT_I420", /**< I420 pixel format */
+"CAMERA_PIXEL_FORMAT_YV12", /**< YV12 pixel format */
+"CAMERA_PIXEL_FORMAT_RGB565", /**< RGB565 pixel format */
+"CAMERA_PIXEL_FORMAT_RGB888", /**< RGB888 pixel format */
+"CAMERA_PIXEL_FORMAT_RGBA", /**< RGBA pixel format */
+"CAMERA_PIXEL_FORMAT_ARGB", /**< ARGB pixel format */
+"CAMERA_PIXEL_FORMAT_JPEG" /**< Encoded pixel format */
+};
+
+
+bool supported_preview_format_test(camera_pixel_format_e format,void *user_data){
+ printf("%s\n", table[format]);
+ return true;
+}
+
+int preview_format_test(){
+ camera_h camera;
+ camera_pixel_format_e format;
+ camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ printf("----------CAMERA_DEVICE_CAMERA0 -----------------\n");
+ camera_foreach_supported_preview_format(camera, supported_preview_format_test, NULL);
+ camera_get_preview_format(camera, &format);
+ printf("default - %s\n", table[format]);
+
+ camera_destroy(camera);
+ camera_create(CAMERA_DEVICE_CAMERA1, &camera);
+ printf("----------CAMERA_DEVICE_CAMERA1 -----------------\n");
+ camera_foreach_supported_preview_format(camera, supported_preview_format_test, NULL);
+ camera_get_preview_format(camera, &format);
+ printf("default - %s\n", table[format]);
+ camera_destroy(camera);
+
+ return 0;
+
+}
+
+void _hdr_progress_cb(int percent, void *user_data){
+ printf("percent = %d\n", percent);
+}
+
+void _hdr_capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
+ printf("hdr capturing!\n");
+}
+
+void _hdr_capture_completed_cb(void *user_data){
+ printf("hdr capture complete\n");
+}
+
+
+
+int hdr_capture_test(){
+ camera_h camera;
+ int ret;
+ camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ if( !camera_attr_is_supported_hdr_capture(camera) ){
+ printf("Not supported HDR Capture\n");
+ return 0;
+ }
+
+ camera_attr_set_hdr_capture_progress_cb(camera, _hdr_progress_cb, NULL);
+ camera_attr_set_hdr_mode(camera, CAMERA_ATTR_HDR_MODE_KEEP_ORIGINAL);
+ ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+ camera_start_preview(camera);
+ camera_start_capture(camera, _hdr_capturing_cb , _hdr_capture_completed_cb , NULL);
+
+ return 0;
+}
+
+Eina_Bool captured_event_check5(void *data){
+ printf("!!!captured_event_check5\n");
+ camera_h camera = (camera_h)data;
+ camera_start_capture(camera, _hdr_capturing_cb , _hdr_capture_completed_cb , NULL);
+ camera_state_e state;
+ camera_get_state(camera,&state);
+ while( state == CAMERA_STATE_CAPTURING ){
+ //printf("current state = %d\n", state);
+ usleep(10000);
+ camera_get_state(camera,&state);
+ }
+ printf("current state = %d\n", state);
+ camera_start_preview(camera);
+ camera_stop_preview(camera);
+ camera_destroy(camera);
+
+ return false;
+}
+
+
+int hdr_capture_test2(){
+ camera_h camera;
+ int ret;
+ camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ if( !camera_attr_is_supported_hdr_capture(camera) ){
+ printf("Not supported HDR Capture\n");
+ return 0;
+ }
+
+ camera_attr_set_hdr_capture_progress_cb(camera, _hdr_progress_cb, NULL);
+ camera_attr_set_hdr_mode(camera, CAMERA_ATTR_HDR_MODE_KEEP_ORIGINAL);
+ ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+ camera_start_preview(camera);
+ ecore_idler_add(captured_event_check5, camera);
+
+ return 0;
+}
+
+
+void _captured_check_capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
+ printf("capturing!\n");
+}
+
+void _captured_check_capture_completed_cb(void *user_data){
+ printf("capture complete\n");
+}
+
+Eina_Bool captured_event_check4(void *data){
+ printf("!!!HDR captured event check4\n");
+ camera_h camera;
+ int ret;
+ camera_state_e state;
+
+ ret= camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview ret = %d\n", ret);
+ camera_attr_set_hdr_mode(camera, CAMERA_ATTR_HDR_MODE_KEEP_ORIGINAL);
+ camera_start_capture(camera, _captured_check_capturing_cb , _captured_check_capture_completed_cb , NULL);
+ printf("camera_start_capture ret = %d\n", ret);
+ camera_get_state(camera,&state);
+ while( state == CAMERA_STATE_CAPTURING ){
+ //printf("current state = %d\n", state);
+ usleep(10000);
+ camera_get_state(camera,&state);
+ }
+ printf("current state = %d\n", state);
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview ret = %d\n", ret);
+ ret = camera_stop_preview(camera);
+ printf("camera_stop_preview ret = %d\n", ret);
+ ret = camera_destroy(camera);
+ printf("camera_destroy ret = %d\n", ret);
+ return false;
+}
+
+Eina_Bool captured_event_check3(void *data){
+ printf("!!!continuous break captured event check3\n");
+ camera_h camera;
+ int ret;
+ camera_state_e state;
+
+ ret= camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ printf("camera_create ret = %d\n", ret);
+ ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview ret = %d\n", ret);
+ ret = camera_start_continuous_capture(camera, 5 , 1000, _captured_check_capturing_cb, _captured_check_capture_completed_cb, NULL);
+ printf("camera_start_continuous_capture ret = %d\n", ret);
+ camera_get_state(camera,&state);
+ int count = 0;
+ while( state == CAMERA_STATE_CAPTURING ){
+ //printf("current state = %d\n", state);
+ usleep(10000);
+ count++;
+ if( count == 10)
+ camera_stop_continuous_capture(camera);
+ camera_get_state(camera,&state);
+ }
+ printf("current state = %d\n", state);
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview ret = %d\n", ret);
+ ret = camera_stop_preview(camera);
+ printf("camera_stop_preview ret = %d\n", ret);
+ ret = camera_destroy(camera);
+ printf("camera_destroy ret = %d\n", ret);
+ ecore_idler_add(captured_event_check4, NULL);
+ return false;
+}
+
+Eina_Bool captured_event_check2(void *data){
+ printf("!!!continuous shot captured event check2\n");
+ camera_h camera;
+ int ret;
+ camera_state_e state;
+
+ ret= camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ printf("camera_create ret = %d\n", ret);
+ ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview ret = %d\n", ret);
+ ret = camera_start_continuous_capture(camera, 5 , 1000, _captured_check_capturing_cb, _captured_check_capture_completed_cb, NULL);
+ printf("camera_start_continuous_capture ret = %d\n", ret);
+ camera_get_state(camera,&state);
+ while( state == CAMERA_STATE_CAPTURING ){
+ //printf("current state = %d\n", state);
+ usleep(10000);
+ camera_get_state(camera,&state);
+ }
+ printf("current state = %d\n", state);
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview ret = %d\n", ret);
+ ret = camera_stop_preview(camera);
+ printf("camera_stop_preview ret = %d\n", ret);
+ ret = camera_destroy(camera);
+ printf("camera_destroy ret = %d\n", ret);
+ ecore_idler_add(captured_event_check3, NULL);
+ return false;
+}
+
+
+Eina_Bool captured_event_check(void *data){
+ printf("!!!Normal captured event check\n");
+ camera_h camera;
+ camera_state_e state;
+
+ int ret;
+ ret= camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ ret = camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview ret = %d\n", ret);
+ camera_start_capture(camera, _captured_check_capturing_cb , _captured_check_capture_completed_cb , NULL);
+ printf("camera_start_capture ret = %d\n", ret);
+ camera_get_state(camera,&state);
+ while( state == CAMERA_STATE_CAPTURING ){
+ //printf("current state = %d\n", state);
+ usleep(10000);
+ camera_get_state(camera,&state);
+ }
+ printf("current state = %d\n", state);
+ ret = camera_start_preview(camera);
+ printf("camera_start_preview ret = %d\n", ret);
+ ret = camera_stop_preview(camera);
+ printf("camera_stop_preview ret = %d\n", ret);
+ ret = camera_destroy(camera);
+ printf("camera_destroy ret = %d\n", ret);
+
+ ecore_idler_add(captured_event_check2, NULL);
+ return false;
+}
+
int camera_test(){
-
+
int ret=0;
- /*
- ret = camera_attribute_test();
- ret += camera_preview_test();
- ret += camera_state_change_test();
- ret += capture_test();
- ret += capture_resolution_test();
- ret += stillshot_test();
- camera_lens_rotation_test();
-
- contrast_test2();
- */
- rotation_flip_test();
+
+ //ret = camera_attribute_test();
+ //ret += camera_preview_test();
+ //ret += camera_state_change_test();
+ //ret += capture_test();
+ //ret += capture_resolution_test();
+ //ret += stillshot_test();
+ //camera_lens_rotation_test();
+ //contrast_test2();
+ //rotation_flip_test();
+ //ret += continuous_capture_test();
+ //ret = face_detection_test();
+ //face_zoom_test();
+ //preview_format_test();
+ //hdr_capture_test();
+ //hdr_capture_test();
+ hdr_capture_test2();
return ret;
}
evas_object_image_fill_set(img, 0, 0, w, h);
- evas_object_show(img);
+ evas_object_show(img);
pthread_t gloop_thread;
pthread_create(&gloop_thread, NULL, test_main, NULL);
- //ecore_timer_add(0.01, video_window_update, NULL);
-
+ //ecore_idler_add(captured_event_check, NULL);
elm_run();
elm_shutdown();
projects / platform / core / api / camera.git / commitdiff