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