test/mm_camcorder_testsuite.c

   1 /*
   2  * mm_camcorder_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 EDIT HISTORY FOR MODULE
  24         This section contains comments describing changes made to the module.
  25         Notice that changes are listed in reverse chronological order.
  26 when            who                                             what, where, why
  27 ---------       --------------------    ----------------------------------------------------------
  28 10/08/07        soyeon.kang@samsung.com         Created
  29 10/10/07        wh01.cho@samsung.com            Created
  30 12/30/08        jh1979.park@samsung.com         Modified
  31 08/31/11        sc11.lee@samsung.com            Modified (Reorganized for easy look)
  32 */
  33
  34
  35 /*===========================================================================================
  36 |                                                                                                                                                                                       |
  37 |  INCLUDE FILES                                                                                                                                                        |
  38 |                                                                                                                                                                                       |
  39 ========================================================================================== */
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <glib.h>
  43 #include <gst/gst.h>
  44 #include <sys/time.h>
  45 #include <mm_camcorder.h>
  46 #include <mm_camcorder_internal.h>
  47 #include <mm_camcorder_util.h>
  48 #include <gst/interfaces/colorbalance.h>
  49 #include <mm_ta.h>
  50
  51 /*---------------------------------------------------------------------------
  52 |    GLOBAL VARIABLE DEFINITIONS:                                                                                       |
  53 ---------------------------------------------------------------------------*/
  54 #define EXPORT_API __attribute__((__visibility__("default")))
  55
  56 #define PACKAGE "mm_camcorder_testsuite"
  57
  58 GMainLoop       *g_loop;
  59 GIOChannel *stdin_channel;
  60 int resolution_set;
  61 int     g_current_state;
  62 int src_w, src_h;
  63 GstCaps *filtercaps;
  64 bool            isMultishot;
  65 MMCamPreset cam_info;
  66 int mmcamcorder_state;
  67 int mmcamcorder_print_state;
  68 int multishot_num;
  69 static int audio_stream_cb_cnt, video_stream_cb_cnt;
  70 static GTimer *timer = NULL;
  71
  72 /*---------------------------------------------------------------------------
  73 |    GLOBAL CONSTANT DEFINITIONS:                                                                                       |
  74 ---------------------------------------------------------------------------*/
  75
  76
  77 /*---------------------------------------------------------------------------
  78 |    IMPORTED VARIABLE DECLARATIONS:                                                                            |
  79 ---------------------------------------------------------------------------*/
  80
  81
  82 /*---------------------------------------------------------------------------
  83 |    IMPORTED FUNCTION DECLARATIONS:                                                                            |
  84 ---------------------------------------------------------------------------*/
  85
  86
  87 /*---------------------------------------------------------------------------
  88 |    LOCAL #defines:                                                                                                            |
  89 ---------------------------------------------------------------------------*/
  90 #define test_ffmux_mp4
  91
  92 // FULLHD(1080P)
  93 #define SRC_W_1920                                                      1920
  94 #define SRC_H_1080                                                      1080
  95
  96
  97 // 2M
  98 #define SRC_W_1600                                                      1600
  99 #define SRC_H_1200                                                      1200
 100
 101 //VGA
 102 #define SRC_W_640                                                       640
 103 #define SRC_H_480                                                       480
 104
 105 //QVGA
 106 #define SRC_W_320                                                       320                                     // video input width
 107 #define SRC_H_240                                                       240                                             // video input height
 108
 109 //QCIF
 110 #define SRC_W_176                                                       176                                     // video input width
 111 #define SRC_H_144                                                       144                                             // video input height
 112
 113 //QQVGA
 114 #define SRC_W_160                                                       160                                             // video input width
 115 #define SRC_H_120                                                       120                                             // video input heith
 116
 117 //special resolution
 118 #define SRC_W_400                                                       400                                     // video input width
 119 #define SRC_H_300                                                       300                                             // video input height
 120
 121 #define SRC_W_192                                                       192                                     // video input width
 122 #define SRC_H_256                                                       256                                             // video input height
 123
 124 #define SRC_W_144                                                       144                                     // video input width
 125 #define SRC_H_176                                                       176                                             // video input height
 126
 127 #define SRC_W_300                                                       300
 128 #define SRC_W_400                                                       400
 129
 130
 131 #define DISPLAY_X_0                                                     0                                               //for direct FB
 132 #define DISPLAY_Y_0                                                     0                                               //for direct FB
 133
 134 #define DISPLAY_W_320                                           320                                     //for direct FB
 135 #define DISPLAY_H_240                                           240                                             //for direct FB
 136
 137
 138 #define SRC_VIDEO_FRAME_RATE_15         15    // video input frame rate
 139 #define SRC_VIDEO_FRAME_RATE_30         30    // video input frame rate
 140 #define IMAGE_ENC_QUALITY               85    // quality of jpeg
 141 #define IMAGE_CAPTURE_COUNT_STILL       1     // the number of still-shot
 142 #define IMAGE_CAPTURE_COUNT_MULTI       3     // default the number of multi-shot
 143 #define IMAGE_CAPTURE_COUNT_INTERVAL    500   // mili seconds
 144
 145 #define MAX_FILE_SIZE_FOR_MMS           (250 * 1024)
 146
 147 #define EXT_JPEG                        "jpg"
 148 #define EXT_MP4                         "mp4"
 149 #define EXT_3GP                         "3gp"
 150 #define EXT_AMR                         "amr"
 151 #define EXT_MKV                         "mkv"
 152
 153 #define STILL_CAPTURE_FILE_PATH_NAME    "/root/StillshotCapture"
 154 #define MULTI_CAPTURE_FILE_PATH_NAME    "/root/MultishotCapture"
 155 #define TARGET_FILENAME_PATH            "/opt/media/"
 156 #define TARGET_FILENAME_VIDEO           "/opt/media/test_rec_video.3gp"
 157 #define TARGET_FILENAME_AUDIO           "/opt/media/test_rec_audio.amr"
 158 #define CAPTURE_FILENAME_LEN            256
 159
 160 #define AUDIO_SOURCE_SAMPLERATE_AAC     44100
 161 #define AUDIO_SOURCE_SAMPLERATE_AMR     8000
 162 #define AUDIO_SOURCE_FORMAT             MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE
 163 #define AUDIO_SOURCE_CHANNEL_AAC        2
 164 #define AUDIO_SOURCE_CHANNEL_AMR        1
 165
 166 #define DEFAULT_CAM_DEVICE                              MM_VIDEO_DEVICE_CAMERA1
 167
 168 /*
 169  * D E B U G   M E S S A G E
 170  */
 171 #define MMF_DEBUG                       "** (mmcamcorder testsuite) DEBUG: "
 172 #define MMF_ERR                         "** (mmcamcorder testsuite) ERROR: "
 173 #define MMF_INFO                        "** (mmcamcorder testsuite) INFO: "
 174 #define MMF_WARN                        "** (mmcamcorder testsuite) WARNING: "
 175 #define MMF_TIME                        "** (mmcamcorder testsuite) TIME: "
 176
 177 #define CHECK_MM_ERROR(expr) \
 178 do {\
 179         int ret = 0; \
 180         ret = expr; \
 181         if (ret != MM_ERROR_NONE) {\
 182                 printf("[%s:%d] error code : %x \n", __func__, __LINE__, ret); \
 183                 return; \
 184         }\
 185 } while(0)
 186
 187 #define time_msg_t(fmt,arg...)  \
 188 do { \
 189         fprintf(stderr,"\x1b[44m\x1b[37m"MMF_TIME"[%s:%05d]  " fmt ,__func__, __LINE__, ##arg); \
 190         fprintf(stderr,"\x1b[0m\n"); \
 191 } while(0)
 192
 193  #define debug_msg_t(fmt,arg...)\
 194  do { \
 195         fprintf(stderr, MMF_DEBUG"[%s:%05d]  " fmt "\n",__func__, __LINE__, ##arg); \
 196  } while(0)
 197
 198 #define err_msg_t(fmt,arg...)   \
 199 do { \
 200         fprintf(stderr, MMF_ERR"[%s:%05d]  " fmt "\n",__func__, __LINE__, ##arg); \
 201 } while(0)
 202
 203 #define info_msg_t(fmt,arg...)  \
 204 do { \
 205         fprintf(stderr, MMF_INFO"[%s:%05d]  " fmt "\n",__func__, __LINE__, ##arg); \
 206 } while(0)
 207
 208 #define warn_msg_t(fmt,arg...)  \
 209 do { \
 210         fprintf(stderr, MMF_WARN"[%s:%05d]  " fmt "\n",__func__, __LINE__, ##arg); \
 211 } while(0)
 212
 213 #ifndef SAFE_FREE
 214 #define SAFE_FREE(x)       if(x) {g_free(x); x = NULL;}
 215 #endif
 216
 217
 218 GTimeVal previous;
 219 GTimeVal current;
 220 GTimeVal result;
 221 //temp
 222
 223 /**
 224  * Enumerations for command
 225  */
 226 #define SENSOR_WHITEBALANCE_NUM         10
 227 #define SENSOR_COLOR_TONE_NUM                   27
 228 #define SENSOR_FLIP_NUM                         3
 229 #define SENSOR_PROGRAM_MODE_NUM         15
 230 #define SENSOR_FOCUS_NUM                                5
 231 #define SENSOR_INPUT_ROTATION                   6
 232 #define SENSOR_AF_SCAN_NUM                              4
 233 #define SENSOR_ISO_NUM                                  8
 234 #define SENSOR_EXPOSURE_NUM                     9
 235 #define SENSOR_IMAGE_FORMAT                     9
 236
 237
 238 /*---------------------------------------------------------------------------
 239 |    LOCAL CONSTANT DEFINITIONS:                                                                                        |
 240 ---------------------------------------------------------------------------*/
 241 enum
 242 {
 243         MODE_IMAGE,             /* capture mode */
 244         MODE_VIDEO,             /* recording mode */
 245         MODE_AUDIO,             /* audio recording*/
 246         MODE_NUM,
 247 };
 248
 249 enum
 250 {
 251         MENU_STATE_MAIN,
 252         MENU_STATE_SETTING,
 253         MENU_STATE_NUM,
 254 };
 255
 256 /*---------------------------------------------------------------------------
 257 |    LOCAL DATA TYPE DEFINITIONS:                                                                                       |
 258 ---------------------------------------------------------------------------*/
 259 typedef struct _cam_handle
 260 {
 261         MMHandleType camcorder;
 262         int mode;                                                /* image(capture)/video(recording) mode */
 263         bool isMultishot;
 264         int stillshot_count;                    /* total stillshot count */
 265         int multishot_count;                    /* total multishot count */
 266         char *stillshot_filename;               /* stored filename of  stillshot  */
 267         char *multishot_filename;               /* stored filename of  multishot  */
 268         int     menu_state;
 269         int     fps;
 270         bool    isMute;
 271         unsigned int elapsed_time;
 272 } cam_handle_t;
 273
 274 typedef struct _cam_xypair
 275 {
 276         char* attr_subcat_x;
 277         char* attr_subcat_y;
 278         int x;
 279         int y;
 280 } cam_xypair_t;
 281
 282 /*---------------------------------------------------------------------------
 283 |    LOCAL VARIABLE DEFINITIONS:                                                                                        |
 284 ---------------------------------------------------------------------------*/
 285 static cam_handle_t *hcamcorder ;
 286
 287 char *wb[SENSOR_WHITEBALANCE_NUM]={
 288         "None",
 289         "Auto",
 290         "Daylight",
 291         "Cloudy",
 292         "Fluoroscent",
 293         "Incandescent",
 294         "Shade",
 295         "Horizon",
 296         "Flash",
 297         "Custom",
 298 };
 299
 300 char *ct[SENSOR_COLOR_TONE_NUM] = {
 301         "NONE",
 302         "MONO",
 303         "SEPIA",
 304         "NEGATIVE",
 305         "BLUE",
 306         "GREEN",
 307         "AQUA",
 308         "VIOLET",
 309         "ORANGE",
 310         "GRAY",
 311         "RED",
 312         "ANTIQUE",
 313         "WARM",
 314         "PINK",
 315         "YELLOW",
 316         "PURPLE",
 317         "EMBOSS",
 318         "OUTLINE",
 319         "SOLARIZATION_1",
 320         "SOLARIZATION_2",
 321         "SOLARIZATION_3",
 322         "SOLARIZATION_4",
 323         "SKETCH_1",
 324         "SKETCH_2",
 325         "SKETCH_3",
 326         "SKETCH_4",
 327 };
 328
 329 char *flip[SENSOR_FLIP_NUM] = {
 330         "Horizontal",
 331         "Vertical",
 332         "Not flipped",
 333 };
 334
 335 char *program_mode[SENSOR_PROGRAM_MODE_NUM] = {
 336         "NORMAL",
 337         "PORTRAIT",
 338         "LANDSCAPE",
 339         "SPORTS",
 340         "PARTY_N_INDOOR",
 341         "BEACH_N_INDOOR",
 342         "SUNSET",
 343         "DUSK_N_DAWN",
 344         "FALL_COLOR",
 345         "NIGHT_SCENE",
 346         "FIREWORK",
 347         "TEXT",
 348         "SHOW_WINDOW",
 349         "CANDLE_LIGHT",
 350         "BACKLIGHT",
 351 };
 352
 353 char *focus_mode[SENSOR_FOCUS_NUM] = {
 354         "None",
 355         "Pan",
 356         "Auto",
 357         "Manual",
 358         "Touch Auto",
 359 };
 360
 361 char *camera_rotation[SENSOR_INPUT_ROTATION] = {
 362         "None",
 363         "90",
 364         "180",
 365         "270",
 366         "Flip Horizontal",
 367         "Flip Vertical",
 368 };
 369
 370 char *af_scan[SENSOR_AF_SCAN_NUM] = {
 371         "None",
 372         "Normal",
 373         "Macro mode",
 374         "Full mode",
 375 };
 376
 377 char *iso_name[SENSOR_ISO_NUM] = {
 378         "ISO Auto",
 379         "ISO 50",
 380         "ISO 100",
 381         "ISO 200",
 382         "ISO 400",
 383         "ISO 800",
 384         "ISO 1600",
 385         "ISO 3200",
 386 };
 387
 388 char *exposure_mode[SENSOR_EXPOSURE_NUM] = {
 389         "AE off",
 390         "AE all mode",
 391         "AE center 1 mode",
 392         "AE center 2 mode",
 393         "AE center 3 mode",
 394         "AE spot 1 mode",
 395         "AE spot 2 mode",
 396         "AE custom 1 mode",
 397         "AE custom 2 mode",
 398 };
 399
 400 char *image_fmt[SENSOR_IMAGE_FORMAT] = {
 401         "NV12",
 402         "NV12T",
 403         "NV16",
 404         "NV21",
 405         "YUYV",
 406         "UYVY",
 407         "422P",
 408         "I420",
 409         "YV12",
 410 };
 411
 412 char *output_mode[] = {
 413         "Letter Box mode",
 414         "Original Size mode",
 415         "Full Screen mode",
 416         "Cropped Full Screen mode",
 417         "ROI mode",
 418 };
 419
 420 char *rotate_mode[] = {
 421         "0",
 422         "90",
 423         "180",
 424         "270",
 425         "Flip Horizontal",
 426         "Flip Vertical",
 427 };
 428
 429 char* strobe_mode[] = {
 430         "Strobe OFF",
 431         "Strobe ON",
 432         "Strobe Auto",
 433         "Strobe RedEyeReduction",
 434         "Strobe SlowSync",
 435         "Strobe FrontCurtain",
 436         "Strobe RearCurtain",
 437         "Strobe Permanent",
 438 };
 439
 440 char *detection_mode[2] = {
 441         "Face Detection OFF",
 442         "Face Detection ON",
 443 };
 444
 445 char *wdr_mode[] = {
 446         "WDR OFF",
 447         "WDR ON",
 448         "WDR AUTO",
 449 };
 450
 451 char *ahs_mode[] = {
 452         "Anti-handshake OFF",
 453         "Anti-handshake ON",
 454         "Anti-handshake AUTO",
 455         "Anti-handshake MOVIE",
 456 };
 457
 458 char *visible_mode[] = {
 459         "Display OFF",
 460         "Display ON",
 461 };
 462
 463 char *camcorder_rotate_val[] = {
 464         "0",
 465         "90",
 466         "180",
 467         "270",
 468 };
 469
 470 /*---------------------------------------------------------------------------
 471 |    LOCAL FUNCTION PROTOTYPES:                                                                                         |
 472 ---------------------------------------------------------------------------*/
 473 static void print_menu();
 474 void  get_me_out();
 475 static gboolean cmd_input(GIOChannel *channel);
 476 //static bool filename_callback (int format, char *filename, void *user_param);
 477 static gboolean msg_callback(int message, void *msg_param, void *user_param);
 478 static gboolean init(int type);
 479 static gboolean mode_change();
 480 int camcordertest_set_attr_int(char* attr_subcategory, int value);
 481
 482
 483 static inline void flush_stdin()
 484 {
 485         int ch;
 486         while((ch=getchar()) != EOF && ch != '\n');
 487 }
 488
 489 void
 490 cam_utils_convert_YUYV_to_UYVY(unsigned char* dst, unsigned char* src, gint length)
 491 {
 492         int i = 0;
 493
 494         //memset dst
 495         memset(dst, 0x00, length);
 496         memcpy(dst, src + 1, length-1);
 497
 498         for ( i = 0 ; i < length; i ++)
 499         {
 500                 if ( !(i % 2) )
 501                 {
 502                         dst[i+1] = src[i];
 503                 }
 504         }
 505 }
 506
 507 static int camcordertest_audio_stream_cb(MMCamcorderAudioStreamDataType *stream, void *user_param)
 508 {
 509         if ( (int)(stream->timestamp)/1000 == audio_stream_cb_cnt ) {
 510                 audio_stream_cb_cnt++;
 511                 printf("audio_stream cb is called ( data:%p, format:%d, channel:%d, volume_dB:%f, length:%d, timestamp:%d)\n",  stream->data, stream->format, stream->channel, stream->volume_dB, stream->length, stream->timestamp);
 512         }
 513         return TRUE;
 514 }
 515
 516 static int camcordertest_video_stream_cb(MMCamcorderVideoStreamDataType *stream, void *user_param)
 517 {
 518         if ( (int)(stream->timestamp)/1000 == video_stream_cb_cnt ) {
 519                 video_stream_cb_cnt++;
 520                 printf("video_stream cb is called ( data:%p, format:%d, length:%d, width:%d, height:%d, timestamp:%d)\n",  stream->data, stream->format, stream->length, stream->width, stream->height, stream->timestamp);
 521         }
 522         return TRUE;
 523 }
 524
 525 static int
 526 camcordertest_video_capture_cb(MMCamcorderCaptureDataType *main, MMCamcorderCaptureDataType *thumb, void *data)
 527 {
 528         int nret = 0;
 529         int scrnl_size = 0;
 530         char m_filename[CAPTURE_FILENAME_LEN];
 531         FILE *fp = NULL;
 532         MMCamcorderCaptureDataType *scrnl = NULL;
 533
 534         debug_msg_t("hcamcorder->isMultishot=%d =>1: MULTI, 0: STILL",hcamcorder->isMultishot);
 535
 536         if (main == NULL) {
 537                 warn_msg_t("Capture callback : Main image buffer is NULL!!!");
 538                 return FALSE;
 539         }
 540
 541         if (hcamcorder->isMultishot == TRUE) {
 542                 snprintf(m_filename, CAPTURE_FILENAME_LEN, "%s%03d.jpg",   hcamcorder->multishot_filename,hcamcorder->multishot_count++);
 543         } else {
 544                 snprintf(m_filename, CAPTURE_FILENAME_LEN, "%s%03d.jpg",   hcamcorder->stillshot_filename,hcamcorder->stillshot_count++);
 545         }
 546
 547         debug_msg_t("filename : %s", m_filename);
 548
 549         if (main->format != MM_PIXEL_FORMAT_ENCODED) {
 550                 unsigned int dst_size = 0;
 551                 void *dst = NULL;
 552
 553                 nret = _mmcamcorder_encode_jpeg(main->data, main->width, main->height, main->format,
 554                                                 main->length, 90, &dst, &dst_size);
 555                 if (nret) {
 556                         fp = fopen(m_filename, "w+");
 557                         if (fp == NULL) {
 558                                 printf("FileOPEN error!!\n");
 559                                 warn_msg_t("FileOPEN error!!");
 560                                 return FALSE;
 561                         } else {
 562                                 printf("open success\n");
 563                                 if (fwrite(dst, dst_size, 1, fp) != 1) {
 564                                         printf("File write error!!\n");
 565                                         warn_msg_t("File write error!!");
 566                                         fclose(fp);
 567                                         return FALSE;
 568                                 }
 569                                 printf("write success\n");
 570                         }
 571                         fclose(fp);
 572                         fp = NULL;
 573                 } else {
 574                         printf("Failed to encode YUV(%d) -> JPEG. \n", main->format);
 575                 }
 576
 577                 free(dst);
 578                 dst = NULL;
 579         } else {
 580                 printf("MM_PIXEL_FORMAT_ENCODED main->data=%p main->length=%d, main->width=%d, main->heigtht=%d \n",
 581                        main->data, main->length, main->width, main->height);
 582
 583                 /* main image */
 584                 fp = fopen(m_filename, "w+");
 585                 if (fp == NULL) {
 586                         printf("FileOPEN error!!\n");
 587                         warn_msg_t("FileOPEN error!!");
 588                         return FALSE;
 589                 } else {
 590                         printf("open success\n");
 591                         if (fwrite(main->data, main->length, 1, fp) != 1) {
 592                                 printf("File write error!!\n");
 593                                 warn_msg_t("File write error!!");
 594                                 fclose(fp);
 595                                 return FALSE;
 596                         }
 597                         printf("write success\n");
 598                 }
 599                 fclose(fp);
 600                 fp = NULL;
 601
 602                 /* thumbnail */
 603                 if (thumb != NULL) {
 604                         fp = fopen("./thumbnail.jpg", "w+");
 605                         if (fp == NULL) {
 606                                 printf("FileOPEN error!!\n");
 607                                 warn_msg_t("FileOPEN error!!");
 608                                 return FALSE;
 609                         } else {
 610                                 printf("open success\n");
 611                                 if (fwrite(thumb->data, thumb->length, 1, fp) != 1) {
 612                                         printf("File write error!!\n");
 613                                         warn_msg_t("File write error!!");
 614                                         fclose(fp);
 615                                         return FALSE;
 616                                 }
 617                                 printf("write success\n");
 618                         }
 619                         fclose(fp);
 620                         fp = NULL;
 621                 }
 622
 623                 /* screennail */
 624                 mm_camcorder_get_attributes(hcamcorder->camcorder, NULL,
 625                                             "captured-screennail", &scrnl, &scrnl_size,
 626                                             NULL);
 627                 if (scrnl != NULL) {
 628                         fp = fopen("./screennail.yuv", "w+");
 629                         if (fp == NULL) {
 630                                 printf("FileOPEN error!!\n");
 631                                 warn_msg_t("FileOPEN error!!");
 632                                 return FALSE;
 633                         } else {
 634                                 printf("open success\n");
 635
 636                                 if (fwrite(scrnl->data, scrnl->length, 1, fp) != 1) {
 637                                         printf("File write error!!\n");
 638                                         warn_msg_t("File write error!!");
 639                                         fclose(fp);
 640                                         fp = NULL;
 641                                         return FALSE;
 642                                 }
 643
 644                                 fclose(fp);
 645                                 fp = NULL;
 646
 647                                 printf("write success\n");
 648                         }
 649                 } else {
 650                         printf( "Screennail buffer is NULL.\n" );
 651                 }
 652         }
 653
 654         return TRUE;
 655 }
 656
 657 static gboolean test_idle_capture_start()
 658 {
 659         int err;
 660
 661         if (!hcamcorder->isMultishot)
 662         {
 663                 camcordertest_set_attr_int("capture-format", MM_PIXEL_FORMAT_ENCODED);
 664                 camcordertest_set_attr_int(MMCAM_IMAGE_ENCODER, MM_IMAGE_CODEC_JPEG);
 665         }
 666         else
 667         {
 668 //              camcordertest_set_attr_int("capture-format", MM_PIXEL_FORMAT_I420);
 669                 camcordertest_set_attr_int("capture-format", MM_PIXEL_FORMAT_YUYV);
 670         }
 671
 672         g_timer_reset(timer);
 673         err = mm_camcorder_capture_start(hcamcorder->camcorder);
 674
 675         if (err < 0)
 676         {
 677 //              if(hcamcorder->isMultishot == TRUE)
 678 //                      hcamcorder->isMultishot = FALSE;
 679                 warn_msg_t("Multishot mm_camcorder_capture_start = %x", err);
 680         }
 681         return FALSE;
 682 }
 683
 684 int camcordertest_set_attr_int(char * attr_subcategory, int value)
 685 {
 686         char * err_attr_name = NULL;
 687         int err;
 688
 689         if (hcamcorder)
 690         {
 691                 if (hcamcorder->camcorder)
 692                 {
 693                         debug_msg_t("camcordertest_set_attr_int(%s, %d)", attr_subcategory, value);
 694
 695                         err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
 696                                                                                                 attr_subcategory, value,
 697                                                                                                 NULL);
 698                         if (err < 0)
 699                         {
 700                                 err_msg_t("camcordertest_set_attr_int : Error(%s:%x)!!!!!!!", err_attr_name, err);
 701                                 SAFE_FREE (err_attr_name);
 702                                 return FALSE;
 703                         }
 704
 705                         //success
 706                         return TRUE;
 707                 }
 708
 709                 debug_msg_t("camcordertest_set_attr_int(!hcamcorder->camcorde)");
 710         }
 711
 712         debug_msg_t("camcordertest_set_attr_int(!hcamcorder)");
 713         return FALSE;
 714
 715 }
 716
 717 int camcordertest_set_attr_xypair(cam_xypair_t pair)
 718 {
 719         char * err_attr_name = NULL;
 720         int err;
 721
 722         if (hcamcorder)
 723         {
 724                 if (hcamcorder->camcorder)
 725                 {
 726                         debug_msg_t("camcordertest_set_attr_xypair((%s, %s), (%d, %d))",  pair.attr_subcat_x, pair.attr_subcat_y, pair.x, pair.y);
 727
 728                         err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
 729                                                                         pair.attr_subcat_x, pair.x,
 730                                                                         pair.attr_subcat_y, pair.y,
 731                                                                         NULL);
 732                         if (err < 0)
 733                         {
 734                                 err_msg_t("camcordertest_set_attr_xypair : Error(%s:%x)!!", err_attr_name, err);
 735                                 SAFE_FREE (err_attr_name);
 736                                 return FALSE;
 737                         }
 738
 739                         //success
 740                         return TRUE;
 741                 }
 742
 743                 debug_msg_t("camcordertest_set_attr_xypair(!hcamcorder->camcorde)");
 744         }
 745
 746         debug_msg_t("camcordertest_set_attr_xypair(!hcamcorder)");
 747         return FALSE;
 748 }
 749
 750 int camcordertest_get_attr_valid_intarray(char * attr_name, int ** array, int *count)
 751 {
 752         MMCamAttrsInfo info;
 753         int err;
 754
 755         if (hcamcorder)
 756         {
 757                 if (hcamcorder->camcorder)
 758                 {
 759                         debug_msg_t("camcordertest_get_attr_valid_intarray((%s),(%p, %p))",  attr_name, array, count);
 760
 761                         err = mm_camcorder_get_attribute_info(hcamcorder->camcorder, attr_name, &info);
 762
 763                         if (err < 0)
 764                         {
 765                                 err_msg_t("camcordertest_get_attr_valid_intarray : Error(%x)!!",  err);
 766                                 return FALSE;
 767                         }
 768                         else
 769                         {
 770                                 if (info.type == MM_CAM_ATTRS_TYPE_INT)
 771                                         if (info.validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_ARRAY)
 772                                         {
 773                                                 *array = info.int_array.array;
 774                                                 *count = info.int_array.count;
 775                                                 return TRUE;
 776                                         }
 777
 778                                 err_msg_t("camcordertest_get_attr_valid_intarray : Type mismatched!!");
 779                                 return FALSE;
 780                         }
 781                         //success
 782                 }
 783
 784                 debug_msg_t("camcordertest_get_attr_valid_intarray(!hcamcorder->camcorde)");
 785         }
 786
 787         debug_msg_t("camcordertest_get_attr_valid_intarray(!hcamcorder)");
 788         return FALSE;
 789 }
 790
 791 int camcordertest_get_attr_valid_intrange(char * attr_name, int *min, int *max)
 792 {
 793         MMCamAttrsInfo info;
 794         int err;
 795
 796         if (hcamcorder)
 797         {
 798                 if (hcamcorder->camcorder)
 799                 {
 800                         debug_msg_t("camcordertest_get_attr_valid_intarray((%s),(%p, %p))",  attr_name, min, max);
 801
 802                         err = mm_camcorder_get_attribute_info(hcamcorder->camcorder, attr_name, &info);
 803
 804                         if (err < 0)
 805                         {
 806                                 err_msg_t("camcordertest_get_attr_valid_intarray : Error(%x)!!",  err);
 807                                 return FALSE;
 808                         }
 809                         else
 810                         {
 811                                 if (info.type == MM_CAM_ATTRS_TYPE_INT)
 812                                         if (info.validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_RANGE)
 813                                         {
 814                                                 *min = info.int_range.min;
 815                                                 *max = info.int_range.max;
 816                                                 return TRUE;
 817                                         }
 818
 819                                 err_msg_t("camcordertest_get_attr_valid_intarray : Type mismatched!!");
 820                                 return FALSE;
 821                         }
 822                         //success
 823
 824                 }
 825
 826                 debug_msg_t("camcordertest_get_attr_valid_intarray(!hcamcorder->camcorde)");
 827         }
 828
 829         debug_msg_t("camcordertest_get_attr_valid_intarray(!hcamcorder)");
 830         return FALSE;
 831 }
 832
 833
 834 void  get_me_out()
 835 {
 836         mm_camcorder_capture_stop(hcamcorder->camcorder);
 837 }
 838
 839 static void print_menu()
 840 {
 841         switch(hcamcorder->menu_state)
 842         {
 843                 case MENU_STATE_MAIN:
 844                         if (hcamcorder->mode == MODE_IMAGE)
 845                         {
 846                                 g_print("\n\t=======================================\n");
 847                                 if ( cam_info.videodev_type == MM_VIDEO_DEVICE_CAMERA1 )
 848                                         g_print("\t   Image Capture (Front camera)\n");
 849                                 else if(  cam_info.videodev_type == MM_VIDEO_DEVICE_CAMERA0 )
 850                                         g_print("\t   Image Capture (Rear camera)\n");
 851                                 g_print("\t=======================================\n");
 852                                 g_print("\t   '1' Take a photo\n");
 853                                 g_print("\t   '2' Setting\n");
 854                                 g_print("\t   '3' Print FPS\n");
 855                                 g_print("\t   'b' back\n");
 856                                 g_print("\t=======================================\n");
 857                         }
 858                         else if (hcamcorder->mode == MODE_VIDEO)
 859                         {
 860                                 g_print("\n\t=======================================\n");
 861                                 if ( cam_info.videodev_type == MM_VIDEO_DEVICE_CAMERA1 )
 862                                         g_print("\t   Video Recording (Front camera)\n");
 863                                 else if(  cam_info.videodev_type == MM_VIDEO_DEVICE_CAMERA0 )
 864                                         g_print("\t   Video Recording (Rear camera)\n");
 865                                 g_print("\t=======================================\n");
 866
 867                                 if(mmcamcorder_print_state <= MM_CAMCORDER_STATE_PREPARE) {
 868                                         g_print("\t   '1' Start Recording\n");
 869                                         g_print("\t   '2' Setting\n");
 870                                         g_print("\t   '3' Print FPS\n");
 871                                         g_print("\t   'b' back\n");
 872                                 }
 873                                 else if(mmcamcorder_print_state == MM_CAMCORDER_STATE_RECORDING) {
 874                                         g_print("\t   'p' Pause Recording\n");
 875                                         g_print("\t   'c' Cancel\n");
 876                                         g_print("\t   's' Save\n");
 877                                 }
 878                                 else if(mmcamcorder_print_state == MM_CAMCORDER_STATE_PAUSED) {
 879                                         g_print("\t   'r' Resume Recording\n");
 880                                         g_print("\t   'c' Cancel\n");
 881                                         g_print("\t   's' Save\n");
 882                                 }
 883                                 g_print("\t=======================================\n");
 884                         }
 885                         else if (hcamcorder->mode == MODE_AUDIO)
 886                         {
 887                                 g_print("\n\t=======================================\n");
 888                                 g_print("\t   Audio Recording\n");
 889                                 g_print("\t=======================================\n");
 890                                 if(mmcamcorder_print_state <= MM_CAMCORDER_STATE_PREPARE) {
 891                                         g_print("\t   '1' Start Recording\n");
 892                                         g_print("\t   'b' back\n");
 893                                 }
 894                                 else if(mmcamcorder_print_state == MM_CAMCORDER_STATE_RECORDING) {
 895                                 g_print("\t   'p' Pause Recording\n");
 896                                 g_print("\t   'c' Cancel\n");
 897                                 g_print("\t   's' Save\n");
 898                                 }
 899                                 else if(mmcamcorder_print_state == MM_CAMCORDER_STATE_PAUSED) {
 900                                         g_print("\t   'r' Resume Recording\n");
 901                                         g_print("\t   'c' Cancel\n");
 902                                         g_print("\t   's' Save\n");
 903                                 }
 904                                 g_print("\t=======================================\n");
 905                         }
 906                         break;
 907
 908                 case MENU_STATE_SETTING:
 909                         if (hcamcorder->mode == MODE_IMAGE) {
 910                                 g_print("\n\t=======================================\n");
 911                                 g_print("\t   Image Capture > Setting\n");
 912                                 g_print("\t=======================================\n");
 913                                 g_print("\t  >>>>>>>>>>>>>>>>>>>>>>>>>>>> [Camera]  \n");
 914                                 g_print("\t     '1' Capture resolution \n");
 915                                 g_print("\t     '2' Digital zoom level \n");
 916                                 g_print("\t     '3' Optical zoom level \n");
 917                                 g_print("\t     '4' AF mode \n");
 918                                 g_print("\t     '5' AF scan range \n");
 919                                 g_print("\t     '6' Exposure mode \n");
 920                                 g_print("\t     '7' Exposure value \n");
 921                                 g_print("\t     '8' F number \n");
 922                                 g_print("\t     '9' Shutter speed \n");
 923                                 g_print("\t     'i' ISO \n");
 924                                 g_print("\t     'r' Rotate camera input \n");
 925                                 g_print("\t     'j' Jpeg quality \n");
 926                                 g_print("\t     'p' Picture format \n");
 927                                 g_print("\t  >>>>>>>>>>>>>>>>>>>> [Display/Filter]\n");
 928                                 g_print("\t     'v' Visible \n");
 929                                 g_print("\t     'o' Output mode \n");
 930                                 g_print("\t     'y' Rotate display \n");
 931                                 g_print("\t     'g' Brightness \n");
 932                                 g_print("\t     'c' Contrast \n");
 933                                 g_print("\t     's' Saturation \n");
 934                                 g_print("\t     'h' Hue \n");
 935                                 g_print("\t     'a' Sharpness \n");
 936                                 g_print("\t     'w' White balance \n");
 937                                 g_print("\t     't' Color tone \n");
 938                                 g_print("\t     'd' WDR \n");
 939                                 g_print("\t     'e' EV program mode \n");
 940                                 g_print("\t  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [etc.]\n");
 941                                 g_print("\t     'z' Strobe (Flash) \n");
 942                                 g_print("\t     'x' Capture mode (Still/Multishot)\n");
 943                                 g_print("\t     'f' Face detection \n");
 944                                 g_print("\t     'k' Anti-handshake \n");
 945                                 g_print("\t     'u' Touch AF area \n");
 946                                 g_print("\t     'm' Stream callback function \n");
 947                                 g_print("\t     'b' back\n");
 948                                 g_print("\t=======================================\n");
 949
 950                         } else if (hcamcorder->mode == MODE_VIDEO) {
 951                                 g_print("\n\t=======================================\n");
 952                                 g_print("\t   Video Recording > Setting\n");
 953                                 g_print("\t=======================================\n");
 954                                 g_print("\t  >>>>>>>>>>>>>>>>>>>>>>>>>>>> [Camera]  \n");
 955                                 g_print("\t     '1' Recording resolution \n");
 956                                 g_print("\t     '2' Digital zoom level \n");
 957                                 g_print("\t     '3' Optical zoom level \n");
 958                                 g_print("\t     '4' AF mode \n");
 959                                 g_print("\t     '5' AF scan range \n");
 960                                 g_print("\t     '6' Exposure mode \n");
 961                                 g_print("\t     '7' Exposure value \n");
 962                                 g_print("\t     '8' F number \n");
 963                                 g_print("\t     'i' ISO \n");
 964                                 g_print("\t     'r' Rotate camera input \n");
 965                                 g_print("\t     'p' FPS \n");
 966                                 g_print("\t  >>>>>>>>>>>>>>>>>>>> [Display/Filter]\n");
 967                                 g_print("\t     'v' Visible \n");
 968                                 g_print("\t     'o' Output mode \n");
 969                                 g_print("\t     'y' Rotate display \n");
 970                                 g_print("\t     'g' Brightness \n");
 971                                 g_print("\t     'c' Contrast \n");
 972                                 g_print("\t     's' Saturation \n");
 973                                 g_print("\t     'h' Hue \n");
 974                                 g_print("\t     'a' Sharpness \n");
 975                                 g_print("\t     'w' White balance \n");
 976                                 g_print("\t     't' Color tone \n");
 977                                 g_print("\t     'd' WDR \n");
 978                                 g_print("\t  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [etc.]\n");
 979                                 g_print("\t     'x' High speed recording\n");
 980                                 g_print("\t     'u' Mute \n");
 981                                 g_print("\t     'z' Strobe (Flash) \n");
 982                                 g_print("\t     'k' Anti-handshake \n");
 983                                 g_print("\t     'e' Camcorder-rotation setting \n");
 984                                 g_print("\t     'm' Stream callback function \n");
 985                                 g_print("\t     'b' back\n");
 986                                 g_print("\t=======================================\n");
 987                         }
 988                         break;
 989
 990                 default:
 991                         warn_msg_t("unknow menu state !!\n");
 992                         break;
 993         }
 994
 995         return;
 996 }
 997
 998 static void main_menu(gchar buf)
 999 {
1000         int err = 0;
1001         int current_fps = 0;
1002         int average_fps = 0;
1003         char *err_attr_name = NULL;
1004         int width = 0, height = 0;
1005
1006         if (hcamcorder->mode == MODE_IMAGE) {
1007                 switch(buf) {
1008                         case '1' : //Capture
1009                                 if(hcamcorder->isMultishot) {
1010                                         err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
1011                                                                                         MMCAM_CAPTURE_WIDTH, 640,
1012                                                                                         MMCAM_CAPTURE_HEIGHT, 480,
1013                                                                                         MMCAM_CAPTURE_COUNT, multishot_num,
1014                                                                                         MMCAM_CAPTURE_INTERVAL, IMAGE_CAPTURE_COUNT_INTERVAL,
1015                                                                                         NULL);
1016                                         if (err < 0) {
1017                                                 err_msg_t("Attribute setting fail : (%s:%x)", err_attr_name, err);
1018                                                 SAFE_FREE (err_attr_name);
1019                                         }
1020                                 } else {
1021                                         err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
1022                                                                                         MMCAM_CAPTURE_COUNT, IMAGE_CAPTURE_COUNT_STILL,
1023                                                                                         NULL);
1024                                         if (err < 0) {
1025                                                 err_msg_t("Attribute setting fail : (%s:%x)", err_attr_name, err);
1026                                                 SAFE_FREE (err_attr_name);
1027                                         }
1028                                 }
1029
1030                                 g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, (GSourceFunc)test_idle_capture_start, NULL, NULL);
1031                                 break;
1032
1033                         case '2' : // Setting
1034                                 hcamcorder->menu_state = MENU_STATE_SETTING;
1035                                 break;
1036
1037                         case '3' : // Print frame rate
1038                                 current_fps = _mmcamcorder_video_current_framerate(hcamcorder->camcorder);
1039                                 average_fps = _mmcamcorder_video_average_framerate(hcamcorder->camcorder);
1040                                 g_print("\tVideo Frame Rate[Current : %d.0 fps, Average : %d.0 fps]\n", current_fps, average_fps);
1041                                 break;
1042
1043                         case 'b' : // back
1044                                 hcamcorder->menu_state = MENU_STATE_MAIN;
1045                                 mode_change();
1046                                 break;
1047
1048                         default:
1049                                 g_print("\t Invalid input \n");
1050                                 break;
1051                 }
1052         }
1053         else if (hcamcorder->mode == MODE_VIDEO)
1054         {
1055                 if (mmcamcorder_state == MM_CAMCORDER_STATE_PREPARE) {
1056                         switch(buf) {
1057                                 case '1' : // Start Recording
1058                                         g_print("*Recording start!\n");
1059                                         video_stream_cb_cnt = 0;
1060                                         audio_stream_cb_cnt = 0;
1061
1062                                         mm_camcorder_get_attributes( hcamcorder->camcorder, NULL,
1063                                                                                 MMCAM_CAMERA_WIDTH, &width,
1064                                                                                 MMCAM_CAMERA_HEIGHT, &height,
1065                                                                                 NULL );
1066
1067                                         mm_camcorder_set_attributes( hcamcorder->camcorder, NULL,
1068                                                                                 MMCAM_CAMERA_AF_TOUCH_X, width>>1,
1069                                                                                 MMCAM_CAMERA_AF_TOUCH_Y, height>>1,
1070                                                                                 MMCAM_CAMERA_AF_TOUCH_WIDTH, 30,
1071                                                                                 MMCAM_CAMERA_AF_TOUCH_HEIGHT, 30,
1072                                                                                 NULL );
1073
1074                                         mm_camcorder_start_focusing(hcamcorder->camcorder);
1075
1076                                         g_timer_reset(timer);
1077                                         err = mm_camcorder_record(hcamcorder->camcorder);
1078
1079                                         if (err < 0) {
1080                                                 warn_msg_t("Rec start mm_camcorder_record  = %x", err);
1081                                         }
1082
1083                                         mmcamcorder_print_state = MM_CAMCORDER_STATE_RECORDING;
1084                                         break;
1085
1086                                 case '2' : // Setting
1087                                         hcamcorder->menu_state = MENU_STATE_SETTING;
1088                                         break;
1089
1090                                 case '3' :
1091                                         current_fps = _mmcamcorder_video_current_framerate(hcamcorder->camcorder);
1092                                         average_fps = _mmcamcorder_video_average_framerate(hcamcorder->camcorder);
1093                                         g_print("\tVideo Frame Rate[Current : %d.0 fps, Average : %d.0 fps]\n", current_fps, average_fps);
1094                                         break;
1095
1096                                 case 'b' : // back
1097                                         hcamcorder->menu_state = MENU_STATE_MAIN;
1098                                         mode_change();
1099                                         break;
1100                         }
1101                 } else if (mmcamcorder_state == MM_CAMCORDER_STATE_RECORDING || mmcamcorder_state == MM_CAMCORDER_STATE_PAUSED) {
1102                         switch(buf) {
1103                                 if (mmcamcorder_state == MM_CAMCORDER_STATE_RECORDING) {
1104                                         case 'p'  : // Pause Recording
1105                                                 g_print("*Pause!\n");
1106                                                 err = mm_camcorder_pause(hcamcorder->camcorder);
1107
1108                                                 if (err < 0) {
1109                                                         warn_msg_t("Rec pause mm_camcorder_pause  = %x", err);
1110                                                 }
1111                                                 mmcamcorder_print_state = MM_CAMCORDER_STATE_PAUSED;
1112                                                 break;
1113
1114                                 } else {
1115                                         case 'r'  : // Resume Recording
1116                                                 g_print("*Resume!\n");
1117                                                 err = mm_camcorder_record(hcamcorder->camcorder);
1118                                                 if (err < 0) {
1119                                                         warn_msg_t("Rec start mm_camcorder_record  = %x", err);
1120                                                 }
1121                                                 mmcamcorder_print_state = MM_CAMCORDER_STATE_RECORDING;
1122                                                 break;
1123                                 }
1124
1125                                 case 'c' : // Cancel
1126                                         g_print("*Cancel Recording !\n");
1127
1128                                         err = mm_camcorder_cancel(hcamcorder->camcorder);
1129
1130                                         if (err < 0) {
1131                                                 warn_msg_t("Cancel recording mm_camcorder_cancel  = %x", err);
1132                                         }
1133                                         mmcamcorder_print_state = MM_CAMCORDER_STATE_PREPARE;
1134                                         break;
1135
1136                                 case 's' : // Save
1137                                         g_print("*Save Recording!\n");
1138                                         g_timer_reset(timer);
1139
1140                                         err = mm_camcorder_commit(hcamcorder->camcorder);
1141
1142                                         if (err < 0) {
1143                                                 warn_msg_t("Save recording mm_camcorder_commit  = %x", err);
1144                                         }
1145                                         mmcamcorder_print_state = MM_CAMCORDER_STATE_PREPARE;
1146                                         break;
1147
1148                                 default :
1149                                         g_print("\t Invalid input \n");
1150                                         break;
1151                         } //switch
1152                 } else {
1153                         err_msg_t("Wrong camcorder state, check status!!");
1154                 }
1155         }
1156         else if (hcamcorder->mode == MODE_AUDIO)
1157         {
1158                 if (mmcamcorder_state == MM_CAMCORDER_STATE_PREPARE) {
1159                         switch(buf) {
1160                                 case '1' : //  Start Recording
1161                                         g_print("*Recording start!\n");
1162                                         g_timer_reset(timer);
1163                                         err = mm_camcorder_record(hcamcorder->camcorder);
1164
1165                                         if (err < 0) {
1166                                                 warn_msg_t("Rec start mm_camcorder_record  = %x", err);
1167                                         }
1168                                         mmcamcorder_print_state = MM_CAMCORDER_STATE_RECORDING;
1169                                         break;
1170
1171                                 case 'b' : // back
1172                                                 hcamcorder->menu_state = MENU_STATE_MAIN;
1173                                                 mode_change();
1174                                                 break;
1175
1176                                 default :
1177                                         g_print("\t Invalid input \n");
1178                                         break;
1179                         }
1180                 } else if (mmcamcorder_state == MM_CAMCORDER_STATE_RECORDING || mmcamcorder_state == MM_CAMCORDER_STATE_PAUSED) {
1181                         switch(buf) {
1182                                 if (mmcamcorder_state == MM_CAMCORDER_STATE_RECORDING) {
1183                                         case 'p' : // Pause Recording
1184                                                 g_print("*Pause!\n");
1185                                                 err = mm_camcorder_pause(hcamcorder->camcorder);
1186
1187                                                 if (err < 0)    {
1188                                                         warn_msg_t("Rec pause mm_camcorder_pause  = %x", err);
1189                                                 }
1190                                                 mmcamcorder_print_state = MM_CAMCORDER_STATE_PAUSED;
1191                                                 break;
1192                                 } else {
1193                                         case 'r'  : // Resume Recording
1194                                                 g_print("*Resume!\n");
1195                                                 err = mm_camcorder_record(hcamcorder->camcorder);
1196                                                 if (err < 0) {
1197                                                         warn_msg_t("Rec start mm_camcorder_record  = %x", err);
1198                                                 }
1199                                                 mmcamcorder_print_state = MM_CAMCORDER_STATE_RECORDING;
1200                                                 break;
1201                                 }
1202
1203                                 case 'c' : // Cancel
1204                                         g_print("*Cancel Recording !\n");
1205                                         err = mm_camcorder_cancel(hcamcorder->camcorder);
1206
1207                                         if (err < 0)    {
1208                                                 warn_msg_t("Cancel recording mm_camcorder_cancel  = %x", err);
1209                                         }
1210                                         mmcamcorder_print_state = MM_CAMCORDER_STATE_PREPARE;
1211                                         break;
1212
1213                                 case 's' : //  Save
1214                                         g_print("*Save Recording!\n");
1215                                         g_timer_reset(timer);
1216                                         err = mm_camcorder_commit(hcamcorder->camcorder);
1217
1218                                         if (err < 0)    {
1219                                                 warn_msg_t("Save recording mm_camcorder_commit  = %x", err);
1220                                         }
1221                                         mmcamcorder_print_state = MM_CAMCORDER_STATE_PREPARE;
1222                                         break;
1223
1224                                 default :
1225                                         g_print("\t Invalid input \n");
1226                                         break;
1227                         }
1228                 } else {
1229                         err_msg_t("Wrong camcorder state, check status!!");
1230                 }
1231         }
1232         else {
1233                 g_print("\t Invalid mode, back to upper menu \n");
1234                 hcamcorder->menu_state = MENU_STATE_MAIN;
1235                 mode_change();
1236         }
1237 }
1238
1239
1240 static void setting_menu(gchar buf)
1241 {
1242         gboolean bret = FALSE;
1243         int index=0;
1244         int min = 0;
1245         int max = 0;
1246         int width_count = 0;
1247         int heigh_count = 0;
1248         int i=0;
1249         int count = 0;
1250         int value = 0;
1251         int* array = NULL;
1252         int *width_array = NULL;
1253         int *heigh_array = NULL;
1254         char *err_attr_name = NULL;
1255         cam_xypair_t input_pair;
1256         int err = MM_ERROR_NONE;
1257         int x = 0, y = 0, width = 0, height = 0;
1258         double new_volume = 0.0;
1259         gint error_num=0;
1260
1261         if (hcamcorder->mode == MODE_IMAGE)
1262         {
1263                 switch(buf) {
1264         /* Camera setting */
1265                         case '1' : // Setting > Capture Resolution setting
1266                                 g_print("*Select the resolution!\n");
1267                                 camcordertest_get_attr_valid_intarray("capture-width", &width_array, &width_count);
1268                                 camcordertest_get_attr_valid_intarray("capture-height", &heigh_array, &heigh_count);
1269
1270                                 if(width_count != heigh_count) {
1271                                         err_msg_t("System has wrong information!!");
1272                                 } else if (width_count == 0) {
1273                                         g_print("Not supported!!\n");
1274                                 } else {
1275                                         g_print("\n Select  resolution \n");
1276                                         flush_stdin();
1277
1278                                         for ( i = 0; i < width_count; i++) {
1279                                                 g_print("\t %d. %d*%d\n", i+1, width_array[i], heigh_array[i]);
1280                                         }
1281                                         scanf("%d",&index);
1282
1283                                         if( index > 0 && index <= width_count ) {
1284                                 //Set capture size first
1285                                                 input_pair.attr_subcat_x = "capture-width";
1286                                                 input_pair.attr_subcat_y = "capture-height";
1287                                                 input_pair.x = width_array[index-1];
1288                                                 input_pair.y = heigh_array[index-1];
1289                                                 bret = camcordertest_set_attr_xypair(input_pair);
1290                                         }
1291                                 }
1292                                 break;
1293
1294                         case '2' : // Setting > Digital zoom level
1295                                 g_print("*Digital zoom level  !\n");
1296                                 camcordertest_get_attr_valid_intrange("camera-digital-zoom", &min, &max);
1297
1298                                 if(min >= max) {
1299                                         g_print("Not supported !! \n");
1300                                 } else {
1301                                         flush_stdin();
1302                                         g_print("\n Select  Digital zoom level (%d ~ %d)\n", min, max);
1303                                         scanf("%d",&index);
1304                                         bret = camcordertest_set_attr_int("camera-digital-zoom", index);
1305                                 }
1306                                 break;
1307
1308                         case '3' : // Setting > Optical zoom level
1309                                 g_print("*Optical zoom level  !\n");
1310                                 camcordertest_get_attr_valid_intrange("camera-optical-zoom", &min, &max);
1311
1312                                 if(min >= max) {
1313                                         g_print("Not supported !! \n");
1314                                 } else {
1315                                         flush_stdin();
1316                                         g_print("\n Select  Optical zoom level (%d ~ %d)\n", min, max);
1317                                         scanf("%d",&index);
1318                                         bret = camcordertest_set_attr_int("camera-optical-zoom", index);
1319                                 }
1320                                 break;
1321
1322                         case '4' : // Setting > AF mode
1323                                 g_print("*Focus mode !\n");
1324                                 camcordertest_get_attr_valid_intarray("camera-focus-mode", &array, &count);
1325
1326                                 if(count <= 0) {
1327                                         g_print("Not supported !! \n");
1328                                 } else {
1329                                         g_print("\n Select Focus mode \n");
1330                                         flush_stdin();
1331                                         for ( i = 0; i < count; i++) {
1332                                                 g_print("\t %d. %s\n", array[i], focus_mode[array[i]]);
1333                                         }
1334                                         scanf("%d",&index);
1335                                         bret = camcordertest_set_attr_int("camera-focus-mode", index);
1336                                 }
1337                                 break;
1338
1339                         case '5' : // Setting > AF scan range
1340                                 g_print("*AF scan range !\n");
1341                                 camcordertest_get_attr_valid_intarray("camera-af-scan-range", &array, &count);
1342
1343                                 if(count <= 0) {
1344                                         g_print("Not supported !! \n");
1345                                 } else {
1346                                         g_print("\n Select AF scan range \n");
1347                                         flush_stdin();
1348                                         for ( i = 0; i < count; i++) {
1349                                                 g_print("\t %d. %s\n", array[i], af_scan[array[i]]);
1350                                         }
1351                                         scanf("%d",&index);
1352                                         bret = camcordertest_set_attr_int("camera-af-scan-range", index);
1353
1354                                         if( bret ) {
1355                                                 mm_camcorder_start_focusing(hcamcorder->camcorder);
1356                                         }
1357                                 }
1358                                 break;
1359
1360                         case '6' : // Setting > Exposure mode
1361                                 g_print("* Exposure mode!\n");
1362                                 camcordertest_get_attr_valid_intarray("camera-exposure-mode", &array, &count);
1363
1364                                 if(count <= 0) {
1365                                         g_print("Not supported !! \n");
1366                                 } else {
1367                                         g_print("\n Select  Exposure mode \n");
1368                                         flush_stdin();
1369                                         for ( i = 0; i < count; i++) {
1370                                                 g_print("\t %d. %s\n", array[i], exposure_mode[array[i]]);
1371                                         }
1372                                         scanf("%d",&index);
1373                                         bret = camcordertest_set_attr_int("camera-exposure-mode", index);
1374                                 }
1375                                 break;
1376
1377                         case '7' :  // Setting > Exposure value
1378                                 g_print("*Exposure value  !\n");
1379                                 camcordertest_get_attr_valid_intrange("camera-exposure-value", &min, &max);
1380
1381                                 if(min >= max) {
1382                                         g_print("Not supported !! \n");
1383                                 } else {
1384                                         flush_stdin();
1385                                         g_print("\n Select  Exposure value(%d ~ %d)\n", min, max);
1386                                         scanf("%d",&index);
1387                                         bret = camcordertest_set_attr_int("camera-exposure-value", index);
1388                                 }
1389                                 break;
1390
1391                         case '8' : // Setting > F number
1392                                 g_print("Not supported !! \n");
1393                                 break;
1394
1395                         case '9' : // Setting > Shutter speed
1396                                 g_print("*Shutter speed !\n");
1397                                 camcordertest_get_attr_valid_intarray("camera-shutter-speed", &array, &count);
1398
1399                                 if(count <= 0) {
1400                                         g_print("Not supported !! \n");
1401                                 } else {
1402                                         g_print("\n Select Shutter speed \n");
1403                                         flush_stdin();
1404                                         for ( i = 0; i < count; i++) {
1405                                                 g_print("\t %d. %d \n", i+1, array[i]);
1406                                         }
1407                                         scanf("%d",&index);
1408
1409                                         if( index > 0 && index <= count ) {
1410                                                 bret = camcordertest_set_attr_int("camera-shutter-speed", array[index-1]);
1411                                         }
1412                                 }
1413                                 break;
1414
1415                         case 'i' : // Setting > ISO
1416                                 g_print("*ISO !\n");
1417                                 camcordertest_get_attr_valid_intarray("camera-iso", &array, &count);
1418
1419                                 if(count <= 0) {
1420                                         g_print("Not supported !! \n");
1421                                 } else {
1422                                         g_print("\n Select ISO \n");
1423                                         flush_stdin();
1424                                         for ( i = 0; i < count; i++) {
1425                                                 g_print("\t %d. %s\n", array[i], iso_name[array[i]]);
1426                                         }
1427                                         scanf("%d",&index);
1428                                         bret = camcordertest_set_attr_int("camera-iso", index);
1429                                 }
1430                                 break;
1431
1432                         case 'r' : // Setting > Rotate camera input when recording
1433                                 g_print("*Rotate camera input when recording !\n");
1434                                 camcordertest_get_attr_valid_intarray(MMCAM_CAMERA_ROTATION, &array, &count);
1435
1436                                 if(count <= 0) {
1437                                         g_print("Not supported !! \n");
1438                                 } else {
1439                                         g_print("\n Select Rotate angle of camera \n");
1440                                         flush_stdin();
1441                                         for ( i = 0; i < count; i++) {
1442                                                 g_print("\t %d. %s\n", array[i], camera_rotation[array[i]]);
1443                                         }
1444                                         scanf("%d",&index);
1445                                         bret = camcordertest_set_attr_int(MMCAM_CAMERA_ROTATION, index);
1446                                         CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
1447                                         CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
1448                                         CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
1449                                         CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
1450                                 }
1451                                 break;
1452
1453                         case 'j' : // Setting > Jpeg quality
1454                                 g_print("*Jpeg quality !\n");
1455                                 camcordertest_get_attr_valid_intrange("image-encoder-quality", &min, &max);
1456
1457                                 if(min >= max) {
1458                                         g_print("Not supported !! \n");
1459                                 } else {
1460                                         flush_stdin();
1461                                         g_print("\n Select  Jpeg quality (%d ~ %d)\n", min, max);
1462                                         scanf("%d",&index);
1463                                         bret = camcordertest_set_attr_int("image-encoder-quality", index);
1464                                 }
1465                                 break;
1466
1467                         case 'p' : // Setting > Picture format
1468                                 g_print("* Picture format!\n");
1469                                 camcordertest_get_attr_valid_intarray("camera-format", &array, &count);
1470
1471                                 if(count <= 0) {
1472                                         g_print("Not supported !! \n");
1473                                 } else {
1474                                         g_print("\n Select Picture format \n");
1475                                         flush_stdin();
1476                                         for ( i = 0; i < count; i++) {
1477                                                 g_print("\t %d. %s\n", array[i], image_fmt[array[i]]);
1478                                         }
1479                                         scanf("%d",&index);
1480                                         bret = camcordertest_set_attr_int("camera-format", index);
1481                                         CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
1482                                         CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
1483                                         CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
1484                                         CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
1485                                 }
1486                                 break;
1487
1488                 /* Display / Filter setting */
1489                         case 'v' : // Display visible
1490                                 g_print("* Display visible setting !\n");
1491                                 camcordertest_get_attr_valid_intarray( "display-visible", &array, &count );
1492
1493                                 if( count < 1 ) {
1494                                         g_print("Not supported !! \n");
1495                                 } else {
1496                                         g_print("\n Select Display visible \n");
1497                                         flush_stdin();
1498                                         for ( i = 0; i < count; i++) {
1499                                                 g_print("\t %d. %s\n", array[i], visible_mode[array[i]]);
1500                                         }
1501                                         scanf("%d",&value);
1502                                         bret = camcordertest_set_attr_int( "display-visible", value );
1503                                 }
1504                                 break;
1505
1506                         case 'o' : //  Setting > Output mode
1507                                 g_print("* Output mode!\n");
1508                                 camcordertest_get_attr_valid_intrange("display-geometry-method", &min, &max);
1509
1510                                 if( min > max ) {
1511                                         g_print("Not supported !! \n");
1512                                 } else {
1513                                         flush_stdin();
1514                                         g_print("\n Select Output mode(%d ~ %d)\n", min, max);
1515                                         for( i = min ; i <= max ; i++ ) {
1516                                                 g_print( "%d. %s\n", i, output_mode[i] );
1517                                         }
1518                                         scanf("%d",&index);
1519                                         bret = camcordertest_set_attr_int("display-geometry-method", index);
1520                                 }
1521                                 break;
1522
1523                         case 'y' : // Setting > Rotate Display
1524                                 camcordertest_get_attr_valid_intarray( MMCAM_DISPLAY_ROTATION, &array, &count );
1525
1526                                 if( count <= 0 || count > 256 ) {
1527                                         g_print("Not supported !! \n");
1528                                 } else {
1529                                         flush_stdin();
1530                                         g_print("\n Select Rotation mode\n");
1531                                         for ( i = 0; i < count; i++) {
1532                                                 g_print("\t %d. %s\n", array[i], rotate_mode[array[i]]);
1533                                         }
1534                                         scanf("%d",&index);
1535                                         bret = camcordertest_set_attr_int( MMCAM_DISPLAY_ROTATION, index );
1536                                 }
1537                                 break;
1538
1539                         case 'g' : // Setting > Brightness
1540                                 g_print("*Brightness !\n");
1541                                 camcordertest_get_attr_valid_intrange("filter-brightness", &min, &max);
1542
1543                                 if(min >= max) {
1544                                         g_print("Not supported !! \n");
1545                                 } else {
1546                                         flush_stdin();
1547                                         g_print("\n Select  brightness (%d ~ %d)\n", min, max);
1548                                         scanf("%d",&index);
1549                                         bret = camcordertest_set_attr_int("filter-brightness", index);
1550                                 }
1551                                 break;
1552
1553                         case 'c' : // Setting > Contrast
1554                                 g_print("*Contrast !\n");
1555                                 camcordertest_get_attr_valid_intrange("filter-contrast", &min, &max);
1556
1557                                 if(min >= max) {
1558                                         g_print("Not supported !! \n");
1559                                 } else {
1560                                         flush_stdin();
1561                                         g_print("\n Select  Contrast (%d ~ %d)\n", min, max);
1562                                         scanf("%d",&index);
1563                                         bret = camcordertest_set_attr_int("filter-contrast", index);
1564                                 }
1565                                 break;
1566
1567                         case 's' : // Setting > Saturation
1568                                 g_print("*Saturation !\n");
1569                                 camcordertest_get_attr_valid_intrange("filter-saturation", &min, &max);
1570
1571                                 if(min >= max) {
1572                                         g_print("Not supported !! \n");
1573                                 } else {
1574                                         flush_stdin();
1575                                         g_print("\n Select  Saturation (%d ~ %d)\n", min, max);
1576                                         scanf("%d",&index);
1577                                         bret = camcordertest_set_attr_int("filter-saturation", index);
1578                                 }
1579                                 break;
1580
1581                         case 'h' : // Setting > Hue
1582                                 g_print("*Hue !\n");
1583                                 camcordertest_get_attr_valid_intrange("filter-hue", &min, &max);
1584
1585                                 if(min >= max) {
1586                                         g_print("Not supported !! \n");
1587                                 } else {
1588                                         flush_stdin();
1589                                         g_print("\n Select  Hue (%d ~ %d)\n", min, max);
1590                                         scanf("%d",&index);
1591                                         bret = camcordertest_set_attr_int("filter-hue", index);
1592                                 }
1593                                 break;
1594
1595                         case 'a' : // Setting > Sharpness
1596                                 g_print("*Sharpness !\n");
1597                                 camcordertest_get_attr_valid_intrange("filter-sharpness", &min, &max);
1598
1599                                 if(min >= max) {
1600                                         g_print("Not supported !! \n");
1601                                 } else {
1602                                         flush_stdin();
1603                                         g_print("\n Select  Sharpness (%d ~ %d)\n", min, max);
1604                                         scanf("%d",&index);
1605                                         bret = camcordertest_set_attr_int("filter-sharpness", index);
1606                                 }
1607                                 break;
1608
1609                         case 'w' : // Setting > White balance
1610                                 g_print("*White balance !\n");
1611                                 camcordertest_get_attr_valid_intarray("filter-wb", &array, &count);
1612
1613                                 if(count <= 0) {
1614                                         g_print("Not supported !! \n");
1615                                 } else {
1616                                         flush_stdin();
1617                                         g_print("\n Select White balance \n");
1618                                         for ( i = 0; i < count; i++) {
1619                                                 g_print("\t %d. %s\n", array[i], wb[array[i]]);
1620                                         }
1621                                         scanf("%d",&index);
1622                                         bret = camcordertest_set_attr_int("filter-wb", index);
1623                                 }
1624                                 break;
1625
1626                         case 't' : // Setting > Color tone
1627                                 g_print("*Color tone !\n");
1628                                 camcordertest_get_attr_valid_intarray("filter-color-tone", &array, &count);
1629
1630                                 if(count <= 0) {
1631                                         g_print("Not supported !! \n");
1632                                 } else {
1633                                         g_print("\n Select Color tone \n");
1634                                         flush_stdin();
1635                                         for ( i = 0; i < count; i++) {
1636                                                 g_print("\t %d. %s\n", array[i], ct[array[i]]);
1637                                         }
1638                                         scanf("%d",&index);
1639                                         bret = camcordertest_set_attr_int("filter-color-tone", index);
1640                                 }
1641                                 break;
1642
1643                         case 'd' : // Setting > WDR
1644                                 g_print("*WDR !\n");
1645                                 camcordertest_get_attr_valid_intarray("camera-wdr", &array, &count);
1646
1647                                 if(count <= 0) {
1648                                         g_print("Not supported !! \n");
1649                                 }
1650                                 else {
1651                                         g_print("\n Select WDR Mode \n");
1652                                         flush_stdin();
1653                                         for ( i = 0; i < count; i++) {
1654                                                 g_print("\t %d. %s\n", array[i], wdr_mode[array[i]]);
1655                                         }
1656                                         scanf("%d",&index);
1657                                         bret = camcordertest_set_attr_int("camera-wdr", index);
1658                                 }
1659                                 break;
1660
1661                         case 'e' : // Setting > EV program mode
1662                                 g_print("* EV program mode!\n");
1663                                 camcordertest_get_attr_valid_intarray("filter-scene-mode", &array, &count);
1664
1665                                 if(count <= 0) {
1666                                         g_print("Not supported !! \n");
1667                                 } else {
1668                                         g_print("\n Select EV program mode \n");
1669                                         flush_stdin();
1670                                         for ( i = 0; i < count; i++) {
1671                                                 g_print("\t %d. %s\n", array[i], program_mode[array[i]]);
1672                                         }
1673                                         scanf("%d",&index);
1674                                         bret = camcordertest_set_attr_int("filter-scene-mode", index);
1675                                 }
1676                                 break;
1677
1678                 /* ext. setting */
1679                         case 'z' : // Setting > Strobe setting
1680                                 g_print("*Strobe Mode\n");
1681                                 camcordertest_get_attr_valid_intarray("strobe-mode", &array, &count);
1682                                 if(count <= 0) {
1683                                         g_print("Not supported !! \n");
1684                                 } else {
1685                                         g_print("\n Select Strobe Mode \n");
1686                                         flush_stdin();
1687                                         for ( i = 0; i < count; i++) {
1688                                                 g_print("\t %d. %s\n", array[i], strobe_mode[array[i]]);
1689                                         }
1690                                         scanf("%d",&index);
1691                                         bret = camcordertest_set_attr_int("strobe-mode", index);
1692                                 }
1693                                 break;
1694
1695                         case 'x' : // Setting > Capture mode ,Muitishot?
1696                                 g_print("*Select Capture mode!\n");
1697                                 flush_stdin();
1698                                 g_print(" \n\t1. Stillshot mode\n\t2. Multishot mode \n");
1699                                 scanf("%d",&index);
1700
1701                                 if(index == 1) {
1702                                         g_print("stillshot mode selected and capture callback is set!!!!\n");
1703                                         hcamcorder->isMultishot = FALSE;
1704                                 } else if (index == 2) {
1705                                         g_print("Multilshot mode selected!!\n");
1706
1707                                         index = 0;
1708                                         min = 0;
1709                                         max = 0;
1710
1711                                         camcordertest_get_attr_valid_intrange("capture-count", &min, &max);
1712                                         if(min >= max) {
1713                                                 g_print("Not supported !! \n");
1714                                         } else {
1715                                                 flush_stdin();
1716                                                 //g_print("\n Check Point!!! [Change resolution to 800x480]\n");
1717                                                 g_print("Select  mulitshot number (%d ~ %d)\n", min, max);
1718                                                 scanf("%d",&index);
1719                                                 if( index >= min && index <= max ) {
1720                                                         multishot_num = index;
1721                                                         hcamcorder->isMultishot = TRUE;
1722                                                 } else {
1723                                                         g_print("Wrong input value, Multishot setting failed!!\n");
1724                                                 }
1725                                         }
1726                                 } else {
1727                                         g_print("Wrong input, select again!!\n");
1728                                 }
1729                                 break;
1730
1731                         case 'f' : // Setting > Face detection setting
1732                                 //hcamcorder->menu_state = MENU_STATE_SETTING_DETECTION;
1733                                 g_print("* Face detect mode !\n");
1734
1735                                 camcordertest_get_attr_valid_intarray("detect-mode", &array, &count);
1736                                 if(count <= 0 || count > 256) {
1737                                         g_print("Not supported !! \n");
1738                                 } else {
1739                                         g_print("\n Face detect mode  \n");
1740                                         flush_stdin();
1741                                         for ( i = 0; i < count; i++) {
1742                                                 g_print("\t %d. %s \n", array[i], detection_mode[array[i]]);
1743                                         }
1744                                         scanf("%d",&index);
1745
1746                                         if( index >= 0 && index < count ) {
1747                                                 bret = camcordertest_set_attr_int("detect-mode", array[index]);
1748                                         } else {
1749                                                 g_print("Wrong input value. Try again!!\n");
1750                                                 bret = FALSE;
1751                                         }
1752                                 }
1753                                 break;
1754
1755                         case 'k' : // Setting > Anti-handshake
1756                                 g_print("*Anti-handshake !\n");
1757                                 camcordertest_get_attr_valid_intarray("camera-anti-handshake", &array, &count);
1758
1759                                 if(count <= 0) {
1760                                         g_print("Not supported !! \n");
1761                                 } else {
1762                                         g_print("\n Select Anti-handshake mode \n");
1763                                         flush_stdin();
1764                                         for ( i = 0; i < count; i++) {
1765                                                 g_print("\t %d. %s\n", array[i], ahs_mode[array[i]]);
1766                                         }
1767                                         scanf("%d",&index);
1768                                         bret = camcordertest_set_attr_int("camera-anti-handshake", index);
1769                                 }
1770                                 break;
1771
1772                         case 'u': // Touch AF area
1773                                 g_print("* Touch AF area !\n");
1774                                 camcordertest_get_attr_valid_intrange("camera-af-touch-x", &min, &max);
1775                                 if( max < min ) {
1776                                         g_print( "Not Supported camera-af-touch-x !!\n" );
1777                                         break;
1778                                 }
1779                                 camcordertest_get_attr_valid_intrange("camera-af-touch-y", &min, &max);
1780                                 if( max < min ) {
1781                                         g_print( "Not Supported camera-af-touch-y !!\n" );
1782                                         break;
1783                                 }
1784                                 camcordertest_get_attr_valid_intrange("camera-af-touch-width", &min, &max);
1785                                 if( max < min ) {
1786                                         g_print( "Not Supported camera-af-touch-width !!\n" );
1787                                         break;
1788                                 }
1789                                 camcordertest_get_attr_valid_intrange("camera-af-touch-height", &min, &max);
1790                                 if( max < min ) {
1791                                         g_print( "Not Supported camera-af-touch-height!!\n" );
1792                                         break;
1793                                 }
1794
1795                                 flush_stdin();
1796                                 g_print( "\n Input x,y,width,height \n" );
1797                                 scanf( "%d,%d,%d,%d", &x, &y, &width, &height );
1798                                 err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
1799                                                                                                 MMCAM_CAMERA_AF_TOUCH_X, x,
1800                                                                                                 MMCAM_CAMERA_AF_TOUCH_Y, y,
1801                                                                                                 MMCAM_CAMERA_AF_TOUCH_WIDTH, width,
1802                                                                                                 MMCAM_CAMERA_AF_TOUCH_HEIGHT, height,
1803                                                                                                 NULL);
1804
1805                                 if( err != MM_ERROR_NONE ) {
1806                                         g_print( "Failed to set touch AF area.(%x)(%s)\n", err, err_attr_name );
1807                                         free( err_attr_name );
1808                                         err_attr_name = NULL;
1809                                 } else {
1810                                         g_print( "Succeed to set touch AF area.\n" );
1811                                 }
1812                                 break;
1813
1814                         case 'm' : // Setting > Stream callback function
1815                                 g_print("Not supported !! \n");
1816                                 break;
1817
1818                         case 'b' : // back
1819                                 hcamcorder->menu_state = MENU_STATE_MAIN;
1820                                 break;
1821
1822                         default :
1823                                 g_print("\t Invalid input \n");
1824                                 break;
1825                 }
1826         }
1827         else if(hcamcorder->mode == MODE_VIDEO)
1828         {
1829                 switch(buf)
1830                 {
1831                 /* Camera setting */
1832                         case '1' : // Setting > Recording Resolution
1833                                 g_print("*Select resolution!\n");
1834
1835                                 camcordertest_get_attr_valid_intarray("camera-width", &width_array, &width_count);
1836                                 camcordertest_get_attr_valid_intarray("camera-height", &heigh_array, &heigh_count);
1837
1838                                 if(width_count != heigh_count) {
1839                                         err_msg_t("System has wrong information!!");
1840                                 } else if(width_count == 0) {
1841                                         g_print("Not supported !! \n");
1842                                 } else {
1843                                         g_print("\n Select  the resolution \n");
1844                                         flush_stdin();
1845                                         for ( i = 0; i < width_count; i++) {
1846                                                 g_print("\t %d. %d*%d\n", i+1, width_array[i], heigh_array[i]);
1847                                         }
1848                                         scanf("%d",&index);
1849
1850                                         if( index > 0 && index <= width_count ) {
1851                                                 g_timer_reset(timer);
1852                                                 CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
1853                                                 CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
1854
1855                                                 //Set source size
1856                                                 input_pair.attr_subcat_x = "camera-width";
1857                                                 input_pair.attr_subcat_y = "camera-height";
1858                                                 input_pair.x = width_array[index-1];
1859                                                 input_pair.y = heigh_array[index-1];
1860
1861                                                 bret = camcordertest_set_attr_xypair(input_pair);
1862
1863                                                 CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
1864                                                 CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
1865                                                 time_msg_t("Resolution change  : %12.6lf s", g_timer_elapsed(timer, NULL));
1866                                         } else {
1867                                                 warn_msg_t( "Out of index" );
1868                                         }
1869                                 }
1870                         break;
1871
1872                         case '2' : // Setting > Digital zoom level
1873                                 g_print("*Digital zoom level  !\n");
1874                                 camcordertest_get_attr_valid_intrange("camera-digital-zoom", &min, &max);
1875
1876                                 if(min >= max) {
1877                                         g_print("Not supported !! \n");
1878                                 } else {
1879                                         flush_stdin();
1880                                         g_print("\n Select  Digital zoom level (%d ~ %d)\n", min, max);
1881                                         scanf("%d",&index);
1882                                         bret = camcordertest_set_attr_int("camera-digital-zoom", index);
1883                                 }
1884                                 break;
1885
1886                         case '3' : // Setting > Optical zoom level
1887                                 g_print("*Optical zoom level  !\n");
1888                                 camcordertest_get_attr_valid_intrange("camera-optical-zoom", &min, &max);
1889
1890                                 if(min >= max) {
1891                                         g_print("Not supported !! \n");
1892                                 } else {
1893                                         flush_stdin();
1894                                         g_print("\n Select  Optical zoom level (%d ~ %d)\n", min, max);
1895                                         scanf("%d",&index);
1896                                         bret = camcordertest_set_attr_int("camera-optical-zoom", index);
1897                                 }
1898                                 break;
1899
1900                         case '4' : // Setting > AF mode
1901                                 g_print("*Focus mode !\n");
1902                                 camcordertest_get_attr_valid_intarray("camera-focus-mode", &array, &count);
1903
1904                                 if(count <= 0) {
1905                                         g_print("Not supported !! \n");
1906                                 } else {
1907                                         g_print("\n Select Focus mode \n");
1908                                         flush_stdin();
1909                                         for ( i = 0; i < count; i++) {
1910                                                 g_print("\t %d. %s\n", array[i], focus_mode[array[i]]);
1911                                         }
1912                                         scanf("%d",&index);
1913                                         bret = camcordertest_set_attr_int("camera-focus-mode", index);
1914                                 }
1915                                 break;
1916
1917                         case '5' : // Setting > AF scan range
1918                                 g_print("*AF scan range !\n");
1919                                 camcordertest_get_attr_valid_intarray("camera-af-scan-range", &array, &count);
1920
1921                                 if(count <= 0) {
1922                                         g_print("Not supported !! \n");
1923                                 } else {
1924                                         g_print("\n Select AF scan range \n");
1925                                         flush_stdin();
1926                                         for ( i = 0; i < count; i++) {
1927                                                 g_print("\t %d. %s\n", array[i], af_scan[array[i]]);
1928                                         }
1929                                         scanf("%d",&index);
1930                                         bret = camcordertest_set_attr_int("camera-af-scan-range", index);
1931
1932                                         if( bret ) {
1933                                                 mm_camcorder_start_focusing(hcamcorder->camcorder);
1934                                         }
1935                                 }
1936                                 break;
1937
1938                         case '6' : // Setting > Exposure mode
1939                                 g_print("* Exposure mode!\n");
1940                                 camcordertest_get_attr_valid_intarray("camera-exposure-mode", &array, &count);
1941
1942                                 if(count <= 0) {
1943                                         g_print("Not supported !! \n");
1944                                 } else {
1945                                         g_print("\n Select  Exposure mode \n");
1946                                         flush_stdin();
1947                                         for ( i = 0; i < count; i++) {
1948                                                 g_print("\t %d. %s\n", array[i], exposure_mode[array[i]]);
1949                                         }
1950                                         scanf("%d",&index);
1951                                         bret = camcordertest_set_attr_int("camera-exposure-mode", index);
1952                                 }
1953                                 break;
1954
1955                         case '7' :  // Setting > Exposure value
1956                                 g_print("*Exposure value  !\n");
1957                                 camcordertest_get_attr_valid_intrange("camera-exposure-value", &min, &max);
1958
1959                                 if(min >= max) {
1960                                         g_print("Not supported !! \n");
1961                                 } else {
1962                                         flush_stdin();
1963                                         g_print("\n Select  Exposure value(%d ~ %d)\n", min, max);
1964                                         scanf("%d",&index);
1965                                         bret = camcordertest_set_attr_int("camera-exposure-value", index);
1966                                 }
1967                                 break;
1968
1969                         case '8' : // Setting > F number
1970                                 g_print("Not supported !! \n");
1971                                 break;
1972
1973                         case 'i' : // Setting > ISO
1974                                 g_print("*ISO !\n");
1975                                 camcordertest_get_attr_valid_intarray("camera-iso", &array, &count);
1976
1977                                 if(count <= 0) {
1978                                         g_print("Not supported !! \n");
1979                                 } else {
1980                                         g_print("\n Select ISO \n");
1981                                         flush_stdin();
1982                                         for ( i = 0; i < count; i++) {
1983                                                 g_print("\t %d. %s\n", array[i], iso_name[array[i]]);
1984                                         }
1985                                         scanf("%d",&index);
1986                                         bret = camcordertest_set_attr_int("camera-iso", index);
1987                                 }
1988                                 break;
1989
1990                         case 'r' : // Setting > Rotate camera input when recording
1991                                 g_print("*Rotate camera input !\n");
1992                                 camcordertest_get_attr_valid_intarray(MMCAM_CAMERA_ROTATION, &array, &count);
1993
1994                                 if(count <= 0) {
1995                                         g_print("Not supported !! \n");
1996                                 } else {
1997                                         g_print("\n Select Rotate angle of camera (Do Not use it for recording test !!) \n");
1998                                         flush_stdin();
1999                                         for ( i = 0; i < count; i++) {
2000                                                 g_print("\t %d. %s\n", array[i], camera_rotation[array[i]]);
2001                                         }
2002                                         scanf("%d",&index);
2003
2004                                         CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
2005                                         CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
2006
2007                                         bret = camcordertest_set_attr_int(MMCAM_CAMERA_ROTATION, index);
2008
2009                                         CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
2010                                         CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
2011                                 }
2012                                 break;
2013
2014                         case 'p' : // Setting > FPS
2015                                 g_print("* FPS !\n");
2016
2017                                 camcordertest_get_attr_valid_intarray("camera-fps", &array, &count);
2018
2019                                 if(count <= 0 || count > 256)
2020                                 {
2021                                         g_print("Not supported !! \n");
2022                                 }
2023                                 else
2024                                 {
2025                                         g_print("\n Select  FPS \n");
2026                                         flush_stdin();
2027                                         for ( i = 0; i < count; i++)
2028                                         {
2029                                                 g_print("\t %d. %d \n", i+1, array[i]);
2030                                         }
2031                                         scanf("%d",&index);
2032
2033                                         if( index > 0 && index <= count )
2034                                         {
2035                                                 bret = camcordertest_set_attr_int("camera-fps", array[index-1]);
2036                                                 hcamcorder->fps = array[index-1];
2037                                         }
2038                                         else
2039                                         {
2040                                                 bret = FALSE;
2041                                                 g_print("\n Out of index \n");
2042                                         }
2043                                 }
2044                                 break;
2045
2046                 /* Display / Filter setting */
2047                         case 'v' : // Setting > Display visible
2048                                 g_print("* Display visible setting !\n");
2049                                 camcordertest_get_attr_valid_intarray( "display-visible", &array, &count );
2050
2051                                 if( count < 1 ) {
2052                                         g_print("Not supported !! \n");
2053                                 } else {
2054                                         g_print("\n Select Display visible \n");
2055                                         flush_stdin();
2056                                         for ( i = 0; i < count; i++) {
2057                                                 g_print("\t %d. %s\n", array[i], visible_mode[array[i]]);
2058                                         }
2059                                         scanf("%d",&value);
2060                                         bret = camcordertest_set_attr_int( "display-visible", value );
2061                                 }
2062                                 break;
2063
2064                         case 'o' : // Setting > Output mode
2065                                 g_print("* Output mode!\n");
2066                                 camcordertest_get_attr_valid_intrange("display-geometry-method", &min, &max);
2067
2068                                 if( min > max ) {
2069                                         g_print("Not supported !! \n");
2070                                 } else {
2071                                         flush_stdin();
2072                                         g_print("\n Select Output mode(%d ~ %d)\n", min, max);
2073                                         for( i = min ; i <= max ; i++ ) {
2074                                                 g_print( "%d. %s\n", i, output_mode[i] );
2075                                         }
2076                                         scanf("%d",&index);
2077                                         bret = camcordertest_set_attr_int("display-geometry-method", index);
2078                                 }
2079                                 break;
2080
2081                         case 'y' : // Setting > Rotate Display
2082                                 camcordertest_get_attr_valid_intarray( MMCAM_DISPLAY_ROTATION, &array, &count );
2083
2084                                 if( count <= 0 || count > 256 ) {
2085                                         g_print("Not supported !! \n");
2086                                 } else {
2087                                         flush_stdin();
2088                                         g_print("\n Select Rotation mode\n");
2089                                         for ( i = 0; i < count; i++) {
2090                                                 g_print("\t %d. %s\n", array[i], rotate_mode[array[i]]);
2091                                         }
2092                                         scanf("%d",&index);
2093                                         bret = camcordertest_set_attr_int( MMCAM_DISPLAY_ROTATION, index );
2094                                 }
2095                                 break;
2096
2097                         case 'g' : // Setting > Brightness
2098                                 g_print("*Brightness !\n");
2099                                 camcordertest_get_attr_valid_intrange("filter-brightness", &min, &max);
2100
2101                                 if(min >= max) {
2102                                         g_print("Not supported !! \n");
2103                                 } else {
2104                                         flush_stdin();
2105                                         g_print("\n Select  brightness (%d ~ %d)\n", min, max);
2106                                         scanf("%d",&index);
2107                                         bret = camcordertest_set_attr_int("filter-brightness", index);
2108                                 }
2109                                 break;
2110
2111                         case 'c' : // Setting > Contrast
2112                                 g_print("*Contrast !\n");
2113                                 camcordertest_get_attr_valid_intrange("filter-contrast", &min, &max);
2114
2115                                 if(min >= max) {
2116                                         g_print("Not supported !! \n");
2117                                 } else {
2118                                         flush_stdin();
2119                                         g_print("\n Select  Contrast (%d ~ %d)\n", min, max);
2120                                         scanf("%d",&index);
2121                                         bret = camcordertest_set_attr_int("filter-contrast", index);
2122                                 }
2123                                 break;
2124
2125                         case 's' : // Setting > Saturation
2126                                 g_print("*Saturation !\n");
2127                                 camcordertest_get_attr_valid_intrange("filter-saturation", &min, &max);
2128
2129                                 if(min >= max) {
2130                                         g_print("Not supported !! \n");
2131                                 } else {
2132                                         flush_stdin();
2133                                         g_print("\n Select  Saturation (%d ~ %d)\n", min, max);
2134                                         scanf("%d",&index);
2135                                         bret = camcordertest_set_attr_int("filter-saturation", index);
2136                                 }
2137                                 break;
2138
2139                         case 'h' : // Setting > Hue
2140                                 g_print("*Hue !\n");
2141                                 camcordertest_get_attr_valid_intrange("filter-hue", &min, &max);
2142
2143                                 if(min >= max) {
2144                                         g_print("Not supported !! \n");
2145                                 } else {
2146                                         flush_stdin();
2147                                         g_print("\n Select  Hue (%d ~ %d)\n", min, max);
2148                                         scanf("%d",&index);
2149                                         bret = camcordertest_set_attr_int("filter-hue", index);
2150                                 }
2151                                 break;
2152
2153                         case 'a' : // Setting > Sharpness
2154                                 g_print("*Sharpness !\n");
2155                                 camcordertest_get_attr_valid_intrange("filter-sharpness", &min, &max);
2156
2157                                 if(min >= max) {
2158                                         g_print("Not supported !! \n");
2159                                 } else {
2160                                         flush_stdin();
2161                                         g_print("\n Select  Sharpness (%d ~ %d)\n", min, max);
2162                                         scanf("%d",&index);
2163                                         bret = camcordertest_set_attr_int("filter-sharpness", index);
2164                                 }
2165                                 break;
2166
2167                         case 'w' : // Setting > White balance
2168                                 g_print("*White balance !\n");
2169                                 camcordertest_get_attr_valid_intarray("filter-wb", &array, &count);
2170
2171                                 if(count <= 0) {
2172                                         g_print("Not supported !! \n");
2173                                 } else {
2174                                         flush_stdin();
2175                                         g_print("\n Select White balance \n");
2176                                         for ( i = 0; i < count; i++) {
2177                                                 g_print("\t %d. %s\n", array[i], wb[array[i]]);
2178                                         }
2179                                         scanf("%d",&index);
2180                                         bret = camcordertest_set_attr_int("filter-wb", index);
2181                                 }
2182                                 break;
2183
2184                         case 't' : // Setting > Color tone
2185                                 g_print("*Color tone !\n");
2186                                 camcordertest_get_attr_valid_intarray("filter-color-tone", &array, &count);
2187
2188                                 if(count <= 0) {
2189                                         g_print("Not supported !! \n");
2190                                 } else {
2191                                         g_print("\n Select Color tone \n");
2192                                         flush_stdin();
2193                                         for ( i = 0; i < count; i++) {
2194                                                 g_print("\t %d. %s\n", array[i], ct[array[i]]);
2195                                         }
2196                                         scanf("%d",&index);
2197                                         bret = camcordertest_set_attr_int("filter-color-tone", index);
2198                                 }
2199                                 break;
2200
2201                         case 'd' : // Setting > WDR
2202                                 g_print("*WDR !\n");
2203                                 camcordertest_get_attr_valid_intarray("camera-wdr", &array, &count);
2204
2205                                 if(count <= 0) {
2206                                         g_print("Not supported !! \n");
2207                                 }
2208                                 else {
2209                                         g_print("\n Select WDR Mode \n");
2210                                         flush_stdin();
2211                                         for ( i = 0; i < count; i++) {
2212                                                 g_print("\t %d. %s\n", array[i], wdr_mode[array[i]]);
2213                                         }
2214                                         scanf("%d",&index);
2215                                         bret = camcordertest_set_attr_int("camera-wdr", index);
2216                                 }
2217                                 break;
2218
2219                 /* ext. setting */
2220                         case 'x' : // Setting > High Speed
2221                         {
2222                                 static int backup_width = 0;
2223                                 static int backup_height = 0;
2224
2225                                 g_print("\n Select High Speed Recording mode\n");
2226                                 g_print("\t 1. High Speed Recording mode ON\n");
2227                                 g_print("\t 2. High Speed Recording mode OFF \n");
2228
2229                                 flush_stdin();
2230                                 scanf("%d",&index);
2231                                 if (index == 1) {
2232                                         mm_camcorder_get_attributes(hcamcorder->camcorder, &err_attr_name,
2233                                                                     MMCAM_CAMERA_WIDTH, &backup_width,
2234                                                                     MMCAM_CAMERA_HEIGHT, &backup_height,
2235                                                                     NULL);
2236
2237                                         CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
2238                                         CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
2239
2240                                         err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
2241                                                                           MMCAM_CAMERA_WIDTH, 320,
2242                                                                           MMCAM_CAMERA_HEIGHT, 240,
2243                                                                           MMCAM_CAMERA_FPS, 120,
2244                                                                           "camera-slow-motion-fps", 30,
2245                                                                           NULL);
2246                                         if (err != MM_ERROR_NONE) {
2247                                                 warn_msg_t("High speed recording. mm_camcorder_set_attributes fail. (%s:%x)", err_attr_name, err);
2248                                                 SAFE_FREE(err_attr_name);
2249                                         }
2250
2251                                         CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
2252                                         CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
2253
2254                                 } else if(index == 2) {
2255                                         CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
2256                                         CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
2257
2258                                         if (backup_width && backup_height) {
2259                                                 err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
2260                                                                                   MMCAM_CAMERA_WIDTH, backup_width,
2261                                                                                   MMCAM_CAMERA_HEIGHT, backup_height,
2262                                                                                   NULL);
2263                                                 if (err != MM_ERROR_NONE) {
2264                                                         warn_msg_t("get_attributes fail. (%s:%x)", err_attr_name, err);
2265                                                         SAFE_FREE (err_attr_name);
2266                                                 }
2267                                         }
2268
2269                                         err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
2270                                                                           MMCAM_CAMERA_FPS, SRC_VIDEO_FRAME_RATE_30,
2271                                                                           "camera-slow-motion-fps", 0,
2272                                                                           NULL);
2273                                         if (err != MM_ERROR_NONE) {
2274                                                 warn_msg_t("Normal speed recording. mm_camcorder_set_attributes fail. (%s:%x)", err_attr_name, err);
2275                                                 SAFE_FREE (err_attr_name);
2276                                         }
2277
2278                                         CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
2279                                         CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
2280                                 } else {
2281                                         g_print("Wrong input, Try again!!\n");
2282                                 }
2283                                 break;
2284                         }
2285                         case 'u' : // Setting > Mute
2286                                 g_print("*Mute!(%d)\n", hcamcorder->isMute);
2287
2288                                 if (hcamcorder->isMute) {
2289                                         new_volume = 0.0;
2290                                 } else {
2291                                         new_volume = 1.0;
2292                                 }
2293
2294                                 err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
2295                                                                                 MMCAM_AUDIO_VOLUME, new_volume,
2296                                                                                 NULL);
2297                                 if (err < 0) {
2298                                         warn_msg_t("Can' Mute. mm_camcorder_set_attributes fail. (%s:%x)", err_attr_name, err);
2299                                         SAFE_FREE (err_attr_name);
2300                                 }
2301
2302                                 hcamcorder->isMute = !(hcamcorder->isMute);
2303                                 break;
2304
2305                         case 'z' : // Setting > Strobe setting
2306                                 g_print("*Strobe Mode\n");
2307                                 camcordertest_get_attr_valid_intarray("strobe-mode", &array, &count);
2308                                 if(count <= 0) {
2309                                         g_print("Not supported !! \n");
2310                                 } else {
2311                                         g_print("\n Select Strobe Mode \n");
2312                                         flush_stdin();
2313                                         for ( i = 0; i < count; i++) {
2314                                                 g_print("\t %d. %s\n", array[i], strobe_mode[array[i]]);
2315                                         }
2316                                         scanf("%d",&index);
2317                                         bret = camcordertest_set_attr_int("strobe-mode", index);
2318                                 }
2319                                 break;
2320
2321                         case 'k' : //  Setting > Anti-handshake
2322                                 g_print("*Anti-handshake !\n");
2323                                 camcordertest_get_attr_valid_intarray("camera-anti-handshake", &array, &count);
2324
2325                                 if(count <= 0) {
2326                                         g_print("Not supported !! \n");
2327                                 } else {
2328                                         g_print("\n Select Anti-handshake mode \n");
2329                                         flush_stdin();
2330                                         for ( i = 0; i < count; i++) {
2331                                                 g_print("\t %d. %s\n", array[i], ahs_mode[array[i]]);
2332                                         }
2333                                         scanf("%d",&index);
2334                                         bret = camcordertest_set_attr_int("camera-anti-handshake", index);
2335                                 }
2336                                 break;
2337
2338                         case 'e' : //  Setting > Camcorder-rotation setting
2339                                 g_print("*Camcorder-rotation setting!\n");
2340                                 camcordertest_get_attr_valid_intrange("camcorder-rotation", &min, &max);
2341
2342                                 if(min >= max) {
2343                                         g_print("Not supported !! \n");
2344                                 } else {
2345                                         g_print("\n Select camcorder-rotation value \n");
2346                                         flush_stdin();
2347                                         for ( i = 0; i < (max-min+1); i++) {
2348                                                 g_print("\t %d. %s\n", i, camcorder_rotate_val[i]);
2349                                         }
2350                                         scanf("%d",&index);
2351                                         bret = camcordertest_set_attr_int("camcorder-rotation", index);
2352                                 }
2353                                 break;
2354
2355                         case 'm' : // Setting > Stream callback function
2356                                 g_print("\n Select Stream Callback Function\n");
2357                                 g_print("\t 1. Set Video Stream Callback \n");
2358                                 g_print("\t 2. Set Audio Stream Callback \n");
2359                                 g_print("\t 3. Unset Stream Callback \n");
2360                                 flush_stdin();
2361                                 scanf("%d", &index);
2362                                 if(index == 1) {
2363                                         video_stream_cb_cnt = 0;
2364                                         error_num = mm_camcorder_set_video_stream_callback(hcamcorder->camcorder, (mm_camcorder_video_stream_callback)camcordertest_video_stream_cb, (void*)hcamcorder->camcorder);
2365                                         if( error_num == MM_ERROR_NONE ) {
2366                                                 g_print("\n Setting Success\n");
2367                                         } else {
2368                                                 g_print("\n Setting Failure\n");
2369                                         }
2370                                 } else if(index == 2) {
2371                                         audio_stream_cb_cnt = 0;
2372                                         error_num = mm_camcorder_set_audio_stream_callback(hcamcorder->camcorder, (mm_camcorder_audio_stream_callback)camcordertest_audio_stream_cb, (void*)hcamcorder->camcorder);
2373                                         if( error_num == MM_ERROR_NONE ) {
2374                                                 g_print("\n Setting Success\n");
2375                                         } else {
2376                                                 g_print("\n Setting Failure\n");
2377                                         }
2378                                 } else if(index == 3) {
2379                                         mm_camcorder_set_video_stream_callback(hcamcorder->camcorder, NULL, (void*)hcamcorder->camcorder);
2380                                         mm_camcorder_set_audio_stream_callback(hcamcorder->camcorder, NULL, (void*)hcamcorder->camcorder);
2381                                         video_stream_cb_cnt = 0;
2382                                         audio_stream_cb_cnt = 0;
2383                                         g_print("\n Unset stream callback success\n");
2384                                 } else {
2385                                         g_print("\t Invalid input \n");
2386                                 }
2387                                 //g_print("Not supported !! \n");
2388                                 break;
2389
2390                         case 'b' : //  back
2391                                 hcamcorder->menu_state = MENU_STATE_MAIN;
2392                                 break;
2393
2394                         default :
2395                                 g_print("\t Invalid input \n");
2396                                 break;
2397                 }
2398         }
2399         else
2400         {
2401                 g_print("\t Invalid mode, back to upper menu \n");
2402                 hcamcorder->menu_state = MENU_STATE_MAIN;
2403         }
2404 }
2405
2406
2407 /**
2408  * This function is to execute command.
2409  *
2410  * @param       channel [in]    1st parameter
2411  *
2412  * @return      This function returns TRUE/FALSE
2413  * @remark
2414  * @see
2415  */
2416 static gboolean cmd_input(GIOChannel *channel)
2417 {
2418         gchar buf[256];
2419         gsize read;
2420
2421         debug_msg_t("ENTER");
2422
2423         g_io_channel_read(channel, buf, CAPTURE_FILENAME_LEN, &read);
2424         buf[read] = '\0';
2425         g_strstrip(buf);
2426
2427         debug_msg_t("Menu Status : %d", hcamcorder->menu_state);
2428         switch(hcamcorder->menu_state)
2429         {
2430                 case MENU_STATE_MAIN:
2431                         main_menu(buf[0]);
2432                         break;
2433                 case MENU_STATE_SETTING:
2434                         setting_menu(buf[0]);
2435                         break;
2436                 default:
2437                         break;
2438         }
2439         print_menu();
2440         return TRUE;
2441 }
2442
2443 void validity_print(MMCamAttrsInfo *info)
2444 {
2445                         printf("info(%d,%d, %d))\n", info->type, info->flag, info->validity_type);
2446                         if (info->validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_ARRAY)
2447                         {
2448                                 printf("int array(%p, %d)\n", info->int_array.array, info->int_array.count);
2449                         }
2450                         else if (info->validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_RANGE)
2451                         {
2452                                 printf("int range(%d, %d)\n", info->int_range.min, info->int_range.max);
2453                         }
2454                         else if (info->validity_type == MM_CAM_ATTRS_VALID_TYPE_DOUBLE_ARRAY)
2455                         {
2456                                 printf("double array(%p, %d)\n", info->double_array.array, info->double_array.count);
2457                         }
2458                         else if(info->validity_type == MM_CAM_ATTRS_VALID_TYPE_DOUBLE_RANGE)
2459                         {
2460                                 printf("double range(%f, %f)\n", info->double_range.min, info->double_range.max);
2461                         }
2462                         else
2463                         {
2464                                 printf("validity none\n");
2465                         }
2466                         return;
2467 }
2468
2469
2470 /**
2471  * This function is to initiate camcorder attributes .
2472  *
2473  * @param       type    [in]    image(capture)/video(recording) mode
2474  *
2475  * @return      This function returns TRUE/FALSE
2476  * @remark
2477  * @see         other functions
2478  */
2479 static gboolean init(int type)
2480 {
2481         int err;
2482         int size;
2483         int preview_format = MM_PIXEL_FORMAT_NV12;
2484         MMHandleType cam_handle = 0;
2485
2486         char *err_attr_name = NULL;
2487
2488         if (!hcamcorder)
2489                 return FALSE;
2490
2491         if(!hcamcorder->camcorder)
2492                 return FALSE;
2493
2494         cam_handle = (MMHandleType)(hcamcorder->camcorder);
2495
2496         /*================================================================================
2497                 image mode
2498         *=================================================================================*/
2499         if (type == MODE_IMAGE)
2500         {
2501                 mm_camcorder_get_attributes((MMHandleType)cam_handle, NULL,
2502                                             MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, &preview_format,
2503                                             NULL);
2504
2505                 /* camcorder attribute setting */
2506                 err = mm_camcorder_set_attributes( (MMHandleType)cam_handle, &err_attr_name,
2507                                                    MMCAM_MODE, MM_CAMCORDER_MODE_IMAGE,
2508                                                    MMCAM_CAMERA_FORMAT, preview_format,
2509                                                    "camera-delay-attr-setting", TRUE,
2510                                                    MMCAM_IMAGE_ENCODER, MM_IMAGE_CODEC_JPEG,
2511                                                    MMCAM_IMAGE_ENCODER_QUALITY, IMAGE_ENC_QUALITY,
2512                                                    MMCAM_TAG_ENABLE, 1,
2513                                                    MMCAM_TAG_LATITUDE, 35.3036944,
2514                                                    MMCAM_TAG_LONGITUDE, 176.67837,
2515                                                    MMCAM_TAG_ALTITUDE, 190.3455,
2516                                                    MMCAM_DISPLAY_DEVICE, MM_DISPLAY_DEVICE_MAINLCD,
2517                                                    MMCAM_DISPLAY_SURFACE, MM_DISPLAY_SURFACE_X,
2518                                                    MMCAM_DISPLAY_RECT_X, DISPLAY_X_0,
2519                                                    MMCAM_DISPLAY_RECT_Y, DISPLAY_Y_0,
2520                                                    MMCAM_DISPLAY_RECT_WIDTH, 480,
2521                                                    MMCAM_DISPLAY_RECT_HEIGHT, 640,
2522                                                    MMCAM_DISPLAY_ROTATION, MM_DISPLAY_ROTATION_270,
2523                                                    MMCAM_DISPLAY_GEOMETRY_METHOD, MM_DISPLAY_METHOD_LETTER_BOX,
2524                                                    MMCAM_CAPTURE_COUNT, IMAGE_CAPTURE_COUNT_STILL,
2525                                                    "capture-thumbnail", TRUE,
2526                                                    "tag-gps-time-stamp", 72815.5436243543,
2527                                                    "tag-gps-date-stamp", "2010:09:20", 10,
2528                                                    "tag-gps-processing-method", "GPS NETWORK HYBRID ARE ALL FINE.", 32,
2529                                                    "capture-sound-enable", TRUE,
2530                                                    NULL );
2531
2532                 if (err != MM_ERROR_NONE) {
2533                         warn_msg_t("Init fail. (%s:%x)", err_attr_name, err);
2534                         SAFE_FREE (err_attr_name);
2535                         goto ERROR;
2536                 }
2537
2538                 mm_camcorder_set_video_capture_callback(hcamcorder->camcorder, (mm_camcorder_video_capture_callback)camcordertest_video_capture_cb, hcamcorder);
2539         }
2540         /*================================================================================
2541                 video mode
2542         *=================================================================================*/
2543         else if (type == MODE_VIDEO)
2544         {
2545                 mm_camcorder_get_attributes((MMHandleType)cam_handle, NULL,
2546                                             MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, &preview_format,
2547                                             NULL);
2548
2549                 size = strlen(TARGET_FILENAME_VIDEO)+1;
2550
2551                 /* camcorder attribute setting */
2552                 err = mm_camcorder_set_attributes( (MMHandleType)cam_handle, &err_attr_name,
2553                                                    MMCAM_MODE, MM_CAMCORDER_MODE_VIDEO,
2554                                                    MMCAM_AUDIO_DEVICE, MM_AUDIO_DEVICE_MIC,
2555                                                    MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AMR,
2556                                                    MMCAM_VIDEO_ENCODER, MM_VIDEO_CODEC_H264,
2557                                                    MMCAM_FILE_FORMAT, MM_FILE_FORMAT_3GP,
2558                                                    MMCAM_CAMERA_FORMAT, preview_format,
2559                                                    MMCAM_CAMERA_FPS, SRC_VIDEO_FRAME_RATE_30,
2560                                                    MMCAM_CAMERA_FPS_AUTO, 0,
2561                                                    "camera-delay-attr-setting", TRUE,
2562                                                    MMCAM_CAMERA_ROTATION, MM_VIDEO_INPUT_ROTATION_NONE,
2563                                                    MMCAM_AUDIO_SAMPLERATE, AUDIO_SOURCE_SAMPLERATE_AMR,
2564                                                    MMCAM_AUDIO_FORMAT, AUDIO_SOURCE_FORMAT,
2565                                                    MMCAM_AUDIO_CHANNEL, AUDIO_SOURCE_CHANNEL_AMR,
2566                                                    MMCAM_AUDIO_INPUT_ROUTE, MM_AUDIOROUTE_CAPTURE_NORMAL,
2567                                                    MMCAM_TAG_ENABLE, 1,
2568                                                    MMCAM_TAG_LATITUDE, 37.25796666,
2569                                                    MMCAM_TAG_LONGITUDE, 127.05332222,
2570                                                    MMCAM_TAG_ALTITUDE, 45.0000,
2571                                                    MMCAM_DISPLAY_DEVICE, MM_DISPLAY_DEVICE_MAINLCD,
2572                                                    MMCAM_DISPLAY_SURFACE, MM_DISPLAY_SURFACE_X,
2573                                                    MMCAM_DISPLAY_RECT_X, DISPLAY_X_0,
2574                                                    MMCAM_DISPLAY_RECT_Y, DISPLAY_Y_0,
2575                                                    MMCAM_DISPLAY_RECT_WIDTH, 480,
2576                                                    MMCAM_DISPLAY_RECT_HEIGHT, 640,
2577                                                    MMCAM_DISPLAY_ROTATION, MM_DISPLAY_ROTATION_270,
2578                                                    MMCAM_TARGET_FILENAME, TARGET_FILENAME_VIDEO, size,
2579                                                    "capture-sound-enable", TRUE,
2580                                                    NULL );
2581
2582                 if (err != MM_ERROR_NONE) {
2583                         fprintf(stderr, "video mode init fail. [%s][%x)", err_attr_name, err);
2584                         SAFE_FREE (err_attr_name);
2585                         goto ERROR;
2586                 }
2587 //              mm_camcorder_set_audio_stream_callback(hcamcorder->camcorder, (mm_camcorder_audio_stream_callback)camcordertest_audio_stream_cb, (void*)hcamcorder->camcorder);
2588         }
2589
2590         /*================================================================================
2591                 Audio mode
2592         *=================================================================================*/
2593         else if (type == MODE_AUDIO)
2594         {
2595                 size = strlen(TARGET_FILENAME_AUDIO)+1;
2596
2597                 /* camcorder attribute setting */
2598                 err = mm_camcorder_set_attributes( hcamcorder->camcorder, &err_attr_name,
2599                                                    MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
2600                                                    MMCAM_AUDIO_DEVICE, MM_AUDIO_DEVICE_MIC,
2601                                                    MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AMR,
2602                                                    MMCAM_FILE_FORMAT, MM_FILE_FORMAT_AMR,
2603                                                    MMCAM_AUDIO_SAMPLERATE, AUDIO_SOURCE_SAMPLERATE_AMR,
2604                                                    MMCAM_AUDIO_FORMAT, AUDIO_SOURCE_FORMAT,
2605                                                    MMCAM_AUDIO_CHANNEL, AUDIO_SOURCE_CHANNEL_AMR,
2606                                                    MMCAM_AUDIO_INPUT_ROUTE, MM_AUDIOROUTE_CAPTURE_NORMAL,
2607                                                    MMCAM_TARGET_FILENAME, TARGET_FILENAME_AUDIO, size,
2608                                                    MMCAM_TARGET_TIME_LIMIT, 360000,
2609                                                    NULL);
2610
2611                 if (err < 0)
2612                 {
2613                         warn_msg_t("Init fail. (%s:%x)", err_attr_name, err);
2614                         SAFE_FREE (err_attr_name);
2615                         goto ERROR;
2616                 }
2617
2618 //              mm_camcorder_set_audio_stream_callback(hcamcorder->camcorder, (mm_camcorder_audio_stream_callback)camcordertest_audio_stream_cb, (void*)hcamcorder->camcorder);
2619         }
2620
2621         debug_msg_t("Init DONE.");
2622
2623         return TRUE;
2624
2625 ERROR:
2626         err_msg_t("init failed.");
2627         return FALSE;
2628 }
2629
2630 /**
2631  * This function is to represent messagecallback
2632  *
2633  * @param       message [in]    Specifies the message
2634  * @param       param   [in]    Specifies the message type
2635  * @param       user_param      [in]    Specifies the user poiner for passing to callback function
2636  * @return      This function returns TRUE/FALSE
2637  * @remark
2638  * @see         other functions
2639  */
2640 static gboolean msg_callback(int message, void *msg_param, void *user_param)
2641 {
2642
2643         MMMessageParamType *param = (MMMessageParamType *) msg_param;
2644
2645         switch (message) {
2646                 case MM_MESSAGE_CAMCORDER_ERROR:
2647                         g_print("MM_MESSAGE_ERROR : code = %x", param->code);
2648                         break;
2649                 case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
2650                         g_current_state = param->state.current;
2651                         switch(g_current_state)
2652                         {
2653                                 case MM_CAMCORDER_STATE_NULL :
2654                                         mmcamcorder_state = MM_CAMCORDER_STATE_NULL;
2655                                         debug_msg_t("Camcorder State is [NULL]");
2656                                         break;
2657                                 case MM_CAMCORDER_STATE_READY :
2658                                         mmcamcorder_state = MM_CAMCORDER_STATE_READY;
2659                                         debug_msg_t("Camcorder State is [READY]");
2660                                         break;
2661                                 case MM_CAMCORDER_STATE_PREPARE :
2662                                         mmcamcorder_state = MM_CAMCORDER_STATE_PREPARE;
2663                                         debug_msg_t("Camcorder State is [PREPARE]");
2664                                         break;
2665                                 case MM_CAMCORDER_STATE_CAPTURING :
2666                                         mmcamcorder_state = MM_CAMCORDER_STATE_CAPTURING;
2667                                         debug_msg_t("Camcorder State is [CAPTURING]");
2668                                         break;
2669                                 case MM_CAMCORDER_STATE_RECORDING :
2670                                         mmcamcorder_state = MM_CAMCORDER_STATE_RECORDING;
2671                                         time_msg_t("Recording start time  : %12.6lf s", g_timer_elapsed(timer, NULL));
2672                                         debug_msg_t("Camcorder State is [RECORDING]");
2673                                         break;
2674                                 case MM_CAMCORDER_STATE_PAUSED :
2675                                         mmcamcorder_state = MM_CAMCORDER_STATE_PAUSED;
2676                                         debug_msg_t("Camcorder State is [PAUSED]");
2677                                         break;
2678                         }
2679                         break;
2680
2681                 case MM_MESSAGE_CAMCORDER_CAPTURED:
2682                 {
2683                         if (hcamcorder->mode == MODE_IMAGE)
2684                         {
2685                                 time_msg_t("Stillshot capture  : %12.6lf s", g_timer_elapsed(timer, NULL));
2686
2687                                 g_print("*******************************************************\n");
2688                                 g_print("[Camcorder Testsuite] Camcorder Stillshot Captured!!\n");
2689                                 g_print("*******************************************************\n");
2690
2691                                 if (hcamcorder->isMultishot)            //multishot
2692                                 {
2693                                         g_print("[CamcorderApp] Camcorder Captured(Capture Count=%d)\n", param->code);
2694
2695                                         if (param->code >= multishot_num)
2696                                         {
2697                                                 get_me_out();
2698 //                                              g_timeout_add (100, (GSourceFunc)get_me_out, NULL);
2699 //                                              hcamcorder->isMultishot = FALSE;
2700                                         }
2701                                 }
2702                                 else            //singleshot
2703                                 {
2704                                         get_me_out();
2705 //                                      g_timeout_add (1000, (GSourceFunc)get_me_out, NULL);
2706                                 }
2707
2708                         }
2709                         else
2710                         {
2711                                 MMCamRecordingReport* report ;
2712
2713                                 time_msg_t("Recording commit time : %12.6lf s", g_timer_elapsed(timer, NULL));
2714
2715                                 if (param)
2716                                         report = (MMCamRecordingReport*)(param->data);
2717                                 else
2718                                         return FALSE;
2719
2720                                 if( report != NULL )
2721                                 {
2722                                         g_print("*******************************************************\n");
2723                                         g_print("[Camcorder Testsuite] Camcorder Captured(filename=%s)\n", report->recording_filename);
2724                                         g_print("*******************************************************\n");
2725
2726                                         SAFE_FREE (report->recording_filename);
2727                                         SAFE_FREE (report);
2728                                 }
2729                                 else
2730                                 {
2731                                         g_print( "[Camcorder Testsuite] report is NULL.\n" );
2732                                 }
2733                         }
2734                 }
2735                         break;
2736                 case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
2737                 {
2738                         debug_msg_t("Got TIME LIMIT MESSAGE");
2739                 }
2740                         break;
2741                 case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
2742                 {
2743                         unsigned int elapsed;
2744                         elapsed = param->recording_status.elapsed / 1000;
2745                         if (hcamcorder->elapsed_time != elapsed) {
2746                                 unsigned int temp_time;
2747                                 int hour, minute, second;
2748                                 hcamcorder->elapsed_time = elapsed;
2749                                 temp_time = elapsed;
2750                                 hour = temp_time / 3600;
2751                                 temp_time = elapsed % 3600;
2752                                 minute = temp_time / 60;
2753                                 second = temp_time % 60;
2754                                 debug_msg_t("Current Time - %d:%d:%d", hour, minute, second);
2755                         }
2756                 }
2757                         break;
2758                 case MM_MESSAGE_CAMCORDER_MAX_SIZE:
2759                 {
2760                         int err;
2761                         g_print("*Save Recording because receives message : MM_MESSAGE_CAMCORDER_MAX_SIZE\n");
2762                         g_timer_reset(timer);
2763                         err = mm_camcorder_commit(hcamcorder->camcorder);
2764
2765                         if (err < 0)
2766                         {
2767                                 warn_msg_t("Save recording mm_camcorder_commit  = %x", err);
2768 //                                      goto ERROR;
2769                         }
2770                 }
2771                         break;
2772                 case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
2773                         break;
2774                 case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
2775                 {
2776                         int err;
2777                         g_print("*Save Recording because receives message : MM_MESSAGE_CAMCORDER_NO_FREE_SPACE\n");
2778                         g_timer_reset(timer);
2779                         err = mm_camcorder_commit(hcamcorder->camcorder);
2780
2781                         if (err < 0)
2782                         {
2783                                 warn_msg_t("Save recording mm_camcorder_commit  = %x", err);
2784 //                                      goto ERROR;
2785                         }
2786                 }
2787                         break;
2788                 case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED:
2789                 {
2790                         g_print( "Focus State changed. State:[%d]\n", param->code );
2791                 }
2792                         break;
2793                 default:
2794                         g_print("Message %x received\n", message);
2795                         break;
2796         }
2797
2798         return TRUE;
2799 }
2800
2801 static gboolean init_handle()
2802 {
2803         hcamcorder->mode = MODE_IMAGE;                                           /* image(capture)/video(recording) mode */
2804         hcamcorder->isMultishot =  FALSE;
2805         hcamcorder->stillshot_count = 0;                        /* total stillshot count */
2806         hcamcorder->multishot_count = 0;                        /* total multishot count */
2807         hcamcorder->stillshot_filename = STILL_CAPTURE_FILE_PATH_NAME;          /* stored filename of  stillshot  */
2808         hcamcorder->multishot_filename = MULTI_CAPTURE_FILE_PATH_NAME;          /* stored filename of  multishot  */
2809         hcamcorder->menu_state = MENU_STATE_MAIN;
2810         hcamcorder->isMute = FALSE;
2811         hcamcorder->elapsed_time = 0;
2812         hcamcorder->fps = SRC_VIDEO_FRAME_RATE_15; //SRC_VIDEO_FRAME_RATE_30;
2813         multishot_num = IMAGE_CAPTURE_COUNT_MULTI;
2814
2815         return TRUE;
2816 }
2817 /**
2818  * This function is to change camcorder mode.
2819  *
2820  * @param       type    [in]    image(capture)/video(recording) mode
2821  *
2822  * @return      This function returns TRUE/FALSE
2823  * @remark
2824  * @see         other functions
2825  */
2826 static gboolean mode_change()
2827 {
2828         int err = MM_ERROR_NONE;
2829         int state;
2830         char media_type = '\0';
2831         bool check= FALSE;
2832
2833         debug_msg_t("MMCamcorder State : %d", mmcamcorder_state);
2834
2835         err = mm_camcorder_get_state(hcamcorder->camcorder, (MMCamcorderStateType *)&state);
2836         if(state != MM_CAMCORDER_STATE_NONE)
2837         {
2838                 if ((state == MM_CAMCORDER_STATE_RECORDING)
2839                         || (state == MM_CAMCORDER_STATE_PAUSED))
2840                 {
2841                         debug_msg_t("mm_camcorder_cancel");
2842                         err = mm_camcorder_cancel(hcamcorder->camcorder);
2843
2844                         if (err < 0)
2845                         {
2846                                 warn_msg_t("exit mm_camcorder_cancel  = %x", err);
2847                                 return FALSE;
2848                         }
2849                 }
2850                 else if (state == MM_CAMCORDER_STATE_CAPTURING)
2851                 {
2852                         debug_msg_t("mm_camcorder_capture_stop");
2853                         err = mm_camcorder_capture_stop(hcamcorder->camcorder);
2854
2855                         if (err < 0)
2856                         {
2857                                 warn_msg_t("exit mmcamcorder_capture_stop  = %x", err);
2858                                 return FALSE;
2859                         }
2860                 }
2861
2862                 err = mm_camcorder_get_state(hcamcorder->camcorder, (MMCamcorderStateType *)&state);
2863                 if(state == MM_CAMCORDER_STATE_PREPARE)
2864                 {
2865                         debug_msg_t("mm_camcorder_stop");
2866                         mm_camcorder_stop(hcamcorder->camcorder);
2867                 }
2868
2869                 err = mm_camcorder_get_state(hcamcorder->camcorder, (MMCamcorderStateType *)&state);
2870                 if(state == MM_CAMCORDER_STATE_READY)
2871                 {
2872                         debug_msg_t("mm_camcorder_unrealize");
2873                         mm_camcorder_unrealize(hcamcorder->camcorder);
2874                 }
2875
2876                 err = mm_camcorder_get_state(hcamcorder->camcorder, (MMCamcorderStateType *)&state);
2877                 if(state == MM_CAMCORDER_STATE_NULL)
2878                 {
2879                         debug_msg_t("mm_camcorder_destroy");
2880                         mm_camcorder_destroy(hcamcorder->camcorder);
2881
2882                         mmcamcorder_state = MM_CAMCORDER_STATE_NONE;
2883                 }
2884         }
2885
2886         init_handle();
2887         mmcamcorder_print_state = MM_CAMCORDER_STATE_PREPARE;
2888         while(!check) {
2889                 g_print("\n\t=======================================\n");
2890                 g_print("\t   MM_CAMCORDER_TESTSUIT\n");
2891                 g_print("\t=======================================\n");
2892                 g_print("\t   '1' Image Capture - Front Camera\n");
2893                 g_print("\t   '2' Image Capture - Rear Camera\n");
2894                 g_print("\t   '3' Video Recording - Front Camera\n");
2895                 g_print("\t   '4' Video Recording - Rear Camera\n");
2896                 g_print("\t   '5' Audio Recording\n");
2897                 g_print("\t   'q' Exit\n");
2898                 g_print("\t=======================================\n");
2899
2900                 g_print("\t  Enter the media type:\n\t");
2901
2902                 while ((media_type=getchar()) == '\n');
2903
2904                 switch(media_type) {
2905                         case '1':
2906                                 hcamcorder->mode= MODE_IMAGE;
2907                                 cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA1;
2908                                 check = TRUE;
2909                                 break;
2910                         case '2':
2911                                 hcamcorder->mode= MODE_IMAGE;
2912                                 cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA0;
2913                                 check = TRUE;
2914                                 break;
2915                         case '3':
2916                                 hcamcorder->mode= MODE_VIDEO;
2917                                 cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA1;
2918                                 check = TRUE;
2919                                 break;
2920                         case '4':
2921                                 hcamcorder->mode= MODE_VIDEO;
2922                                 cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA0;
2923                                 check = TRUE;
2924                                 break;
2925                         case '5':
2926                                 hcamcorder->mode= MODE_AUDIO;
2927                                 cam_info.videodev_type = MM_VIDEO_DEVICE_NONE;
2928                                 check = TRUE;
2929                                 break;
2930                         case 'q':
2931                                 g_print("\t Quit Camcorder Testsuite!!\n");
2932                                 hcamcorder->mode = -1;
2933                                 if(g_main_loop_is_running(g_loop)) {
2934                                         g_main_loop_quit(g_loop);
2935                                 }
2936                                 return FALSE;
2937                         default:
2938                                 g_print("\t Invalid media type(%d)\n", media_type);
2939                                 continue;
2940                 }
2941         }
2942
2943         debug_msg_t("mm_camcorder_create");
2944         g_get_current_time(&previous);
2945         g_timer_reset(timer);
2946
2947         err = mm_camcorder_create(&hcamcorder->camcorder, &cam_info);
2948         time_msg_t("mm_camcorder_create()  : %12.6lfs", g_timer_elapsed(timer, NULL));
2949
2950         if (err != MM_ERROR_NONE) {
2951                 err_msg_t("mmcamcorder_create = %x", err);
2952                 return -1;
2953         } else {
2954                 mmcamcorder_state = MM_CAMCORDER_STATE_NULL;
2955         }
2956
2957         mm_camcorder_set_message_callback(hcamcorder->camcorder, (MMMessageCallback)msg_callback, hcamcorder);
2958
2959         if (!init(hcamcorder->mode)) {
2960                 err_msg_t("testsuite init() failed.");
2961                 return -1;
2962         }
2963
2964         debug_msg_t("mm_camcorder_realize");
2965
2966         g_timer_reset(timer);
2967
2968         err =  mm_camcorder_realize(hcamcorder->camcorder);
2969         time_msg_t("mm_camcorder_realize()  : %12.6lfs", g_timer_elapsed(timer, NULL));
2970         if (err != MM_ERROR_NONE) {
2971                 err_msg_t("mm_camcorder_realize  = %x", err);
2972                 return -1;
2973         }
2974
2975         /* start camcorder */
2976         debug_msg_t("mm_camcorder_start");
2977
2978         g_timer_reset(timer);
2979
2980         err = mm_camcorder_start(hcamcorder->camcorder);
2981         time_msg_t("mm_camcorder_start()  : %12.6lfs", g_timer_elapsed(timer, NULL));
2982
2983         if (err != MM_ERROR_NONE) {
2984                 err_msg_t("mm_camcorder_start  = %x", err);
2985                 return -1;
2986         }
2987
2988         g_get_current_time(&current);
2989         timersub(&current, &previous, &result);
2990         time_msg_t("Camera Starting Time  : %ld.%lds", result.tv_sec, result.tv_usec);
2991
2992         return TRUE;
2993 }
2994
2995
2996 /**
2997  * This function is the example main function for mmcamcorder API.
2998  *
2999  * @param
3000  *
3001  * @return      This function returns 0.
3002  * @remark
3003  * @see         other functions
3004  */
3005 int main(int argc, char **argv)
3006 {
3007         int bret;
3008
3009         if (!g_thread_supported())
3010                 g_thread_init (NULL);
3011
3012         timer = g_timer_new();
3013
3014         gst_init(&argc, &argv);
3015
3016         time_msg_t("gst_init() : %12.6lfs", g_timer_elapsed(timer, NULL));
3017
3018         hcamcorder = (cam_handle_t *) g_malloc0(sizeof(cam_handle_t));
3019         mmcamcorder_state = MM_CAMCORDER_STATE_NONE;
3020
3021         g_timer_reset(timer);
3022
3023         bret = mode_change();
3024         if(!bret){
3025                 return bret;
3026         }
3027
3028         print_menu();
3029
3030         g_loop = g_main_loop_new(NULL, FALSE);
3031
3032         stdin_channel = g_io_channel_unix_new(fileno(stdin));/* read from stdin */
3033         g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)cmd_input, NULL);
3034
3035         debug_msg_t("RUN main loop");
3036
3037         g_main_loop_run(g_loop);
3038
3039         debug_msg_t("STOP main loop");
3040
3041         if (timer) {
3042                 g_timer_stop(timer);
3043                 g_timer_destroy(timer);
3044                 timer = NULL;
3045         }
3046         //g_print("\t Exit from the application.\n");
3047         g_free(hcamcorder);
3048         g_main_loop_unref(g_loop);
3049         g_io_channel_unref(stdin_channel);
3050
3051         return bret;
3052 }
3053
3054 /*EOF*/