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