test/recorder_test.c

   1 /*
   2  * recorder_testsuite
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jeongmo Yang <jm80.yang@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /*=======================================================================================
  23   |  INCLUDE FILES                                                                        |
  24   =======================================================================================*/
  25 #include "recorder_test.h"
  26
  27 /*-----------------------------------------------------------------------
  28   |    GLOBAL VARIABLES:                                                  |
  29   -----------------------------------------------------------------------*/
  30 static int g_recorder_state;
  31 static int g_recorder_device_changed_cb_id;
  32 static int g_recorder_ve_frame_count = 0;
  33 static cam_handle_t *g_cam_handle;
  34
  35
  36 /*-----------------------------------------------------------------------
  37   |    DEFINITIONS:                                                       |
  38   -----------------------------------------------------------------------*/
  39 #define SRC_VIDEO_FRAME_RATE_15         15    /* video input frame rate */
  40 #define SRC_VIDEO_FRAME_RATE_30         30    /* video input frame rate */
  41 #define TARGET_FILENAME_PATH            "/opt/usr/home/owner/media/"
  42 #define TARGET_FILENAME_VIDEO           TARGET_FILENAME_PATH"test_rec_video.mp4"
  43 #define TARGET_FILENAME_AUDIO           TARGET_FILENAME_PATH"test_rec_audio.m4a"
  44 #define TARGET_FILENAME_MUXED_CB        TARGET_FILENAME_PATH"muxed_stream_cb.mp4"
  45 #define TARGET_FILENAME_VE_DECISION_CB  TARGET_FILENAME_PATH"ve_decision_cb.data"
  46 #define AUDIO_SOURCE_SAMPLERATE_AAC     44100
  47 #define AUDIO_SOURCE_SAMPLERATE_AMR     8000
  48 #define AUDIO_SOURCE_CHANNEL_AAC        2
  49 #define AUDIO_SOURCE_CHANNEL_AMR        1
  50 #define VIDEO_ENCODE_BITRATE            40000000 /* bps */
  51 #define CHECK_MM_ERROR(expr) \
  52         do {\
  53                 int ret = 0; \
  54                 ret = expr; \
  55                 if (ret != 0) {\
  56                         g_print("[%s:%d] error code : %x \n", __func__, __LINE__, ret); \
  57                         return; \
  58                 } \
  59         } while (0)
  60 #ifndef SAFE_FREE
  61 #define SAFE_FREE(x)       if (x) { g_free(x); x = NULL; }
  62 #endif
  63
  64
  65 /*-----------------------------------------------------------------------
  66   |    ENUMS:                                                             |
  67   -----------------------------------------------------------------------*/
  68 enum {
  69         MODE_VIDEO_CAPTURE, /* recording and image capture mode */
  70         MODE_AUDIO,         /* audio recording*/
  71         MODE_NUM,
  72 };
  73
  74 enum {
  75         MENU_STATE_INIT,
  76         MENU_STATE_MAIN,
  77         MENU_STATE_SETTING,
  78         MENU_STATE_NUM,
  79 };
  80
  81 /*-----------------------------------------------------------------------
  82   |    DATA STRUCTURES:                                                   |
  83   -----------------------------------------------------------------------*/
  84 typedef struct {
  85         int width[20];
  86         int height[20];
  87         int count;
  88 } resolution_stack_t;
  89
  90
  91 /*---------------------------------------------------------------------------
  92   |    CONSTANT VARIABLES:                                                    |
  93   ---------------------------------------------------------------------------*/
  94 static const char *video_codec[] = {
  95         "H.263",
  96         "H.264",
  97         "MPEG4",
  98         "THEORA"
  99 };
 100
 101 static const char *audio_codec[] = {
 102         "AMR",
 103         "AAC",
 104         "VORBIS",
 105         "PCM",
 106         "MP3"
 107 };
 108
 109 static const char *file_format[] = {
 110         "3GP",
 111         "MP4",
 112         "AMR",
 113         "ADTS",
 114         "WAV",
 115         "OGG",
 116         "M2TS"
 117 };
 118
 119 static const char *display_mode[] = {
 120         "Letter Box mode",
 121         "Original Size mode",
 122         "Full Screen mode",
 123         "Cropped Full Screen mode",
 124         "Original size or Letter Box mode",
 125         "ROI mode"
 126 };
 127
 128 static const char* strobe_mode[] = {
 129         "OFF",
 130         "ON",
 131         "Auto",
 132         "RedEyeReduction",
 133         "SlowSync",
 134         "FrontCurtain",
 135         "RearCurtain",
 136         "Permanent",
 137 };
 138
 139 static const char *vs_mode[] = {
 140         "OFF",
 141         "ON",
 142 };
 143
 144
 145 /*---------------------------------------------------------------------------
 146   |    FUNCTION PROTOTYPES:                                                   |
 147   ---------------------------------------------------------------------------*/
 148 static gboolean init(int type);
 149 static gboolean mode_change(gchar buf);
 150
 151
 152 static bool resolution_cb(int width, int height, void *user_data)
 153 {
 154         resolution_stack_t *data = (resolution_stack_t*)user_data;
 155
 156         if (data == NULL) {
 157                 g_print("NULL data\n");
 158                 return false;
 159         }
 160
 161         data->width[data->count] = width;
 162         data->height[data->count] = height;
 163
 164         g_print("%d. %dx%d\n", data->count, width, height);
 165
 166         data->count++;
 167
 168         return true;
 169 }
 170
 171 static bool video_codec_cb(recorder_video_codec_e codec, void *user_data)
 172 {
 173         g_print("%d. %s\n", codec, video_codec[codec]);
 174         return true;
 175 }
 176
 177 static bool audio_codec_cb(recorder_audio_codec_e codec, void *user_data)
 178 {
 179         g_print("%d. %s\n", codec, audio_codec[codec]);
 180         return true;
 181 }
 182
 183 static bool file_format_cb(recorder_file_format_e format, void *user_data)
 184 {
 185         g_print("%d. %s\n", format, file_format[format]);
 186         return true;
 187 }
 188
 189 static bool strobe_mode_cb(camera_attr_flash_mode_e mode , void *user_data)
 190 {
 191         g_print("%d.%s\n", mode, strobe_mode[mode]);
 192         return true;
 193 }
 194
 195 static void _state_changed_cb(recorder_state_e previous_state, recorder_state_e current_state, bool by_policy, void *user_data)
 196 {
 197         g_print("\tstate changed[by_policy:%d] : %d -> %d\n\n", by_policy, previous_state, current_state);
 198         return;
 199 }
 200
 201 static void _interrupted_cb(recorder_policy_e policy, recorder_state_e previous_state, recorder_state_e current_state, void *user_data)
 202 {
 203         g_print("\nrecorder interrupted callback called [state %d -> %d, policy %d]\n",
 204                 previous_state, current_state, policy);
 205         return;
 206 }
 207
 208 static void _recorder_device_state_changed_cb(recorder_type_e type, recorder_device_state_e state, void *user_data)
 209 {
 210         g_print("\nrecorder device[%d] state changed to %d\n", type, state);
 211         return;
 212 }
 213
 214 static void _recording_status_cb(unsigned long long elapsed_time, unsigned long long file_size, void *user_data)
 215 {
 216         static unsigned long long elapsed = -1;
 217
 218         if (elapsed != elapsed_time / 1000) {
 219                 unsigned long temp_time;
 220                 unsigned long long hour, minute, second;
 221                 elapsed = elapsed_time / 1000;
 222                 temp_time = elapsed;
 223                 hour = temp_time / 3600;
 224                 temp_time = elapsed % 3600;
 225                 minute = temp_time / 60;
 226                 second = temp_time % 60;
 227                 g_print("\tCurrent Time - %lld:%lld:%lld, filesize %lld KB\n",
 228                                 hour, minute, second, file_size);
 229         }
 230
 231         return;
 232 }
 233
 234 static void _recording_limit_reached_cb(recorder_recording_limit_type_e type, void *user_data)
 235 {
 236         g_print("\tRECORDING LIMIT REACHED [type: %d]\n\n", type);
 237         return;
 238 }
 239
 240 static void _recording_muxed_stream_cb(void *stream, int size, unsigned long long offset, void *user_data)
 241 {
 242         static unsigned long long current_offset = 0;
 243
 244         FILE *fp = NULL;
 245
 246         g_print("\tRECORDING MUXED STREAM CB - %p, size %d, offset %llu\n", stream, size, offset);
 247
 248         if (stream && size > 0) {
 249                 if (offset == 0)
 250                         fp = fopen(TARGET_FILENAME_MUXED_CB, "w");
 251                 else
 252                         fp = fopen(TARGET_FILENAME_MUXED_CB, "rb+");
 253
 254                 if (fp) {
 255                         if (current_offset > offset) {
 256                                 g_print("\tback to %llu\n", offset);
 257                         }
 258
 259                         if (fseeko(fp, (off_t)offset, SEEK_SET) == 0)
 260                                 fwrite(stream, 1, size, fp);
 261                         else
 262                                 g_print("\nSeek Error : offset %llu\n", offset);
 263
 264                         fclose(fp);
 265                         fp = NULL;
 266                 } else {
 267                         g_print("\tFile open failed [%s], errno %d", TARGET_FILENAME_MUXED_CB, errno);
 268                 }
 269
 270                 current_offset = offset;
 271         }
 272
 273         return;
 274 }
 275
 276
 277 static void _dump_video_frame(recorder_video_data_s *frame)
 278 {
 279         FILE *fp = NULL;
 280
 281         if (!frame) {
 282                 g_print("\n==== NULL video frame ====\n");
 283                 return;
 284         }
 285
 286         fp = fopen(TARGET_FILENAME_VE_DECISION_CB, "a");
 287         if (fp == NULL) {
 288                 g_print("\n==== file[%s] open failed ====\n", TARGET_FILENAME_VE_DECISION_CB);
 289                 return;
 290         }
 291
 292         if (frame->format == CAMERA_PIXEL_FORMAT_RGBA ||
 293                 frame->format == CAMERA_PIXEL_FORMAT_ARGB) {
 294                 fwrite(frame->data.rgb_plane.data, 1, frame->data.rgb_plane.size, fp);
 295         } else if (frame->format == CAMERA_PIXEL_FORMAT_INVZ) {
 296                 fwrite(frame->data.depth_plane.data, 1, frame->data.depth_plane.size, fp);
 297         } else if (frame->format == CAMERA_PIXEL_FORMAT_MJPEG) {
 298                 fwrite(frame->data.encoded_plane.data, 1, frame->data.encoded_plane.size, fp);
 299         } else {
 300                 switch (frame->num_of_planes) {
 301                 case 1:
 302                         fwrite(frame->data.single_plane.yuv, 1, frame->data.single_plane.size, fp);
 303                         break;
 304                 case 2:
 305                         fwrite(frame->data.double_plane.y, 1, frame->data.double_plane.y_size, fp);
 306                         fwrite(frame->data.double_plane.uv, 1, frame->data.double_plane.uv_size, fp);
 307                         break;
 308                 case 3:
 309                         fwrite(frame->data.triple_plane.y, 1, frame->data.triple_plane.y_size, fp);
 310                         fwrite(frame->data.triple_plane.u, 1, frame->data.triple_plane.u_size, fp);
 311                         fwrite(frame->data.triple_plane.v, 1, frame->data.triple_plane.v_size, fp);
 312                         break;
 313                 default:
 314                         break;
 315                 }
 316         }
 317
 318         fclose(fp);
 319         fp = NULL;
 320 }
 321
 322
 323 static bool _recording_video_encode_decision_cb(recorder_video_data_s *frame, void *user_data)
 324 {
 325         if (g_recorder_ve_frame_count == 0) {
 326                 g_print("==== VE decision cb : file[%s][fmt %d, %dx%d, plane %d] ====\n",
 327                         TARGET_FILENAME_VE_DECISION_CB,
 328                         frame->format, frame->width, frame->height, frame->num_of_planes);
 329
 330                 _dump_video_frame(frame);
 331         }
 332
 333         if ((g_recorder_ve_frame_count++ % 10) >= 5) {
 334                 g_print("-------- VE decision cb : [ret:false]\n");
 335                 return false;
 336         } else {
 337                 g_print("-------- VE decision cb : [ret:true ]\n");
 338                 return true;
 339         }
 340 }
 341
 342
 343 void flush_stdin()
 344 {
 345         int ch;
 346         while ((ch = getchar()) != EOF && ch != '\n');
 347         return;
 348 }
 349
 350 static gboolean _release_idle_event_callback(void *data)
 351 {
 352         g_print("destroy recorder handle\n\n");
 353
 354         recorder_destroy(g_cam_handle->recorder);
 355         g_cam_handle->recorder = NULL;
 356         g_cam_handle->menu_state = MENU_STATE_INIT;
 357         print_menu();
 358
 359         return 0;
 360 }
 361
 362 static void _recorder_error_cb(int error, recorder_state_e current_state, void *user_data)
 363 {
 364         g_print("\tERROR [0x%x], current state %d\n", error, current_state);
 365
 366         switch (error) {
 367         case RECORDER_ERROR_RESOURCE_CONFLICT:
 368                 g_print("\t\t[RECORDER_ERROR_RESOURCE_CONFLICT]\n\n");
 369                 break;
 370         case RECORDER_ERROR_SECURITY_RESTRICTED:
 371                 g_print("\t\t[RECORDER_ERROR_SECURITY_RESTRICTED]\n\n");
 372                 break;
 373         case RECORDER_ERROR_SERVICE_DISCONNECTED:
 374                 g_print("\t\t[RECORDER_ERROR_SERVICE_DISCONNECTED]\n\n");
 375                 g_idle_add_full(G_PRIORITY_DEFAULT,
 376                         (GSourceFunc)_release_idle_event_callback,
 377                         NULL, NULL);
 378                 break;
 379         default:
 380                 break;
 381         }
 382
 383         return;
 384 }
 385
 386
 387 static int _recorder_set_muxed_stream_cb(void)
 388 {
 389         int idx = 0;
 390         int err = 0;
 391
 392         g_print("* Muxed stream callback\n");
 393
 394         flush_stdin();
 395
 396         g_print("[set(1)/unset(2)] : ");
 397
 398         err = scanf("%d", &idx);
 399
 400         switch (idx) {
 401         case 1:
 402                 return recorder_set_muxed_stream_cb(g_cam_handle->recorder, _recording_muxed_stream_cb, NULL);
 403         case 2:
 404                 return recorder_unset_muxed_stream_cb(g_cam_handle->recorder);
 405         default:
 406                 return RECORDER_ERROR_INVALID_PARAMETER;
 407         }
 408 }
 409
 410
 411 static int _recorder_set_audio_encoder(void)
 412 {
 413         int encoder = 0;
 414         int err = 0;
 415
 416         g_print("* Audio codec\n");
 417
 418         flush_stdin();
 419
 420         g_print("-1. DISABLE\n");
 421         recorder_foreach_supported_audio_encoder(g_cam_handle->recorder, audio_codec_cb, (void *)g_cam_handle);
 422
 423         err = scanf("%d", &encoder);
 424
 425         return recorder_set_audio_encoder(g_cam_handle->recorder, encoder);
 426 }
 427
 428
 429 static int _recorder_set_file_format(void)
 430 {
 431         int format = 0;
 432         int err = 0;
 433
 434         g_print("* File format\n");
 435
 436         flush_stdin();
 437
 438         recorder_foreach_supported_file_format(g_cam_handle->recorder, file_format_cb, (void *)g_cam_handle);
 439
 440         err = scanf("%d", &format);
 441
 442         return recorder_set_file_format(g_cam_handle->recorder, format);
 443 }
 444
 445
 446 static int _recorder_set_size_limit(void)
 447 {
 448         int limit = 0;
 449         int err = 0;
 450
 451         g_print("* Size limit\n");
 452
 453         flush_stdin();
 454
 455         g_print("[KByte] : ");
 456
 457         err = scanf("%d", &limit);
 458
 459         return recorder_attr_set_size_limit(g_cam_handle->recorder, limit);
 460 }
 461
 462
 463 static int _recorder_set_time_limit(void)
 464 {
 465         int limit = 0;
 466         int err = 0;
 467
 468         g_print("* Time limit\n");
 469
 470         flush_stdin();
 471
 472         g_print("[Second] : ");
 473
 474         err = scanf("%d", &limit);
 475
 476         return recorder_attr_set_time_limit(g_cam_handle->recorder, limit);
 477 }
 478
 479
 480 static int _recorder_set_audio_samplerate(void)
 481 {
 482         int samplerate = 0;
 483         int err = 0;
 484
 485         g_print("* Samplerate\n");
 486
 487         flush_stdin();
 488
 489         g_print("[Hz] : ");
 490
 491         err = scanf("%d", &samplerate);
 492
 493         return recorder_attr_set_audio_samplerate(g_cam_handle->recorder, samplerate);
 494 }
 495
 496
 497 static int _recorder_set_audio_channel(void)
 498 {
 499         int channel = 0;
 500         int err = 0;
 501
 502         g_print("* Channel\n");
 503
 504         flush_stdin();
 505
 506         g_print("[1 or 2] : ");
 507
 508         err = scanf("%d", &channel);
 509
 510         return recorder_attr_set_audio_channel(g_cam_handle->recorder, channel);
 511 }
 512
 513
 514 static int _recorder_set_encoder_bitrate(void)
 515 {
 516         int type = 0;
 517         int bitrate = 0;
 518         int err = 0;
 519
 520         g_print("* Bitrate\n");
 521
 522         flush_stdin();
 523
 524         g_print("[type(1:Audio,2:Video) bps] : ");
 525
 526         err = scanf("%d %d", &type, &bitrate);
 527
 528         switch (type) {
 529         case 1:
 530                 return recorder_attr_set_audio_encoder_bitrate(g_cam_handle->recorder, bitrate);
 531         case 2:
 532                 return recorder_attr_set_video_encoder_bitrate(g_cam_handle->recorder, bitrate);
 533         default:
 534                 g_print("invalid type [%d]", type);
 535                 return -1;
 536         }
 537 }
 538
 539
 540 void print_menu()
 541 {
 542         switch (g_cam_handle->menu_state) {
 543         case MENU_STATE_INIT:
 544                 g_print("\n\t=======================================\n");
 545                 g_print("\t   RECORDER_TESTSUIT\n");
 546                 g_print("\t=======================================\n");
 547                 g_print("\t   '1' Video Recording - Rear Camera\n");
 548                 g_print("\t   '2' Audio Recording\n");
 549                 g_print("\t   '3' Audio Recording with stream info\n");
 550                 g_print("\t   '4' Add recorder device changed callback\n");
 551                 g_print("\t   '5' Remove recorder device changed callback\n");
 552                 g_print("\t   '6' Get recorder device state\n");
 553                 g_print("\t   'q' Exit\n");
 554                 g_print("\t=======================================\n");
 555                 g_print("\t  Choose the menu : ");
 556                 break;
 557         case MENU_STATE_MAIN:
 558                 g_print("\n\t=======================================\n");
 559                 if (g_cam_handle->mode == MODE_VIDEO_CAPTURE)
 560                         g_print("\t   Video + Audio Recording\n");
 561                 else
 562                         g_print("\t   Audio Recording\n");
 563                 g_print("\t=======================================\n");
 564                 if (g_recorder_state <= RECORDER_STATE_NONE) {
 565                         g_print("\t   '1' Start Recording\n");
 566                         g_print("\t   '2' Setting\n");
 567                         g_print("\t   'b' back\n");
 568                 } else if (g_recorder_state == RECORDER_STATE_RECORDING) {
 569                         g_print("\t   'p' Pause Recording\n");
 570                         g_print("\t   'c' Cancel\n");
 571                         g_print("\t   's' Save\n");
 572                 } else if (g_recorder_state == RECORDER_STATE_PAUSED) {
 573                         g_print("\t   'r' Resume Recording\n");
 574                         g_print("\t   'c' Cancel\n");
 575                         g_print("\t   's' Save\n");
 576                 }
 577                 g_print("\t=======================================\n");
 578                 break;
 579
 580         case MENU_STATE_SETTING:
 581                 if (g_cam_handle->mode == MODE_VIDEO_CAPTURE) {
 582                         g_print("\n\t=======================================\n");
 583                         g_print("\t   Video + Audio recording > Setting\n");
 584                         g_print("\t=======================================\n");
 585                         g_print("\t  >>>>>>>>>>>>>>>>>>>>>>>>>>>> [Camera/Recorder]  \n");
 586                         g_print("\t     '0' Preview resolution \n");
 587                         g_print("\t     '1' Video resolution \n");
 588                         g_print("\t     '2' Video codec \n");
 589                         g_print("\t     '3' Audio codec \n");
 590                         g_print("\t     '4' File format \n");
 591                         g_print("\t     '5' Size limit \n");
 592                         g_print("\t     '6' Time limit \n");
 593                         g_print("\t     '7' Samplerate \n");
 594                         g_print("\t     '8' Channel \n");
 595                         g_print("\t     '9' Encoder bitrate \n");
 596                         g_print("\t  >>>>>>>>>>>>>>>>>>>> [Display]\n");
 597                         g_print("\t     'v' Display visible \n");
 598                         g_print("\t     'd' Display mode \n");
 599                         g_print("\t     'r' Display rotation \n");
 600                         g_print("\t     'f' Display flip\n");
 601                         g_print("\t  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [etc]\n");
 602                         g_print("\t     's' Strobe (Flash) \n");
 603                         g_print("\t     'z' Video-stabilization \n");
 604                         g_print("\t     'm' Recording Motion Rate setting \n");
 605                         g_print("\t     'M' Set/Unset muxed stream callback \n");
 606                         g_print("\t     'E' Set/Unset video encode decision callback \n");
 607                         g_print("\t     'F' Set file name - %s\n", TARGET_FILENAME_VIDEO);
 608                         g_print("\t     'b' back\n");
 609                         g_print("\t=======================================\n");
 610                 } else {
 611                         g_print("\n\t=======================================\n");
 612                         g_print("\t   Audio recording > Setting\n");
 613                         g_print("\t=======================================\n");
 614                         g_print("\t     '1' Audio codec \n");
 615                         g_print("\t     '2' File format \n");
 616                         g_print("\t     '3' Size limit \n");
 617                         g_print("\t     '4' Time limit \n");
 618                         g_print("\t     '5' Samplerate \n");
 619                         g_print("\t     '6' Channel \n");
 620                         g_print("\t     '7' Encoder bitrate \n");
 621                         g_print("\t     'M' Set/Unset muxed stream callback \n");
 622                         g_print("\t     'F' Set file name - %s\n", TARGET_FILENAME_AUDIO);
 623                         g_print("\t     'b' back\n");
 624                         g_print("\t=======================================\n");
 625                 }
 626                 break;
 627
 628         default:
 629                 g_print("unknow menu state !!\n");
 630                 break;
 631         }
 632
 633         return;
 634 }
 635
 636 static void main_menu(gchar buf)
 637 {
 638         int err = 0;
 639
 640         if (g_cam_handle->mode != MODE_VIDEO_CAPTURE && g_cam_handle->mode != MODE_AUDIO) {
 641                 g_print("\t Invalid mode, back to upper menu \n");
 642                 g_cam_handle->menu_state = MENU_STATE_INIT;
 643                 return;
 644         }
 645
 646         if (g_recorder_state == RECORDER_STATE_NONE) {
 647                 switch (buf) {
 648                 case '1': /* Start Recording */
 649                         g_print("*Recording start!\n");
 650
 651                         g_cam_handle->elapsed_time = 0;
 652                         g_recorder_ve_frame_count = 0;
 653
 654                         err = recorder_start(g_cam_handle->recorder);
 655
 656                         if (err != 0)
 657                                 g_print("Rec start camcorder_record 0x%x\n", err);
 658
 659                         g_recorder_state = RECORDER_STATE_RECORDING;
 660                         break;
 661
 662                 case '2': /* Setting */
 663                         g_cam_handle->menu_state = MENU_STATE_SETTING;
 664                         break;
 665
 666                 case 'b': /* back */
 667                         recorder_unprepare(g_cam_handle->recorder);
 668                         recorder_destroy(g_cam_handle->recorder);
 669                         g_cam_handle->recorder = NULL;
 670
 671                         if (g_cam_handle->camera) {
 672                                 camera_destroy(g_cam_handle->camera);
 673                                 g_cam_handle->camera = NULL;
 674                         }
 675
 676                         g_cam_handle->menu_state = MENU_STATE_INIT;
 677                         break;
 678
 679                 default:
 680                         g_print("\t Invalid input \n");
 681                         break;
 682                 }
 683         } else if (g_recorder_state == RECORDER_STATE_RECORDING || g_recorder_state == RECORDER_STATE_PAUSED) {
 684                 switch (buf) {
 685                 case 'p': /* Pause Recording */
 686                         g_print("*Pause!\n");
 687                         err = recorder_pause(g_cam_handle->recorder);
 688
 689                         if (err < 0)
 690                                 g_print("Rec pause camcorder_pause  = %x\n", err);
 691
 692                         g_recorder_state = RECORDER_STATE_PAUSED;
 693                         break;
 694
 695                 case 'r': /* Resume Recording */
 696                         g_print("*Resume!\n");
 697                         err = recorder_start(g_cam_handle->recorder);
 698                         if (err < 0)
 699                                 g_print("Rec start camcorder_record  = %x\n", err);
 700
 701                         g_recorder_state = RECORDER_STATE_RECORDING;
 702                         break;
 703
 704                 case 'c': /* Cancel */
 705                         g_print("*Cancel Recording !\n");
 706
 707                         err = recorder_cancel(g_cam_handle->recorder);
 708
 709                         if (err < 0)
 710                                 g_print("Cancel recording camcorder_cancel  = %x\n", err);
 711
 712                         g_recorder_state = RECORDER_STATE_NONE;
 713                         break;
 714
 715                 case 's': /* Save */
 716                         g_print("*Save Recording!\n");
 717
 718                         err = recorder_commit(g_cam_handle->recorder);
 719
 720                         if (err < 0)
 721                                 g_print("Save recording recorder_commit  = %x\n", err);
 722
 723                         g_recorder_state = RECORDER_STATE_NONE;
 724                         break;
 725
 726                 default:
 727                         g_print("\t Invalid input \n");
 728                         break;
 729                 }
 730         } else {
 731                 g_print("Wrong camcorder state, check status!!\n");
 732         }
 733
 734         return;
 735 }
 736
 737
 738 static void setting_menu(gchar buf)
 739 {
 740         int idx = 0;
 741         int err = 0;
 742         int result = 0;
 743         int bitrate = 0;
 744
 745         if (g_cam_handle->mode == MODE_VIDEO_CAPTURE) {
 746                 int x = 0;
 747                 int y = 0;
 748                 int width = 0;
 749                 int height = 0;
 750                 float motion_rate = 0.0;
 751                 resolution_stack_t resolution_list;
 752
 753                 switch (buf) {
 754                 /* Camera/Recorder setting */
 755                 case '0':  /* Setting > Preview Resolution setting */
 756                         g_print("* Preview resolution\n");
 757                         resolution_list.count = 0;
 758
 759                         flush_stdin();
 760
 761                         camera_foreach_supported_preview_resolution(g_cam_handle->camera,
 762                                 resolution_cb, &resolution_list);
 763
 764                         err = scanf("%d", &idx);
 765                         if (resolution_list.count > idx && idx >= 0) {
 766                                 g_print("----------------- SET %dx%d ---------------------\n",
 767                                         resolution_list.width[idx], resolution_list.height[idx]);
 768
 769                                 result = camera_set_preview_resolution(g_cam_handle->camera,
 770                                         resolution_list.width[idx], resolution_list.height[idx]);
 771                         } else {
 772                                 g_print("invalid input %d\n", idx);
 773                                 result = -1;
 774                         }
 775
 776                         resolution_list.count = 0;
 777                         break;
 778
 779                 case '1':  /* Setting > Video Resolution setting */
 780                         g_print("* Video resolution\n");
 781                         resolution_list.count = 0;
 782
 783                         flush_stdin();
 784
 785                         recorder_foreach_supported_video_resolution(g_cam_handle->recorder,
 786                                 resolution_cb, &resolution_list);
 787
 788                         err = scanf("%d", &idx);
 789                         if (resolution_list.count > idx && idx >= 0) {
 790                                 g_print("----------------- SET %dx%d ---------------------\n",
 791                                         resolution_list.width[idx], resolution_list.height[idx]);
 792
 793                                 result = recorder_set_video_resolution(g_cam_handle->recorder,
 794                                         resolution_list.width[idx], resolution_list.height[idx]);
 795                         } else {
 796                                 g_print("invalid input %d\n", idx);
 797                                 result = -1;
 798                         }
 799
 800                         resolution_list.count = 0;
 801                         break;
 802
 803                 case '2': /* Setting > Video codec */
 804                         g_print("* Video codec\n");
 805
 806                         flush_stdin();
 807
 808                         recorder_foreach_supported_video_encoder(g_cam_handle->recorder, video_codec_cb, (void *)g_cam_handle);
 809
 810                         err = scanf("%d", &idx);
 811
 812                         result = recorder_set_video_encoder(g_cam_handle->recorder, idx);
 813                         break;
 814
 815                 case '3': /* Setting > Audio codec */
 816                         result = _recorder_set_audio_encoder();
 817                         break;
 818
 819                 case '4': /* Setting > File format */
 820                         result = _recorder_set_file_format();
 821                         break;
 822
 823                 case '5': /* Setting > Size limit */
 824                         result = _recorder_set_size_limit();
 825                         break;
 826
 827                 case '6': /* Setting > Time limit */
 828                         result = _recorder_set_time_limit();
 829                         break;
 830
 831                 case '7': /* Setting > Samplerate */
 832                         result = _recorder_set_audio_samplerate();
 833                         break;
 834
 835                 case '8': /* Setting > Channel */
 836                         result = _recorder_set_audio_channel();
 837                         break;
 838
 839                 case '9': /* Setting > Bitrate */
 840                         result = _recorder_set_encoder_bitrate();
 841                         break;
 842
 843                         /* Display setting */
 844                 case 'v': /* Display visible */
 845                         g_print("* Display visible\n");
 846
 847                         flush_stdin();
 848
 849                         g_print("\t 0. OFF\n");
 850                         g_print("\t 1. ON\n");
 851
 852                         err = scanf("%d", &idx);
 853
 854                         result = camera_set_display_visible(g_cam_handle->camera, idx);
 855                         break;
 856
 857                 case 'd': /*  Setting > Display mode */
 858                         g_print("* Display mode\n");
 859
 860                         flush_stdin();
 861                         for (idx = 0 ; idx < 6  ; idx++)
 862                                 g_print("%d. %s\n", idx, display_mode[idx]);
 863
 864                         err = scanf("%d", &idx);
 865
 866                         if (idx == CAMERA_DISPLAY_MODE_CUSTOM_ROI) {
 867                                 g_print("ROI area [x y width height] : ");
 868                                 err = scanf("%d %d %d %d", &x, &y, &width, &height);
 869                         }
 870
 871                         result = camera_set_display_mode(g_cam_handle->camera, idx - 1);
 872
 873                         if (idx == CAMERA_DISPLAY_MODE_CUSTOM_ROI)
 874                                 result |= camera_attr_set_display_roi_area(g_cam_handle->camera, x, y, width, height);
 875                         break;
 876
 877                 case 'r': /* Setting > Display Rotate */
 878                         g_print("* Display rotation\n");
 879
 880                         flush_stdin();
 881
 882                         g_print("\t0. 0\n\t1. 90\n\t2. 180\n\t3. 270\n\n");
 883
 884                         err = scanf("%d", &idx);
 885
 886                         result = camera_set_display_rotation(g_cam_handle->camera, idx);
 887                         break;
 888
 889                 case 'f': /* Setting > Display Flip */
 890                         g_print("* Display flip\n");
 891
 892                         flush_stdin();
 893
 894                         g_print("\t0. NONE\n\t1. HORIZONTAL\n\t2. VERTICAL\n\t3. BOTH\n\n");
 895
 896                         err = scanf("%d", &idx);
 897
 898                         result = camera_set_display_flip(g_cam_handle->camera, idx);
 899                         break;
 900
 901                         /* ext. setting */
 902                 case 's': /* Setting > Strobe setting */
 903                         g_print("* Strobe Mode\n");
 904
 905                         flush_stdin();
 906
 907                         camera_attr_foreach_supported_flash_mode(g_cam_handle->camera, strobe_mode_cb, NULL);
 908
 909                         err = scanf("%d", &idx);
 910
 911                         result = camera_attr_set_flash_mode(g_cam_handle->camera, idx);
 912                         break;
 913
 914                 case 'z': /* Setting > Video-stabilization */
 915                         g_print("* Video stabilization\n");
 916
 917                         flush_stdin();
 918
 919                         for (idx = 0 ; idx < 2 ; idx++)
 920                                 g_print("\t %d. %s\n", idx + 1, vs_mode[idx]);
 921
 922                         err = scanf("%d", &idx);
 923
 924                         if (idx == 2) {
 925                                 g_print("\n Restart preview with NV12 and 720p resolution\n");
 926
 927                                 result = camera_stop_preview(g_cam_handle->camera);
 928                                 result |= camera_set_preview_resolution(g_cam_handle->camera, 1280, 720);
 929                                 result |= camera_set_preview_format(g_cam_handle->camera, CAMERA_PIXEL_FORMAT_NV12);
 930
 931                                 result |= camera_attr_enable_video_stabilization(g_cam_handle->camera, idx-1);
 932
 933                                 if (result == 0)
 934                                         result |= camera_start_preview(g_cam_handle->camera);
 935                         }
 936                         break;
 937
 938                 case 'm':
 939                         g_print("*Recording Motion Rate setting! (should be bigger than zero)\n");
 940
 941                         flush_stdin();
 942
 943                         err = scanf("%f", &motion_rate);
 944
 945                         result = recorder_attr_set_recording_motion_rate(g_cam_handle->recorder, motion_rate);
 946                         break;
 947
 948                 case 'M': /* Setting > muxed stream callback */
 949                         result = _recorder_set_muxed_stream_cb();
 950                         break;
 951
 952                 case 'E': /* Setting > video encode decision callback */
 953                         g_print("* Video encode decision callback\n");
 954
 955                         flush_stdin();
 956
 957                         g_print("[set(1)/unset(2)] : ");
 958
 959                         err = scanf("%d", &idx);
 960
 961                         if (idx == 1)
 962                                 result = recorder_set_video_encode_decision_cb(g_cam_handle->recorder, _recording_video_encode_decision_cb, NULL);
 963                         else if (idx == 2)
 964                                 result = recorder_unset_video_encode_decision_cb(g_cam_handle->recorder);
 965                         else
 966                                 result = RECORDER_ERROR_INVALID_PARAMETER;
 967
 968                         break;
 969
 970                 case 'F': /* Set file name */
 971                         result = recorder_set_filename(g_cam_handle->recorder, TARGET_FILENAME_VIDEO);
 972                         break;
 973
 974                 case 'b': /* back */
 975                         g_cam_handle->menu_state = MENU_STATE_MAIN;
 976                         break;
 977
 978                 default:
 979                         g_print("\t Invalid input \n");
 980                         break;
 981                 }
 982         } else {
 983                 switch (buf) {
 984                 case '1': /* Setting > Audio codec */
 985                         result = _recorder_set_audio_encoder();
 986                         break;
 987
 988                 case '2': /* Setting > File format */
 989                         result = _recorder_set_file_format();
 990                         break;
 991
 992                 case '3': /* Setting > Size limit */
 993                         result = _recorder_set_size_limit();
 994                         break;
 995
 996                 case '4': /* Setting > Time limit */
 997                         result = _recorder_set_time_limit();
 998                         break;
 999
1000                 case '5': /* Setting > Samplerate */
1001                         result = _recorder_set_audio_samplerate();
1002                         break;
1003
1004                 case '6': /* Setting > Channel */
1005                         result = _recorder_set_audio_channel();
1006                         break;
1007
1008                 case '7': /* Setting > Bitrate */
1009                         g_print("* Bitrate\n");
1010
1011                         flush_stdin();
1012
1013                         g_print("[bps] : ");
1014
1015                         err = scanf("%d", &bitrate);
1016
1017                         result = recorder_attr_set_audio_encoder_bitrate(g_cam_handle->recorder, bitrate);
1018                         break;
1019
1020                 case 'M': /* Setting > muxed stream callback */
1021                         result = _recorder_set_muxed_stream_cb();
1022                         break;
1023
1024                 case 'F': /* Set file name */
1025                         result = recorder_set_filename(g_cam_handle->recorder, TARGET_FILENAME_AUDIO);
1026                         break;
1027
1028                 case 'b': /* back */
1029                         g_cam_handle->menu_state = MENU_STATE_MAIN;
1030                         break;
1031
1032                 default:
1033                         g_print("\t Invalid input \n");
1034                         break;
1035                 }
1036         }
1037
1038         if (buf != 'b') {
1039                 if (result == 0) /* CAMERA_ERROR_NONE or RECORDER_ERROR_NONE */
1040                         g_print("\n===== SET OK =====\n");
1041                 else
1042                         g_print("\n===== SET FAIL 0x%x =====\n", result);
1043         }
1044
1045         return;
1046 }
1047
1048
1049 gboolean cmd_input(GIOChannel *channel, GIOCondition condition, gpointer data)
1050 {
1051         gchar *buf = NULL;
1052         gsize read_size;
1053         GError *g_error = NULL;
1054
1055         g_io_channel_read_line(channel, &buf, &read_size, NULL, &g_error);
1056         if (g_error) {
1057                 g_print("\tg_io_channel_read_chars error\n");
1058                 g_error_free(g_error);
1059                 g_error = NULL;
1060         }
1061
1062         if (buf) {
1063                 g_strstrip(buf);
1064
1065                 g_print("\tMenu Status : %d\n", g_cam_handle->menu_state);
1066                 switch (g_cam_handle->menu_state) {
1067                 case MENU_STATE_INIT:
1068                         mode_change(buf[0]);
1069                         break;
1070                 case MENU_STATE_MAIN:
1071                         main_menu(buf[0]);
1072                         break;
1073                 case MENU_STATE_SETTING:
1074                         setting_menu(buf[0]);
1075                         break;
1076                 default:
1077                         break;
1078                 }
1079
1080                 g_free(buf);
1081                 buf = NULL;
1082
1083                 print_menu();
1084         } else {
1085                 g_print("\tNo read input\n");
1086         }
1087
1088         return TRUE;
1089 }
1090
1091 static gboolean init(int type)
1092 {
1093         int ret;
1094
1095         if (!g_cam_handle || !g_cam_handle->recorder) {
1096                 g_print("NULL handle[%p]\n", g_cam_handle);
1097                 return FALSE;
1098         }
1099
1100         ret = recorder_set_file_format(g_cam_handle->recorder, RECORDER_FILE_FORMAT_MP4);
1101         if (ret != RECORDER_ERROR_NONE) {
1102                 g_print("recorder_set_file_format failed[0x%x]\n", ret);
1103                 return FALSE;
1104         }
1105
1106         ret = recorder_attr_set_audio_device(g_cam_handle->recorder, RECORDER_AUDIO_DEVICE_MIC);
1107         if (ret != RECORDER_ERROR_NONE) {
1108                 g_print("recorder_attr_set_audio_device failed[0x%x]\n", ret);
1109                 return FALSE;
1110         }
1111
1112         ret = recorder_set_audio_encoder(g_cam_handle->recorder, RECORDER_AUDIO_CODEC_AAC);
1113         if (ret != RECORDER_ERROR_NONE) {
1114                 g_print("recorder_set_audio_encoder failed[0x%x]\n", ret);
1115                 return FALSE;
1116         }
1117
1118         ret = recorder_attr_set_audio_samplerate(g_cam_handle->recorder, AUDIO_SOURCE_SAMPLERATE_AAC);
1119         if (ret != RECORDER_ERROR_NONE) {
1120                 g_print("recorder_attr_set_audio_samplerate failed[0x%x]\n", ret);
1121                 return FALSE;
1122         }
1123
1124         ret = recorder_attr_set_audio_channel(g_cam_handle->recorder, AUDIO_SOURCE_CHANNEL_AAC);
1125         if (ret != RECORDER_ERROR_NONE) {
1126                 g_print("recorder_attr_set_audio_channel failed[0x%x]\n", ret);
1127                 return FALSE;
1128         }
1129
1130         if (type == MODE_VIDEO_CAPTURE) {
1131                 /*================================================================================
1132                   Video capture mode
1133                  *=================================================================================*/
1134                 ret = recorder_set_video_encoder(g_cam_handle->recorder, RECORDER_VIDEO_CODEC_MPEG4);
1135                 if (ret != RECORDER_ERROR_NONE) {
1136                         g_print("recorder_set_video_encoder failed[0x%x]\n", ret);
1137                         return FALSE;
1138                 }
1139
1140                 ret = recorder_attr_set_video_encoder_bitrate(g_cam_handle->recorder, VIDEO_ENCODE_BITRATE);
1141                 if (ret != RECORDER_ERROR_NONE) {
1142                         g_print("recorder_attr_set_video_encoder_bitrate failed[0x%x]\n", ret);
1143                         return FALSE;
1144                 }
1145         } else if (type == MODE_AUDIO) {
1146                 /*================================================================================
1147                   Audio mode
1148                  *=================================================================================*/
1149                 ret = recorder_attr_set_time_limit(g_cam_handle->recorder, 360000);
1150                 if (ret != RECORDER_ERROR_NONE) {
1151                         g_print("recorder_attr_set_time_limit failed[0x%x]\n", ret);
1152                         return FALSE;
1153                 }
1154
1155                 ret = recorder_attr_set_audio_encoder_bitrate(g_cam_handle->recorder, 128000);
1156                 if (ret != RECORDER_ERROR_NONE) {
1157                         g_print("recorder_attr_set_audio_encoder_bitrate failed[0x%x]\n", ret);
1158                         return FALSE;
1159                 }
1160         }
1161
1162         recorder_set_error_cb(g_cam_handle->recorder, _recorder_error_cb, NULL);
1163         recorder_set_state_changed_cb(g_cam_handle->recorder, _state_changed_cb, NULL);
1164         recorder_set_interrupted_cb(g_cam_handle->recorder, _interrupted_cb, NULL);
1165         recorder_set_recording_status_cb(g_cam_handle->recorder, _recording_status_cb, NULL);
1166         recorder_set_recording_limit_reached_cb(g_cam_handle->recorder, _recording_limit_reached_cb, NULL);
1167
1168         g_print("Init DONE.\n");
1169
1170         return TRUE;
1171 }
1172
1173 cam_handle_t *init_handle()
1174 {
1175         g_cam_handle = g_new0(cam_handle_t, 1);
1176
1177         g_cam_handle->mode = MODE_VIDEO_CAPTURE;  /* image(capture)/video(recording) mode */
1178         g_cam_handle->menu_state = MENU_STATE_INIT;
1179         g_cam_handle->isMute = FALSE;
1180         g_cam_handle->elapsed_time = 0;
1181         g_cam_handle->fps = SRC_VIDEO_FRAME_RATE_15; /*SRC_VIDEO_FRAME_RATE_30;*/
1182
1183         return g_cam_handle;
1184 }
1185
1186 static void _sound_stream_focus_state_changed_cb(sound_stream_info_h stream_info, sound_stream_focus_mask_e focus_mask, sound_stream_focus_state_e focus_state,
1187         sound_stream_focus_change_reason_e reason_for_change, int sound_behavior, const char *additional_info, void *user_data)
1188 {
1189         g_print("focus changed : reason %d\n", reason_for_change);
1190         return;
1191 }
1192
1193
1194 /**
1195  * This function is to change camcorder mode.
1196  *
1197  * @param    buf    [in]    user input
1198  *
1199  * @return   This function returns TRUE/FALSE
1200  * @remark
1201  * @see      other functions
1202  */
1203 static gboolean mode_change(gchar buf)
1204 {
1205         int err = RECORDER_ERROR_NONE;
1206         int state = RECORDER_STATE_NONE;
1207         char media_type = '\0';
1208         bool check = FALSE;
1209         struct timeval time_previous;
1210         struct timeval time_current;
1211         struct timeval time_result;
1212         recorder_device_state_e device_state = RECORDER_DEVICE_STATE_IDLE;
1213         sound_stream_info_h stream_info = NULL;
1214
1215         gettimeofday(&time_previous, NULL);
1216
1217         if (g_cam_handle->recorder) {
1218                 err = recorder_get_state(g_cam_handle->recorder, (recorder_state_e*)&state);
1219                 if (state != RECORDER_STATE_NONE) {
1220                         if (state == RECORDER_STATE_RECORDING ||
1221                                         state == RECORDER_STATE_PAUSED) {
1222                                 g_print("recorder_cancel\n");
1223                                 err = recorder_cancel(g_cam_handle->recorder);
1224                                 if (err != RECORDER_ERROR_NONE) {
1225                                         g_print("exit recorder_cancel failed 0x%x\n", err);
1226                                         return FALSE;
1227                                 }
1228                         }
1229
1230                         err = recorder_get_state(g_cam_handle->recorder, (recorder_state_e*)&state);
1231                         if (state == RECORDER_STATE_READY) {
1232                                 g_print("recorder_unprepare\n");
1233                                 recorder_unprepare(g_cam_handle->recorder);
1234                         }
1235
1236                         err = recorder_get_state(g_cam_handle->recorder, (recorder_state_e*)&state);
1237                         if (state == RECORDER_STATE_CREATED) {
1238                                 g_print("recorder_destroy\n");
1239                                 err = recorder_destroy(g_cam_handle->recorder);
1240                                 if (err == RECORDER_ERROR_NONE) {
1241                                         g_print("recorder_destroy done\n");
1242                                         g_cam_handle->recorder = NULL;
1243                                 }
1244                         }
1245                 }
1246         }
1247
1248         switch (buf) {
1249         case '1':
1250                 g_cam_handle->mode = MODE_VIDEO_CAPTURE;
1251
1252                 err = camera_create(CAMERA_DEVICE_CAMERA0, &g_cam_handle->camera);
1253                 if (err != CAMERA_ERROR_NONE) {
1254                         g_print("camera create failed 0x%d\n", err);
1255                         return FALSE;
1256                 }
1257
1258                 set_display(g_cam_handle);
1259
1260                 err = recorder_create_videorecorder(g_cam_handle->camera, &g_cam_handle->recorder);
1261                 if (err != RECORDER_ERROR_NONE) {
1262                         g_print("video recorder create failed 0x%d\n", err);
1263                         camera_stop_preview(g_cam_handle->camera);
1264                         camera_destroy(g_cam_handle->camera);
1265                         g_cam_handle->camera = NULL;
1266                         return FALSE;
1267                 }
1268
1269                 check = TRUE;
1270                 break;
1271         case '2':
1272                 g_cam_handle->mode = MODE_AUDIO;
1273                 err = recorder_create_audiorecorder(&g_cam_handle->recorder);
1274                 if (err != RECORDER_ERROR_NONE) {
1275                         g_print("audio recorder create failed 0x%x\n", err);
1276                         return FALSE;
1277                 }
1278
1279                 check = TRUE;
1280                 break;
1281         case '3':
1282                 g_cam_handle->mode = MODE_AUDIO;
1283                 err = recorder_create_audiorecorder(&g_cam_handle->recorder);
1284                 if (err != RECORDER_ERROR_NONE) {
1285                         g_print("audio recorder create failed 0x%d\n", err);
1286                         return FALSE;
1287                 }
1288
1289                 sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, _sound_stream_focus_state_changed_cb, g_cam_handle, &stream_info);
1290                 if (stream_info) {
1291                         recorder_set_sound_stream_info(g_cam_handle->recorder, stream_info);
1292                         sound_manager_destroy_stream_information(stream_info);
1293                 }
1294
1295                 check = TRUE;
1296                 break;
1297         case '4':
1298                 err = recorder_add_device_state_changed_cb(_recorder_device_state_changed_cb,
1299                         NULL, &g_recorder_device_changed_cb_id);
1300                 g_print("add result 0x%x - cb id %d\n", err, g_recorder_device_changed_cb_id);
1301                 return FALSE;
1302         case '5':
1303                 if (g_recorder_device_changed_cb_id > 0) {
1304                         err = recorder_remove_device_state_changed_cb(g_recorder_device_changed_cb_id);
1305                         g_recorder_device_changed_cb_id = 0;
1306                         g_print("remove result 0x%x\n", err);
1307                 } else {
1308                         g_print("invalid callback id %d\n", g_recorder_device_changed_cb_id);
1309                 }
1310                 return FALSE;
1311         case '6':
1312                 err = recorder_get_device_state(RECORDER_TYPE_AUDIO, &device_state);
1313                 g_print("get result 0x%x - audio state %d\n", err, device_state);
1314                 err = recorder_get_device_state(RECORDER_TYPE_VIDEO, &device_state);
1315                 g_print("get result 0x%x - video state %d\n", err, device_state);
1316                 return FALSE;
1317         case 'q':
1318                 g_print("\t Quit Recorder Testsuite!!\n");
1319                 g_cam_handle->mode = -1;
1320                 quit_test();
1321                 return FALSE;
1322         default:
1323                 g_print("\t Invalid media type(%c)\n", media_type);
1324                 return FALSE;
1325         }
1326
1327         if (!init(g_cam_handle->mode)) {
1328                 g_print("testsuite init() failed.\n");
1329                 return FALSE;
1330         }
1331
1332         err = recorder_prepare(g_cam_handle->recorder);
1333         if (err != RECORDER_ERROR_NONE) {
1334                 g_print("recorder_prepare  = %x\n", err);
1335                 return FALSE;
1336         }
1337
1338         gettimeofday(&time_current, NULL);
1339         timersub(&time_current, &time_previous, &time_result);
1340
1341         g_print("Recorder Preparing Time  : %ld.%lds\n", time_result.tv_sec, time_result.tv_usec);
1342
1343         g_cam_handle->menu_state = MENU_STATE_MAIN;
1344
1345         return TRUE;
1346 }