test/recorder_test.c

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