test/recorder_test.c

   1 /*
   2  * recorder_testsuite
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jeongmo Yang <jm80.yang@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /*=======================================================================================
  23   |  INCLUDE FILES                                                                        |
  24   =======================================================================================*/
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <glib.h>
  28 #include <sys/time.h>
  29 #include <camera.h>
  30 #include <recorder.h>
  31 #include <Elementary.h>
  32 #include <sound_manager.h>
  33 #include <appcore-efl.h>
  34
  35 /*-----------------------------------------------------------------------
  36   |    GLOBAL VARIABLE DEFINITIONS:                                       |
  37   -----------------------------------------------------------------------*/
  38 #define EXPORT_API __attribute__((__visibility__("default")))
  39
  40 #ifdef LOG_TAG
  41 #undef LOG_TAG
  42 #endif
  43 #define LOG_TAG "RECORDER_TESTSUITE"
  44
  45 #ifdef PACKAGE
  46 #undef PACKAGE
  47 #endif
  48 #define PACKAGE "recorder_test"
  49
  50
  51 static int app_create(void *data);
  52 static int app_terminate(void *data);
  53
  54 struct _appdata {
  55         Evas_Object *win;
  56         Evas_Object *eo;
  57         Evas_Object *bg;
  58         Evas_Object *rect;
  59 };
  60 typedef struct _appdata appdata;
  61
  62 struct appcore_ops ops = {
  63         .create = app_create,
  64         .terminate = app_terminate,
  65 };
  66
  67 appdata ad;
  68 GIOChannel *stdin_channel;
  69 int resolution_set;
  70 int g_current_state;
  71 int src_w, src_h;
  72 bool isMultishot;
  73 int  cam_info;
  74 int recorder_state;
  75 int multishot_num;
  76 static GTimer *timer = NULL;
  77 static int g_recorder_device_changed_cb_id;
  78
  79 /*-----------------------------------------------------------------------
  80   |    GLOBAL CONSTANT DEFINITIONS:                                       |
  81   -----------------------------------------------------------------------*/
  82
  83
  84 /*-----------------------------------------------------------------------
  85   |    IMPORTED VARIABLE DECLARATIONS:                                    |
  86   -----------------------------------------------------------------------*/
  87
  88
  89 /*-----------------------------------------------------------------------
  90   |    IMPORTED FUNCTION DECLARATIONS:                                    |
  91   -----------------------------------------------------------------------*/
  92
  93
  94 /*-----------------------------------------------------------------------
  95   |    LOCAL #defines:                                                    |
  96   -----------------------------------------------------------------------*/
  97
  98
  99 #define DISPLAY_W_320                       320                 /* for direct FB */
 100 #define DISPLAY_H_240                       240                 /* for direct FB */
 101
 102
 103 #define SRC_VIDEO_FRAME_RATE_15         15    /* video input frame rate */
 104 #define SRC_VIDEO_FRAME_RATE_30         30    /* video input frame rate */
 105 #define IMAGE_ENC_QUALITY               85    /* quality of jpeg */
 106
 107 #define MAX_FILE_SIZE_FOR_MMS           (250 * 1024)
 108
 109 #define EXT_JPEG                        "jpg"
 110 #define EXT_MP4                         "mp4"
 111 #define EXT_3GP                         "3gp"
 112 #define EXT_AMR                         "amr"
 113 #define EXT_MKV                         "mkv"
 114
 115 #define TARGET_FILENAME_PATH            "/opt/usr/home/owner/media/Sounds/"
 116 #define IMAGE_CAPTURE_EXIF_PATH         TARGET_FILENAME_PATH"exif.raw"
 117 #define TARGET_FILENAME_VIDEO           TARGET_FILENAME_PATH"test_rec_video.mp4"
 118 #define TARGET_FILENAME_AUDIO           TARGET_FILENAME_PATH"test_rec_audio.m4a"
 119 #define CAPTURE_FILENAME_LEN            256
 120
 121 #define AUDIO_SOURCE_SAMPLERATE_AAC     44100
 122 #define AUDIO_SOURCE_SAMPLERATE_AMR     8000
 123 #define AUDIO_SOURCE_CHANNEL_AAC        2
 124 #define AUDIO_SOURCE_CHANNEL_AMR        1
 125 #define VIDEO_ENCODE_BITRATE            40000000 /* bps */
 126
 127 #define CHECK_MM_ERROR(expr) \
 128         do {\
 129                 int ret = 0; \
 130                 ret = expr; \
 131                 if (ret != 0) {\
 132                         g_print("[%s:%d] error code : %x \n", __func__, __LINE__, ret); \
 133                         return; \
 134                 } \
 135         } while (0)
 136
 137
 138 #ifndef SAFE_FREE
 139 #define SAFE_FREE(x)       if (x) { g_free(x); x = NULL; }
 140 #endif
 141
 142
 143 GTimeVal previous;
 144 GTimeVal current;
 145 GTimeVal res;
 146 /* temp */
 147
 148 /**
 149  * Enumerations for command
 150  */
 151 #define SENSOR_WHITEBALANCE_NUM     10
 152 #define SENSOR_COLOR_TONE_NUM       31
 153 #define SENSOR_FLIP_NUM         3
 154 #define SENSOR_PROGRAM_MODE_NUM     15
 155 #define SENSOR_FOCUS_NUM        6
 156 #define SENSOR_INPUT_ROTATION       4
 157 #define SENSOR_AF_SCAN_NUM      4
 158 #define SENSOR_ISO_NUM          8
 159 #define SENSOR_EXPOSURE_NUM     9
 160 #define SENSOR_IMAGE_FORMAT     9
 161
 162
 163 /*-----------------------------------------------------------------------
 164   |    LOCAL CONSTANT DEFINITIONS:                                        |
 165   -----------------------------------------------------------------------*/
 166 enum {
 167         MODE_VIDEO_CAPTURE, /* recording and image capture mode */
 168         MODE_AUDIO,     /* audio recording*/
 169         MODE_NUM,
 170 };
 171
 172 enum {
 173         MENU_STATE_INIT,
 174         MENU_STATE_MAIN,
 175         MENU_STATE_SETTING,
 176         MENU_STATE_NUM,
 177 };
 178
 179 /*-----------------------------------------------------------------------
 180   |    LOCAL DATA TYPE DEFINITIONS:                   |
 181   -----------------------------------------------------------------------*/
 182 typedef struct _cam_handle {
 183         camera_h camera;
 184         recorder_h recorder;
 185         int mode;                       /*video/audio(recording) mode */
 186         int menu_state;
 187         int fps;
 188         bool isMute;
 189         unsigned long long elapsed_time;
 190 } cam_handle_t;
 191
 192 typedef struct _cam_xypair {
 193         const char *attr_subcat_x;
 194         const char *attr_subcat_y;
 195         int x;
 196         int y;
 197 } cam_xypair_t;
 198
 199 typedef struct {
 200         int width[100];
 201         int height[100];
 202         int count;
 203 } resolution_stack;
 204
 205 typedef struct {
 206         camera_attr_exposure_mode_e mode;
 207         int count;
 208 } exposure_stack;
 209
 210 typedef struct {
 211         camera_attr_iso_e mode;
 212         int count;
 213 } iso_stack;
 214
 215 typedef struct {
 216         camera_rotation_e mode;
 217         int count;
 218 } camera_rotation_stack;
 219
 220 /*---------------------------------------------------------------------------
 221   |    LOCAL VARIABLE DEFINITIONS:                                            |
 222   ---------------------------------------------------------------------------*/
 223 static cam_handle_t *hcamcorder ;
 224
 225 const char *wb[SENSOR_WHITEBALANCE_NUM] = {
 226         "None",
 227         "Auto",
 228         "Daylight",
 229         "Cloudy",
 230         "Fluoroscent",
 231         "Incandescent",
 232         "Shade",
 233         "Horizon",
 234         "Flash",
 235         "Custom",
 236 };
 237
 238 const char *ct[SENSOR_COLOR_TONE_NUM] = {
 239         "NONE",
 240         "MONO",
 241         "SEPIA",
 242         "NEGATIVE",
 243         "BLUE",
 244         "GREEN",
 245         "AQUA",
 246         "VIOLET",
 247         "ORANGE",
 248         "GRAY",
 249         "RED",
 250         "ANTIQUE",
 251         "WARM",
 252         "PINK",
 253         "YELLOW",
 254         "PURPLE",
 255         "EMBOSS",
 256         "OUTLINE",
 257         "SOLARIZATION",
 258         "SKETCH",
 259         "WASHED",
 260         "VINTAGE_WARM",
 261         "VINTAGE_COLD",
 262         "POSTERIZATION",
 263         "CARTOON",
 264         "SELECTVE_COLOR_RED",
 265         "SELECTVE_COLOR_GREEN",
 266         "SELECTVE_COLOR_BLUE",
 267         "SELECTVE_COLOR_YELLOW",
 268         "SELECTVE_COLOR_RED_YELLOW",
 269         "GRAPHICS"
 270 };
 271
 272 const char *flip[SENSOR_FLIP_NUM] = {
 273         "Horizontal",
 274         "Vertical",
 275         "Not flipped",
 276 };
 277
 278 const char *program_mode[SENSOR_PROGRAM_MODE_NUM] = {
 279         "NORMAL",
 280         "PORTRAIT",
 281         "LANDSCAPE",
 282         "SPORTS",
 283         "PARTY_N_INDOOR",
 284         "BEACH_N_INDOOR",
 285         "SUNSET",
 286         "DUSK_N_DAWN",
 287         "FALL_COLOR",
 288         "NIGHT_SCENE",
 289         "FIREWORK",
 290         "TEXT",
 291         "SHOW_WINDOW",
 292         "CANDLE_LIGHT",
 293         "BACKLIGHT",
 294 };
 295
 296 const char *focus_mode[SENSOR_FOCUS_NUM] = {
 297         "None",
 298         "Pan",
 299         "Auto",
 300         "Manual",
 301         "Touch Auto",
 302         "Continuous Auto",
 303 };
 304
 305 const char *camera_rotation[SENSOR_INPUT_ROTATION] = {
 306         "None",
 307         "90",
 308         "180",
 309         "270",
 310 };
 311
 312 const char *af_scan[SENSOR_AF_SCAN_NUM] = {
 313         "None",
 314         "Normal",
 315         "Macro mode",
 316         "Full mode",
 317 };
 318
 319 const char *iso_mode[SENSOR_ISO_NUM] = {
 320         "ISO Auto",
 321         "ISO 50",
 322         "ISO 100",
 323         "ISO 200",
 324         "ISO 400",
 325         "ISO 800",
 326         "ISO 1600",
 327         "ISO 3200",
 328 };
 329
 330 const char *exposure_mode[SENSOR_EXPOSURE_NUM] = {
 331         "AE off",
 332         "AE all mode",
 333         "AE center 1 mode",
 334         "AE center 2 mode",
 335         "AE center 3 mode",
 336         "AE spot 1 mode",
 337         "AE spot 2 mode",
 338         "AE custom 1 mode",
 339         "AE custom 2 mode",
 340 };
 341
 342 const char *image_fmt[SENSOR_IMAGE_FORMAT] = {
 343         "NV12",
 344         "NV12T",
 345         "NV16",
 346         "NV21",
 347         "YUYV",
 348         "UYVY",
 349         "422P",
 350         "I420",
 351         "YV12",
 352 };
 353
 354 const char *face_zoom_mode[] = {
 355         "Face Zoom OFF",
 356         "Face Zoom ON",
 357 };
 358
 359 const char *display_mode[] = {
 360         "Default",
 361         "Primary Video ON and Secondary Video Full Screen",
 362         "Primary Video OFF and Secondary Video Full Screen",
 363 };
 364
 365 const char *output_mode[] = {
 366         "Letter Box mode",
 367         "Original Size mode",
 368         "Full Screen mode",
 369         "Cropped Full Screen mode",
 370         "ROI mode",
 371 };
 372
 373 const char *capture_sound[] = {
 374         "Default",
 375         "Extra 01",
 376         "Extra 02",
 377 };
 378
 379 const char *rotate_mode[] = {
 380         "0",
 381         "90",
 382         "180",
 383         "270",
 384 };
 385
 386 const char* strobe_mode[] = {
 387         "Strobe OFF",
 388         "Strobe ON",
 389         "Strobe Auto",
 390         "Strobe RedEyeReduction",
 391         "Strobe SlowSync",
 392         "Strobe FrontCurtain",
 393         "Strobe RearCurtain",
 394         "Strobe Permanent",
 395 };
 396
 397 const char *detection_mode[2] = {
 398         "Face Detection OFF",
 399         "Face Detection ON",
 400 };
 401
 402 const char *wdr_mode[] = {
 403         "WDR OFF",
 404         "WDR ON",
 405         "WDR AUTO",
 406 };
 407
 408 const char *hdr_mode[] = {
 409         "HDR OFF",
 410         "HDR ON",
 411         "HDR ON and Original",
 412 };
 413
 414 const char *ahs_mode[] = {
 415         "Anti-handshake OFF",
 416         "Anti-handshake ON",
 417         "Anti-handshake AUTO",
 418         "Anti-handshake MOVIE",
 419 };
 420
 421 const char *vs_mode[] = {
 422         "Video-stabilization OFF",
 423         "Video-stabilization ON",
 424 };
 425
 426 const char *visible_mode[] = {
 427         "Display OFF",
 428         "Display ON",
 429 };
 430
 431
 432 /*---------------------------------------------------------------------------
 433   |    LOCAL FUNCTION PROTOTYPES:                                             |
 434   ---------------------------------------------------------------------------*/
 435 static void print_menu();
 436 static gboolean cmd_input(GIOChannel *channel);
 437 static gboolean init(int type);
 438 static gboolean mode_change(gchar buf);
 439
 440
 441 static bool preview_resolution_cb(int width, int height, void *user_data)
 442 {
 443         resolution_stack *data = (resolution_stack*)user_data;
 444
 445         if (data == NULL) {
 446                 g_print("NULL data\n");
 447                 return false;
 448         }
 449
 450         data->width[data->count] = width;
 451         data->height[data->count] = height;
 452
 453         g_print("%d. %dx%d\n", data->count, width, height);
 454
 455         data->count++;
 456
 457         return true;
 458 }
 459
 460 static bool af_mode_foreach_cb(camera_attr_iso_e mode , void *user_data)
 461 {
 462         g_print("%d.%s\n", mode, af_scan[mode]);
 463         return true;
 464 }
 465
 466 static bool exposure_mode_cb(camera_attr_af_mode_e mode , void *user_data)
 467 {
 468         exposure_stack *data = (exposure_stack*)user_data;
 469
 470         if (data == NULL) {
 471                 g_print("NULL data\n");
 472                 return false;
 473         }
 474
 475         data->mode = mode;
 476         data->count++;
 477
 478         g_print("%d.%s\n", mode, exposure_mode[mode]);
 479         return true;
 480 }
 481
 482 static bool iso_mode_cb(camera_attr_iso_e mode , void *user_data)
 483 {
 484         g_print("%d.%s\n", mode, iso_mode[mode]);
 485         return true;
 486 }
 487
 488 static bool camera_rotation_cb(camera_rotation_e mode , void *user_data)
 489 {
 490         camera_rotation_stack *data = (camera_rotation_stack*)user_data;
 491
 492         if (data == NULL) {
 493                 g_print("NULL data\n");
 494                 return false;
 495         }
 496
 497         data->mode = mode;
 498         data->count++;
 499
 500         g_print("%d.%s\n", mode, camera_rotation[mode]);
 501         return true;
 502 }
 503
 504 static bool white_balance_cb(camera_attr_whitebalance_e mode , void *user_data)
 505 {
 506         g_print("%d.%s\n", mode, wb[mode]);
 507         return true;
 508 }
 509
 510 static bool colortone_cb(camera_attr_effect_mode_e mode , void *user_data)
 511 {
 512         g_print("%d.%s\n", mode, ct[mode]);
 513         return true;
 514 }
 515
 516 static bool program_mode_cb(camera_attr_scene_mode_e mode , void *user_data)
 517 {
 518         g_print("%d.%s\n", mode, program_mode[mode]);
 519         return true;
 520 }
 521
 522 static bool strobe_mode_cb(camera_attr_flash_mode_e mode , void *user_data)
 523 {
 524         g_print("%d.%s\n", mode, strobe_mode[mode]);
 525         return true;
 526 }
 527
 528 static void _face_detected(camera_detected_face_s *faces, int count, void *user_data)
 529 {
 530         int i;
 531
 532         g_print("face detected!!\n");
 533
 534         for (i = 0 ; i < count ; i++)
 535                 g_print("%d) - %dx%d\n", faces[i].id, faces[i].x, faces[i].y);
 536
 537         return;
 538 }
 539
 540 static void _state_changed_cb(recorder_state_e previous_state, recorder_state_e current_state, bool by_policy, void *user_data)
 541 {
 542         g_print("\n\tstate changed[by_policy:%d] : %d -> %d\n\n", by_policy, previous_state, current_state);
 543         return;
 544 }
 545
 546 static void _recorder_device_state_changed_cb(recorder_type_e type, recorder_device_state_e state, void *user_data)
 547 {
 548         g_print("\nrecorder device[%d] state changed to %d\n", type, state);
 549         return;
 550 }
 551
 552 static void _recording_status_cb(unsigned long long elapsed_time, unsigned long long file_size, void *user_data)
 553 {
 554         static unsigned long long elapsed = -1;
 555
 556         if (elapsed != elapsed_time / 1000) {
 557                 unsigned long temp_time;
 558                 unsigned long long hour, minute, second;
 559                 elapsed = elapsed_time / 1000;
 560                 temp_time = elapsed;
 561                 hour = temp_time / 3600;
 562                 temp_time = elapsed % 3600;
 563                 minute = temp_time / 60;
 564                 second = temp_time % 60;
 565                 g_print("\n\tCurrent Time - %lld:%lld:%lld, filesize %lld KB\n\n",
 566                                 hour, minute, second, file_size);
 567         }
 568
 569         return;
 570 }
 571
 572 static void _recording_limit_reached_cb(recorder_recording_limit_type_e type, void *user_data)
 573 {
 574         g_print("\n\tRECORDING LIMIT REACHED [type: %d]\n\n", type);
 575         return;
 576 }
 577
 578
 579 static inline void flush_stdin()
 580 {
 581         int ch;
 582         while ((ch = getchar()) != EOF && ch != '\n');
 583         return;
 584 }
 585
 586 static bool _release_idle_event_callback(void *data)
 587 {
 588         g_print("destroy recorder handle\n\n");
 589
 590         recorder_destroy(hcamcorder->recorder);
 591         hcamcorder->recorder = NULL;
 592         hcamcorder->menu_state = MENU_STATE_INIT;
 593         print_menu();
 594
 595         return 0;
 596 }
 597
 598 static void _recorder_error_cb(int error, recorder_state_e current_state, void *user_data)
 599 {
 600         g_print("\n\n\tERROR [0x%x], current state %d\n", error, current_state);
 601
 602         switch (error) {
 603         case RECORDER_ERROR_RESOURCE_CONFLICT:
 604                 g_print("\t\t[RECORDER_ERROR_RESOURCE_CONFLICT]\n\n");
 605                 break;
 606         case RECORDER_ERROR_SECURITY_RESTRICTED:
 607                 g_print("\t\t[RECORDER_ERROR_SECURITY_RESTRICTED]\n\n");
 608                 break;
 609         case RECORDER_ERROR_SERVICE_DISCONNECTED:
 610                 g_print("\t\t[RECORDER_ERROR_SERVICE_DISCONNECTED]\n\n");
 611                 g_idle_add_full(G_PRIORITY_DEFAULT,
 612                         (GSourceFunc)_release_idle_event_callback,
 613                         NULL, NULL);
 614                 break;
 615         default:
 616                 break;
 617         }
 618
 619         return;
 620 }
 621
 622
 623 static void print_menu()
 624 {
 625         switch (hcamcorder->menu_state) {
 626         case MENU_STATE_INIT:
 627                 g_print("\n\t=======================================\n");
 628                 g_print("\t   RECORDER_TESTSUIT\n");
 629                 g_print("\t=======================================\n");
 630                 g_print("\t   '1' Video Recording - Rear Camera\n");
 631                 g_print("\t   '2' Audio Recording - MIC\n");
 632                 g_print("\t   '3' Audio Recording - MODEM\n");
 633                 g_print("\t   '4' Add recorder device changed callback\n");
 634                 g_print("\t   '5' Remove recorder device changed callback\n");
 635                 g_print("\t   '6' Get recorder device state\n");
 636                 g_print("\t   'q' Exit\n");
 637                 g_print("\t=======================================\n");
 638                 g_print("\t  Choose the menu :\n\t");
 639                 break;
 640         case MENU_STATE_MAIN:
 641                 if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
 642                         g_print("\n\t=======================================\n");
 643                         if (recorder_state <= RECORDER_STATE_NONE) {
 644                                 g_print("\t   '1' Start Recording\n");
 645                                 g_print("\t   '2' Setting\n");
 646                                 g_print("\t   'b' back\n");
 647                         } else if (recorder_state == RECORDER_STATE_RECORDING) {
 648                                 g_print("\t   'p' Pause Recording\n");
 649                                 g_print("\t   'c' Cancel\n");
 650                                 g_print("\t   's' Save\n");
 651                         } else if (recorder_state == RECORDER_STATE_PAUSED) {
 652                                 g_print("\t   'r' Resume Recording\n");
 653                                 g_print("\t   'c' Cancel\n");
 654                                 g_print("\t   's' Save\n");
 655                         }
 656                         g_print("\t=======================================\n");
 657                 } else if (hcamcorder->mode == MODE_AUDIO) {
 658                         g_print("\n\t=======================================\n");
 659                         g_print("\t   Audio Recording\n");
 660                         g_print("\t=======================================\n");
 661                         if (recorder_state <= RECORDER_STATE_NONE) {
 662                                 g_print("\t   '1' Start Recording\n");
 663                                 g_print("\t   'b' back\n");
 664                         } else if (recorder_state == RECORDER_STATE_RECORDING) {
 665                                 g_print("\t   'p' Pause Recording\n");
 666                                 g_print("\t   'c' Cancel\n");
 667                                 g_print("\t   's' Save\n");
 668                         } else if (recorder_state == RECORDER_STATE_PAUSED) {
 669                                 g_print("\t   'r' Resume Recording\n");
 670                                 g_print("\t   'c' Cancel\n");
 671                                 g_print("\t   's' Save\n");
 672                         }
 673                         g_print("\t=======================================\n");
 674                 }
 675                 break;
 676
 677         case MENU_STATE_SETTING:
 678                 g_print("\n\t=======================================\n");
 679                 g_print("\t   Video Capture > Setting\n");
 680                 g_print("\t=======================================\n");
 681                 g_print("\t  >>>>>>>>>>>>>>>>>>>>>>>>>>>> [Camera]  \n");
 682                 g_print("\t     '0' Preview resolution \n");
 683                 g_print("\t     '2' Digital zoom level \n");
 684                 g_print("\t     '3' Optical zoom level \n");
 685                 g_print("\t     '4' AF mode \n");
 686                 g_print("\t     '5' AF scan range \n");
 687                 g_print("\t     '6' Exposure mode \n");
 688                 g_print("\t     '7' Exposure value \n");
 689                 g_print("\t     '8' F number \n");
 690                 g_print("\t     '9' Shutter speed \n");
 691                 g_print("\t     'i' ISO \n");
 692                 g_print("\t     'r' Rotate camera input \n");
 693                 g_print("\t     'f' Flip camera input \n");
 694                 g_print("\t  >>>>>>>>>>>>>>>>>>>> [Display/Filter]\n");
 695                 g_print("\t     'v' Visible \n");
 696                 g_print("\t     'n' Display mode \n");
 697                 g_print("\t     'o' Output mode \n");
 698                 g_print("\t     'y' Rotate display \n");
 699                 g_print("\t     'Y' Flip display \n");
 700                 g_print("\t     'g' Brightness \n");
 701                 g_print("\t     'c' Contrast \n");
 702                 g_print("\t     's' Saturation \n");
 703                 g_print("\t     'h' Hue \n");
 704                 g_print("\t     'a' Sharpness \n");
 705                 g_print("\t     'w' White balance \n");
 706                 g_print("\t     't' Color tone \n");
 707                 g_print("\t     'd' WDR \n");
 708                 g_print("\t     'e' EV program mode \n");
 709                 g_print("\t  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [etc.]\n");
 710                 g_print("\t     'z' Strobe (Flash) \n");
 711                 g_print("\t     'l' Face detection \n");
 712                 g_print("\t     'k' Anti-handshake \n");
 713                 g_print("\t     'K' Video-stabilization \n");
 714                 g_print("\t     'u' Touch AF area \n");;
 715                 g_print("\t     'M' Camcorder Motion Rate setting \n");
 716                 g_print("\t     'b' back\n");
 717                 g_print("\t=======================================\n");
 718                 break;
 719
 720         default:
 721                 g_print("unknow menu state !!\n");
 722                 break;
 723         }
 724
 725         return;
 726 }
 727
 728 static void main_menu(gchar buf)
 729 {
 730         int err = 0;
 731
 732         if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
 733                 if (recorder_state == RECORDER_STATE_NONE) {
 734                         switch (buf) {
 735                         case '1': /* Start Recording */
 736                                 g_print("*Recording start!\n");
 737                                 hcamcorder->elapsed_time = 0;
 738
 739                                 g_timer_reset(timer);
 740                                 err = recorder_start(hcamcorder->recorder);
 741
 742                                 if (err != 0)
 743                                         g_print("Rec start camcorder_record 0x%x\n", err);
 744
 745                                 recorder_state = RECORDER_STATE_RECORDING;
 746                                 break;
 747
 748                         case '2': /* Setting */
 749                                 hcamcorder->menu_state = MENU_STATE_SETTING;
 750                                 break;
 751
 752                         case 'b': /* back */
 753                                 recorder_unprepare(hcamcorder->recorder);
 754                                 recorder_destroy(hcamcorder->recorder);
 755                                 hcamcorder->recorder = NULL;
 756
 757                                 if (hcamcorder->camera) {
 758                                         camera_destroy(hcamcorder->camera);
 759                                         hcamcorder->camera = NULL;
 760                                 }
 761
 762                                 hcamcorder->menu_state = MENU_STATE_INIT;
 763                                 print_menu();
 764                                 break;
 765
 766                         default:
 767                                 g_print("\t Invalid input \n");
 768                                 break;
 769                         }
 770                 } else if (recorder_state == RECORDER_STATE_RECORDING || recorder_state == RECORDER_STATE_PAUSED) {
 771                         switch (buf) {
 772                         case 'p': /* Pause Recording */
 773                                 g_print("*Pause!\n");
 774                                 err = recorder_pause(hcamcorder->recorder);
 775
 776                                 if (err < 0)
 777                                         g_print("Rec pause camcorder_pause  = %x\n", err);
 778
 779                                 recorder_state = RECORDER_STATE_PAUSED;
 780                                 break;
 781
 782                         case 'r': /* Resume Recording */
 783                                 g_print("*Resume!\n");
 784                                 err = recorder_start(hcamcorder->recorder);
 785                                 if (err < 0)
 786                                         g_print("Rec start camcorder_record  = %x\n", err);
 787
 788                                 recorder_state = RECORDER_STATE_RECORDING;
 789                                 break;
 790
 791                         case 'c': /* Cancel */
 792                                 g_print("*Cancel Recording !\n");
 793
 794                                 err = recorder_cancel(hcamcorder->recorder);
 795
 796                                 if (err < 0)
 797                                         g_print("Cancel recording camcorder_cancel  = %x\n", err);
 798
 799                                 recorder_state = RECORDER_STATE_NONE;
 800                                 break;
 801
 802                         case 's': /* Save */
 803                                 g_print("*Save Recording!\n");
 804                                 g_timer_reset(timer);
 805
 806                                 err = recorder_commit(hcamcorder->recorder);
 807
 808                                 if (err < 0)
 809                                         g_print("Save recording recorder_commit  = %x\n", err);
 810
 811                                 recorder_state = RECORDER_STATE_NONE;
 812                                 break;
 813
 814                         default:
 815                                 g_print("\t Invalid input \n");
 816                                 break;
 817                         } /* switch */
 818                 } else {
 819                         g_print("Wrong camcorder state, check status!!\n");
 820                 }
 821         } else if (hcamcorder->mode == MODE_AUDIO) {
 822                 if (recorder_state == RECORDER_STATE_NONE) {
 823                         switch (buf) {
 824                         case '1': /*  Start Recording */
 825                                 g_print("*Recording start!\n");
 826                                 hcamcorder->elapsed_time = 0;
 827                                 g_timer_reset(timer);
 828                                 err = recorder_start(hcamcorder->recorder);
 829
 830                                 if (err < 0)
 831                                         g_print("Rec start camcorder_record  = %x\n", err);
 832
 833                                 recorder_state = RECORDER_STATE_RECORDING;
 834                                 break;
 835
 836                         case 'b': /* back */
 837                                 recorder_unprepare(hcamcorder->recorder);
 838                                 recorder_destroy(hcamcorder->recorder);
 839                                 hcamcorder->recorder = NULL;
 840
 841                                 hcamcorder->menu_state = MENU_STATE_INIT;
 842                                 print_menu();
 843                                 break;
 844
 845                         default:
 846                                 g_print("\t Invalid input \n");
 847                                 break;
 848                         }
 849                 } else if (recorder_state == RECORDER_STATE_RECORDING || recorder_state == RECORDER_STATE_PAUSED) {
 850                         switch (buf) {
 851                         case 'p': /* Pause Recording */
 852                                 g_print("*Pause!\n");
 853                                 err = recorder_pause(hcamcorder->recorder);
 854
 855                                 if (err < 0)
 856                                         g_print("Rec pause camcorder_pause  = %x\n", err);
 857
 858                                 recorder_state = RECORDER_STATE_PAUSED;
 859                                 break;
 860
 861                         case 'r': /* Resume Recording */
 862                                 g_print("*Resume!\n");
 863                                 err = recorder_start(hcamcorder->recorder);
 864                                 if (err < 0)
 865                                         g_print("Rec start camcorder_record  = %x\n", err);
 866
 867                                 recorder_state = RECORDER_STATE_RECORDING;
 868                                 break;
 869
 870                         case 'c': /* Cancel */
 871                                 g_print("*Cancel Recording !\n");
 872                                 err = recorder_cancel(hcamcorder->recorder);
 873
 874                                 if (err < 0)
 875                                         g_print("Cancel recording camcorder_cancel  = %x\n", err);
 876
 877                                 recorder_state = RECORDER_STATE_NONE;
 878                                 break;
 879
 880                         case 's': /*  Save */
 881                                 g_print("*Save Recording!\n");
 882                                 g_timer_reset(timer);
 883                                 err = recorder_commit(hcamcorder->recorder);
 884
 885                                 if (err < 0)
 886                                         g_print("Save recording recorder_commit  = %x\n", err);
 887
 888                                 recorder_state = RECORDER_STATE_NONE;
 889                                 break;
 890
 891                         default:
 892                         g_print("\t Invalid input \n");
 893                         break;
 894                         }
 895                 } else {
 896                         g_print("Wrong camcorder state, check status!!\n");
 897                 }
 898         } else {
 899                 g_print("\t Invalid mode, back to upper menu \n");
 900                 hcamcorder->menu_state = MENU_STATE_INIT;
 901                 print_menu();
 902         }
 903 }
 904
 905
 906 static void setting_menu(gchar buf)
 907 {
 908         gboolean bret = FALSE;
 909         int idx = 0;
 910         int min = 0;
 911         int max = 0;
 912         int value = 0;
 913         int err = 0;
 914         int x = 0, y = 0, width = 0, height = 0;
 915
 916         if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
 917                 switch (buf) {
 918                 /* Camera setting */
 919                 case '0':  /* Setting > Preview Resolution setting */
 920                         g_print("*Select the preview resolution!\n");
 921                         resolution_stack resolution_list;
 922                         resolution_list.count = 0;
 923
 924                         recorder_foreach_supported_video_resolution(hcamcorder->recorder,
 925                                 preview_resolution_cb, &resolution_list);
 926
 927                         flush_stdin();
 928                         err = scanf("%d", &idx);
 929                         int result = 0;
 930                         if (resolution_list.count > idx && idx >= 0) {
 931                                 g_print("-----------------PREVIEW RESOLUTION (%dx%d)---------------------\n",
 932                                         resolution_list.width[idx], resolution_list.height[idx]);
 933
 934                                 result = recorder_set_video_resolution(hcamcorder->recorder,
 935                                         resolution_list.width[idx], resolution_list.height[idx]);
 936                         } else {
 937                                 g_print("invalid input %d\n", idx);
 938                                 result = -1;
 939                         }
 940
 941                         resolution_list.count = 0;
 942
 943                         if (result != 0)
 944                                 g_print("FAIL\n");
 945                         else
 946                                 g_print("PASS\n");
 947                         break;
 948
 949                 case '2': /* Setting > Digital zoom level */
 950                         g_print("*Digital zoom level  !\n");
 951
 952                         camera_attr_get_zoom_range(hcamcorder->camera, &min, &max);
 953                         if (min >= max) {
 954                                 g_print("Not supported !! \n");
 955                         } else {
 956                                 flush_stdin();
 957                                 g_print("\n Select  Digital zoom level min %d - max %d\n", min, max);
 958                                 err = scanf("%d", &idx);
 959                                 bret = camera_attr_set_zoom(hcamcorder->camera, idx);
 960                         }
 961                         break;
 962
 963
 964                 case '3': /* Setting > AF mode */
 965
 966                         g_print("*AF mode !\n");
 967                         g_print("\t1. AF Start !\n");
 968                         g_print("\t2. AF Stop !\n\n");
 969
 970                         flush_stdin();
 971                         err = scanf("%d", &idx);
 972                         switch (idx) {
 973                         case 1:
 974                                 camera_start_focusing(hcamcorder->camera, 0);
 975                                 break;
 976                         case 2:
 977                                 camera_cancel_focusing(hcamcorder->camera);
 978                                 break;
 979                         default:
 980                                 g_print("Wrong Input[%d] !! \n", idx);
 981                                 break;
 982                         }
 983
 984                         break;
 985
 986                 case '4': /* Setting > AF scan range */
 987                         g_print("*AF scan range !\n");
 988
 989                         camera_attr_foreach_supported_af_mode(hcamcorder->camera,
 990                                 (camera_attr_supported_af_mode_cb)af_mode_foreach_cb, NULL);
 991
 992                         flush_stdin();
 993                         err = scanf("%d", &idx);
 994                         bret = camera_attr_set_af_mode(hcamcorder->camera, idx);
 995                         break;
 996
 997                 case '5': /* Setting > Exposure mode */
 998                         g_print("* Exposure mode!\n");
 999
1000                         camera_attr_foreach_supported_exposure_mode(hcamcorder->camera,
1001                                 (camera_attr_supported_exposure_mode_cb)exposure_mode_cb, NULL);
1002
1003                         flush_stdin();
1004
1005                         g_print("\n Select  Exposure mode \n");
1006                         err = scanf("%d", &idx);
1007                         bret = camera_attr_set_exposure_mode(hcamcorder->camera, idx);
1008
1009                         break;
1010
1011                 case '6':  /* Setting > Exposure value */
1012                         camera_attr_get_exposure_range(hcamcorder->camera, &min, &max);
1013                         if (min >= max) {
1014                                 g_print("Not supported !! \n");
1015                         } else {
1016
1017                                 flush_stdin();
1018                                 g_print("\n Select  Exposure mode min%d -max %d\n", min, max);
1019                                 err = scanf("%d", &idx);
1020                                 bret = camera_attr_set_exposure(hcamcorder->camera, idx);
1021                         }
1022                         break;
1023
1024                 case '7': /* Setting > F number */
1025                         g_print("Not supported !! \n");
1026                         break;
1027
1028                 case 'i': /* Setting > ISO */
1029                         g_print("*ISO !\n");
1030                         camera_attr_foreach_supported_iso(hcamcorder->camera, iso_mode_cb, NULL);
1031
1032                         flush_stdin();
1033
1034                         err = scanf("%d", &idx);
1035                         bret =  camera_attr_set_iso(hcamcorder->camera, idx);
1036                         break;
1037
1038                 case 'r': /* Setting > Rotate camera input when recording */
1039                         g_print("*Rotate camera input\n");
1040                         camera_attr_foreach_supported_stream_rotation(hcamcorder->camera, camera_rotation_cb, NULL);
1041
1042                         flush_stdin();
1043                         err = scanf("%d", &idx);
1044                         CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera));
1045                         bret = camera_attr_set_stream_rotation(hcamcorder->camera, idx);
1046                         CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera));
1047                         break;
1048
1049                 case 'f': /* Setting > Flip camera input */
1050                         flush_stdin();
1051                         g_print("*Flip camera input\n");
1052                         g_print(" 0. Flip NONE\n");
1053                         g_print(" 1. Flip HORIZONTAL\n");
1054                         g_print(" 2. Flip VERTICAL\n");
1055                         g_print(" 3. Flip BOTH\n");
1056
1057                         err = scanf("%d", &idx);
1058
1059                         CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera));
1060                         camera_attr_set_stream_flip(hcamcorder->camera, idx);
1061                         CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera));
1062                         break;
1063
1064                         /* Display / Filter setting */
1065                 case 'v': /* Display visible */
1066                         g_print("* Display visible setting !\n");
1067
1068                         g_print("\n Select Display visible \n");
1069                         flush_stdin();
1070                         int i;
1071                         for (i = 0; i < 2; i++)
1072                                 g_print("\t %d. %s\n", i+1, visible_mode[i]);
1073
1074                         err = scanf("%d", &value);
1075                         bret = camera_set_display_visible(hcamcorder->camera, idx-1);
1076
1077                         break;
1078
1079
1080                 case 'o': /*  Setting > Display MODe */
1081                         g_print("* Display mode!\n");
1082
1083                         flush_stdin();
1084                         for (i = 1 ; i <= 2  ; i++)
1085                                 g_print("%d. %s\n", i, display_mode[i]);
1086
1087                         err = scanf("%d", &idx);
1088                         bret =  camera_set_display_mode(hcamcorder->camera, idx-1);
1089                         break;
1090
1091                 case 'y': /* Setting > Rotate Display */
1092
1093                         flush_stdin();
1094                         g_print("\n Select Rotate mode\n");
1095                         g_print("\t0. 0\n\t1. 90\n\t2. 180\n\t3. 270\n\n");
1096                         err = scanf("%d", &idx);
1097                         CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera));
1098                         bret = camera_set_display_rotation(hcamcorder->camera, idx);
1099                         CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera));
1100                         break;
1101
1102                 case 'Y': /* Setting > Flip Display */
1103                         flush_stdin();
1104                         g_print("\n Select Rotate mode\n");
1105                         g_print("\t0. NONE\n\t1. HORIZONTAL\n\t2. VERTICAL\n\t3. BOTH\n\n");
1106                         err = scanf("%d", &idx);
1107                         bret = camera_set_display_flip(hcamcorder->camera, idx);
1108                         break;
1109
1110                 case 'g': /* Setting > Brightness */
1111                         g_print("*Brightness !\n");
1112                         camera_attr_get_brightness_range(hcamcorder->camera, &min, &max);
1113
1114                         flush_stdin();
1115                         g_print("\n Select  brightness min (%d) -max(%d)\n", min, max);
1116                         err = scanf("%d", &idx);
1117                         bret = camera_attr_set_brightness(hcamcorder->camera, idx);
1118                         break;
1119
1120                 case 'c': /* Setting > Contrast */
1121                         g_print("*Contrast !\n");
1122                         camera_attr_get_contrast_range(hcamcorder->camera, &min, &max);
1123
1124                         flush_stdin();
1125                         g_print("\n Select  Contrast min(%d)-max(%d)\n", min, max);
1126                         err = scanf("%d", &idx);
1127                         bret = camera_attr_set_contrast(hcamcorder->camera, idx);
1128                         break;
1129
1130
1131
1132                 case 'w': /* Setting > White balance */
1133                         g_print("*White balance !\n");
1134
1135                         flush_stdin();
1136                         g_print("\n Select White balance \n");
1137                         camera_attr_foreach_supported_whitebalance(hcamcorder->camera, white_balance_cb, NULL);
1138                         err = scanf("%d", &idx);
1139                         bret = camera_attr_set_whitebalance(hcamcorder->camera, idx);
1140                         break;
1141
1142                 case 't': /* Setting > Color tone */
1143                         g_print("*Color tone !\n");
1144                         camera_attr_foreach_supported_effect(hcamcorder->camera, colortone_cb, NULL);
1145
1146                         g_print("\n Select Color tone \n");
1147                         flush_stdin();
1148                         err = scanf("%d", &idx);
1149                         bret = camera_attr_set_effect(hcamcorder->camera, idx);
1150
1151                         break;
1152
1153                 case 'd': /* Setting > WDR */
1154                         g_print("*WDR !\n");
1155
1156                         g_print("\n Select WDR Mode \n");
1157                         flush_stdin();
1158                         for (i = 0; i < 2; i++)
1159                                 g_print("\t %d. %s\n", i+1, wdr_mode[i]);
1160
1161                         err = scanf("%d", &idx);
1162                         if (idx == 1)
1163                                 bret = camera_attr_enable_auto_contrast(hcamcorder->camera, 0);
1164                         else if (idx == 2)
1165                                 bret = camera_attr_enable_auto_contrast(hcamcorder->camera, 1);
1166
1167                         break;
1168
1169                 case 'e': /* Setting > EV program mode */
1170                         g_print("* EV program mode!\n");
1171                         camera_attr_foreach_supported_scene_mode(hcamcorder->camera, program_mode_cb, NULL);
1172
1173                         g_print("\n Select EV program mode \n");
1174                         flush_stdin();
1175                         err = scanf("%d", &idx);
1176                         bret = camera_attr_set_scene_mode(hcamcorder->camera, idx);
1177
1178                         break;
1179
1180                         /* ext. setting */
1181                 case 'z': /* Setting > Strobe setting */
1182                         g_print("*Strobe Mode\n");
1183                         camera_attr_foreach_supported_flash_mode(hcamcorder->camera, strobe_mode_cb, NULL);
1184                         g_print("\n Select Strobe Mode \n");
1185                         flush_stdin();
1186                         err = scanf("%d", &idx);
1187                         bret = camera_attr_set_flash_mode(hcamcorder->camera, idx);
1188
1189                         break;
1190
1191                 case 'l': /* Setting > Face detection setting */
1192                         /* hcamcorder->menu_state = MENU_STATE_SETTING_DETECTION; */
1193                         g_print("* Face detect mode !\n");
1194
1195
1196                         flush_stdin();
1197                         for (i = 0; i < 2; i++)
1198                                 g_print("\t %d. %s \n", i+1, detection_mode[i]);
1199
1200                         err = scanf("%d", &idx);
1201                         if (camera_is_supported_face_detection(hcamcorder->camera)) {
1202                                 if (idx >= 0 && idx < 2)
1203                                         bret = camera_start_face_detection(hcamcorder->camera, _face_detected, NULL);
1204                         } else {
1205                                 g_print("face detection_not supported\n");
1206                         }
1207
1208                         break;
1209
1210                 case 'k': /* Setting > Anti-handshake */
1211                         g_print("*Anti-handshake !\n");
1212
1213                         g_print("\n Select Anti-handshake mode \n");
1214                         flush_stdin();
1215                         for (i = 0; i < 2; i++)
1216                                 g_print("\t %d. %s\n", i+1, ahs_mode[i]);
1217
1218                         err = scanf("%d", &idx);
1219                         bret = camera_attr_enable_anti_shake(hcamcorder->camera, idx-1);
1220
1221                         break;
1222
1223                 case 'K': /* Setting > Video-stabilization */
1224                         g_print("*Video-stabilization !\n");
1225
1226                         g_print("\n Select Video-stabilization mode \n");
1227                         flush_stdin();
1228                         for (i = 0; i < 2; i++)
1229                                 g_print("\t %d. %s\n", i+1, vs_mode[i]);
1230
1231                         err = scanf("%d", &idx);
1232
1233                         if (idx == 2) {
1234                                 g_print("\n Restart preview with NV12 and 720p resolution\n");
1235
1236                                 err = camera_stop_preview(hcamcorder->camera);
1237
1238                                 camera_set_preview_resolution(hcamcorder->camera, 1280, 720);
1239                                 camera_set_preview_format(hcamcorder->camera, CAMERA_PIXEL_FORMAT_NV12);
1240                                 camera_attr_enable_video_stabilization(hcamcorder->camera, idx-1);
1241
1242                                 if (err == 0) {
1243                                         err = camera_start_preview(hcamcorder->camera);
1244
1245                                         if (err != 0)
1246                                                 g_print("\n Restart FAILED! %x\n", err);
1247                                 }
1248                         }
1249                         break;
1250
1251                 case 'u': /* Touch AF area */
1252                         g_print("* Touch AF area !\n");
1253
1254                         flush_stdin();
1255                         g_print("\n Input x,y,width,height \n");
1256                         err = scanf("%d,%d,%d,%d", &x, &y, &width, &height);
1257                         err = camera_attr_set_af_area(hcamcorder->camera, width, height);
1258
1259                         if (err != 0)
1260                                 g_print("Failed to set touch AF area.(%x)\n", err);
1261                         else
1262                                 g_print("Succeed to set touch AF area.\n");
1263
1264                         break;
1265
1266
1267                 case 'M':
1268                         {
1269                                 float motion_rate = 0.0;
1270
1271                                 flush_stdin();
1272
1273                                 g_print("*Camcorder Motion Rate setting! (should be bigger than zero)\n");
1274
1275                                 err = scanf("%f", &motion_rate);
1276                                 err = recorder_attr_set_recording_motion_rate(hcamcorder->recorder, motion_rate);
1277                                 if (err != 0)
1278                                         g_print("Failed to set Camcorder Motion Rate %f [err:0x%x]\n", motion_rate, err);
1279                                 else
1280                                         g_print("Succeed to set Motion Rate %f\n", motion_rate);
1281                         }
1282                         break;
1283
1284                 case 'b': /* back */
1285                         hcamcorder->menu_state = MENU_STATE_MAIN;
1286                         break;
1287
1288                 default:
1289                         g_print("\t Invalid input \n");
1290                         break;
1291                 }
1292         } else {
1293                 g_print("\t Invalid mode, back to upper menu \n");
1294                 hcamcorder->menu_state = MENU_STATE_MAIN;
1295         }
1296
1297         g_print("\t bret : 0x%x \n", bret);
1298 }
1299
1300
1301 /**
1302  * This function is to execute command.
1303  *
1304  * @param    channel [in]    1st parameter
1305  *
1306  * @return   This function returns TRUE/FALSE
1307  * @remark
1308  * @see
1309  */
1310 static gboolean cmd_input(GIOChannel *channel)
1311 {
1312         gchar *buf = NULL;
1313         gsize read_size;
1314         GError *g_error = NULL;
1315
1316         g_print("\n\tENTER\n");
1317
1318         g_io_channel_read_line(channel, &buf, &read_size, NULL, &g_error);
1319         if (g_error) {
1320                 g_print("\n\tg_io_channel_read_chars error\n");
1321                 g_error_free(g_error);
1322                 g_error = NULL;
1323         }
1324
1325         if (buf) {
1326                 g_strstrip(buf);
1327
1328                 g_print("\n\tMenu Status : %d\n", hcamcorder->menu_state);
1329                 switch (hcamcorder->menu_state) {
1330                 case MENU_STATE_INIT:
1331                         mode_change(buf[0]);
1332                         break;
1333                 case MENU_STATE_MAIN:
1334                         main_menu(buf[0]);
1335                         break;
1336                 case MENU_STATE_SETTING:
1337                         setting_menu(buf[0]);
1338                         break;
1339                 default:
1340                         break;
1341                 }
1342
1343                 g_free(buf);
1344                 buf = NULL;
1345
1346                 print_menu();
1347         } else {
1348                 g_print("\n\tNo read input\n");
1349         }
1350
1351         return TRUE;
1352 }
1353
1354 static gboolean init(int type)
1355 {
1356         int err;
1357
1358         if (!hcamcorder)
1359                 return FALSE;
1360
1361         if (!hcamcorder->recorder)
1362                 return FALSE;
1363
1364         /*================================================================================
1365           Video capture mode
1366          *=================================================================================*/
1367         if (type == MODE_VIDEO_CAPTURE) {
1368                 err = recorder_set_file_format(hcamcorder->recorder, RECORDER_FILE_FORMAT_MP4);
1369                 if (err < 0) {
1370                         g_print("Init fail. (%x)\n", err);
1371                         goto ERROR;
1372                 }
1373                 err = recorder_attr_set_audio_device(hcamcorder->recorder, RECORDER_AUDIO_DEVICE_MIC);
1374                 if (err < 0) {
1375                         g_print("Init fail. (%x)\n", err);
1376                         goto ERROR;
1377                 }
1378                 err = recorder_set_audio_encoder(hcamcorder->recorder, RECORDER_AUDIO_CODEC_AAC);
1379                 if (err < 0) {
1380                         g_print("Init fail. (%x)\n", err);
1381                         goto ERROR;
1382                 }
1383                 err = recorder_set_video_encoder(hcamcorder->recorder, RECORDER_VIDEO_CODEC_MPEG4);
1384                 if (err < 0) {
1385                         g_print("Init fail. (%x)\n", err);
1386                         goto ERROR;
1387                 }
1388                 err = recorder_attr_set_video_encoder_bitrate(hcamcorder->recorder, VIDEO_ENCODE_BITRATE);
1389                 if (err < 0) {
1390                         g_print("Init fail. (%x)\n", err);
1391                         goto ERROR;
1392                 }
1393                 err = recorder_attr_set_audio_samplerate(hcamcorder->recorder, AUDIO_SOURCE_SAMPLERATE_AAC);
1394                 if (err < 0) {
1395                         g_print("Init fail. (%x)\n", err);
1396                         goto ERROR;
1397                 }
1398                 err = recorder_attr_set_audio_channel(hcamcorder->recorder, AUDIO_SOURCE_CHANNEL_AAC);
1399                 if (err < 0) {
1400                         g_print("Init fail. (%x)\n", err);
1401                         goto ERROR;
1402                 }
1403                 err = recorder_set_filename(hcamcorder->recorder, TARGET_FILENAME_VIDEO);
1404                 if (err < 0) {
1405                         g_print("Init fail. (%x)\n", err);
1406                         goto ERROR;
1407                 }
1408         } else if (type == MODE_AUDIO) {
1409         /*================================================================================
1410           Audio mode
1411          *=================================================================================*/
1412                 err = recorder_set_file_format(hcamcorder->recorder, RECORDER_FILE_FORMAT_MP4);
1413                 if (err < 0) {
1414                         g_print("Init fail. (%x)\n", err);
1415                         goto ERROR;
1416                 }
1417                 err = recorder_attr_set_audio_device(hcamcorder->recorder, RECORDER_AUDIO_DEVICE_MIC);
1418                 if (err < 0) {
1419                         g_print("Init fail. (%x)\n", err);
1420                         goto ERROR;
1421                 }
1422                 err = recorder_set_audio_encoder(hcamcorder->recorder, RECORDER_AUDIO_CODEC_AAC);
1423                 if (err < 0) {
1424                         g_print("Init fail. (%x)\n", err);
1425                         goto ERROR;
1426                 }
1427                 err = recorder_attr_set_audio_samplerate(hcamcorder->recorder, AUDIO_SOURCE_SAMPLERATE_AAC);
1428                 if (err < 0) {
1429                         g_print("Init fail. (%x)\n", err);
1430                         goto ERROR;
1431                 }
1432                 err = recorder_attr_set_audio_channel(hcamcorder->recorder, AUDIO_SOURCE_CHANNEL_AAC);
1433                 if (err < 0) {
1434                         g_print("Init fail. (%x)\n", err);
1435                         goto ERROR;
1436                 }
1437                 err = recorder_set_filename(hcamcorder->recorder, TARGET_FILENAME_AUDIO);
1438                 if (err < 0) {
1439                         g_print("Init fail. (%x)\n", err);
1440                         goto ERROR;
1441                 }
1442                 err = recorder_attr_set_time_limit(hcamcorder->recorder, 360000);
1443                 if (err < 0) {
1444                         g_print("Init fail. (%x)\n", err);
1445                         goto ERROR;
1446                 }
1447                 err = recorder_attr_set_audio_encoder_bitrate(hcamcorder->recorder, 128000);
1448                 if (err < 0) {
1449                         g_print("Init fail. (%x)\n", err);
1450                         goto ERROR;
1451                 }
1452         }
1453
1454         recorder_set_error_cb(hcamcorder->recorder, _recorder_error_cb, NULL);
1455         recorder_set_state_changed_cb(hcamcorder->recorder, _state_changed_cb, NULL);
1456         recorder_set_recording_status_cb(hcamcorder->recorder, _recording_status_cb, NULL);
1457         recorder_set_recording_limit_reached_cb(hcamcorder->recorder, _recording_limit_reached_cb, NULL);
1458
1459         g_print("Init DONE.\n");
1460
1461         return TRUE;
1462
1463 ERROR:
1464         g_print("init failed.\n");
1465         return FALSE;
1466 }
1467
1468 static gboolean init_handle()
1469 {
1470         hcamcorder->mode = MODE_VIDEO_CAPTURE;  /* image(capture)/video(recording) mode */
1471         hcamcorder->menu_state = MENU_STATE_INIT;
1472         hcamcorder->isMute = FALSE;
1473         hcamcorder->elapsed_time = 0;
1474         hcamcorder->fps = SRC_VIDEO_FRAME_RATE_15; /*SRC_VIDEO_FRAME_RATE_30;*/
1475
1476         return TRUE;
1477 }
1478
1479
1480 static void _sound_stream_focus_state_changed_cb(sound_stream_info_h stream_info, sound_stream_focus_change_reason_e reason_for_change, const char *additional_info, void *user_data)
1481 {
1482         g_print("focus changed : reason %d\n", reason_for_change);
1483         return;
1484 }
1485
1486 /**
1487  * This function is to change camcorder mode.
1488  *
1489  * @param    buf    [in]    user input
1490  *
1491  * @return   This function returns TRUE/FALSE
1492  * @remark
1493  * @see      other functions
1494  */
1495 static gboolean mode_change(gchar buf)
1496 {
1497         int err = RECORDER_ERROR_NONE;
1498         int state = RECORDER_STATE_NONE;
1499         char media_type = '\0';
1500         bool check = FALSE;
1501         recorder_device_state_e device_state = RECORDER_DEVICE_STATE_IDLE;
1502
1503         g_get_current_time(&previous);
1504         g_timer_reset(timer);
1505
1506         if (hcamcorder->recorder) {
1507                 err = recorder_get_state(hcamcorder->recorder, (recorder_state_e*)&state);
1508                 if (state != RECORDER_STATE_NONE) {
1509                         if (state == RECORDER_STATE_RECORDING ||
1510                                         state == RECORDER_STATE_PAUSED) {
1511                                 g_print("recorder_cancel\n");
1512                                 err = recorder_cancel(hcamcorder->recorder);
1513                                 if (err != RECORDER_ERROR_NONE) {
1514                                         g_print("exit recorder_cancel failed 0x%x\n", err);
1515                                         return FALSE;
1516                                 }
1517                         }
1518
1519                         err = recorder_get_state(hcamcorder->recorder, (recorder_state_e*)&state);
1520                         if (state == RECORDER_STATE_READY) {
1521                                 g_print("recorder_unprepare\n");
1522                                 recorder_unprepare(hcamcorder->recorder);
1523                         }
1524
1525                         err = recorder_get_state(hcamcorder->recorder, (recorder_state_e*)&state);
1526                         if (state == RECORDER_STATE_CREATED) {
1527                                 g_print("recorder_destroy\n");
1528                                 err = recorder_destroy(hcamcorder->recorder);
1529                                 if (err == RECORDER_ERROR_NONE) {
1530                                         g_print("recorder_destroy done\n");
1531                                         hcamcorder->recorder = NULL;
1532                                 }
1533                         }
1534                 }
1535         }
1536
1537         init_handle();
1538
1539         switch (buf) {
1540         case '1':
1541                 hcamcorder->mode = MODE_VIDEO_CAPTURE;
1542
1543                 g_print("camera_create\n");
1544
1545                 err = camera_create(CAMERA_DEVICE_CAMERA0, &hcamcorder->camera);
1546                 if (err != CAMERA_ERROR_NONE) {
1547                         g_print("camera create failed 0x%d\n", err);
1548                         return FALSE;
1549                 }
1550
1551                 err = camera_set_display(hcamcorder->camera, CAMERA_DISPLAY_TYPE_OVERLAY, GET_DISPLAY(ad.win));
1552                 if (err != CAMERA_ERROR_NONE) {
1553                         g_print("set display failed 0x%d\n", err);
1554                         camera_destroy(hcamcorder->camera);
1555                         hcamcorder->camera = NULL;
1556                         return FALSE;
1557                 }
1558
1559                 err = recorder_create_videorecorder(hcamcorder->camera, &hcamcorder->recorder);
1560                 if (err != RECORDER_ERROR_NONE) {
1561                         g_print("video recorder create failed 0x%d\n", err);
1562                         camera_stop_preview(hcamcorder->camera);
1563                         camera_destroy(hcamcorder->camera);
1564                         hcamcorder->camera = NULL;
1565                         return FALSE;
1566                 }
1567
1568                 check = TRUE;
1569                 break;
1570         case '2':
1571                 hcamcorder->mode = MODE_AUDIO;
1572                 err = recorder_create_audiorecorder(&hcamcorder->recorder);
1573                 if (err != RECORDER_ERROR_NONE) {
1574                         g_print("audio recorder create failed 0x%x\n", err);
1575                         return FALSE;
1576                 }
1577
1578                 {
1579                         sound_stream_info_h stream_info = NULL;
1580
1581                         sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, _sound_stream_focus_state_changed_cb, hcamcorder, &stream_info);
1582                         if (stream_info) {
1583                                 recorder_set_sound_stream_info(hcamcorder->recorder, stream_info);
1584                                 sound_manager_destroy_stream_information(stream_info);
1585                         }
1586                 }
1587
1588                 err = recorder_attr_set_audio_device(hcamcorder->recorder, RECORDER_AUDIO_DEVICE_MIC);
1589                 if (err != RECORDER_ERROR_NONE) {
1590                         g_print("set audio device failed 0x%x\n", err);
1591                         recorder_destroy(hcamcorder->recorder);
1592                         hcamcorder->recorder = NULL;
1593                         return FALSE;
1594                 }
1595
1596                 check = TRUE;
1597                 break;
1598         case '3':
1599                 hcamcorder->mode = MODE_AUDIO;
1600                 err = recorder_create_audiorecorder(&hcamcorder->recorder);
1601                 if (err != RECORDER_ERROR_NONE) {
1602                         g_print("audio recorder create failed 0x%d\n", err);
1603                         return FALSE;
1604                 }
1605
1606                 err = recorder_attr_set_audio_device(hcamcorder->recorder, RECORDER_AUDIO_DEVICE_MODEM);
1607                 if (err != RECORDER_ERROR_NONE) {
1608                         g_print("set audio device failed 0x%d\n", err);
1609                         recorder_destroy(hcamcorder->recorder);
1610                         hcamcorder->recorder = NULL;
1611                         return FALSE;
1612                 }
1613
1614                 check = TRUE;
1615                 break;
1616         case '4':
1617                 err = recorder_add_device_state_changed_cb(_recorder_device_state_changed_cb,
1618                         NULL, &g_recorder_device_changed_cb_id);
1619                 g_print("add result 0x%x - cb id %d\n", err, g_recorder_device_changed_cb_id);
1620                 return FALSE;
1621         case '5':
1622                 if (g_recorder_device_changed_cb_id > 0) {
1623                         err = recorder_remove_device_state_changed_cb(g_recorder_device_changed_cb_id);
1624                         g_recorder_device_changed_cb_id = 0;
1625                         g_print("remove result 0x%x\n", err);
1626                 } else {
1627                         g_print("invalid callback id %d\n", g_recorder_device_changed_cb_id);
1628                 }
1629                 return FALSE;
1630         case '6':
1631                 err = recorder_get_device_state(RECORDER_TYPE_AUDIO, &device_state);
1632                 g_print("get result 0x%x - audio state %d\n", err, device_state);
1633                 err = recorder_get_device_state(RECORDER_TYPE_VIDEO, &device_state);
1634                 g_print("get result 0x%x - video state %d\n", err, device_state);
1635                 return FALSE;
1636         case 'q':
1637                 g_print("\t Quit Camcorder Testsuite!!\n");
1638                 hcamcorder->mode = -1;
1639                 elm_exit();
1640                 return FALSE;
1641         default:
1642                 g_print("\t Invalid media type(%c)\n", media_type);
1643                 return FALSE;
1644         }
1645
1646         if (!init(hcamcorder->mode)) {
1647                 g_print("testsuite init() failed.\n");
1648                 return FALSE;
1649         }
1650
1651         err = recorder_prepare(hcamcorder->recorder);
1652
1653         g_print("recorder_prepare()  : %12.6lfs\n", g_timer_elapsed(timer, NULL));
1654
1655         if (err != RECORDER_ERROR_NONE) {
1656                 g_print("recorder_prepare  = %x\n", err);
1657                 return FALSE;
1658         }
1659
1660         g_get_current_time(&current);
1661         timersub(&current, &previous, &res);
1662
1663         g_print("Recorder Preparing Time  : %ld.%lds\n", res.tv_sec, res.tv_usec);
1664
1665         hcamcorder->menu_state = MENU_STATE_MAIN;
1666
1667         return TRUE;
1668 }
1669
1670
1671 static int app_create(void *data)
1672 {
1673         appdata *app_data = data;
1674         int w = 0;
1675         int h = 0;
1676         Evas_Object *win = NULL;
1677         Evas_Object *eo = NULL;
1678         Evas_Object *bg = NULL;
1679         Evas_Object *rect = NULL;
1680
1681         if (app_data == NULL) {
1682                 g_print("\t\nappdata is NULL\n");
1683                 return 0;
1684         }
1685
1686         /* use gl backend */
1687         elm_config_accel_preference_set("opengl");
1688
1689         win = elm_win_add(NULL, "camera_test", ELM_WIN_BASIC);
1690         if (win) {
1691                 elm_win_title_set(win, "camera_test");
1692                 elm_win_borderless_set(win, EINA_TRUE);
1693                 elm_win_screen_size_get(win, NULL, NULL, &w, &h);
1694                 g_print("\n\tscreen size %dx%d\n\n", w, h);
1695                 evas_object_resize(win, w, h);
1696                 elm_win_autodel_set(win, EINA_TRUE);
1697                 elm_win_alpha_set(win, EINA_TRUE);
1698         } else {
1699                 g_print("\n\tfailed to get window\n\n");
1700                 return 1;
1701         }
1702
1703         bg = elm_bg_add(win);
1704         if (bg) {
1705                 elm_win_resize_object_add(win, bg);
1706                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1707                 evas_object_show(bg);
1708         } else {
1709                 g_print("\n\tfailed to get elm bg\n\n");
1710                 return 1;
1711         }
1712
1713         rect = evas_object_rectangle_add(evas_object_evas_get(win));
1714         if (rect) {
1715                 evas_object_color_set(rect, 0, 0, 0, 0);
1716                 evas_object_render_op_set(rect, EVAS_RENDER_COPY);
1717         } else {
1718                 g_print("\n\tfailed to get rectangle\n\n");
1719                 return 1;
1720         }
1721
1722         elm_win_resize_object_add(win, rect);
1723         evas_object_size_hint_weight_set(rect, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1724         evas_object_show(rect);
1725
1726         /* Create evas image object for EVAS surface */
1727         eo = evas_object_image_add(evas_object_evas_get(win));
1728         evas_object_image_size_set(eo, w, h);
1729         evas_object_image_fill_set(eo, 0, 0, w, h);
1730         evas_object_resize(eo, w, h);
1731         evas_object_show(eo);
1732
1733         elm_win_activate(win);
1734         evas_object_show(win);
1735
1736         app_data->win = win;
1737         app_data->eo = eo;
1738
1739         timer = g_timer_new();
1740         g_timer_reset(timer);
1741
1742         init_handle();
1743
1744         print_menu();
1745
1746         return 0;
1747 }
1748
1749 static int app_terminate(void *data)
1750 {
1751         appdata *app_data = data;
1752
1753         if (app_data == NULL) {
1754                 g_print("\n\tappdata is NULL\n");
1755                 return 0;
1756         }
1757
1758         if (timer) {
1759                 g_timer_stop(timer);
1760                 g_timer_destroy(timer);
1761                 timer = NULL;
1762         }
1763
1764         return 0;
1765 }
1766
1767
1768 /**
1769  * This function is the example main function for mmcamcorder API.
1770  *
1771  * @param
1772  *
1773  * @return  This function returns 0.
1774  * @remark
1775  * @see     other functions
1776  */
1777 int main(int argc, char **argv)
1778 {
1779         int bret;
1780
1781         hcamcorder = (cam_handle_t *)g_malloc0(sizeof(cam_handle_t));
1782         recorder_state = RECORDER_STATE_NONE;
1783
1784         stdin_channel = g_io_channel_unix_new(fileno(stdin));/* read from stdin */
1785         g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)cmd_input, NULL);
1786
1787         memset(&ad, 0x0, sizeof(appdata));
1788         ops.data = &ad;
1789
1790         bret = appcore_efl_main(PACKAGE, &argc, &argv, &ops);
1791
1792         g_print("\n\treturn appcore_efl : %d\n\n", bret);
1793
1794         g_free(hcamcorder);
1795         g_io_channel_unref(stdin_channel);
1796
1797         return bret;
1798 }
1799 /*EOF*/