test/video_util_test.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at
   6  *
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <unistd.h>
  20 #include <glib.h>
  21 #include <dlog.h>
  22 #include <video_util.h>
  23
  24 #define PACKAGE                 "video_util_test"
  25 #define MAX_STRING_LEN  256
  26
  27 #ifdef LOG_TAG
  28 #undef LOG_TAG
  29 #endif
  30
  31 #define LOG_TAG                 "VIDEO_UTIL_TEST"
  32
  33 enum {
  34         CURRENT_STATUS_MAINMENU,
  35         CURRENT_STATUS_FILENAME,
  36         CURRENT_STATUS_SET_FORMAT,
  37         CURRENT_STATUS_SET_VIDEO_CODEC,
  38         CURRENT_STATUS_SET_AUDIO_CODEC,
  39         CURRENT_STATUS_SET_ACCURATE_MODE,
  40         CURRENT_STATUS_SET_RESOLUTION,
  41         CURRENT_STATUS_SET_FPS,
  42         CURRENT_STATUS_SET_TIME,
  43         CURRENT_STATUS_SET_OUTFILENAME,
  44         CURRENT_STATUS_MAX
  45 };
  46
  47 static video_util_h video_h = NULL;
  48 gchar *g_out = NULL;
  49
  50 int g_menu_state = CURRENT_STATUS_MAINMENU;
  51 int g_handle_num = 1;
  52 int format = VIDEO_UTIL_FILE_FORMAT_3GP;
  53 int video_codec = VIDEO_UTIL_VIDEO_CODEC_MPEG4;
  54 int audio_codec = VIDEO_UTIL_AUDIO_CODEC_AAC;
  55 int accurate_mode = 0;
  56 int width = 176;
  57 int height = 144;
  58 int fps = 10;
  59 unsigned long start_position = 0;
  60 unsigned long duration = 5000;
  61 int make_video_cnt = 1;
  62
  63 typedef struct {
  64         video_util_h video_h;
  65         int idx;
  66         unsigned long start_time;
  67         unsigned long duration;
  68 } test_util_s;
  69
  70 test_util_s *_util_s;
  71
  72
  73 static void display_sub_basic();
  74 static void _video_util_start_transcoding(test_util_s *util_s);
  75 static void _reset_var();
  76
  77 void _quit_program(void)
  78 {
  79         _reset_var();
  80         exit(0);
  81 }
  82
  83 bool test_transcode_spec_cb(int value, void *user_data)
  84 {
  85         if (!user_data) {
  86                 LOGE("user_data is NULL");
  87                 return FALSE;
  88         }
  89
  90         if (!strcmp(user_data, "format_check")) {
  91                 switch (value) {
  92                 case 0:
  93                         LOGI("[%s] --- [3gp]", (const char *)user_data);
  94                         break;
  95                 case 1:
  96                         LOGI("[%s] --- [mp4]", (const char *)user_data);
  97                         break;
  98                 default:
  99                         break;
 100                 }
 101         } else if (!strcmp(user_data, "video_codec_check")) {
 102                 switch (value) {
 103                 case 0:
 104                         LOGI("[%s] --- [m4v]", (const char *)user_data);
 105                         break;
 106                 case 1:
 107                         LOGI("[%s] --- [h263]", (const char *)user_data);
 108                         break;
 109                 case 2:
 110                         LOGI("[%s] --- [h264]", (const char *)user_data);
 111                         break;
 112                 default:
 113                         break;
 114                 }
 115         } else if (!strcmp(user_data, "audio_codec_check")) {
 116                 switch (value) {
 117                 case 0:
 118                         LOGI("[%s] --- [aac]", (const char *)user_data);
 119                         break;
 120                 case 1:
 121                         LOGI("[%s] --- [amrnb]", (const char *)user_data);
 122                         break;
 123                 default:
 124                         break;
 125                 }
 126         }
 127
 128         return true;
 129 }
 130
 131 bool _supported_spec_check(video_util_h handle)
 132 {
 133         int ret = 0;
 134         ret = video_util_foreach_supported_file_format(handle, (video_util_supported_file_format_cb)test_transcode_spec_cb, "format_check");
 135         printf("video_util_foreach_supported_file_format [%d]\n", ret);
 136         ret = video_util_foreach_supported_video_codec(handle, (video_util_supported_video_encoder_cb)test_transcode_spec_cb, "video_codec_check");
 137         printf("video_util_foreach_supported_video_codec [%d]\n", ret);
 138         ret = video_util_foreach_supported_audio_codec(handle, (video_util_supported_audio_encoder_cb)test_transcode_spec_cb, "audio_codec_check");
 139         printf("video_util_foreach_supported_audio_codec [%d]\n", ret);
 140
 141         return true;
 142 }
 143
 144 void _transcode_completed_cb(video_util_error_e error, void *user_data)
 145 {
 146         int idx = 0;
 147         unsigned long ntn_start_position = 0;
 148
 149         test_util_s *_util_s = (test_util_s *)user_data;
 150
 151         if (!_util_s) {
 152                 LOGE("completed_cb user data is NULL");
 153                 return;
 154         }
 155
 156         LOGI("transcode_completed_cb============= [%2d / %2d][%d]\n", _util_s->idx, make_video_cnt, error);
 157         printf("transcode_completed_cb============= [%2d / %2d][%d]\n", _util_s->idx, make_video_cnt, error);
 158
 159         if (_util_s->idx == (make_video_cnt - 1)) {
 160                 LOGI("End trascoding");
 161                 return;
 162         }
 163
 164         idx = _util_s->idx + 1;
 165         ntn_start_position = _util_s->start_time + duration;
 166         _util_s->idx = idx;
 167         _util_s->start_time = ntn_start_position;
 168
 169         _video_util_start_transcoding(_util_s);
 170
 171         return;
 172 }
 173
 174 void _transcode_progress_cb(unsigned long current_position, unsigned long duration, void *user_data)
 175 {
 176         test_util_s *_util_s = (test_util_s *)user_data;
 177
 178         LOGD("transcode_progress_cb-------------- [%2d][%ld][%ld]\n", _util_s->idx, current_position, duration);
 179
 180         return;
 181 }
 182
 183 static void _video_util_start_transcoding(test_util_s *util_s)
 184 {
 185         int ret = VIDEO_UTIL_ERROR_NONE;
 186         gchar *output_file_path = NULL;
 187
 188         if (!video_h) {
 189                 LOGE("video_util handle is NULL, please set format after create");
 190                 return;
 191         }
 192
 193         LOGI("video_util set below");
 194         LOGI("format: %d, video codec: %d, audio codec: %d, accurate mode: %d", format, video_codec, audio_codec, accurate_mode);
 195         LOGI("width: %d, height: %d, fps: %d", width, height, fps);
 196         LOGI("start time: %lu, durtation: %lu", start_position, duration);
 197
 198         ret = video_util_set_file_format(video_h, format);
 199         if (ret != VIDEO_UTIL_ERROR_NONE) {
 200                 LOGE("video_util_set_file_format is failed (%d)", ret);
 201                 return;
 202         }
 203
 204         ret = video_util_set_video_codec(video_h, video_codec);
 205         if (ret != VIDEO_UTIL_ERROR_NONE) {
 206                 LOGE("video_util_set_video_codec is failed (%d)", ret);
 207                 return;
 208         }
 209
 210         ret = video_util_set_audio_codec(video_h, audio_codec);
 211         if (ret != VIDEO_UTIL_ERROR_NONE) {
 212                 LOGE("video_util_set_audio_codec is failed (%d)", ret);
 213                 return;
 214         }
 215
 216         ret = video_util_set_accurate_mode(video_h, accurate_mode);
 217         if (ret != VIDEO_UTIL_ERROR_NONE) {
 218                 LOGE("video_util_set_accurate_mode is failed (%d)", ret);
 219                 return;
 220         }
 221
 222         ret = video_util_set_resolution(video_h, width, height);
 223         if (ret != VIDEO_UTIL_ERROR_NONE) {
 224                 LOGE("video_util_set_resolution is failed (%d)", ret);
 225                 return;
 226         }
 227
 228         ret = video_util_set_fps(video_h, fps);
 229         if (ret != VIDEO_UTIL_ERROR_NONE) {
 230                 LOGE("video_util_set_fps is failed (%d)", ret);
 231                 return;
 232         }
 233
 234         output_file_path = g_strdup_printf("%s_%d.%s", g_out, util_s->idx, format ? "mp4" : "3gp");
 235         g_free(g_out);
 236         g_out = NULL;
 237
 238         LOGI("input start_time: %lu, duration: %lu, output_file_path: %s", util_s->start_time, util_s->duration, output_file_path);
 239         ret = video_util_start_transcoding(util_s->video_h, util_s->start_time, util_s->duration, output_file_path, _transcode_progress_cb, _transcode_completed_cb, util_s);
 240         if (ret != VIDEO_UTIL_ERROR_NONE) {
 241                 LOGE("video_util_start_transcoding is failed (%d)", ret);
 242                 g_free(output_file_path);
 243                 return;
 244         }
 245
 246         g_free(output_file_path);
 247         return;
 248 }
 249
 250 static void _reset_var()
 251 {
 252         if (video_h) {
 253                 video_util_destroy(video_h);
 254                 video_h = NULL;
 255         }
 256
 257         g_free(g_out);
 258         g_out = NULL;
 259
 260         g_menu_state = CURRENT_STATUS_MAINMENU;
 261         g_handle_num = 1;
 262         format = VIDEO_UTIL_FILE_FORMAT_3GP;
 263         video_codec = VIDEO_UTIL_VIDEO_CODEC_MPEG4;
 264         audio_codec = VIDEO_UTIL_AUDIO_CODEC_AAC;
 265         accurate_mode = 0;
 266         width = 176;
 267         height = 144;
 268         fps = 25;
 269         start_position = 5000;
 270         duration = 5000;
 271         make_video_cnt = 3;
 272 }
 273
 274 static void input_filename(char *filename)
 275 {
 276         int len = strlen(filename);
 277         int ret = VIDEO_UTIL_ERROR_NONE;
 278         gchar *g_uri = NULL;
 279
 280         if (len < 0 || len > MAX_STRING_LEN - 1) {
 281                 LOGE("Input file name is wrong");
 282                 return;
 283         }
 284
 285         _reset_var();
 286
 287         if (video_h) {
 288                 ret = video_util_cancel_transcoding(video_h);
 289                 ret = video_util_destroy(video_h);
 290         }
 291
 292         video_h = NULL;
 293
 294         ret = video_util_create(&video_h);
 295
 296         if (ret != VIDEO_UTIL_ERROR_NONE) {
 297                 LOGE("video_util create is failed (%d)", ret);
 298                 return;
 299         }
 300
 301         g_uri = g_strndup(filename, len);
 302
 303         ret = video_util_set_file_path(video_h, g_uri);
 304         if (ret != VIDEO_UTIL_ERROR_NONE) {
 305                 LOGE("video_util_set_file_path is failed");
 306                 g_free(g_uri);
 307                 return;
 308         }
 309
 310         g_free(g_uri);
 311
 312         _supported_spec_check(video_h);
 313 }
 314
 315 void reset_menu_state()
 316 {
 317         g_menu_state = CURRENT_STATUS_MAINMENU;
 318         return;
 319 }
 320
 321 void _interpret_main_menu(char *cmd)
 322 {
 323         int len = strlen(cmd);
 324
 325         if (len == 1) {
 326                 if (strncmp(cmd, "a", 1) == 0) {
 327                         g_menu_state = CURRENT_STATUS_FILENAME;
 328                 } else if (strncmp(cmd, "s", 1) == 0) {
 329                         if (!_util_s) {
 330                                 _util_s = (test_util_s *)calloc(1, sizeof(test_util_s));
 331                                 LOGE("_util_s malloc");
 332                         }
 333
 334                         if (!_util_s) {
 335                                 LOGE("test util calloc failed");
 336                                 return;
 337                         }
 338
 339                         _util_s->video_h = video_h;
 340                         _util_s->idx = 0;
 341                         _util_s->start_time = start_position;
 342                         _util_s->duration = duration;
 343
 344                         _video_util_start_transcoding(_util_s);
 345
 346                 } else if (strncmp(cmd, "c", 1) == 0) {
 347                         int ret = VIDEO_UTIL_ERROR_NONE;
 348                         if (!video_h) {
 349                                 g_print("video_util handle is NULL, please set format after create");
 350                                 return;;
 351                         }
 352                         ret = video_util_cancel_transcoding(video_h);
 353                         if (ret != VIDEO_UTIL_ERROR_NONE) {
 354                                 g_print("video_util_cancel_transcoding is failed (%d)", ret);
 355                                 return;
 356                         }
 357                 } else if (strncmp(cmd, "f", 1) == 0) {
 358                         g_menu_state = CURRENT_STATUS_SET_FORMAT;
 359                 } else if (strncmp(cmd, "m", 1) == 0) {
 360                         g_menu_state = CURRENT_STATUS_SET_ACCURATE_MODE;
 361                 } else if (strncmp(cmd, "t", 1) == 0) {
 362                         g_menu_state = CURRENT_STATUS_SET_TIME;
 363                 } else if (strncmp(cmd, "o", 1) == 0) {
 364                         g_menu_state = CURRENT_STATUS_SET_OUTFILENAME;
 365                 } else if (strncmp(cmd, "q", 1) == 0) {
 366                         _quit_program();
 367                 } else if (strncmp(cmd, "d", 1) == 0) {
 368                         int ret = VIDEO_UTIL_ERROR_NONE;
 369                         if (!video_h) {
 370                                 g_print("video_util handle is NULL, please set format after create");
 371                                 return;;
 372                         }
 373                         ret = video_util_destroy(video_h);
 374                         if (ret != VIDEO_UTIL_ERROR_NONE) {
 375                                 g_print("video_util_cancel_transcoding is failed (%d)", ret);
 376                                 return;
 377                         }
 378                         free(_util_s);
 379                         _util_s = NULL;
 380                 } else {
 381                         g_print("unknown menu \n");
 382                 }
 383         } else if (len == 2) {
 384                 if (strncmp(cmd, "vc", 2) == 0)
 385                         g_menu_state = CURRENT_STATUS_SET_VIDEO_CODEC;
 386                 else if (strncmp(cmd, "ac", 2) == 0)
 387                         g_menu_state = CURRENT_STATUS_SET_AUDIO_CODEC;
 388                 else if (strncmp(cmd, "vr", 2) == 0)
 389                         g_menu_state = CURRENT_STATUS_SET_RESOLUTION;
 390                 else if (strncmp(cmd, "vf", 2) == 0)
 391                         g_menu_state = CURRENT_STATUS_SET_FPS;
 392                 else
 393                         g_print("unknown menu \n");
 394         } else {
 395                 g_print("unknown menu \n");
 396         }
 397         return;
 398 }
 399
 400 static void displaymenu(void)
 401 {
 402         if (g_menu_state == CURRENT_STATUS_MAINMENU) {
 403                 display_sub_basic();
 404         } else if (g_menu_state == CURRENT_STATUS_FILENAME) {
 405                 g_print("*** input mediapath.\n");
 406         } else if (g_menu_state == CURRENT_STATUS_SET_FORMAT) {
 407                 g_print("*** input file format.(0:3gp, 1:mp4)\n");
 408         } else if (g_menu_state == CURRENT_STATUS_SET_VIDEO_CODEC) {
 409                 g_print("*** input video codec.(0:m4v, 1:h263, 2:h264)\n");
 410         } else if (g_menu_state == CURRENT_STATUS_SET_AUDIO_CODEC) {
 411                 g_print("*** input audio codec.(0:aac, 1:amrnb)\n");
 412         } else if (g_menu_state == CURRENT_STATUS_SET_ACCURATE_MODE) {
 413                 g_print("*** input accurate mode.(0: OFF, 1: ON)\n");
 414         } else if (g_menu_state == CURRENT_STATUS_SET_RESOLUTION) {
 415                 g_print("*** input video resolution.(width, height)\n");
 416         } else if (g_menu_state == CURRENT_STATUS_SET_FPS) {
 417                 g_print("*** input video fps.(5<=fps<=30)\n");
 418         } else if (g_menu_state == CURRENT_STATUS_SET_TIME) {
 419                 g_print("*** input transcode start/duration time(ms), run nth.(start time, duration, n)\n");
 420         } else if (g_menu_state == CURRENT_STATUS_SET_OUTFILENAME) {
 421                 g_print("*** input output filename.(defaunt path /opt/usr/media/)\n");
 422         } else {
 423                 g_print("*** unknown status.\n");
 424                 _quit_program();
 425         }
 426         g_print(" >>> ");
 427 }
 428
 429 gboolean timeout_menu_display(void *data)
 430 {
 431         displaymenu();
 432         return FALSE;
 433 }
 434
 435 static void interpret(char *cmd)
 436 {
 437         switch (g_menu_state) {
 438
 439         case CURRENT_STATUS_MAINMENU:
 440                 {
 441                         _interpret_main_menu(cmd);
 442                         break;
 443                 }
 444         case CURRENT_STATUS_FILENAME:
 445                 {
 446                         input_filename(cmd);
 447                         reset_menu_state();
 448                         break;
 449                 }
 450         case CURRENT_STATUS_SET_FORMAT:
 451                 {
 452                         int ret = VIDEO_UTIL_ERROR_NONE;
 453                         format = atoi(cmd);
 454                         if (format < 0 || format >= VIDEO_UTIL_FILE_FORMAT_MAX) {
 455                                 LOGE("input cmd is out of range.");
 456                                 reset_menu_state();
 457                                 break;
 458                         }
 459                         if (!video_h) {
 460                                 LOGE("video_util handle is NULL, please set format after create");
 461                                 reset_menu_state();
 462                                 break;
 463                         }
 464                         ret = video_util_set_file_format(video_h, format);
 465                         if (ret != VIDEO_UTIL_ERROR_NONE) {
 466                                 LOGE("video_util_set_file_format is failed (%d)", ret);
 467                                 reset_menu_state();
 468                                 break;
 469                         }
 470
 471                         reset_menu_state();
 472                         break;
 473                 }
 474         case CURRENT_STATUS_SET_VIDEO_CODEC:
 475                 {
 476                         int ret = VIDEO_UTIL_ERROR_NONE;
 477                         video_codec = atoi(cmd);
 478                         if (video_codec < 0 || video_codec >= VIDEO_UTIL_VIDEO_CODEC_NONE) {
 479                                 LOGE("input cmd is out of range");
 480                                 reset_menu_state();
 481                                 break;
 482                         }
 483                         if (!video_h) {
 484                                 LOGE("video_util handle is NULL, please set format after create");
 485                                 reset_menu_state();
 486                                 break;
 487                         }
 488                         ret = video_util_set_video_codec(video_h, video_codec);
 489                         if (ret != VIDEO_UTIL_ERROR_NONE) {
 490                                 LOGE("video_util_set_video_codec is failed (%d)", ret);
 491                                 reset_menu_state();
 492                                 break;
 493                         }
 494
 495                         reset_menu_state();
 496                         break;
 497                 }
 498         case CURRENT_STATUS_SET_AUDIO_CODEC:
 499                 {
 500                         int ret = VIDEO_UTIL_ERROR_NONE;
 501                         audio_codec = atoi(cmd);
 502                         if (audio_codec < 0 || audio_codec >= VIDEO_UTIL_VIDEO_CODEC_NONE) {
 503                                 LOGE("input cmd is out of range");
 504                                 reset_menu_state();
 505                                 break;
 506                         }
 507                         if (!video_h) {
 508                                 LOGE("video_util handle is NULL, please set format after create");
 509                                 reset_menu_state();
 510                                 break;
 511                         }
 512                         ret = video_util_set_video_codec(video_h, audio_codec);
 513                         if (ret != VIDEO_UTIL_ERROR_NONE) {
 514                                 LOGE("video_util_set_video_codec is failed (%d)", ret);
 515                                 reset_menu_state();
 516                                 break;
 517                         }
 518
 519                         reset_menu_state();
 520                         break;
 521                 }
 522         case CURRENT_STATUS_SET_ACCURATE_MODE:
 523                 {
 524                         int ret = VIDEO_UTIL_ERROR_NONE;
 525                         accurate_mode = atoi(cmd);
 526
 527                         if (!video_h) {
 528                                 LOGE("video_util handle is NULL, please set format after create");
 529                                 reset_menu_state();
 530                                 break;
 531                         }
 532                         ret = video_util_set_accurate_mode(video_h, (bool)accurate_mode);
 533                         if (ret != VIDEO_UTIL_ERROR_NONE) {
 534                                 LOGE("video_util_set_video_codec is failed (%d)", ret);
 535                                 reset_menu_state();
 536                                 break;
 537                         }
 538
 539                         reset_menu_state();
 540                         break;
 541                 }
 542         case CURRENT_STATUS_SET_RESOLUTION:
 543                 {
 544                         int ret = VIDEO_UTIL_ERROR_NONE;
 545                         int value = atoi(cmd);
 546                         static int resolution_cnt = 0;
 547
 548                         if (!video_h) {
 549                                 LOGE("video_util handle is NULL, please set format after create");
 550                                 reset_menu_state();
 551                                 break;
 552                         }
 553
 554                         switch (resolution_cnt) {
 555                         case 0:
 556                                 width = value;
 557                                 resolution_cnt++;
 558                                 break;
 559                         case 1:
 560                                 resolution_cnt = 0;
 561                                 height = value;
 562
 563                                 ret = video_util_set_resolution(video_h, width, height);
 564                                 if (ret != VIDEO_UTIL_ERROR_NONE) {
 565                                         LOGE("video_util_set_resolution is failed (%d)", ret);
 566                                         reset_menu_state();
 567                                         break;
 568                                 }
 569
 570                                 reset_menu_state();
 571                                 break;
 572                         }
 573                         break;
 574                 }
 575         case CURRENT_STATUS_SET_FPS:
 576                 {
 577                         int ret = VIDEO_UTIL_ERROR_NONE;
 578                         fps = atoi(cmd);
 579
 580                         if (fps < 5 || fps > 30) {
 581                                 LOGE("input cmd is out of range");
 582                                 reset_menu_state();
 583                                 break;
 584                         }
 585                         if (!video_h) {
 586                                 LOGE("video_util handle is NULL, please set format after create");
 587                                 reset_menu_state();
 588                                 break;
 589                         }
 590                         ret = video_util_set_fps(video_h, fps);
 591                         if (ret != VIDEO_UTIL_ERROR_NONE) {
 592                                 LOGE("video_util_set_fps is failed (%d)", ret);
 593                                 reset_menu_state();
 594                                 break;
 595                         }
 596
 597                         reset_menu_state();
 598                         break;
 599                 }
 600         case CURRENT_STATUS_SET_TIME:
 601                 {
 602                         int value = atoi(cmd);
 603                         static int set_time_cnt = 0;
 604
 605                         switch (set_time_cnt) {
 606                         case 0:
 607                                 start_position = value;
 608                                 set_time_cnt++;
 609                                 break;
 610                         case 1:
 611                                 duration = value;
 612                                 set_time_cnt++;
 613                                 break;
 614                         case 2:
 615                                 set_time_cnt = 0;
 616                                 make_video_cnt = value;
 617                                 reset_menu_state();
 618                                 break;
 619
 620                         }
 621                         break;
 622                 }
 623         case CURRENT_STATUS_SET_OUTFILENAME:
 624                 {
 625                         LOGI("output file is %s", g_out);
 626                         g_free(g_out);
 627                         g_out = g_strdup_printf("/opt/usr/media/%s", cmd);
 628                         LOGI("output file is %s", g_out);
 629                         reset_menu_state();
 630                         break;
 631                 }
 632         default:
 633                 break;
 634         }
 635
 636         g_timeout_add(100, timeout_menu_display, 0);
 637 }
 638
 639 static void display_sub_basic()
 640 {
 641         g_print("\n");
 642         g_print("=========================================================================================\n");
 643         g_print("                                    video_util_test test\n");
 644         g_print("-----------------------------------------------------------------------------------------\n");
 645         g_print(" a. Create \t\t\t");
 646         g_print(" s. Start transcoding \t");
 647         g_print(" c. Cancel transcoding \n");
 648         g_print(" f. Set file format\t\t");
 649         g_print("vc. Set video codec\t");
 650         g_print("ac. Set audio codec\n");
 651         g_print(" m. Set accurate mode\t\t");
 652         g_print("vr. Set resolution\t");
 653         g_print("vf. Set video fps\n");
 654         g_print(" t. Set start/duration time \t");
 655         g_print(" o. Set output filename\t");
 656         g_print(" q. quite test suite\t\n");
 657         g_print(" d. Destroy\t");
 658         g_print("\n");
 659         g_print("=========================================================================================\n");
 660 }
 661
 662 gboolean input(GIOChannel *channel)
 663 {
 664         gchar buf[MAX_STRING_LEN];
 665         gsize read;
 666         GError *error = NULL;
 667
 668         g_io_channel_read_chars(channel, buf, MAX_STRING_LEN, &read, &error);
 669         buf[read] = '\0';
 670         g_strstrip(buf);
 671         interpret(buf);
 672
 673         return TRUE;
 674 }
 675
 676 int main(int argc, char *argv[])
 677 {
 678         GIOChannel *stdin_channel;
 679         GMainLoop *loop = g_main_loop_new(NULL, 0);
 680         stdin_channel = g_io_channel_unix_new(0);
 681         g_io_channel_set_flags(stdin_channel, G_IO_FLAG_NONBLOCK, NULL);
 682         g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)input, NULL);
 683
 684         displaymenu();
 685
 686         g_main_loop_run(loop);
 687         g_print("STOP main loop\n");
 688
 689         g_main_loop_unref(loop);
 690         return 0;
 691
 692 }