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 Capture - 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                                 hcamcorder->menu_state = MENU_STATE_INIT;
 754                                 print_menu();
 755                                 break;
 756
 757                         default:
 758                                 g_print("\t Invalid input \n");
 759                                 break;
 760                         }
 761                 } else if (recorder_state == RECORDER_STATE_RECORDING || recorder_state == RECORDER_STATE_PAUSED) {
 762                         switch (buf) {
 763                         case 'p': /* Pause Recording */
 764                                 g_print("*Pause!\n");
 765                                 err = recorder_pause(hcamcorder->recorder);
 766
 767                                 if (err < 0)
 768                                         g_print("Rec pause camcorder_pause  = %x\n", err);
 769
 770                                 recorder_state = RECORDER_STATE_PAUSED;
 771                                 break;
 772
 773                         case 'r': /* Resume Recording */
 774                                 g_print("*Resume!\n");
 775                                 err = recorder_start(hcamcorder->recorder);
 776                                 if (err < 0)
 777                                         g_print("Rec start camcorder_record  = %x\n", err);
 778
 779                                 recorder_state = RECORDER_STATE_RECORDING;
 780                                 break;
 781
 782                         case 'c': /* Cancel */
 783                                 g_print("*Cancel Recording !\n");
 784
 785                                 err = recorder_cancel(hcamcorder->recorder);
 786
 787                                 if (err < 0)
 788                                         g_print("Cancel recording camcorder_cancel  = %x\n", err);
 789
 790                                 recorder_state = RECORDER_STATE_NONE;
 791                                 break;
 792
 793                         case 's': /* Save */
 794                                 g_print("*Save Recording!\n");
 795                                 g_timer_reset(timer);
 796
 797                                 err = recorder_commit(hcamcorder->recorder);
 798
 799                                 if (err < 0)
 800                                         g_print("Save recording recorder_commit  = %x\n", err);
 801
 802                                 recorder_state = RECORDER_STATE_NONE;
 803                                 break;
 804
 805                         default:
 806                                 g_print("\t Invalid input \n");
 807                                 break;
 808                         } /* switch */
 809                 } else {
 810                         g_print("Wrong camcorder state, check status!!\n");
 811                 }
 812         } else if (hcamcorder->mode == MODE_AUDIO) {
 813                 if (recorder_state == RECORDER_STATE_NONE) {
 814                         switch (buf) {
 815                         case '1': /*  Start Recording */
 816                                 g_print("*Recording start!\n");
 817                                 hcamcorder->elapsed_time = 0;
 818                                 g_timer_reset(timer);
 819                                 err = recorder_start(hcamcorder->recorder);
 820
 821                                 if (err < 0)
 822                                         g_print("Rec start camcorder_record  = %x\n", err);
 823
 824                                 recorder_state = RECORDER_STATE_RECORDING;
 825                                 break;
 826
 827                         case 'b': /* back */
 828                                 hcamcorder->menu_state = MENU_STATE_INIT;
 829                                 print_menu();
 830                                 break;
 831
 832                         default:
 833                                 g_print("\t Invalid input \n");
 834                                 break;
 835                         }
 836                 } else if (recorder_state == RECORDER_STATE_RECORDING || recorder_state == RECORDER_STATE_PAUSED) {
 837                         switch (buf) {
 838                         case 'p': /* Pause Recording */
 839                                 g_print("*Pause!\n");
 840                                 err = recorder_pause(hcamcorder->recorder);
 841
 842                                 if (err < 0)
 843                                         g_print("Rec pause camcorder_pause  = %x\n", err);
 844
 845                                 recorder_state = RECORDER_STATE_PAUSED;
 846                                 break;
 847
 848                         case 'r': /* Resume Recording */
 849                                 g_print("*Resume!\n");
 850                                 err = recorder_start(hcamcorder->recorder);
 851                                 if (err < 0)
 852                                         g_print("Rec start camcorder_record  = %x\n", err);
 853
 854                                 recorder_state = RECORDER_STATE_RECORDING;
 855                                 break;
 856
 857                         case 'c': /* Cancel */
 858                                 g_print("*Cancel Recording !\n");
 859                                 err = recorder_cancel(hcamcorder->recorder);
 860
 861                                 if (err < 0)
 862                                         g_print("Cancel recording camcorder_cancel  = %x\n", err);
 863
 864                                 recorder_state = RECORDER_STATE_NONE;
 865                                 break;
 866
 867                         case 's': /*  Save */
 868                                 g_print("*Save Recording!\n");
 869                                 g_timer_reset(timer);
 870                                 err = recorder_commit(hcamcorder->recorder);
 871
 872                                 if (err < 0)
 873                                         g_print("Save recording recorder_commit  = %x\n", err);
 874
 875                                 recorder_state = RECORDER_STATE_NONE;
 876                                 break;
 877
 878                         default:
 879                         g_print("\t Invalid input \n");
 880                         break;
 881                         }
 882                 } else {
 883                         g_print("Wrong camcorder state, check status!!\n");
 884                 }
 885         } else {
 886                 g_print("\t Invalid mode, back to upper menu \n");
 887                 hcamcorder->menu_state = MENU_STATE_INIT;
 888                 print_menu();
 889         }
 890 }
 891
 892
 893 static void setting_menu(gchar buf)
 894 {
 895         gboolean bret = FALSE;
 896         int idx = 0;
 897         int min = 0;
 898         int max = 0;
 899         int value = 0;
 900         int err = 0;
 901         int x = 0, y = 0, width = 0, height = 0;
 902
 903         if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
 904                 switch (buf) {
 905                 /* Camera setting */
 906                 case '0':  /* Setting > Preview Resolution setting */
 907                         g_print("*Select the preview resolution!\n");
 908                         resolution_stack resolution_list;
 909                         resolution_list.count = 0;
 910
 911                         recorder_foreach_supported_video_resolution(hcamcorder->recorder,
 912                                 preview_resolution_cb, &resolution_list);
 913
 914                         flush_stdin();
 915                         err = scanf("%d", &idx);
 916                         int result = 0;
 917                         if (resolution_list.count > idx && idx >= 0) {
 918                                 g_print("-----------------PREVIEW RESOLUTION (%dx%d)---------------------\n",
 919                                         resolution_list.width[idx], resolution_list.height[idx]);
 920
 921                                 result = recorder_set_video_resolution(hcamcorder->recorder,
 922                                         resolution_list.width[idx], resolution_list.height[idx]);
 923                         } else {
 924                                 g_print("invalid input %d\n", idx);
 925                                 result = -1;
 926                         }
 927
 928                         resolution_list.count = 0;
 929
 930                         if (result != 0)
 931                                 g_print("FAIL\n");
 932                         else
 933                                 g_print("PASS\n");
 934                         break;
 935
 936                 case '2': /* Setting > Digital zoom level */
 937                         g_print("*Digital zoom level  !\n");
 938
 939                         camera_attr_get_zoom_range(hcamcorder->camera, &min, &max);
 940                         if (min >= max) {
 941                                 g_print("Not supported !! \n");
 942                         } else {
 943                                 flush_stdin();
 944                                 g_print("\n Select  Digital zoom level min %d - max %d\n", min, max);
 945                                 err = scanf("%d", &idx);
 946                                 bret = camera_attr_set_zoom(hcamcorder->camera, idx);
 947                         }
 948                         break;
 949
 950
 951                 case '3': /* Setting > AF mode */
 952
 953                         g_print("*AF mode !\n");
 954                         g_print("\t1. AF Start !\n");
 955                         g_print("\t2. AF Stop !\n\n");
 956
 957                         flush_stdin();
 958                         err = scanf("%d", &idx);
 959                         switch (idx) {
 960                         case 1:
 961                                 camera_start_focusing(hcamcorder->camera, 0);
 962                                 break;
 963                         case 2:
 964                                 camera_cancel_focusing(hcamcorder->camera);
 965                                 break;
 966                         default:
 967                                 g_print("Wrong Input[%d] !! \n", idx);
 968                                 break;
 969                         }
 970
 971                         break;
 972
 973                 case '4': /* Setting > AF scan range */
 974                         g_print("*AF scan range !\n");
 975
 976                         camera_attr_foreach_supported_af_mode(hcamcorder->camera,
 977                                 (camera_attr_supported_af_mode_cb)af_mode_foreach_cb, NULL);
 978
 979                         flush_stdin();
 980                         err = scanf("%d", &idx);
 981                         bret = camera_attr_set_af_mode(hcamcorder->camera, idx);
 982                         break;
 983
 984                 case '5': /* Setting > Exposure mode */
 985                         g_print("* Exposure mode!\n");
 986
 987                         camera_attr_foreach_supported_exposure_mode(hcamcorder->camera,
 988                                 (camera_attr_supported_exposure_mode_cb)exposure_mode_cb, NULL);
 989
 990                         flush_stdin();
 991
 992                         g_print("\n Select  Exposure mode \n");
 993                         err = scanf("%d", &idx);
 994                         bret = camera_attr_set_exposure_mode(hcamcorder->camera, idx);
 995
 996                         break;
 997
 998                 case '6':  /* Setting > Exposure value */
 999                         camera_attr_get_exposure_range(hcamcorder->camera, &min, &max);
1000                         if (min >= max) {
1001                                 g_print("Not supported !! \n");
1002                         } else {
1003
1004                                 flush_stdin();
1005                                 g_print("\n Select  Exposure mode min%d -max %d\n", min, max);
1006                                 err = scanf("%d", &idx);
1007                                 bret = camera_attr_set_exposure(hcamcorder->camera, idx);
1008                         }
1009                         break;
1010
1011                 case '7': /* Setting > F number */
1012                         g_print("Not supported !! \n");
1013                         break;
1014
1015                 case 'i': /* Setting > ISO */
1016                         g_print("*ISO !\n");
1017                         camera_attr_foreach_supported_iso(hcamcorder->camera, iso_mode_cb, NULL);
1018
1019                         flush_stdin();
1020
1021                         err = scanf("%d", &idx);
1022                         bret =  camera_attr_set_iso(hcamcorder->camera, idx);
1023                         break;
1024
1025                 case 'r': /* Setting > Rotate camera input when recording */
1026                         g_print("*Rotate camera input\n");
1027                         camera_attr_foreach_supported_stream_rotation(hcamcorder->camera, camera_rotation_cb, NULL);
1028
1029                         flush_stdin();
1030                         err = scanf("%d", &idx);
1031                         CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera));
1032                         bret = camera_attr_set_stream_rotation(hcamcorder->camera, idx);
1033                         CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera));
1034                         break;
1035
1036                 case 'f': /* Setting > Flip camera input */
1037                         flush_stdin();
1038                         g_print("*Flip camera input\n");
1039                         g_print(" 0. Flip NONE\n");
1040                         g_print(" 1. Flip HORIZONTAL\n");
1041                         g_print(" 2. Flip VERTICAL\n");
1042                         g_print(" 3. Flip BOTH\n");
1043
1044                         err = scanf("%d", &idx);
1045
1046                         CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera));
1047                         camera_attr_set_stream_flip(hcamcorder->camera, idx);
1048                         CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera));
1049                         break;
1050
1051                         /* Display / Filter setting */
1052                 case 'v': /* Display visible */
1053                         g_print("* Display visible setting !\n");
1054
1055                         g_print("\n Select Display visible \n");
1056                         flush_stdin();
1057                         int i;
1058                         for (i = 0; i < 2; i++)
1059                                 g_print("\t %d. %s\n", i+1, visible_mode[i]);
1060
1061                         err = scanf("%d", &value);
1062                         bret = camera_set_display_visible(hcamcorder->camera, idx-1);
1063
1064                         break;
1065
1066
1067                 case 'o': /*  Setting > Display MODe */
1068                         g_print("* Display mode!\n");
1069
1070                         flush_stdin();
1071                         for (i = 1 ; i <= 2  ; i++)
1072                                 g_print("%d. %s\n", i, display_mode[i]);
1073
1074                         err = scanf("%d", &idx);
1075                         bret =  camera_set_display_mode(hcamcorder->camera, idx-1);
1076                         break;
1077
1078                 case 'y': /* Setting > Rotate Display */
1079
1080                         flush_stdin();
1081                         g_print("\n Select Rotate mode\n");
1082                         g_print("\t0. 0\n\t1. 90\n\t2. 180\n\t3. 270\n\n");
1083                         err = scanf("%d", &idx);
1084                         CHECK_MM_ERROR(camera_stop_preview(hcamcorder->camera));
1085                         bret = camera_set_display_rotation(hcamcorder->camera, idx);
1086                         CHECK_MM_ERROR(camera_start_preview(hcamcorder->camera));
1087                         break;
1088
1089                 case 'Y': /* Setting > Flip Display */
1090                         flush_stdin();
1091                         g_print("\n Select Rotate mode\n");
1092                         g_print("\t0. NONE\n\t1. HORIZONTAL\n\t2. VERTICAL\n\t3. BOTH\n\n");
1093                         err = scanf("%d", &idx);
1094                         bret = camera_set_display_flip(hcamcorder->camera, idx);
1095                         break;
1096
1097                 case 'g': /* Setting > Brightness */
1098                         g_print("*Brightness !\n");
1099                         camera_attr_get_brightness_range(hcamcorder->camera, &min, &max);
1100
1101                         flush_stdin();
1102                         g_print("\n Select  brightness min (%d) -max(%d)\n", min, max);
1103                         err = scanf("%d", &idx);
1104                         bret = camera_attr_set_brightness(hcamcorder->camera, idx);
1105                         break;
1106
1107                 case 'c': /* Setting > Contrast */
1108                         g_print("*Contrast !\n");
1109                         camera_attr_get_contrast_range(hcamcorder->camera, &min, &max);
1110
1111                         flush_stdin();
1112                         g_print("\n Select  Contrast min(%d)-max(%d)\n", min, max);
1113                         err = scanf("%d", &idx);
1114                         bret = camera_attr_set_contrast(hcamcorder->camera, idx);
1115                         break;
1116
1117
1118
1119                 case 'w': /* Setting > White balance */
1120                         g_print("*White balance !\n");
1121
1122                         flush_stdin();
1123                         g_print("\n Select White balance \n");
1124                         camera_attr_foreach_supported_whitebalance(hcamcorder->camera, white_balance_cb, NULL);
1125                         err = scanf("%d", &idx);
1126                         bret = camera_attr_set_whitebalance(hcamcorder->camera, idx);
1127                         break;
1128
1129                 case 't': /* Setting > Color tone */
1130                         g_print("*Color tone !\n");
1131                         camera_attr_foreach_supported_effect(hcamcorder->camera, colortone_cb, NULL);
1132
1133                         g_print("\n Select Color tone \n");
1134                         flush_stdin();
1135                         err = scanf("%d", &idx);
1136                         bret = camera_attr_set_effect(hcamcorder->camera, idx);
1137
1138                         break;
1139
1140                 case 'd': /* Setting > WDR */
1141                         g_print("*WDR !\n");
1142
1143                         g_print("\n Select WDR Mode \n");
1144                         flush_stdin();
1145                         for (i = 0; i < 2; i++)
1146                                 g_print("\t %d. %s\n", i+1, wdr_mode[i]);
1147
1148                         err = scanf("%d", &idx);
1149                         if (idx == 1)
1150                                 bret = camera_attr_enable_auto_contrast(hcamcorder->camera, 0);
1151                         else if (idx == 2)
1152                                 bret = camera_attr_enable_auto_contrast(hcamcorder->camera, 1);
1153
1154                         break;
1155
1156                 case 'e': /* Setting > EV program mode */
1157                         g_print("* EV program mode!\n");
1158                         camera_attr_foreach_supported_scene_mode(hcamcorder->camera, program_mode_cb, NULL);
1159
1160                         g_print("\n Select EV program mode \n");
1161                         flush_stdin();
1162                         err = scanf("%d", &idx);
1163                         bret = camera_attr_set_scene_mode(hcamcorder->camera, idx);
1164
1165                         break;
1166
1167                         /* ext. setting */
1168                 case 'z': /* Setting > Strobe setting */
1169                         g_print("*Strobe Mode\n");
1170                         camera_attr_foreach_supported_flash_mode(hcamcorder->camera, strobe_mode_cb, NULL);
1171                         g_print("\n Select Strobe Mode \n");
1172                         flush_stdin();
1173                         err = scanf("%d", &idx);
1174                         bret = camera_attr_set_flash_mode(hcamcorder->camera, idx);
1175
1176                         break;
1177
1178                 case 'l': /* Setting > Face detection setting */
1179                         /* hcamcorder->menu_state = MENU_STATE_SETTING_DETECTION; */
1180                         g_print("* Face detect mode !\n");
1181
1182
1183                         flush_stdin();
1184                         for (i = 0; i < 2; i++)
1185                                 g_print("\t %d. %s \n", i+1, detection_mode[i]);
1186
1187                         err = scanf("%d", &idx);
1188                         if (camera_is_supported_face_detection(hcamcorder->camera)) {
1189                                 if (idx >= 0 && idx < 2)
1190                                         bret = camera_start_face_detection(hcamcorder->camera, _face_detected, NULL);
1191                         } else {
1192                                 g_print("face detection_not supported\n");
1193                         }
1194
1195                         break;
1196
1197                 case 'k': /* Setting > Anti-handshake */
1198                         g_print("*Anti-handshake !\n");
1199
1200                         g_print("\n Select Anti-handshake mode \n");
1201                         flush_stdin();
1202                         for (i = 0; i < 2; i++)
1203                                 g_print("\t %d. %s\n", i+1, ahs_mode[i]);
1204
1205                         err = scanf("%d", &idx);
1206                         bret = camera_attr_enable_anti_shake(hcamcorder->camera, idx-1);
1207
1208                         break;
1209
1210                 case 'K': /* Setting > Video-stabilization */
1211                         g_print("*Video-stabilization !\n");
1212
1213                         g_print("\n Select Video-stabilization mode \n");
1214                         flush_stdin();
1215                         for (i = 0; i < 2; i++)
1216                                 g_print("\t %d. %s\n", i+1, vs_mode[i]);
1217
1218                         err = scanf("%d", &idx);
1219
1220                         if (idx == 2) {
1221                                 g_print("\n Restart preview with NV12 and 720p resolution\n");
1222
1223                                 err = camera_stop_preview(hcamcorder->camera);
1224
1225                                 camera_set_preview_resolution(hcamcorder->camera, 1280, 720);
1226                                 camera_set_preview_format(hcamcorder->camera, CAMERA_PIXEL_FORMAT_NV12);
1227                                 camera_attr_enable_video_stabilization(hcamcorder->camera, idx-1);
1228
1229                                 if (err == 0) {
1230                                         err = camera_start_preview(hcamcorder->camera);
1231
1232                                         if (err != 0)
1233                                                 g_print("\n Restart FAILED! %x\n", err);
1234                                 }
1235                         }
1236                         break;
1237
1238                 case 'u': /* Touch AF area */
1239                         g_print("* Touch AF area !\n");
1240
1241                         flush_stdin();
1242                         g_print("\n Input x,y,width,height \n");
1243                         err = scanf("%d,%d,%d,%d", &x, &y, &width, &height);
1244                         err = camera_attr_set_af_area(hcamcorder->camera, width, height);
1245
1246                         if (err != 0)
1247                                 g_print("Failed to set touch AF area.(%x)\n", err);
1248                         else
1249                                 g_print("Succeed to set touch AF area.\n");
1250
1251                         break;
1252
1253
1254                 case 'M':
1255                         {
1256                                 float motion_rate = 0.0;
1257
1258                                 flush_stdin();
1259
1260                                 g_print("*Camcorder Motion Rate setting! (should be bigger than zero)\n");
1261
1262                                 err = scanf("%f", &motion_rate);
1263                                 err = recorder_attr_set_recording_motion_rate(hcamcorder->recorder, motion_rate);
1264                                 if (err != 0)
1265                                         g_print("Failed to set Camcorder Motion Rate %f [err:0x%x]\n", motion_rate, err);
1266                                 else
1267                                         g_print("Succeed to set Motion Rate %f\n", motion_rate);
1268                         }
1269                         break;
1270
1271                 case 'b': /* back */
1272                         hcamcorder->menu_state = MENU_STATE_MAIN;
1273                         break;
1274
1275                 default:
1276                         g_print("\t Invalid input \n");
1277                         break;
1278                 }
1279         } else {
1280                 g_print("\t Invalid mode, back to upper menu \n");
1281                 hcamcorder->menu_state = MENU_STATE_MAIN;
1282         }
1283
1284         g_print("\t bret : 0x%x \n", bret);
1285 }
1286
1287
1288 /**
1289  * This function is to execute command.
1290  *
1291  * @param    channel [in]    1st parameter
1292  *
1293  * @return   This function returns TRUE/FALSE
1294  * @remark
1295  * @see
1296  */
1297 static gboolean cmd_input(GIOChannel *channel)
1298 {
1299         gchar *buf = NULL;
1300         gsize read_size;
1301         GError *g_error = NULL;
1302
1303         g_print("\n\tENTER\n");
1304
1305         g_io_channel_read_line(channel, &buf, &read_size, NULL, &g_error);
1306         if (g_error) {
1307                 g_print("\n\tg_io_channel_read_chars error\n");
1308                 g_error_free(g_error);
1309                 g_error = NULL;
1310         }
1311
1312         if (buf) {
1313                 g_strstrip(buf);
1314
1315                 g_print("\n\tMenu Status : %d\n", hcamcorder->menu_state);
1316                 switch (hcamcorder->menu_state) {
1317                 case MENU_STATE_INIT:
1318                         mode_change(buf[0]);
1319                         break;
1320                 case MENU_STATE_MAIN:
1321                         main_menu(buf[0]);
1322                         break;
1323                 case MENU_STATE_SETTING:
1324                         setting_menu(buf[0]);
1325                         break;
1326                 default:
1327                         break;
1328                 }
1329
1330                 g_free(buf);
1331                 buf = NULL;
1332
1333                 print_menu();
1334         } else {
1335                 g_print("\n\tNo read input\n");
1336         }
1337
1338         return TRUE;
1339 }
1340
1341 static gboolean init(int type)
1342 {
1343         int err;
1344
1345         if (!hcamcorder)
1346                 return FALSE;
1347
1348         if (!hcamcorder->recorder)
1349                 return FALSE;
1350
1351         /*================================================================================
1352           Video capture mode
1353          *=================================================================================*/
1354         if (type == MODE_VIDEO_CAPTURE) {
1355                 err = recorder_set_file_format(hcamcorder->recorder, RECORDER_FILE_FORMAT_MP4);
1356                 if (err < 0) {
1357                         g_print("Init fail. (%x)\n", err);
1358                         goto ERROR;
1359                 }
1360                 err = recorder_attr_set_audio_device(hcamcorder->recorder, RECORDER_AUDIO_DEVICE_MIC);
1361                 if (err < 0) {
1362                         g_print("Init fail. (%x)\n", err);
1363                         goto ERROR;
1364                 }
1365                 err = recorder_set_audio_encoder(hcamcorder->recorder, RECORDER_AUDIO_CODEC_AAC);
1366                 if (err < 0) {
1367                         g_print("Init fail. (%x)\n", err);
1368                         goto ERROR;
1369                 }
1370                 err = recorder_set_video_encoder(hcamcorder->recorder, RECORDER_VIDEO_CODEC_MPEG4);
1371                 if (err < 0) {
1372                         g_print("Init fail. (%x)\n", err);
1373                         goto ERROR;
1374                 }
1375                 err = recorder_attr_set_video_encoder_bitrate(hcamcorder->recorder, VIDEO_ENCODE_BITRATE);
1376                 if (err < 0) {
1377                         g_print("Init fail. (%x)\n", err);
1378                         goto ERROR;
1379                 }
1380                 err = recorder_attr_set_audio_samplerate(hcamcorder->recorder, AUDIO_SOURCE_SAMPLERATE_AAC);
1381                 if (err < 0) {
1382                         g_print("Init fail. (%x)\n", err);
1383                         goto ERROR;
1384                 }
1385                 err = recorder_attr_set_audio_channel(hcamcorder->recorder, AUDIO_SOURCE_CHANNEL_AAC);
1386                 if (err < 0) {
1387                         g_print("Init fail. (%x)\n", err);
1388                         goto ERROR;
1389                 }
1390                 err = recorder_set_filename(hcamcorder->recorder, TARGET_FILENAME_VIDEO);
1391                 if (err < 0) {
1392                         g_print("Init fail. (%x)\n", err);
1393                         goto ERROR;
1394                 }
1395         } else if (type == MODE_AUDIO) {
1396         /*================================================================================
1397           Audio mode
1398          *=================================================================================*/
1399                 err = recorder_set_file_format(hcamcorder->recorder, RECORDER_FILE_FORMAT_MP4);
1400                 if (err < 0) {
1401                         g_print("Init fail. (%x)\n", err);
1402                         goto ERROR;
1403                 }
1404                 err = recorder_attr_set_audio_device(hcamcorder->recorder, RECORDER_AUDIO_DEVICE_MIC);
1405                 if (err < 0) {
1406                         g_print("Init fail. (%x)\n", err);
1407                         goto ERROR;
1408                 }
1409                 err = recorder_set_audio_encoder(hcamcorder->recorder, RECORDER_AUDIO_CODEC_AAC);
1410                 if (err < 0) {
1411                         g_print("Init fail. (%x)\n", err);
1412                         goto ERROR;
1413                 }
1414                 err = recorder_attr_set_audio_samplerate(hcamcorder->recorder, AUDIO_SOURCE_SAMPLERATE_AAC);
1415                 if (err < 0) {
1416                         g_print("Init fail. (%x)\n", err);
1417                         goto ERROR;
1418                 }
1419                 err = recorder_attr_set_audio_channel(hcamcorder->recorder, AUDIO_SOURCE_CHANNEL_AAC);
1420                 if (err < 0) {
1421                         g_print("Init fail. (%x)\n", err);
1422                         goto ERROR;
1423                 }
1424                 err = recorder_set_filename(hcamcorder->recorder, TARGET_FILENAME_AUDIO);
1425                 if (err < 0) {
1426                         g_print("Init fail. (%x)\n", err);
1427                         goto ERROR;
1428                 }
1429                 err = recorder_attr_set_time_limit(hcamcorder->recorder, 360000);
1430                 if (err < 0) {
1431                         g_print("Init fail. (%x)\n", err);
1432                         goto ERROR;
1433                 }
1434                 err = recorder_attr_set_audio_encoder_bitrate(hcamcorder->recorder, 128000);
1435                 if (err < 0) {
1436                         g_print("Init fail. (%x)\n", err);
1437                         goto ERROR;
1438                 }
1439         }
1440
1441         recorder_set_error_cb(hcamcorder->recorder, _recorder_error_cb, NULL);
1442         recorder_set_state_changed_cb(hcamcorder->recorder, _state_changed_cb, NULL);
1443         recorder_set_recording_status_cb(hcamcorder->recorder, _recording_status_cb, NULL);
1444         recorder_set_recording_limit_reached_cb(hcamcorder->recorder, _recording_limit_reached_cb, NULL);
1445
1446         g_print("Init DONE.\n");
1447
1448         return TRUE;
1449
1450 ERROR:
1451         g_print("init failed.\n");
1452         return FALSE;
1453 }
1454
1455 static gboolean init_handle()
1456 {
1457         hcamcorder->mode = MODE_VIDEO_CAPTURE;  /* image(capture)/video(recording) mode */
1458         hcamcorder->menu_state = MENU_STATE_INIT;
1459         hcamcorder->isMute = FALSE;
1460         hcamcorder->elapsed_time = 0;
1461         hcamcorder->fps = SRC_VIDEO_FRAME_RATE_15; /*SRC_VIDEO_FRAME_RATE_30;*/
1462
1463         return TRUE;
1464 }
1465
1466
1467 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)
1468 {
1469         g_print("focus changed : reason %d\n", reason_for_change);
1470         return;
1471 }
1472
1473 /**
1474  * This function is to change camcorder mode.
1475  *
1476  * @param    buf    [in]    user input
1477  *
1478  * @return   This function returns TRUE/FALSE
1479  * @remark
1480  * @see      other functions
1481  */
1482 static gboolean mode_change(gchar buf)
1483 {
1484         int err = RECORDER_ERROR_NONE;
1485         int state = RECORDER_STATE_NONE;
1486         char media_type = '\0';
1487         bool check = FALSE;
1488         recorder_device_state_e device_state = RECORDER_DEVICE_STATE_IDLE;
1489
1490         g_get_current_time(&previous);
1491         g_timer_reset(timer);
1492
1493         if (hcamcorder->recorder) {
1494                 err = recorder_get_state(hcamcorder->recorder, (recorder_state_e*)&state);
1495                 if (state != RECORDER_STATE_NONE) {
1496                         if (state == RECORDER_STATE_RECORDING ||
1497                                         state == RECORDER_STATE_PAUSED) {
1498                                 g_print("recorder_cancel\n");
1499                                 err = recorder_cancel(hcamcorder->recorder);
1500                                 if (err != RECORDER_ERROR_NONE) {
1501                                         g_print("exit recorder_cancel failed 0x%x\n", err);
1502                                         return FALSE;
1503                                 }
1504                         }
1505
1506                         err = recorder_get_state(hcamcorder->recorder, (recorder_state_e*)&state);
1507                         if (state == RECORDER_STATE_READY) {
1508                                 g_print("recorder_unprepare\n");
1509                                 recorder_unprepare(hcamcorder->recorder);
1510                         }
1511
1512                         err = recorder_get_state(hcamcorder->recorder, (recorder_state_e*)&state);
1513                         if (state == RECORDER_STATE_CREATED) {
1514                                 g_print("recorder_destroy\n");
1515                                 err = recorder_destroy(hcamcorder->recorder);
1516                                 if (err == RECORDER_ERROR_NONE) {
1517                                         g_print("recorder_destroy done\n");
1518                                         hcamcorder->recorder = NULL;
1519                                 }
1520                         }
1521                 }
1522         }
1523
1524         init_handle();
1525
1526         switch (buf) {
1527         case '1':
1528                 hcamcorder->mode = MODE_VIDEO_CAPTURE;
1529
1530                 g_print("camera_create\n");
1531
1532                 err = camera_create(CAMERA_DEVICE_CAMERA0, &hcamcorder->camera);
1533                 if (err != CAMERA_ERROR_NONE) {
1534                         g_print("camera create failed 0x%d\n", err);
1535                         return FALSE;
1536                 }
1537
1538                 err = camera_set_display(hcamcorder->camera, CAMERA_DISPLAY_TYPE_OVERLAY, GET_DISPLAY(ad.win));
1539                 if (err != CAMERA_ERROR_NONE) {
1540                         g_print("set display failed 0x%d\n", err);
1541                         camera_destroy(hcamcorder->camera);
1542                         hcamcorder->camera = NULL;
1543                         return FALSE;
1544                 }
1545
1546                 err = camera_start_preview(hcamcorder->camera);
1547                 if (err != CAMERA_ERROR_NONE) {
1548                         g_print("start preview failed 0x%d\n", err);
1549                         camera_destroy(hcamcorder->camera);
1550                         hcamcorder->camera = NULL;
1551                         return FALSE;
1552                 }
1553
1554                 err = recorder_create_videorecorder(hcamcorder->camera, &hcamcorder->recorder);
1555                 if (err != RECORDER_ERROR_NONE) {
1556                         g_print("video recorder create failed 0x%d\n", err);
1557                         camera_stop_preview(hcamcorder->camera);
1558                         camera_destroy(hcamcorder->camera);
1559                         hcamcorder->camera = NULL;
1560                         return FALSE;
1561                 }
1562
1563                 check = TRUE;
1564                 break;
1565         case '2':
1566                 hcamcorder->mode = MODE_AUDIO;
1567                 err = recorder_create_audiorecorder(&hcamcorder->recorder);
1568                 if (err != RECORDER_ERROR_NONE) {
1569                         g_print("audio recorder create failed 0x%x\n", err);
1570                         return FALSE;
1571                 }
1572
1573                 {
1574                         sound_stream_info_h stream_info = NULL;
1575
1576                         sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, _sound_stream_focus_state_changed_cb, hcamcorder, &stream_info);
1577                         if (stream_info) {
1578                                 recorder_set_sound_stream_info(hcamcorder->recorder, stream_info);
1579                                 sound_manager_destroy_stream_information(stream_info);
1580                         }
1581                 }
1582
1583                 err = recorder_attr_set_audio_device(hcamcorder->recorder, RECORDER_AUDIO_DEVICE_MIC);
1584                 if (err != RECORDER_ERROR_NONE) {
1585                         g_print("set audio device failed 0x%x\n", err);
1586                         recorder_destroy(hcamcorder->recorder);
1587                         hcamcorder->recorder = NULL;
1588                         return FALSE;
1589                 }
1590
1591                 check = TRUE;
1592                 break;
1593         case '3':
1594                 hcamcorder->mode = MODE_AUDIO;
1595                 err = recorder_create_audiorecorder(&hcamcorder->recorder);
1596                 if (err != RECORDER_ERROR_NONE) {
1597                         g_print("audio recorder create failed 0x%d\n", err);
1598                         return FALSE;
1599                 }
1600
1601                 err = recorder_attr_set_audio_device(hcamcorder->recorder, RECORDER_AUDIO_DEVICE_MODEM);
1602                 if (err != RECORDER_ERROR_NONE) {
1603                         g_print("set audio device failed 0x%d\n", err);
1604                         recorder_destroy(hcamcorder->recorder);
1605                         hcamcorder->recorder = NULL;
1606                         return FALSE;
1607                 }
1608
1609                 check = TRUE;
1610                 break;
1611         case '4':
1612                 err = recorder_add_device_state_changed_cb(_recorder_device_state_changed_cb,
1613                         NULL, &g_recorder_device_changed_cb_id);
1614                 g_print("add result 0x%x - cb id %d\n", err, g_recorder_device_changed_cb_id);
1615                 return FALSE;
1616         case '5':
1617                 if (g_recorder_device_changed_cb_id > 0) {
1618                         err = recorder_remove_device_state_changed_cb(g_recorder_device_changed_cb_id);
1619                         g_recorder_device_changed_cb_id = 0;
1620                         g_print("remove result 0x%x\n", err);
1621                 } else {
1622                         g_print("invalid callback id %d\n", g_recorder_device_changed_cb_id);
1623                 }
1624                 return FALSE;
1625         case '6':
1626                 err = recorder_get_device_state(RECORDER_TYPE_AUDIO, &device_state);
1627                 g_print("get result 0x%x - audio state %d\n", err, device_state);
1628                 err = recorder_get_device_state(RECORDER_TYPE_VIDEO, &device_state);
1629                 g_print("get result 0x%x - video state %d\n", err, device_state);
1630                 return FALSE;
1631         case 'q':
1632                 g_print("\t Quit Camcorder Testsuite!!\n");
1633                 hcamcorder->mode = -1;
1634                 elm_exit();
1635                 return FALSE;
1636         default:
1637                 g_print("\t Invalid media type(%c)\n", media_type);
1638                 return FALSE;
1639         }
1640
1641         if (!init(hcamcorder->mode)) {
1642                 g_print("testsuite init() failed.\n");
1643                 return FALSE;
1644         }
1645
1646         err = recorder_prepare(hcamcorder->recorder);
1647
1648         g_print("recorder_prepare()  : %12.6lfs\n", g_timer_elapsed(timer, NULL));
1649
1650         if (err != RECORDER_ERROR_NONE) {
1651                 g_print("recorder_prepare  = %x\n", err);
1652                 return FALSE;
1653         }
1654
1655         g_get_current_time(&current);
1656         timersub(&current, &previous, &res);
1657
1658         g_print("Recorder Preparing Time  : %ld.%lds\n", res.tv_sec, res.tv_usec);
1659
1660         hcamcorder->menu_state = MENU_STATE_MAIN;
1661
1662         return TRUE;
1663 }
1664
1665
1666 static int app_create(void *data)
1667 {
1668         appdata *app_data = data;
1669         int w = 0;
1670         int h = 0;
1671         Evas_Object *win = NULL;
1672         Evas_Object *eo = NULL;
1673         Evas_Object *bg = NULL;
1674         Evas_Object *rect = NULL;
1675
1676         if (app_data == NULL) {
1677                 g_print("\t\nappdata is NULL\n");
1678                 return 0;
1679         }
1680
1681         /* use gl backend */
1682         elm_config_accel_preference_set("opengl");
1683
1684         win = elm_win_add(NULL, "camera_test", ELM_WIN_BASIC);
1685         if (win) {
1686                 elm_win_title_set(win, "camera_test");
1687                 elm_win_borderless_set(win, EINA_TRUE);
1688                 elm_win_screen_size_get(win, NULL, NULL, &w, &h);
1689                 g_print("\n\tscreen size %dx%d\n\n", w, h);
1690                 evas_object_resize(win, w, h);
1691                 elm_win_autodel_set(win, EINA_TRUE);
1692                 elm_win_alpha_set(win, EINA_TRUE);
1693         } else {
1694                 g_print("\n\tfailed to get window\n\n");
1695                 return 1;
1696         }
1697
1698         bg = elm_bg_add(win);
1699         if (bg) {
1700                 elm_win_resize_object_add(win, bg);
1701                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1702                 evas_object_show(bg);
1703         } else {
1704                 g_print("\n\tfailed to get elm bg\n\n");
1705                 return 1;
1706         }
1707
1708         rect = evas_object_rectangle_add(evas_object_evas_get(win));
1709         if (rect) {
1710                 evas_object_color_set(rect, 0, 0, 0, 0);
1711                 evas_object_render_op_set(rect, EVAS_RENDER_COPY);
1712         } else {
1713                 g_print("\n\tfailed to get rectangle\n\n");
1714                 return 1;
1715         }
1716
1717         elm_win_resize_object_add(win, rect);
1718         evas_object_size_hint_weight_set(rect, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1719         evas_object_show(rect);
1720
1721         /* Create evas image object for EVAS surface */
1722         eo = evas_object_image_add(evas_object_evas_get(win));
1723         evas_object_image_size_set(eo, w, h);
1724         evas_object_image_fill_set(eo, 0, 0, w, h);
1725         evas_object_resize(eo, w, h);
1726         evas_object_show(eo);
1727
1728         elm_win_activate(win);
1729         evas_object_show(win);
1730
1731         app_data->win = win;
1732         app_data->eo = eo;
1733
1734         timer = g_timer_new();
1735         g_timer_reset(timer);
1736
1737         init_handle();
1738
1739         print_menu();
1740
1741         return 0;
1742 }
1743
1744 static int app_terminate(void *data)
1745 {
1746         appdata *app_data = data;
1747
1748         if (app_data == NULL) {
1749                 g_print("\n\tappdata is NULL\n");
1750                 return 0;
1751         }
1752
1753         if (timer) {
1754                 g_timer_stop(timer);
1755                 g_timer_destroy(timer);
1756                 timer = NULL;
1757         }
1758
1759         return 0;
1760 }
1761
1762
1763 /**
1764  * This function is the example main function for mmcamcorder API.
1765  *
1766  * @param
1767  *
1768  * @return  This function returns 0.
1769  * @remark
1770  * @see     other functions
1771  */
1772 int main(int argc, char **argv)
1773 {
1774         int bret;
1775
1776         hcamcorder = (cam_handle_t *)g_malloc0(sizeof(cam_handle_t));
1777         recorder_state = RECORDER_STATE_NONE;
1778
1779         stdin_channel = g_io_channel_unix_new(fileno(stdin));/* read from stdin */
1780         g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)cmd_input, NULL);
1781
1782         memset(&ad, 0x0, sizeof(appdata));
1783         ops.data = &ad;
1784
1785         bret = appcore_efl_main(PACKAGE, &argc, &argv, &ops);
1786
1787         g_print("\n\treturn appcore_efl : %d\n\n", bret);
1788
1789         g_free(hcamcorder);
1790         g_io_channel_unref(stdin_channel);
1791
1792         return bret;
1793 }
1794 /*EOF*/