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