test/recorder_test.c

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