/* * camera_test * * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. * * Contact: Jeongmo Yang * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License f(r the specific language governing permissions and * limitations under the License. * */ /*======================================================================================= | INCLUDE FILES | =======================================================================================*/ #include #include #include #include #include #include #include #include #include /*----------------------------------------------------------------------- | GLOBAL VARIABLE DEFINITIONS: | -----------------------------------------------------------------------*/ #define EXPORT_API __attribute__((__visibility__("default"))) #ifdef PACKAGE #undef PACKAGE #endif #define PACKAGE "camera_test" static int app_create(void *data); static int app_terminate(void *data); struct _appdata { Evas_Object *win; Evas_Object *eo; Evas_Object *bg; Evas_Object *rect; }; typedef struct _appdata appdata; struct appcore_ops ops = { .create = app_create, .terminate = app_terminate, }; appdata ad; GIOChannel *stdin_channel; camera_device_e cam_info; static GTimer *timer; static int g_camera_device_changed_cb_id; GTimeVal previous_time; GTimeVal current_time; GTimeVal result_time; /*----------------------------------------------------------------------- | GLOBAL CONSTANT DEFINITIONS: | -----------------------------------------------------------------------*/ /*----------------------------------------------------------------------- | IMPORTED VARIABLE DECLARATIONS: | -----------------------------------------------------------------------*/ /*----------------------------------------------------------------------- | IMPORTED FUNCTION DECLARATIONS: | -----------------------------------------------------------------------*/ /*----------------------------------------------------------------------- | LOCAL #defines: | -----------------------------------------------------------------------*/ #define DEFAULT_FILE_PATH "/home/owner/media" #define MAX_FILE_NAME_LENGTH 256 #define MAX_FILE_PATH_LENGTH (MAX_FILE_NAME_LENGTH - 20) #define CHECK_MM_ERROR(expr) \ do {\ int ret = 0; \ ret = expr; \ if (ret != 0) {\ g_print("[%s:%d] error code : %x \n", __func__, __LINE__, ret); \ return; \ } \ } while (0) #ifndef SAFE_FREE #define SAFE_FREE(x) \ if (x) {\ g_free(x);\ x = NULL;\ } #endif #define SENSOR_WHITEBALANCE_NUM 10 #define SENSOR_COLOR_TONE_NUM 31 #define SENSOR_FLIP_NUM 3 #define SENSOR_PROGRAM_MODE_NUM 15 #define SENSOR_FOCUS_NUM 6 #define SENSOR_INPUT_ROTATION 4 #define SENSOR_AF_SCAN_NUM 4 #define SENSOR_ISO_NUM 8 #define SENSOR_EXPOSURE_NUM 9 #define SENSOR_IMAGE_FORMAT 9 /*----------------------------------------------------------------------- | LOCAL CONSTANT DEFINITIONS: | -----------------------------------------------------------------------*/ enum { MODE_VIDEO_CAPTURE, /* recording and image capture mode */ MODE_AUDIO, /* audio recording*/ MODE_NUM, }; enum { MENU_STATE_INIT, MENU_STATE_MAIN, MENU_STATE_SETTING, MENU_STATE_NUM, }; /*----------------------------------------------------------------------- | LOCAL DATA TYPE DEFINITIONS: | -----------------------------------------------------------------------*/ typedef struct _cam_handle { camera_h camera; int type; int is_multishot; /* flag for multishot mode */ int stillshot_count; /* stillshot count */ int multishot_count; /* multishot count */ char file_path[MAX_FILE_PATH_LENGTH]; /* file path for captured data */ int menu_state; unsigned long long elapsed_time; } cam_handle_t; typedef struct { int width[100]; int height[100]; int count; } resolution_stack; typedef struct { camera_attr_exposure_mode_e mode; int count; } exposure_stack; typedef struct { camera_attr_iso_e mode; int count; } iso_stack; typedef struct { camera_rotation_e mode; int count; } camera_rotation_stack; /*--------------------------------------------------------------------------- | LOCAL VARIABLE DEFINITIONS: | ---------------------------------------------------------------------------*/ static cam_handle_t *hcamcorder; const char *wb[SENSOR_WHITEBALANCE_NUM] = { "None", "Auto", "Daylight", "Cloudy", "Fluoroscent", "Incandescent", "Shade", "Horizon", "Flash", "Custom", }; const char *ct[SENSOR_COLOR_TONE_NUM] = { "NONE", "MONO", "SEPIA", "NEGATIVE", "BLUE", "GREEN", "AQUA", "VIOLET", "ORANGE", "GRAY", "RED", "ANTIQUE", "WARM", "PINK", "YELLOW", "PURPLE", "EMBOSS", "OUTLINE", "SOLARIZATION", "SKETCH", "WASHED", "VINTAGE_WARM", "VINTAGE_COLD", "POSTERIZATION", "CARTOON", "SELECTVE_COLOR_RED", "SELECTVE_COLOR_GREEN", "SELECTVE_COLOR_BLUE", "SELECTVE_COLOR_YELLOW", "SELECTVE_COLOR_RED_YELLOW", "GRAPHICS" }; const char *flip[SENSOR_FLIP_NUM] = { "Horizontal", "Vertical", "Not flipped", }; const char *program_mode[SENSOR_PROGRAM_MODE_NUM] = { "NORMAL", "PORTRAIT", "LANDSCAPE", "SPORTS", "PARTY_N_INDOOR", "BEACH_N_INDOOR", "SUNSET", "DUSK_N_DAWN", "FALL_COLOR", "NIGHT_SCENE", "FIREWORK", "TEXT", "SHOW_WINDOW", "CANDLE_LIGHT", "BACKLIGHT", }; const char *focus_mode[SENSOR_FOCUS_NUM] = { "None", "Pan", "Auto", "Manual", "Touch Auto", "Continuous Auto", }; const char *camera_rotation[SENSOR_INPUT_ROTATION] = { "None", "90", "180", "270", }; const char *iso_mode[SENSOR_ISO_NUM] = { "ISO Auto", "ISO 50", "ISO 100", "ISO 200", "ISO 400", "ISO 800", "ISO 1600", "ISO 3200", }; const char *exposure_mode[SENSOR_EXPOSURE_NUM] = { "AE off", "AE all mode", "AE center mode", "AE spot 1 mode", "AE custom mode", }; const char *image_fmt[SENSOR_IMAGE_FORMAT] = { "NV12", "NV12T", "NV16", "NV21", "YUYV", "UYVY", "422P", "I420", "YV12", }; const char *face_zoom_mode[] = { "Face Zoom OFF", "Face Zoom ON", }; const char *display_mode[] = { "Letter Box mode", "Original Size mode", "Full Screen mode", "Cropped Full Screen mode", "ROI mode", }; const char *capture_sound[] = { "Default", "Extra 01", "Extra 02", }; const char *rotate_mode[] = { "0", "90", "180", "270", }; const char* strobe_mode[] = { "Strobe OFF", "Strobe ON", "Strobe Auto", "Strobe RedEyeReduction", "Strobe SlowSync", "Strobe FrontCurtain", "Strobe RearCurtain", "Strobe Permanent", }; const char *detection_mode[2] = { "Face Detection OFF", "Face Detection ON", }; const char *wdr_mode[] = { "WDR OFF", "WDR ON", "WDR AUTO", }; const char *af_scan[SENSOR_AF_SCAN_NUM] = { "None", "Normal", "Macro mode", "Full mode", }; const char *hdr_mode[] = { "HDR OFF", "HDR ON", "HDR ON and Original", }; const char *ahs_mode[] = { "Anti-handshake OFF", "Anti-handshake ON", "Anti-handshake AUTO", "Anti-handshake MOVIE", }; const char *vs_mode[] = { "Video-stabilization OFF", "Video-stabilization ON", }; const char *visible_mode[] = { "Display OFF", "Display ON", }; const char *facing_direction[] = { "REAR", "FRONT", }; /*--------------------------------------------------------------------------- | LOCAL FUNCTION PROTOTYPES: | ---------------------------------------------------------------------------*/ static void print_menu(); static gboolean cmd_input(GIOChannel *channel); static gboolean mode_change(gchar buf); int camcordertest_set_attr_int(const char* attr_subcategory, int value); static inline void flush_stdin() { int ch; while ((ch = getchar()) != EOF && ch != '\n'); } static bool _release_idle_event_callback(void *data) { g_print("destroy camera handle\n\n"); camera_destroy(hcamcorder->camera); hcamcorder->camera = NULL; hcamcorder->menu_state = MENU_STATE_INIT; print_menu(); return 0; } static void _camera_error_cb(int error, camera_state_e current_state, void *user_data) { g_print("\n\n\tERROR [0x%x], current state %d\n", error, current_state); switch (error) { case CAMERA_ERROR_RESOURCE_CONFLICT: g_print("\t\t[CAMERA_ERROR_RESOURCE_CONFLICT]\n\n"); break; case CAMERA_ERROR_SECURITY_RESTRICTED: g_print("\t\t[CAMERA_ERROR_SECURITY_RESTRICTED]\n\n"); break; case CAMERA_ERROR_SERVICE_DISCONNECTED: g_print("\t\t[CAMERA_ERROR_SERVICE_DISCONNECTED]\n\n"); g_idle_add_full(G_PRIORITY_DEFAULT, (GSourceFunc)_release_idle_event_callback, NULL, NULL); break; default: break; } return; } static void _camera_state_changed_cb(camera_state_e previous, camera_state_e current, bool by_policy, void *user_data) { g_print("\ncamera state changed %d -> %d\n", previous, current); return; } static void _camera_device_state_changed_cb(camera_device_e device, camera_device_state_e state, void *user_data) { g_print("\ncamera device[%d] state changed to %d\n", device, state); return; } static void _camera_interrupted_cb(camera_policy_e policy, camera_state_e previous, camera_state_e current, void *user_data) { g_print("\ncamera interrupted callback called[state %d -> %d, policy %d]\n", previous, current, policy); return; } static bool preview_resolution_cb(int width, int height, void *user_data) { resolution_stack *data = (resolution_stack *)user_data; if (data == NULL) { g_print("NULL data\n"); return false; } data->width[data->count] = width; data->height[data->count] = height; g_print("%d. %dx%d\n", data->count, width, height); data->count++; return true; } static bool capture_resolution_test_cb(int width, int height, void *user_data) { resolution_stack *data = (resolution_stack *)user_data; if (data == NULL) { g_print("NULL data\n"); return false; } data->width[data->count] = width; data->height[data->count] = height; g_print("%d. %dx%d\n", data->count, width, height); data->count++; return true; } static bool af_mode_foreach_cb(camera_attr_iso_e mode, void *user_data) { g_print("%d.%s\n", mode, af_scan[mode]); return true; } static bool exposure_mode_cb(camera_attr_af_mode_e mode, void *user_data) { exposure_stack *data = (exposure_stack *)user_data; if (data == NULL) { g_print("NULL data\n"); return false; } data->mode = mode; data->count++; g_print("%d.%s\n", mode, exposure_mode[mode]); return true; } static bool iso_mode_cb(camera_attr_iso_e mode, void *user_data) { g_print("%d.%s\n", mode, iso_mode[mode]); return true; } static bool camera_rotation_cb(camera_rotation_e mode, void *user_data) { camera_rotation_stack *data = (camera_rotation_stack *)user_data; if (data == NULL) { g_print("NULL data\n"); return false; } data->mode = mode; data->count++; g_print("%d.%s\n", mode, camera_rotation[mode]); return true; } static bool preview_format_cb(camera_pixel_format_e mode, void *user_data) { g_print("%d.%s\n", mode, image_fmt[mode]); return true; } static bool white_balance_cb(camera_attr_whitebalance_e mode, void *user_data) { g_print("%d.%s\n", mode, wb[mode]); return true; } static bool colortone_cb(camera_attr_effect_mode_e mode, void *user_data) { g_print("%d.%s\n", mode, ct[mode]); return true; } static bool program_mode_cb(camera_attr_scene_mode_e mode, void *user_data) { g_print("%d.%s\n", mode, program_mode[mode]); return true; } static bool strobe_mode_cb(camera_attr_flash_mode_e mode, void *user_data) { g_print("%d.%s\n", mode, strobe_mode[mode]); return true; } static void _face_detected(camera_detected_face_s *faces, int count, void *user_data) { g_print("face detected!! - count %d\n", count); int i; for (i = 0 ; i < count ; i++) g_print("%d) - %dx%d\n", faces[i].id, faces[i].x, faces[i].y); return; } static void _file_write(char *path, void *data, int size) { FILE *fp = NULL; if (!path || !data || size <= 0) { g_print("ERROR %p %p %d\n", path, data, size); return; } fp = fopen(path, "w"); if (fp == NULL) { g_print("open error! [%s], errno %d\n", path, errno); return; } else { g_print("open success [%s]\n", path); if (fwrite(data, size, 1, fp) != 1) g_print("write error! errno %d\n", errno); else g_print("write success [%s]\n", path); fclose(fp); fp = NULL; } } static void capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data) { char m_filename[MAX_FILE_NAME_LENGTH]; /* main image */ if (image) { if (hcamcorder->is_multishot) { snprintf(m_filename, MAX_FILE_NAME_LENGTH, "%s/multishot%03d.jpg", hcamcorder->file_path, hcamcorder->multishot_count++); } else { snprintf(m_filename, MAX_FILE_NAME_LENGTH, "%s/stillshot%03d.jpg", hcamcorder->file_path, hcamcorder->stillshot_count++); } _file_write(m_filename, image->data, image->size); } return; } static void capture_completed_cb(void *user_data) { camera_start_preview(hcamcorder->camera); print_menu(); return; } static void print_menu() { switch (hcamcorder->menu_state) { case MENU_STATE_INIT: g_print("\n\t=======================================\n"); g_print("\t CAMERA_TESTSUITE\n"); g_print("\t=======================================\n"); g_print("\t '1' Video Capture - Front Camera\n"); g_print("\t '2' Video Capture - Rear Camera\n"); g_print("\t '3' Add camera device state changed callback\n"); g_print("\t '4' Remove camera device state changed callback\n"); g_print("\t '5' Get camera device state\n"); g_print("\t 'q' Exit\n"); g_print("\t=======================================\n"); g_print("\t Enter the media type:\n\t"); break; case MENU_STATE_MAIN: g_print("\n\t=======================================\n"); if (cam_info == CAMERA_DEVICE_CAMERA1) g_print("\t Video Capture (Front camera)\n"); else if (cam_info == CAMERA_DEVICE_CAMERA0) g_print("\t Video Capture (Rear camera)\n"); g_print("\t=======================================\n"); g_print("\t '1' Stillshot test\n"); g_print("\t '2' Multishot test\n"); g_print("\t '3' Setting\n"); g_print("\t '4' Change device (Rear <-> Front)\n"); g_print("\t 'b' back\n"); g_print("\t=======================================\n"); break; case MENU_STATE_SETTING: g_print("\n\t=======================================\n"); g_print("\t Video Capture > Setting\n"); g_print("\t=======================================\n"); g_print("\t >>>>>>>>>>>>>>>>>>>>>>>>>>>> [Camera] \n"); g_print("\t '0' Preview resolution \n"); g_print("\t '1' Capture resolution \n"); g_print("\t '2' Digital zoom level \n"); g_print("\t '3' AF mode \n"); g_print("\t '4' AF scan range \n"); g_print("\t '5' Exposure mode \n"); g_print("\t '6' Exposure value \n"); g_print("\t '7' F number \n"); g_print("\t '8' Display reuse hint \n"); g_print("\t 'i' ISO \n"); g_print("\t 'r' Rotate camera input \n"); g_print("\t 'f' Flip camera input \n"); g_print("\t 'j' Jpeg quality \n"); g_print("\t 'p' Picture format \n"); g_print("\t 'E' EXIF orientation \n"); g_print("\t 'F' Get facing direction of camera module\n"); g_print("\t >>>>>>>>>>>>>>>>>>>> [Display/Filter]\n"); g_print("\t 'v' Visible \n"); g_print("\t 'o' Output mode \n"); g_print("\t 'y' Rotate display \n"); g_print("\t 'Y' Flip display \n"); g_print("\t 'g' Brightness \n"); g_print("\t 'c' Contrast \n"); g_print("\t 'w' White balance \n"); g_print("\t 't' Color tone \n"); g_print("\t 'd' WDR \n"); g_print("\t 'e' EV program mode \n"); g_print("\t 'R' Display ROI area \n"); g_print("\t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [etc.]\n"); g_print("\t 'z' Strobe (Flash) \n"); g_print("\t 'S' Strobe (Flash) state\n"); g_print("\t 'x' Capture mode (Still/Multishot/HDR)\n"); g_print("\t 'l' Face detection \n"); g_print("\t 'k' Anti-handshake \n"); g_print("\t 'K' Video-stabilization \n"); g_print("\t 'u' Touch AF area \n"); g_print("\t 'n' Set file path to write captured image\n"); g_print("\t 'b' back\n"); g_print("\t=======================================\n"); break; default: g_print("\n\tunknow menu state !!\n"); break; } return; } static void main_menu(gchar buf) { int err = 0; camera_state_e capi_state = CAMERA_STATE_NONE; switch (buf) { case '1': /* Capture */ hcamcorder->is_multishot = FALSE; camera_get_state(hcamcorder->camera, &capi_state); camera_attr_set_image_quality(hcamcorder->camera, 100); camera_set_capture_format(hcamcorder->camera, CAMERA_PIXEL_FORMAT_JPEG); camera_start_capture(hcamcorder->camera, capturing_cb, capture_completed_cb, hcamcorder); break; case '2': /* multishot Capture */ g_print("multishot capture"); hcamcorder->is_multishot = TRUE; int interval = 0, count = 0; flush_stdin(); g_print("\n\tinput interval(ms) : "); err = scanf("%d", &interval); flush_stdin(); g_print("\n\tinput count : "); err = scanf("%d", &count); camera_attr_set_image_quality(hcamcorder->camera, 100); camera_set_capture_format(hcamcorder->camera, CAMERA_PIXEL_FORMAT_JPEG); camera_start_continuous_capture(hcamcorder->camera, count, interval, capturing_cb, NULL, NULL); sleep(3); camera_start_preview(hcamcorder->camera); break; case '3': /* Setting */ hcamcorder->menu_state = MENU_STATE_SETTING; break; case '4': /* Change device (Rear <-> Front) */ camera_set_display_reuse_hint(hcamcorder->camera, true); camera_stop_preview(hcamcorder->camera); if (hcamcorder->type == CAMERA_DEVICE_CAMERA0) { hcamcorder->type = CAMERA_DEVICE_CAMERA1; } else { hcamcorder->type = CAMERA_DEVICE_CAMERA0; } camera_change_device(hcamcorder->camera, hcamcorder->type); camera_set_error_cb(hcamcorder->camera, _camera_error_cb, NULL); camera_set_state_changed_cb(hcamcorder->camera, _camera_state_changed_cb, NULL); camera_set_interrupted_cb(hcamcorder->camera, _camera_interrupted_cb, NULL); camera_set_display_mode(hcamcorder->camera, CAMERA_DISPLAY_MODE_LETTER_BOX); camera_start_preview(hcamcorder->camera); break; case 'b': /* back */ camera_stop_preview(hcamcorder->camera); camera_destroy(hcamcorder->camera); hcamcorder->camera = NULL; hcamcorder->menu_state = MENU_STATE_INIT; print_menu(); break; default: g_print("\t Invalid input \n"); break; } return; } static void setting_menu(gchar buf) { int bret = FALSE; int idx = 0; int min = 0; int max = 0; int i = 0; int value = 0; int err = 0; int x = 0; int y = 0; int width = 0; int height = 0; switch (buf) { /* Camera setting */ case '0': /* Setting > Preview Resolution setting */ g_print("*Select the preview resolution!\n"); resolution_stack resolution_list; resolution_list.count = 0; camera_foreach_supported_preview_resolution(hcamcorder->camera, preview_resolution_cb, &resolution_list); flush_stdin(); err = scanf("%d", &idx); int result = 0; if (resolution_list.count > idx && idx >= 0) { g_print("-----------------PREVIEW RESOLUTION (%dx%d)---------------------\n", resolution_list.width[idx], resolution_list.height[idx]); result = camera_set_preview_resolution(hcamcorder->camera, resolution_list.width[idx], resolution_list.height[idx]); } else { g_print("invalid input %d\n", idx); result = -1; } resolution_list.count = 0; if (result != 0) g_print("FAIL\n"); else g_print("PASS\n"); break; case '1': /* Setting > Capture Resolution setting */ g_print("*Select the preview resolution!\n"); g_print("-----------------CAPTURE RESOLUTION TEST: ---------------------\n"); resolution_list.count = 0; camera_foreach_supported_capture_resolution(hcamcorder->camera, capture_resolution_test_cb, &resolution_list); flush_stdin(); err = scanf("%d", &idx); if (resolution_list.count > idx && idx >= 0) { result = camera_set_capture_resolution(hcamcorder->camera, resolution_list.width[idx], resolution_list.height[idx]); g_print("camera_set_capture_resolution with width =%d, height=%d ret=0x%x\n", resolution_list.width[idx], resolution_list.height[idx], result); } else { g_print("invalid input %d\n", idx); result = -1; } resolution_list.count = 0; if (result != 0) g_print("FAIL\n"); else g_print("PASS\n"); break; case '2': /* Setting > Digital zoom level */ g_print("*Digital zoom level !\n"); camera_attr_get_zoom_range(hcamcorder->camera, &min, &max); if (min >= max) g_print("Not supported !! \n"); else { flush_stdin(); g_print("\n Select Digital zoom level min %d - max %d\n", min, max); err = scanf("%d", &idx); bret = camera_attr_set_zoom(hcamcorder->camera, idx); } break; case '3': /* Setting > AF mode */ g_print("*AF mode !\n"); g_print("\t1. AF Start !\n"); g_print("\t2. AF Stop !\n\n"); flush_stdin(); err = scanf("%d", &idx); switch (idx) { case 1: camera_start_focusing(hcamcorder->camera, 0); break; case 2: camera_cancel_focusing(hcamcorder->camera); break; default: g_print("Wrong Input[%d] !! \n", idx); break; } break; case '4': /* Setting > AF scan range */ g_print("*AF scan range !\n"); camera_attr_foreach_supported_af_mode(hcamcorder->camera, (camera_attr_supported_af_mode_cb)af_mode_foreach_cb, NULL); flush_stdin(); err = scanf("%d", &idx); bret = camera_attr_set_af_mode(hcamcorder->camera, idx); break; case '5': /* Setting > Exposure mode */ g_print("* Exposure mode!\n"); camera_attr_foreach_supported_exposure_mode(hcamcorder->camera, (camera_attr_supported_exposure_mode_cb)exposure_mode_cb, NULL); flush_stdin(); g_print("\n Select Exposure mode \n"); err = scanf("%d", &idx); bret = camera_attr_set_exposure_mode(hcamcorder->camera, idx); break; case '6': /* Setting > Exposure value */ camera_attr_get_exposure_range(hcamcorder->camera, &min, &max); if (min >= max) g_print("Not supported !! \n"); else { flush_stdin(); g_print("\n Select Exposure mode min%d -max %d\n", min, max); err = scanf("%d", &idx); bret = camera_attr_set_exposure(hcamcorder->camera, idx); } break; case '7': /* Setting > F number */ g_print("Not supported !! \n"); break; case '8': /* Setting > Display reuse hint */ { bool reuse_hint = false; err = camera_get_display_reuse_hint(hcamcorder->camera, &reuse_hint); if (err != CAMERA_ERROR_NONE) { g_print("failed to get display reuse hint 0x%x\n", err); break; } g_print("*Display reuse hint : current %d -> set %d\n", reuse_hint, !reuse_hint); reuse_hint = !reuse_hint; err = camera_set_display_reuse_hint(hcamcorder->camera, reuse_hint); g_print("set display reuse hint result : 0x%x\n", err); } break; case 'i': /* Setting > ISO */ g_print("*ISO !\n"); camera_attr_foreach_supported_iso(hcamcorder->camera, iso_mode_cb, NULL); flush_stdin(); err = scanf("%d", &idx); bret = camera_attr_set_iso(hcamcorder->camera, idx); break; case 'r': /* Setting > Rotate camera input when recording */ g_print("*Rotate camera input\n"); camera_attr_foreach_supported_stream_rotation(hcamcorder->camera, camera_rotation_cb, NULL); flush_stdin(); err = scanf("%d", &idx); CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera)); bret = camera_attr_set_stream_rotation(hcamcorder->camera, idx); CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera)); break; case 'f': /* Setting > Flip camera input */ flush_stdin(); g_print("*Flip camera input\n"); g_print(" 0. Flip NONE\n"); g_print(" 1. Flip HORIZONTAL\n"); g_print(" 2. Flip VERTICAL\n"); g_print(" 3. Flip BOTH\n"); err = scanf("%d", &idx); CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera)); camera_attr_set_stream_flip(hcamcorder->camera, idx); CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera)); break; case 'j': /* Setting > Jpeg quality */ g_print("*Jpeg quality !\n"); flush_stdin(); g_print("\n Select Jpeg quality \n"); err = scanf("%d", &idx); bret = camera_attr_set_image_quality(hcamcorder->camera, idx); break; case 'p': /* Setting > Picture format */ g_print("* Picture format!\n"); camera_foreach_supported_preview_format(hcamcorder->camera, preview_format_cb, NULL); flush_stdin(); err = scanf("%d", &idx); bret = camera_set_preview_format(hcamcorder->camera, idx); CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera)); CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera)); break; case 'E': /* Setting > EXIF orientation */ g_print("* EXIF Orientation\n"); g_print("\t 1. TOP_LEFT\n"); g_print("\t 2. TOP_RIGHT(flipped)\n"); g_print("\t 3. BOTTOM_RIGHT\n"); g_print("\t 4. BOTTOM_LEFT(flipped)\n"); g_print("\t 5. LEFT_TOP(flipped)\n"); g_print("\t 6. RIGHT_TOP\n"); g_print("\t 7. RIGHT_BOTTOM(flipped)\n"); g_print("\t 8. LEFT_BOTTOM\n"); flush_stdin(); err = scanf("%d", &idx); if (idx < 1 || idx > 8) g_print("Wrong INPUT[%d]!! \n", idx); else camera_attr_set_tag_orientation(hcamcorder->camera, idx); break; case 'F': /* Getting > Get Facing direction */ g_print("* Get facing direction of camera module\n"); err = camera_get_facing_direction(hcamcorder->camera, (camera_facing_direction_e *)&idx); if (CAMERA_ERROR_NONE == err) g_print("* Facing direction : %s(%d)\n", facing_direction[idx], idx); else g_print("* Error : %d\n", err); break; /* Display / Filter setting */ case 'v': /* Display visible */ g_print("* Display visible setting !\n"); g_print("\n Select Display visible \n"); flush_stdin(); for (i = 0 ; i < 2 ; i++) g_print("\t %d. %s\n", i, visible_mode[i]); err = scanf("%d", &idx); if (idx == 0 || idx == 1) bret = camera_set_display_visible(hcamcorder->camera, idx); else g_print("invalid input %d", idx); break; case 'o': /* Setting > Display Mode */ g_print("* Display mode!\n"); flush_stdin(); for (i = 0 ; i < 5 ; i++) g_print("%d. %s\n", i, display_mode[i]); err = scanf("%d", &idx); bret = camera_set_display_mode(hcamcorder->camera, idx); break; case 'y': /* Setting > Rotate Display */ flush_stdin(); g_print("\n Select Rotate mode\n"); g_print("\t0. 0\n\t1. 90\n\t2. 180\n\t3. 270\n\n"); err = scanf("%d", &idx); CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera)); bret = camera_set_display_rotation(hcamcorder->camera, idx); CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera)); break; case 'Y': /* Setting > Flip Display */ flush_stdin(); g_print("\n Select Rotate mode\n"); g_print("\t0. NONE\n\t1. HORIZONTAL\n\t2. VERTICAL\n\t3. BOTH\n\n"); err = scanf("%d", &idx); bret = camera_set_display_flip(hcamcorder->camera, idx); break; case 'g': /* Setting > Brightness */ g_print("*Brightness !\n"); camera_attr_get_brightness_range(hcamcorder->camera, &min, &max); flush_stdin(); g_print("\n Select brightness min (%d) -max(%d)", min, max); err = scanf("%d", &idx); bret = camera_attr_set_brightness(hcamcorder->camera, idx); break; case 'c': /* Setting > Contrast */ g_print("*Contrast !\n"); camera_attr_get_contrast_range(hcamcorder->camera, &min, &max); flush_stdin(); g_print("\n Select Contrast min(%d)-max(%d)", min, max); err = scanf("%d", &idx); bret = camera_attr_set_contrast(hcamcorder->camera, idx); break; case 'w': /* Setting > White balance */ g_print("*White balance !\n"); flush_stdin(); g_print("\n Select White balance \n"); camera_attr_foreach_supported_whitebalance(hcamcorder->camera, white_balance_cb, NULL); err = scanf("%d", &idx); bret = camera_attr_set_whitebalance(hcamcorder->camera, idx); break; case 't': /* Setting > Color tone */ g_print("*Color tone !\n"); camera_attr_foreach_supported_effect(hcamcorder->camera, colortone_cb, NULL); g_print("\n Select Color tone \n"); flush_stdin(); err = scanf("%d", &idx); bret = camera_attr_set_effect(hcamcorder->camera, idx); break; case 'd': /* Setting > WDR */ g_print("*WDR !\n"); g_print("\n Select WDR Mode \n"); flush_stdin(); for (i = 0 ; i < 2 ; i++) g_print("\t %d. %s\n", i+1, wdr_mode[i]); err = scanf("%d", &idx); if (idx == 1) bret = camera_attr_enable_auto_contrast(hcamcorder->camera, 0); else if (idx == 2) bret = camera_attr_enable_auto_contrast(hcamcorder->camera, 1); break; case 'e': /* Setting > EV program mode */ g_print("* EV program mode!\n"); camera_attr_foreach_supported_scene_mode(hcamcorder->camera, program_mode_cb, NULL); g_print("\n Select EV program mode \n"); flush_stdin(); err = scanf("%d", &idx); bret = camera_attr_set_scene_mode(hcamcorder->camera, idx); break; case 'R': /* Setting > Display ROI area */ g_print("* Set display roi area. Select x y width height \n"); flush_stdin(); err = scanf("%d %d %d %d", &x, &y, &width, &height); camera_set_display_mode(hcamcorder->camera, CAMERA_DISPLAY_MODE_CUSTOM_ROI); err = camera_attr_set_display_roi_area(hcamcorder->camera, x, y, width, height); if (CAMERA_ERROR_NONE != err) g_print("* Error : %d\n", err); err = camera_attr_get_display_roi_area(hcamcorder->camera, &x, &y, &width, &height); if (CAMERA_ERROR_NONE == err) g_print("Current display roi area : x %d, y %d, width %d, height %d\n", x, y, width, height); else g_print("* Error : %d\n", err); break; /* ext. setting */ case 'z': /* Setting > Strobe setting */ g_print("*Strobe Mode\n"); camera_attr_foreach_supported_flash_mode(hcamcorder->camera, strobe_mode_cb, NULL); g_print("\n Select Strobe Mode \n"); flush_stdin(); err = scanf("%d", &idx); bret = camera_attr_set_flash_mode(hcamcorder->camera, idx); break; case 'S': /* Setting > flash state */ g_print("*flash state\n"); err = camera_get_flash_state(cam_info, (camera_flash_state_e *)&idx); if (CAMERA_ERROR_NONE == err) g_print("Current flash state = %s\n", idx ? "ON" : "OFF"); else g_print("* Error : %d\n", err); break; case 'x': /* Setting > Capture mode ,Muitishot? */ g_print("*Select Capture mode!\n"); flush_stdin(); g_print(" \n\t1. Stillshot mode\n\t2. Multishot mode\n\t3. HDR capture\n"); err = scanf("%d", &idx); switch (idx) { case 1: g_print("stillshot mode selected and capture callback is set!!!!\n"); hcamcorder->is_multishot = FALSE; camera_attr_set_hdr_mode(hcamcorder->camera, 0); break; case 2: g_print("HDR Capture mode selected\n"); hcamcorder->is_multishot = FALSE; g_print("\nSelect HDR capture mode\n"); flush_stdin(); for (i = 0 ; i < 3 ; i++) g_print("\t %d. %s\n", i, hdr_mode[i]); err = scanf("%d", &idx); if (idx >= CAMERA_ATTR_HDR_MODE_DISABLE && idx <= CAMERA_ATTR_HDR_MODE_KEEP_ORIGINAL) bret = camera_attr_set_hdr_mode(hcamcorder->camera, idx); else g_print("invalid input %d\n", idx); break; default: g_print("Wrong input, select again!!\n"); break; } break; case 'l': /* Setting > Face detection setting */ if (camera_is_supported_face_detection(hcamcorder->camera)) { g_print("* Face detect mode !\n"); flush_stdin(); for (i = 0 ; i < 2 ; i++) g_print("\t %d. %s \n", i, detection_mode[i]); err = scanf("%d", &idx); if (idx == 0) bret = camera_stop_face_detection(hcamcorder->camera); else if (idx == 1) bret = camera_start_face_detection(hcamcorder->camera, _face_detected, NULL); else g_print("\n invalid input [%d]\n\n", idx); } else { g_print("face detection_not supported"); } break; case 'k': /* Setting > Anti-handshake */ g_print("*Anti-handshake !\n"); g_print("\n Select Anti-handshake mode \n"); flush_stdin(); for (i = 0; i < 2; i++) g_print("\t %d. %s\n", i, ahs_mode[i]); err = scanf("%d", &idx); if (idx == 0 || idx == 1) bret = camera_attr_enable_anti_shake(hcamcorder->camera, idx); else g_print("invalid input %d\n", idx); break; case 'K': /* Setting > Video-stabilization */ g_print("*Video-stabilization !\n"); g_print("\n Select Video-stabilization mode \n"); flush_stdin(); for (i = 0 ; i < 2 ; i++) g_print("\t %d. %s\n", i, vs_mode[i]); err = scanf("%d", &idx); if (idx < 0 || idx > 1) { g_print("invalid input %d\n", idx); break; } if (idx == 1) { g_print("\n Restart preview with NV12 and 720p resolution\n"); err = camera_stop_preview(hcamcorder->camera); camera_set_preview_resolution(hcamcorder->camera, 1280, 720); camera_set_preview_format(hcamcorder->camera, CAMERA_PIXEL_FORMAT_NV12); } bret = camera_attr_enable_video_stabilization(hcamcorder->camera, idx); if (idx == 1) { err = camera_start_preview(hcamcorder->camera); if (err != CAMERA_ERROR_NONE) g_print("\n Restart FAILED! 0x%x\n", err); } break; case 'u': /* Touch AF area */ g_print("* Touch AF area !\n"); flush_stdin(); g_print("\n Input x,y,width,height \n"); err = scanf("%d,%d,%d,%d", &x, &y, &width, &height); err = camera_attr_set_af_area(hcamcorder->camera, width, height); if (err != 0) g_print("Failed to set touch AF area.(%x)\n", err); else g_print("Succeed to set touch AF area.\n"); break; case 'n': /* file path */ g_print("* File path !\n"); flush_stdin(); g_print("\n Input file path to save captured data(string) : "); if (fgets(hcamcorder->file_path, sizeof(hcamcorder->file_path), stdin)) { hcamcorder->file_path[strlen(hcamcorder->file_path) - 1] = '\0'; g_print("\ncaptured data will be saved in [%s]\n", hcamcorder->file_path); } else { g_print("\nset file path failed\n"); } break; case 'b': /* back */ hcamcorder->menu_state = MENU_STATE_MAIN; break; default: g_print("\t Invalid input \n"); break; } g_print("\t bret : 0x%x \n", bret); return; } /** * This function is to execute command. * * @param channel [in] 1st parameter * * @return This function returns TRUE/FALSE * @remark * @see */ static gboolean cmd_input(GIOChannel *channel) { gchar *buf = NULL; gsize read_size; GError *g_error = NULL; g_print("\n\tENTER\n"); g_io_channel_read_line(channel, &buf, &read_size, NULL, &g_error); if (g_error) { g_print("\n\tg_io_channel_read_chars error\n"); g_error_free(g_error); g_error = NULL; } if (buf) { g_strstrip(buf); g_print("\n\tMenu Status : %d\n", hcamcorder->menu_state); switch (hcamcorder->menu_state) { case MENU_STATE_INIT: mode_change(buf[0]); break; case MENU_STATE_MAIN: main_menu(buf[0]); break; case MENU_STATE_SETTING: setting_menu(buf[0]); break; default: break; } g_free(buf); buf = NULL; print_menu(); } else { g_print("\n\tNo read input\n"); } return TRUE; } static gboolean init_handle() { hcamcorder->is_multishot = FALSE; hcamcorder->stillshot_count = 0; hcamcorder->multishot_count = 0; snprintf(hcamcorder->file_path, MAX_FILE_PATH_LENGTH, DEFAULT_FILE_PATH); hcamcorder->menu_state = MENU_STATE_INIT; hcamcorder->elapsed_time = 0; return TRUE; } void _preview_cb(camera_preview_data_s *frame, void *user_data) { #if 0 FILE *fp = fopen("/opt/usr/media/test.yuv", "a"); if (fp == NULL) { g_print("\n============ file open failed ===========================\n"); return; } switch (frame->num_of_planes) { case 1: fwrite(frame->data.single_plane.yuv, 1, frame->data.single_plane.size, fp); case 2: fwrite(frame->data.double_plane.y, 1, frame->data.double_plane.y_size, fp); fwrite(frame->data.double_plane.uv, 1, frame->data.double_plane.uv_size, fp); case 3: fwrite(frame->data.triple_plane.y, 1, frame->data.triple_plane.y_size, fp); fwrite(frame->data.triple_plane.u, 1, frame->data.triple_plane.u_size, fp); fwrite(frame->data.triple_plane.v, 1, frame->data.triple_plane.v_size, fp); default: break; } g_print("file write done ---\n"); fclose(fp); fp = NULL; #else g_print("----- preview callback - format %d, %dx%d, num plane %d\n", frame->format, frame->width, frame->height, frame->num_of_planes); #endif return; } /** * This function is to change camcorder mode. * * @param buf [in] user input * * @return This function returns TRUE/FALSE * @remark * @see other functions */ static gboolean mode_change(gchar buf) { int err = 0; camera_device_state_e device_state = CAMERA_DEVICE_STATE_NULL; char display_type = '\0'; bool check = FALSE; switch (buf) { case '1': hcamcorder->type = cam_info = CAMERA_DEVICE_CAMERA1; check = TRUE; break; case '2': hcamcorder->type = cam_info = CAMERA_DEVICE_CAMERA0; check = TRUE; break; case '3': err = camera_add_device_state_changed_cb(_camera_device_state_changed_cb, NULL, &g_camera_device_changed_cb_id); g_print("add result 0x%x - cb id %d\n", err, g_camera_device_changed_cb_id); return FALSE; case '4': if (g_camera_device_changed_cb_id > 0) { err = camera_remove_device_state_changed_cb(g_camera_device_changed_cb_id); g_camera_device_changed_cb_id = 0; g_print("remove result 0x%x\n", err); } else { g_print("invalid callback id %d\n", g_camera_device_changed_cb_id); } return FALSE; case '5': err = camera_get_device_state(CAMERA_DEVICE_CAMERA0, &device_state); g_print("get result 0x%x - state %d\n", err, device_state); return FALSE; case 'q': g_print("\t Quit Camcorder Testsuite!!\n"); elm_exit(); return FALSE; default: g_print("\t Invalid media type(%c)\n", buf); return FALSE; } g_print("\n[camcorder_create - type %d]\n", cam_info); g_get_current_time(&previous_time); g_timer_reset(timer); err = camera_create(cam_info, &hcamcorder->camera); g_print("[camera_create() : %12.6lfs]\n", g_timer_elapsed(timer, NULL)); if (err != 0) { g_print("\n\tmmcamcorder_create = 0x%x\n", err); return -1; } check = FALSE; while (!check) { g_print("\n\tEnter the Display Type\n"); g_print("\t'1' OVERLAY surface\n"); g_print("\t'2' EVAS surface\n"); g_print("\t'3' NONE surface\n"); err = scanf("%c", &display_type); if (err == EOF) { g_print("\t!!!read input error!!!\n"); continue; } switch (display_type) { case '1': camera_set_display(hcamcorder->camera, CAMERA_DISPLAY_TYPE_OVERLAY, GET_DISPLAY(ad.win)); check = TRUE; break; case '2': camera_set_display(hcamcorder->camera, CAMERA_DISPLAY_TYPE_EVAS, GET_DISPLAY(ad.eo)); check = TRUE; break; case '3': camera_set_display(hcamcorder->camera, CAMERA_DISPLAY_TYPE_NONE, NULL); check = TRUE; break; default: g_print("\t Invalid display type(%c)\n", display_type); break; } } camera_set_error_cb(hcamcorder->camera, _camera_error_cb, NULL); camera_set_state_changed_cb(hcamcorder->camera, _camera_state_changed_cb, NULL); camera_set_interrupted_cb(hcamcorder->camera, _camera_interrupted_cb, NULL); camera_set_display_mode(hcamcorder->camera, CAMERA_DISPLAY_MODE_LETTER_BOX); /*camera_set_display_rotation(hcamcorder->camera, CAMERA_ROTATION_90);*/ /*camera_set_display_flip(hcamcorder->camera, CAMERA_FLIP_VERTICAL);*/ /*camera_set_preview_cb(hcamcorder->camera, _preview_cb, hcamcorder->camera);*/ camera_start_preview(hcamcorder->camera); g_get_current_time(¤t_time); timersub(¤t_time, &previous_time, &result_time); g_print("\n\tCamera Starting Time : %ld.%lds\n", result_time.tv_sec, result_time.tv_usec); hcamcorder->menu_state = MENU_STATE_MAIN; print_menu(); return TRUE; } static int app_create(void *data) { appdata *app_data = data; int w = 0; int h = 0; Evas_Object *win = NULL; Evas_Object *eo = NULL; Evas_Object *bg = NULL; Evas_Object *rect = NULL; if (app_data == NULL) { g_print("\t\nappdata is NULL\n"); return 0; } /* use gl backend */ elm_config_accel_preference_set("opengl"); win = elm_win_add(NULL, "camera_test", ELM_WIN_BASIC); if (win) { elm_win_title_set(win, "camera_test"); elm_win_borderless_set(win, EINA_TRUE); elm_win_screen_size_get(win, NULL, NULL, &w, &h); g_print("\n\tscreen size %dx%d\n\n", w, h); evas_object_resize(win, w, h); elm_win_autodel_set(win, EINA_TRUE); elm_win_alpha_set(win, EINA_TRUE); } else { g_print("\n\tfailed to get window\n\n"); return 1; } bg = elm_bg_add(win); if (bg) { elm_win_resize_object_add(win, bg); evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); evas_object_show(bg); } else { g_print("\n\tfailed to get elm bg\n\n"); return 1; } rect = evas_object_rectangle_add(evas_object_evas_get(win)); if (rect) { evas_object_color_set(rect, 0, 0, 0, 0); evas_object_render_op_set(rect, EVAS_RENDER_COPY); } else { g_print("\n\tfailed to get rectangle\n\n"); return 1; } elm_win_resize_object_add(win, rect); evas_object_size_hint_weight_set(rect, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); evas_object_show(rect); /* Create evas image object for EVAS surface */ eo = evas_object_image_add(evas_object_evas_get(win)); evas_object_image_size_set(eo, w, h); evas_object_image_fill_set(eo, 0, 0, w, h); evas_object_resize(eo, w, h); evas_object_show(eo); elm_win_activate(win); evas_object_show(win); app_data->win = win; app_data->eo = eo; timer = g_timer_new(); g_timer_reset(timer); init_handle(); print_menu(); return 0; } static int app_terminate(void *data) { appdata *app_data = data; if (app_data == NULL) { g_print("\n\tappdata is NULL\n"); return 0; } if (timer) { g_timer_stop(timer); g_timer_destroy(timer); timer = NULL; } return 0; } /** * This function is the example main function for mmcamcorder API. * * @param * * @return This function returns 0. * @remark * @see other functions */ int main(int argc, char **argv) { int bret; hcamcorder = (cam_handle_t *) g_malloc0(sizeof(cam_handle_t)); stdin_channel = g_io_channel_unix_new(fileno(stdin));/* read from stdin */ g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)cmd_input, NULL); memset(&ad, 0x0, sizeof(appdata)); ops.data = &ad; bret = appcore_efl_main(PACKAGE, &argc, &argv, &ops); g_print("\n\treturn appcore_efl : %d\n\n", bret); g_free(hcamcorder); g_io_channel_unref(stdin_channel); return bret; } /*EOF*/