test/multimedia_recorder_test.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17
  18
  19
  20 #include <stdio.h>
  21 #include <Elementary.h>
  22 #include <glib.h>
  23 #include <Ecore.h>
  24 #include <Ecore_X.h>
  25 #include <Elementary.h>
  26 #include <pthread.h>
  27 #include <recorder.h>
  28 #include <camera.h>
  29 #include <mm.h>
  30 #include <mm_camcorder.h>
  31 #include <mm_types.h>
  32
  33 Evas_Object* mEvasWindow;
  34 Ecore_X_Window mXwindow;
  35 Ecore_X_Window preview_win;
  36
  37 bool record_state_cb(recorder_state_e previous , recorder_state_e current , int by_asm, void *user_data){
  38         char * state_table[] = {
  39                 "MEDIARECORDER_STATE_NONE",                             /**< recorder is not created yet */
  40                 "MEDIARECORDER_STATE_CREATED",                          /**< recorder is created, but not initialized yet */
  41                 "MEDIARECORDER_STATE_READY",                    /**< prepare to record if video recorder is playing preview */
  42                 "MEDIARECORDER_STATE_RECORDING",        /**< While recording */
  43                 "MEDIARECORDER_STATE_PAUSED",                   /**< Pause recording */
  44                 "MEDIARECORDER_STATE_NUM"                               /**< Number of recorder states */
  45                 };
  46         printf("%s\n", state_table[current]);
  47         return 0;
  48 }
  49
  50 int recording_size_limit_test(recorder_h recorder){
  51         int ret;
  52         int fail=0;
  53         int int_value;
  54         // negative test
  55         printf("-------------limit size test----------------------\n");
  56         printf("-negative test\n");
  57         ret = recorder_attr_set_size_limit(recorder, -1);
  58         if( ret == 0 ){
  59                 printf("FAIL\n");
  60                 fail++;
  61         }else
  62                 printf("PASS\n");
  63
  64         printf("-0 test\n");
  65         ret = recorder_attr_set_size_limit(recorder, 0);
  66         if( ret != 0 ){
  67                 printf("FAIL\n");
  68                 fail++;
  69         }else
  70                 printf("PASS\n");
  71
  72         ret = recorder_attr_get_size_limit(recorder,&int_value);
  73         if( int_value != 0){
  74                 printf("FAIL\n");
  75                 fail++;
  76         }else
  77                 printf("PASS\n");
  78
  79
  80         printf("-1212 set test\n");
  81         ret = recorder_attr_set_size_limit(recorder, 1212);
  82         if( ret != 0 ){
  83                 printf("FAIL\n");
  84                 fail++;
  85         }else
  86                 printf("PASS\n");
  87
  88         ret = recorder_attr_get_size_limit(recorder,&int_value);
  89         if( int_value != 1212){
  90                 printf("FAIL\n");
  91                 fail++;
  92         }else
  93                 printf("PASS\n");
  94
  95         return -fail;
  96 }
  97
  98 int recording_time_limit_test(recorder_h recorder){
  99         int ret;
 100         int fail=0;
 101         int int_value;
 102         // negative test
 103         printf("-------------limit time test----------------------\n");
 104
 105         ret = recorder_attr_set_time_limit(recorder, -1);
 106         if( ret == 0 ){
 107                 printf("FAIL\n");
 108                 fail++;
 109         }else
 110                 printf("PASS\n");
 111
 112         printf("-0 test\n");
 113         ret = recorder_attr_set_time_limit(recorder, 0);
 114         if( ret != 0 ){
 115                 printf("FAIL\n");
 116                 fail++;
 117         }else
 118                 printf("PASS\n");
 119
 120         ret = recorder_attr_get_time_limit(recorder,&int_value);
 121         if( int_value != 0){
 122                 printf("FAIL\n");
 123                 fail++;
 124         }else
 125                 printf("PASS\n");
 126
 127
 128         printf("-1212 set test\n");
 129         ret = recorder_attr_set_time_limit(recorder, 1212);
 130         if( ret != 0 ){
 131                 printf("FAIL\n");
 132                 fail++;
 133         }else
 134                 printf("PASS\n");
 135
 136         ret = recorder_attr_get_time_limit(recorder,&int_value);
 137         if( int_value != 1212){
 138                 printf("FAIL\n");
 139                 fail++;
 140         }else
 141                 printf("PASS\n");
 142
 143
 144         return -fail;
 145 }
 146
 147 int fileformat_test_fail = 0;
 148 bool _file_format_test_cb(recorder_file_format_e format, void *user_data){
 149         int ret;
 150         recorder_h recorder = (recorder_h)user_data;
 151         recorder_file_format_e get_format;
 152         ret = recorder_set_file_format(recorder, format);
 153         recorder_get_file_format(recorder, &get_format);
 154
 155         if( get_format != format){
 156                 printf("FAIL\n");
 157                 fileformat_test_fail++;
 158         }else
 159                 printf("PASS\n");
 160         return true;
 161 }
 162
 163
 164 int fileformat_test(recorder_h recorder){
 165         fileformat_test_fail = 0;
 166         printf("----------------file format test ------------------\n");
 167         recorder_foreach_supported_file_format(recorder, _file_format_test_cb, recorder);
 168         return -fileformat_test_fail;
 169 }
 170
 171 int videoencoder_test_fail = 0;
 172 bool _video_encoder_test_cb(recorder_video_codec_e codec, void *user_data){
 173         int ret;
 174         recorder_h recorder = (recorder_h)user_data;
 175         recorder_video_codec_e get_codec;
 176         ret = recorder_set_video_encoder(recorder, codec);
 177         recorder_get_video_encoder(recorder, &get_codec);
 178
 179
 180         if( get_codec != codec){
 181                 printf("FAIL\n");
 182                 videoencoder_test_fail++;
 183         }else
 184                 printf("PASS\n");
 185         return true;
 186 }
 187
 188
 189 int video_encoder_test(recorder_h recorder){
 190         videoencoder_test_fail = 0;
 191         printf("----------------video encoder test ------------------\n");
 192         recorder_foreach_supported_video_encoder(recorder, _video_encoder_test_cb, recorder);
 193         return -videoencoder_test_fail;
 194 }
 195
 196 int audioencoder_test_fail = 0;
 197 bool _audio_encoder_test_cb(recorder_audio_codec_e codec, void *user_data){
 198         int ret;
 199         recorder_h recorder = (recorder_h)user_data;
 200         recorder_audio_codec_e get_codec;
 201         ret = recorder_set_audio_encoder(recorder, codec);
 202         recorder_get_audio_encoder(recorder, &get_codec);
 203
 204
 205         if( get_codec != codec){
 206                 printf("FAIL\n");
 207                 audioencoder_test_fail++;
 208         }else
 209                 printf("PASS\n");
 210         return true;
 211 }
 212
 213
 214 int audio_encoder_test(recorder_h recorder){
 215         audioencoder_test_fail = 0;
 216         printf("----------------audio encoder test ------------------\n");
 217         recorder_foreach_supported_audio_encoder(recorder, _audio_encoder_test_cb, recorder);
 218         return -audioencoder_test_fail;
 219 }
 220
 221 int recording_audio_device_test(recorder_h recorder)
 222 {
 223         int ret;
 224         int fail=0;
 225         recorder_audio_device_e  int_value;
 226         // negative test
 227         printf("-------------audio device test----------------------\n");
 228         printf("-negative test\n");
 229         ret = recorder_attr_set_audio_device (recorder, -1);
 230         if( ret == 0 ){
 231                 printf("FAIL\n");
 232                 fail++;
 233         }else
 234                 printf("PASS\n");
 235
 236         printf("-RECORDER_AUDIO_DEVICE_MIC test\n");
 237         ret = recorder_attr_set_audio_device(recorder, RECORDER_AUDIO_DEVICE_MIC);
 238         if( ret != 0 ){
 239                 printf("FAIL\n");
 240                 fail++;
 241         }else
 242                 printf("PASS\n");
 243
 244         ret = recorder_attr_get_audio_device(recorder,&int_value);
 245         if( int_value != RECORDER_AUDIO_DEVICE_MIC){
 246                 printf("FAIL\n");
 247                 fail++;
 248         }else
 249                 printf("PASS\n");
 250
 251
 252         printf("-RECORDER_AUDIO_DEVICE_MODEM  set test\n");
 253         ret = recorder_attr_set_audio_device(recorder, RECORDER_AUDIO_DEVICE_MODEM );
 254         if( ret != 0 ){
 255                 printf("FAIL\n");
 256                 fail++;
 257         }else
 258                 printf("PASS\n");
 259
 260         ret = recorder_attr_get_audio_device(recorder,&int_value);
 261         if( int_value != RECORDER_AUDIO_DEVICE_MODEM){
 262                 printf("FAIL\n");
 263                 fail++;
 264         }else
 265                 printf("PASS\n");
 266
 267         return -fail;
 268 }
 269
 270 int recording_samplerate_test(recorder_h recorder){
 271         int ret;
 272         int fail=0;
 273         int int_value;
 274         // negative test
 275         printf("-------------samplerate test----------------------\n");
 276
 277         ret = recorder_attr_set_audio_samplerate(recorder, -1);
 278         if( ret == 0 ){
 279                 printf("FAIL\n");
 280                 fail++;
 281         }else
 282                 printf("PASS\n");
 283
 284         printf("-44100 test\n");
 285         ret = recorder_attr_set_audio_samplerate(recorder, 44100);
 286         if( ret != 0 ){
 287                 printf("FAIL\n");
 288                 fail++;
 289         }else
 290                 printf("PASS\n");
 291
 292         ret = recorder_attr_get_audio_samplerate(recorder,&int_value);
 293         if( int_value != 44100){
 294                 printf("FAIL\n");
 295                 fail++;
 296         }else
 297                 printf("PASS\n");
 298
 299
 300         printf("-1212 set test\n");
 301         ret = recorder_attr_set_audio_samplerate(recorder, 1212);
 302         if( ret != 0 ){
 303                 printf("FAIL\n");
 304                 fail++;
 305         }else
 306                 printf("PASS\n");
 307
 308         ret = recorder_attr_get_audio_samplerate(recorder,&int_value);
 309         if( int_value != 1212){
 310                 printf("FAIL\n");
 311                 fail++;
 312         }else
 313                 printf("PASS\n");
 314
 315
 316         return -fail;
 317 }
 318
 319
 320 int recording_audio_encoder_bitrate_test(recorder_h recorder){
 321         int ret;
 322         int fail=0;
 323         int int_value;
 324         // negative test
 325         printf("-------------audio encoder bitrate test----------------------\n");
 326         printf("-negative test\n");
 327         ret = recorder_attr_set_audio_encoder_bitrate (recorder, -2);
 328         if( ret == 0 ){
 329                 printf("FAIL\n");
 330                 fail++;
 331         }else
 332                 printf("PASS\n");
 333
 334         printf("-12200 test\n");
 335         ret = recorder_attr_set_audio_encoder_bitrate (recorder, 12200);
 336         if( ret != 0 ){
 337                 printf("FAIL\n");
 338                 fail++;
 339         }else
 340                 printf("PASS\n");
 341
 342         ret = recorder_attr_get_audio_encoder_bitrate (recorder,&int_value);
 343         if( int_value != 12200){
 344                 printf("FAIL\n");
 345                 fail++;
 346         }else
 347                 printf("PASS\n");
 348
 349
 350         printf("-288000  set test\n");
 351         ret = recorder_attr_set_audio_encoder_bitrate (recorder, 288000 );
 352         if( ret != 0 ){
 353                 printf("FAIL\n");
 354                 fail++;
 355         }else
 356                 printf("PASS\n");
 357
 358         ret = recorder_attr_get_audio_encoder_bitrate (recorder,&int_value);
 359         if( int_value != 288000 ){
 360                 printf("FAIL\n");
 361                 fail++;
 362         }else
 363                 printf("PASS\n");
 364
 365         printf("-1212  set test\n");
 366         ret = recorder_attr_set_audio_encoder_bitrate (recorder, 1212 );
 367         if( ret != 0 ){
 368                 printf("FAIL\n");
 369                 fail++;
 370         }else
 371                 printf("PASS\n");
 372
 373         ret = recorder_attr_get_audio_encoder_bitrate (recorder,&int_value);
 374         if( int_value != 1212 ){
 375                 printf("FAIL\n");
 376                 fail++;
 377         }else
 378                 printf("PASS\n");
 379
 380         return -fail;
 381 }
 382
 383 int recording_video_encoder_bitrate_test(recorder_h recorder){
 384         int ret;
 385         int fail=0;
 386         int int_value;
 387         // negative test
 388         printf("-------------video encoder bitrate test----------------------\n");
 389         printf("-negative test\n");
 390         ret = recorder_attr_set_video_encoder_bitrate (recorder, -2);
 391         if( ret == 0 ){
 392                 printf("FAIL\n");
 393                 fail++;
 394         }else
 395                 printf("PASS\n");
 396
 397         printf("-12200 test\n");
 398         ret = recorder_attr_set_video_encoder_bitrate (recorder, 12200);
 399         if( ret != 0 ){
 400                 printf("FAIL\n");
 401                 fail++;
 402         }else
 403                 printf("PASS\n");
 404
 405         ret = recorder_attr_get_video_encoder_bitrate (recorder,&int_value);
 406         if( int_value != 12200){
 407                 printf("FAIL\n");
 408                 fail++;
 409         }else
 410                 printf("PASS\n");
 411
 412
 413         printf("-288000  set test\n");
 414         ret = recorder_attr_set_video_encoder_bitrate (recorder, 288000 );
 415         if( ret != 0 ){
 416                 printf("FAIL\n");
 417                 fail++;
 418         }else
 419                 printf("PASS\n");
 420
 421         ret = recorder_attr_get_video_encoder_bitrate (recorder,&int_value);
 422         if( int_value != 288000 ){
 423                 printf("FAIL\n");
 424                 fail++;
 425         }else
 426                 printf("PASS\n");
 427
 428         printf("-1212  set test\n");
 429         ret = recorder_attr_set_video_encoder_bitrate (recorder, 1212 );
 430         if( ret != 0 ){
 431                 printf("FAIL\n");
 432                 fail++;
 433         }else
 434                 printf("PASS\n");
 435
 436         ret = recorder_attr_get_video_encoder_bitrate (recorder,&int_value);
 437         if( int_value != 1212 ){
 438                 printf("FAIL\n");
 439                 fail++;
 440         }else
 441                 printf("PASS\n");
 442
 443         return -fail;
 444 }
 445
 446
 447 typedef struct{
 448         bool iscalled;
 449         bool isprepare;
 450         bool isrecording;
 451         bool ispaused;
 452         recorder_state_e state;
 453 } state_change_data;
 454
 455 void _state_change_test_cb(recorder_state_e previous, recorder_state_e current, bool by_asm, void *user_data){
 456         printf(" state change %d => %d\n", previous , current);
 457         state_change_data * data = (state_change_data*)user_data;
 458         if( current == RECORDER_STATE_READY )
 459                 data->isprepare = true;
 460         if( current == RECORDER_STATE_RECORDING )
 461                 data->isrecording = true;
 462         if( current == RECORDER_STATE_PAUSED )
 463                 data->ispaused = true;
 464
 465         data->state = current;
 466
 467         //printf("state %d\n",current);
 468 }
 469
 470 int recorder_state_change_test(){
 471         char *state_str[] = {   "RECORDER_STATE_NONE",                          /**< recorder is not created yet */
 472                 "RECORDER_STATE_CREATED",                               /**< recorder is created, but not initialized yet */
 473                 "RECORDER_STATE_READY",                 /**< prepare to record if video recorder is playing preview */
 474                 "RECORDER_STATE_RECORDING",     /**< While recording */
 475                 "RECORDER_STATE_PAUSED",                        /**< Pause recording */
 476         };
 477         recorder_h recorder;
 478         state_change_data data;
 479         int ret;
 480         recorder_state_e state;
 481         recorder_create_audiorecorder(&recorder);
 482         data.iscalled = false;
 483         data.isprepare = false;
 484         data.isrecording = false;
 485         data.ispaused = false;
 486         data.state = 0;
 487         printf("-------------------------recorder state change test -------------------\n");
 488         recorder_get_state(recorder, &state);
 489         printf("state = %s\n", state_str[state]);
 490         recorder_set_state_changed_cb(recorder, _state_change_test_cb, &data);
 491         recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
 492         ret = recorder_prepare(recorder);
 493         printf("recorder_prepare ret = %x\n", ret);
 494         recorder_get_state(recorder, &state);
 495         printf("state = %s\n", state_str[state]);
 496         ret = recorder_start(recorder);
 497         printf("recorder_start ret = %x\n", ret);
 498         recorder_get_state(recorder, &state);
 499         printf("state = %s\n", state_str[state]);
 500         sleep(1);
 501         ret = recorder_pause(recorder);
 502         printf("recorder_pause ret = %x\n", ret);
 503         recorder_get_state(recorder, &state);
 504         printf("state = %s\n", state_str[state]);
 505
 506         ret =recorder_commit(recorder);
 507         sleep(2);
 508
 509         if( data.isprepare && data.isrecording && data.ispaused && data.state == RECORDER_STATE_READY ){
 510                 printf("PASS\n");
 511                 ret = 0;
 512         }else{
 513                 printf("FAIL data.isprepare %d, data.isrecording %d,  data.ispaused %d,  data.state %d \n", data.isprepare , data.isrecording , data.ispaused , data.state );
 514                 ret = -1;
 515         }
 516
 517         ret = recorder_unprepare(recorder);
 518         printf("recorder_unprepare ret = %x\n", ret);
 519         recorder_get_state(recorder, &state);
 520         printf("state = %s\n", state_str[state]);
 521
 522         ret = recorder_destroy(recorder);
 523         printf("recorder_destroy ret = %x\n", ret);
 524
 525         return ret;
 526
 527 }
 528
 529
 530 typedef struct {
 531         int elapsed_time;
 532         int file_size;
 533 } recording_result;
 534 void _recording_status_test_cb(int elapsed_time, int file_size, void *user_data){
 535         recording_result *result = (recording_result*)user_data;
 536         result->elapsed_time = elapsed_time;
 537         result->file_size = file_size;
 538
 539 }
 540
 541 int recorder_recoding_status_cb_test(){
 542         recorder_h recorder;
 543         recording_result result;
 544         int ret;
 545
 546         printf("--------------recording status cb test-------------------\n");
 547         recorder_create_audiorecorder(&recorder);
 548         recorder_set_recording_status_cb(recorder,_recording_status_test_cb, &result);
 549         recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
 550         recorder_prepare(recorder);
 551         ret = recorder_start(recorder);
 552         result.elapsed_time = 0;
 553         result.file_size = 0;
 554         sleep(3);
 555         ret = recorder_cancel(recorder);
 556         ret =recorder_unprepare(recorder);
 557         ret =recorder_destroy(recorder);
 558         if( result.elapsed_time > 0  && result.file_size > 0){
 559                 printf("PASS\n");
 560                 return 0;
 561         }else{
 562                 printf("FAIL\n");
 563                 return -1;
 564         }
 565 }
 566
 567
 568 int recorder_attribute_test(){
 569         int fail =0;
 570         int ret;
 571         recorder_h recorder;
 572         ret = recorder_create_audiorecorder(&recorder);
 573         fail = recording_size_limit_test(recorder);
 574         fail +=recording_time_limit_test(recorder);
 575         fail +=fileformat_test(recorder);
 576         fail +=video_encoder_test(recorder);
 577         fail +=audio_encoder_test(recorder);
 578         fail +=recording_audio_device_test(recorder);
 579         fail +=recording_samplerate_test(recorder);
 580         fail +=recording_audio_encoder_bitrate_test(recorder);
 581         fail +=recording_video_encoder_bitrate_test(recorder);
 582         return fail;
 583 }
 584
 585
 586
 587 void _recording_status_cb2(int elapsed_time, int file_size, void *user_data){
 588         //printf("elapsed time :%d , file_size :%d\n", elapsed_time , file_size);
 589 }
 590
 591 void _recording_limit_reached_cb(recorder_recording_limit_type_e type, void *user_data){
 592         printf("limited!! %d\n", type);
 593         int *ischeck = (int*)user_data;
 594         *ischeck = 1;
 595 }
 596
 597
 598 int recorder_limit_cb_test(){
 599         recorder_h recorder;
 600         int ischeck = 0;
 601         int ret =0;
 602         recorder_create_audiorecorder(&recorder);
 603         printf("------------------------limit cb test -------------------------\n");
 604         //recorder_set_state_changed_cb(recorder, record_state_cb, NULL);
 605         recorder_set_recording_status_cb(recorder, _recording_status_cb2, NULL);
 606         recorder_set_recording_limit_reached_cb(recorder, _recording_limit_reached_cb, &ischeck);
 607         recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
 608         recorder_prepare(recorder);
 609
 610
 611         printf("-time limit test\n");
 612         recorder_attr_set_time_limit(recorder, 2);
 613         recorder_start(recorder);
 614         sleep(5);
 615         recorder_cancel(recorder);
 616         if( ischeck ){
 617                 printf("PASS\n");
 618         }else{
 619                 printf("FAIL\n");
 620                 ret--;
 621         }
 622
 623
 624         printf("-time unlimit test\n");
 625         //recorder_unprepare(recorder);
 626         recorder_attr_set_time_limit(recorder, 0);
 627         //recorder_prepare(recorder);
 628         ischeck = 0;
 629         recorder_set_recording_limit_reached_cb(recorder, _recording_limit_reached_cb, &ischeck);
 630         recorder_start(recorder);
 631         sleep(5);
 632         recorder_cancel(recorder);
 633         if( ischeck ){
 634                 printf("FAIL\n");
 635                 ret--;
 636         }else{
 637                 printf("PASS\n");
 638         }
 639
 640
 641         printf("-size limit test\n");
 642         ischeck = 0;
 643         recorder_attr_set_size_limit(recorder, 2);
 644         recorder_start(recorder);
 645         sleep(5);
 646         recorder_cancel(recorder);
 647
 648         if( ischeck ){
 649                 printf("PASS\n");
 650         }else{
 651                 printf("FAIL\n");
 652                 ret--;
 653         }
 654
 655         printf("-size unlimit test\n");
 656         ischeck = 0;
 657         recorder_attr_set_size_limit(recorder, 0);
 658         recorder_start(recorder);
 659         sleep(5);
 660         recorder_cancel(recorder);
 661
 662         if( ischeck ){
 663                 printf("FAIL\n");
 664                 ret--;
 665         }else{
 666                 printf("PASS\n");
 667         }
 668
 669
 670         recorder_unprepare(recorder);
 671         recorder_destroy(recorder);
 672
 673         return ret;
 674
 675 }
 676
 677 int video_recorder_test(){
 678         camera_h camera ;
 679         recorder_h recorder;
 680         int ret;
 681
 682         printf("-----------------video recorder test--------------------\n");
 683         camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
 684         recorder_create_videorecorder(camera, &recorder);
 685         camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11,GET_DISPLAY(preview_win));
 686         camera_set_x11_display_rotation(camera, CAMERA_DISPLAY_ROTATION_270);
 687         //camera_set_preview_resolution(camera, 320, 240);
 688         camera_attr_set_preview_fps(camera, CAMERA_ATTR_FPS_AUTO);
 689         ret = recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_MP4);
 690         printf("ret = %x\n", ret);
 691         ret = recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_H263);
 692         printf("ret = %x\n", ret);
 693         ret = recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
 694         printf("ret = %x\n", ret);
 695         ret = recorder_set_filename(recorder, "/mnt/nfs/video_recorder_test.mp4");
 696         printf("ret = %x\n", ret);
 697
 698
 699         ret=  recorder_prepare(recorder);
 700         printf("ret = %x\n", ret);
 701         ret = recorder_start(recorder);
 702         printf("ret = %x\n", ret);
 703         sleep(10);
 704         ret = recorder_pause(recorder);
 705         printf("ret = %x\n", ret);
 706         ret = recorder_commit(recorder);
 707         printf("ret = %x\n", ret);
 708         ret =recorder_unprepare(recorder);
 709         printf("ret = %x\n", ret);
 710         ret= recorder_destroy(recorder);
 711         printf("ret = %x\n", ret);
 712         return 0;
 713 }
 714
 715 int mm_test(){
 716         MMCamPreset info;
 717         info.videodev_type= MM_VIDEO_DEVICE_NONE;
 718         MMHandleType camcorder;
 719         int ret;
 720         ret = mm_camcorder_create(&camcorder, &info);
 721         printf("mm_camcorder_create %x\n", ret);
 722         ret = mm_camcorder_set_attributes(camcorder, NULL,
 723                                                                                                                                 MMCAM_MODE , MM_CAMCORDER_MODE_AUDIO,
 724                                                                                                                                 (void*)NULL);
 725         printf("mm_camcorder_set_attributes %x\n", ret);
 726
 727         ret = mm_camcorder_set_attributes(camcorder ,NULL, MMCAM_AUDIO_ENCODER ,MM_AUDIO_CODEC_AAC , NULL);
 728         printf("mm_camcorder_set_attributes %x\n", ret);
 729
 730         ret = mm_camcorder_set_attributes(camcorder ,NULL, MMCAM_FILE_FORMAT ,MM_FILE_FORMAT_MP4 , NULL);
 731         printf("mm_camcorder_set_attributes %x\n", ret);
 732
 733         ret = mm_camcorder_realize(camcorder);
 734         printf("mm_camcorder_realize %x\n", ret);
 735
 736         ret = mm_camcorder_start(camcorder);
 737         printf("mm_camcorder_start %x\n", ret);
 738
 739         ret = mm_camcorder_record(camcorder);
 740         printf("mm_camcorder_record %x\n", ret);
 741
 742
 743
 744         ret = mm_camcorder_pause(camcorder);
 745         printf("mm_camcorder_pause %x\n", ret);
 746
 747         ret = mm_camcorder_cancel(camcorder);
 748         printf("mm_camcorder_cancel %x\n", ret);
 749
 750         ret = mm_camcorder_stop(camcorder);
 751         printf("mm_camcorder_stop %x\n", ret);
 752
 753         ret = mm_camcorder_unrealize(camcorder);
 754         printf("mm_camcorder_unrealize %x\n", ret);
 755
 756         ret = mm_camcorder_destroy(camcorder);
 757         printf("mm_camcorder_destroy %x\n", ret);
 758
 759
 760
 761         return 0;
 762
 763 }
 764
 765
 766
 767 int recorder_encoder_test(){
 768         recorder_h recorder;
 769         camera_h camera;
 770         int ret;
 771
 772         printf("3GP - AMR\n");
 773         ret=recorder_create_audiorecorder(&recorder);
 774         ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
 775         ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 776         ret+=recorder_set_filename(recorder , "/mnt/nfs/audiotest_amr.3gp");
 777         ret+=recorder_prepare(recorder);
 778         ret+=recorder_start(recorder);
 779         sleep(4);
 780         ret+=recorder_commit(recorder);
 781         ret += recorder_unprepare(recorder);
 782         ret+=recorder_destroy(recorder);
 783
 784         printf("3GP - AAC\n");
 785         ret=recorder_create_audiorecorder(&recorder);
 786         ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
 787         ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
 788         ret+=recorder_set_filename(recorder , "/mnt/nfs/audiotest_aac.3gp");
 789         ret+=recorder_prepare(recorder);
 790         ret+=recorder_start(recorder);
 791         sleep(4);
 792         ret+=recorder_commit(recorder);
 793         ret += recorder_unprepare(recorder);
 794         ret+=recorder_destroy(recorder);
 795
 796         printf("AMR - AMR\n");
 797         ret=recorder_create_audiorecorder(&recorder);
 798         ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
 799         ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 800         ret+=recorder_set_filename(recorder , "/mnt/nfs/audiotest.amr");
 801         ret+=recorder_prepare(recorder);
 802         ret+=recorder_start(recorder);
 803         sleep(4);
 804         ret+=recorder_commit(recorder);
 805         ret += recorder_unprepare(recorder);
 806         ret+=recorder_destroy(recorder);
 807
 808         printf("MP4 - AAC\n");
 809         ret=recorder_create_audiorecorder(&recorder);
 810         ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_MP4);
 811         ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
 812         ret+=recorder_set_filename(recorder , "/mnt/nfs/audiotest_aac.mp4");
 813         ret+=recorder_prepare(recorder);
 814         ret+=recorder_start(recorder);
 815         sleep(4);
 816         ret+=recorder_commit(recorder);
 817         ret += recorder_unprepare(recorder);
 818         ret+=recorder_destroy(recorder);
 819
 820
 821         ret+=camera_create(CAMERA_DEVICE_CAMERA0,&camera);
 822         ret+=camera_set_x11_display_rotation(camera, CAMERA_DISPLAY_ROTATION_270);
 823         ret+=camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
 824
 825
 826         printf("3GP - AMR- H263\n");
 827         ret+=recorder_create_videorecorder(camera, &recorder);
 828         ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
 829         ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 830         ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_H263);
 831         ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_amr_h263.3gp");
 832         ret+=recorder_prepare(recorder);
 833         ret+=recorder_start(recorder);
 834         sleep(10);
 835         ret+=recorder_commit(recorder);
 836         ret += recorder_unprepare(recorder);
 837         ret+=recorder_destroy(recorder);
 838
 839
 840         printf("3GP - AMR- H264\n");
 841         ret+=recorder_create_videorecorder(camera, &recorder);
 842         ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
 843         ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 844         ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_H264);
 845         ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_amr_h264.3gp");
 846         ret+=recorder_prepare(recorder);
 847         ret+=recorder_start(recorder);
 848         sleep(10);
 849         ret+=recorder_commit(recorder);
 850         ret += recorder_unprepare(recorder);
 851         ret+=recorder_destroy(recorder);
 852
 853         printf("3GP - AMR- MPEG4\n");
 854         ret+=recorder_create_videorecorder(camera, &recorder);
 855         ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
 856         ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 857         ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
 858         ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_amr_mpeg4.3gp");
 859         ret+=recorder_prepare(recorder);
 860         ret+=recorder_start(recorder);
 861         sleep(10);
 862         ret+=recorder_commit(recorder);
 863         ret += recorder_unprepare(recorder);
 864         ret+=recorder_destroy(recorder);
 865
 866
 867         printf("3GP - AAC- H263\n");
 868         ret+=recorder_create_videorecorder(camera, &recorder);
 869         ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
 870         ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
 871         ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_H263);
 872         ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_AAC_h263.3gp");
 873         ret+=recorder_prepare(recorder);
 874         ret+=recorder_start(recorder);
 875         sleep(10);
 876         ret+=recorder_commit(recorder);
 877         ret += recorder_unprepare(recorder);
 878         ret+=recorder_destroy(recorder);
 879
 880
 881         printf("3GP - AAC- H264\n");
 882         ret+=recorder_create_videorecorder(camera, &recorder);
 883         ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
 884         ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
 885         ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_H264);
 886         ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_AAC_h264.3gp");
 887         ret+=recorder_prepare(recorder);
 888         ret+=recorder_start(recorder);
 889         sleep(10);
 890         ret+=recorder_commit(recorder);
 891         ret += recorder_unprepare(recorder);
 892         ret+=recorder_destroy(recorder);
 893
 894         printf("3GP - AAC- MPEG4\n");
 895         ret+=recorder_create_videorecorder(camera, &recorder);
 896         ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
 897         ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
 898         ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
 899         ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_AAC_MPEG4.3gp");
 900         ret+=recorder_prepare(recorder);
 901         ret+=recorder_start(recorder);
 902         sleep(10);
 903         ret+=recorder_commit(recorder);
 904         ret += recorder_unprepare(recorder);
 905         ret+=recorder_destroy(recorder);
 906
 907         printf("MP4 - AAC- H264\n");
 908         ret+=recorder_create_videorecorder(camera, &recorder);
 909         ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_MP4);
 910         ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
 911         ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_H264);
 912         ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_AAC_h264.mp4");
 913         ret+=recorder_prepare(recorder);
 914         ret+=recorder_start(recorder);
 915         sleep(10);
 916         ret+=recorder_commit(recorder);
 917         ret += recorder_unprepare(recorder);
 918         ret+=recorder_destroy(recorder);
 919
 920         printf("MP4 - AAC- MPEG4\n");
 921         ret+=recorder_create_videorecorder(camera, &recorder);
 922         ret+=recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_MP4);
 923         ret+=recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
 924         ret+=recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
 925         ret+=recorder_set_filename(recorder , "/mnt/nfs/videotest_AAC_MPEG4.mp4");
 926         ret+=recorder_prepare(recorder);
 927         ret+=recorder_start(recorder);
 928         sleep(10);
 929         ret+=recorder_commit(recorder);
 930         ret += recorder_unprepare(recorder);
 931         ret+=recorder_destroy(recorder);
 932
 933
 934         camera_destroy(camera);
 935
 936
 937         return ret;
 938 }
 939
 940
 941 void* test_main(void *arg){
 942         int ret = 0;
 943         ret = recorder_encoder_test();
 944         /*
 945         ret = recorder_attribute_test();
 946         ret += recorder_state_change_test();
 947         ret += recorder_recoding_status_cb_test();
 948         ret += recorder_limit_cb_test();
 949         ret += video_recorder_test();
 950         ret = mm_test();
 951         */
 952
 953         if( ret == 0 )
 954                 printf("--------------RECORDER TEST ALL PASS--------------------------\n");
 955         else
 956                 printf("--------------RECORDER TEST FAIL %d--------------------------\n", -ret);
 957
 958
 959         return 0;
 960 }
 961
 962 int main(int argc, char ** argv)
 963 {
 964
 965         elm_init(argc, argv);
 966
 967
 968
 969         mEvasWindow = elm_win_add(NULL, "VIDEO OVERLAY", ELM_WIN_BASIC);
 970         elm_win_title_set(mEvasWindow, "video overlay window");
 971         elm_win_borderless_set(mEvasWindow, 0);
 972         evas_object_resize(mEvasWindow, 800, 480);
 973         evas_object_move(mEvasWindow, 0, 0);
 974         evas_object_show(mEvasWindow);
 975
 976         //To support full-screen
 977         elm_win_rotation_set(mEvasWindow, 270);
 978         //elm_win_fullscreen_set(mEvasWindow, 1);
 979
 980         evas_object_color_set(mEvasWindow, 0,0,0,0);
 981         elm_win_transparent_set(mEvasWindow, 1);
 982         preview_win = elm_win_xwindow_get(mEvasWindow);
 983
 984         fprintf(stderr, "end of elm\n");
 985
 986         pthread_t gloop_thread;
 987
 988         pthread_create(&gloop_thread, NULL, test_main,  NULL);
 989
 990
 991
 992         elm_run();
 993         elm_shutdown();
 994
 995
 996         return 0;
 997 }