test/media_codec_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 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <unistd.h>
  19 #include <glib.h>
  20 #include <gst/gst.h>
  21 #include <limits.h>
  22
  23 #include <tbm_surface.h>
  24 #include <dlog.h>
  25 #include <time.h>
  26 #include <media_codec.h>
  27 #include <media_packet.h>
  28 #include <media_packet_internal.h>
  29 #include <media_packet_pool.h>
  30 #include <media_codec_internal.h>
  31 #ifdef TIZEN_FEATURE_INTEGRATION
  32 #include <camera.h>
  33 #include <mediademuxer.h>
  34 #include <mediamuxer.h>
  35 #endif
  36
  37 #define PACKAGE "media_codec_test"
  38 #define MAX_HANDLE                      4
  39 #define TEST_FILE_SIZE        (10 * 1024 * 1024)
  40 #define MAX_STRING_LEN        256
  41
  42 #define DEFAULT_SAMPPLERATE   44100
  43 #define DEFAULT_CHANNEL             2
  44 #define DEFAULT_BIT                           16
  45 #define DEFAULT_BITRATE       128
  46 #define DEFAULT_SAMPLEBYTE        1024
  47 #define ADTS_HEADER_SIZE      7
  48 #define AMRNB_PCM_INPUT_SIZE      320
  49 #define AMRWB_PCM_INPUT_SIZE      640
  50
  51 #define CHECK_BIT(x, y) (((x) >> (y)) & 0x01)
  52 #define GET_IS_ENCODER(x) CHECK_BIT(x, 0)
  53 #define GET_IS_DECODER(x) CHECK_BIT(x, 1)
  54 #define GET_IS_HW(x) CHECK_BIT(x, 2)
  55 #define ES_DEFAULT_VIDEO_PTS_OFFSET 33000000
  56 #define CHECK_VALID_PACKET(state, expected_state) \
  57         ((state & (expected_state)) == (expected_state))
  58
  59 #define AAC_CODECDATA_SIZE    16
  60
  61 guint8 buf_adts[ADTS_HEADER_SIZE];
  62
  63 enum {
  64         MC_EXIST_SPS    = 1 << 0,
  65         MC_EXIST_PPS    = 1 << 1,
  66         MC_EXIST_IDR    = 1 << 2,
  67         MC_EXIST_SLICE  = 1 << 3,
  68
  69         MC_VALID_HEADER = (MC_EXIST_SPS | MC_EXIST_PPS),
  70         MC_VALID_FIRST_SLICE = (MC_EXIST_SPS | MC_EXIST_PPS | MC_EXIST_IDR)
  71 };
  72
  73 typedef struct _App App;
  74
  75 enum {
  76         CURRENT_STATUS_MAINMENU,
  77         CURRENT_STATUS_FILENAME,
  78         CURRENT_STATUS_CREATE,
  79         CURRENT_STATUS_DESTROY,
  80         CURRENT_STATUS_SET_CODEC,
  81         CURRENT_STATUS_SET_VDEC_INFO,
  82         CURRENT_STATUS_SET_VENC_INFO,
  83         CURRENT_STATUS_SET_ADEC_INFO,
  84         CURRENT_STATUS_SET_AENC_INFO,
  85         CURRENT_STATUS_PREPARE,
  86         CURRENT_STATUS_UNPREPARE,
  87         CURRENT_STATUS_PROCESS_INPUT,
  88         CURRENT_STATUS_GET_OUTPUT,
  89         CURRENT_STATUS_RESET_OUTPUT_BUFFER,
  90         CURRENT_STATUS_SET_SIZE,
  91         CURRENT_STATUS_AUTO_TEST,
  92 };
  93
  94 typedef enum {
  95         NAL_SLICE_NO_PARTITIONING = 1,
  96         NAL_SLICE_PART_A,
  97         NAL_SLICE_PART_B,
  98         NAL_SLICE_PART_C,
  99         NAL_SLICE_IDR,
 100         NAL_SEI,
 101         NAL_SEQUENCE_PARAMETER_SET,
 102         NAL_PICTURE_PARAMETER_SET,
 103         NAL_PICTURE_DELIMITER,
 104         NAL_END_OF_SEQUENCE,
 105         NAL_END_OF_STREAM,
 106         NAL_FILLER_DATA,
 107         NAL_PREFIX_SVC = 14
 108 } nal_unit_type;
 109
 110 typedef enum {
 111         VIDEO_DEC,
 112         VIDEO_ENC,
 113         AUDIO_DEC,
 114         AUDIO_ENC
 115 } type_e;
 116
 117
 118 struct _App {
 119         GMainLoop *loop;
 120         guint sourceid;
 121         guint audio_id;
 122         guint video_id;
 123
 124         GMappedFile *file;
 125         guint8 *data;
 126         gint length;
 127         gint offset;
 128         gint obj;
 129
 130         GTimer *timer;
 131         glong start;
 132         glong finish;
 133         glong process_time;
 134         gint frame_count;
 135
 136         gint codecid;
 137         gint flag;
 138         gboolean is_video;
 139         gboolean is_encoder;
 140         gboolean hardware;
 141         gboolean enable_dump;
 142         gboolean enable_muxer;
 143         gint frame;
 144         type_e type;
 145
 146 #ifdef TIZEN_FEATURE_INTEGRATION
 147         camera_h camera_handle;
 148         mediademuxer_h demuxer;
 149         mediamuxer_h muxer;
 150 #endif
 151
 152         GThread *thread;
 153         GCond thread_cond;
 154         GMutex thread_mutex;
 155         GMutex eos_mutex;
 156         GCond eos_cond;
 157         GCond dst_eos_cond;
 158         gint demux_eos;
 159         gint codec_eos;
 160         gint suspend;
 161         gchar filepath[256];
 162         /* demuxer */
 163         media_format_h format[MAX_HANDLE];
 164         /* video */
 165         mediacodec_h mc_handle[MAX_HANDLE];
 166         guint width;
 167         guint height;
 168         guint fps;
 169         guint target_bits;
 170         media_format_mimetype_e mime;
 171         gint track;
 172         gint video_track;
 173
 174         /* Audio */
 175         guint samplerate;
 176         guint channel;
 177         guint bit;
 178         guint bitrate;
 179         gboolean is_amr_nb;
 180         gint audio_track;
 181
 182         /* Render */
 183         guint w;
 184         guint h;
 185         media_packet_h packet;
 186         GList *packet_list;
 187         GMutex lock;
 188
 189         gint etb;
 190         gint ftb;
 191         gint ebd;
 192         gint fbd;
 193 };
 194
 195 App s_app;
 196
 197 media_format_h fmt = NULL;
 198 media_packet_pool_h pkt_pool = NULL;
 199
 200 /* Internal Functions */
 201 void displaymenu(void);
 202 void display_sub_basic();
 203
 204 void _mediacodec_unprepare(App *app);
 205 void _mediacodec_destroy(App *app);
 206 void _mediacodec_auto_test(App *app, char *path);
 207 void input_filepath(char *filename, App *app);
 208 /* For debugging */
 209 void mc_hex_dump(char *desc, void *addr, gint len);
 210 void decoder_output_dump(App *app, media_packet_h pkt);
 211 void output_dump(App *app, media_packet_h pkt);
 212 /* */
 213 const char* codec_type_to_string(mediacodec_codec_type_e media_codec_id);
 214
 215 void (*extractor)(App *app, guint8** data, gint *size, gboolean *have_frame, gboolean *codec_data);
 216
 217 gint g_menu_state = CURRENT_STATUS_MAINMENU;
 218
 219 static const guint mp3types_bitrates[2][3][16] = {
 220         {
 221                 {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},
 222                 {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},
 223                 {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}
 224         },
 225         {
 226                 {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},
 227                 {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},
 228                 {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}
 229         },
 230 };
 231
 232 static const guint mp3types_freqs[3][3] = { {44100, 48000, 32000},
 233         {22050, 24000, 16000},
 234         {11025, 12000, 8000}
 235 };
 236
 237 void h264_extractor(App *app, guint8 **data, gint *size, gboolean *have_frame, gboolean *codec_data)
 238 {
 239         guint8 val, zero_count;
 240         guint8 *pNal = app->data + app->offset;
 241         gint max = app->length - app->offset;
 242         gint index = 0;
 243         gint nal_unit_type = 0;
 244         gboolean init;
 245         gboolean slice;
 246         gboolean idr;
 247         static gint state;
 248         gint read;
 249
 250         zero_count = 0;
 251
 252         val = pNal[index++];
 253         while (!val) {
 254                 zero_count++;
 255                 val = pNal[index++];
 256         }
 257
 258         zero_count = 0;
 259
 260         while (1) {
 261                 if (index >= max) {
 262                         read = (index - 1);
 263                         goto DONE;
 264                 }
 265
 266                 val = pNal[index++];
 267
 268                 if (!val)
 269                         zero_count++;
 270                 else {
 271                         if ((zero_count >= 2) && (val == 1))
 272                                 break;
 273                         else
 274                                 zero_count = 0;
 275                 }
 276         }
 277
 278         if (zero_count > 3)
 279                 zero_count = 3;
 280
 281         read = (index - zero_count - 1);
 282
 283         nal_unit_type = *(app->data+app->offset+4) & 0x1F;
 284         g_print("nal_unit_type : %x\n", nal_unit_type);
 285
 286         switch (nal_unit_type) {
 287         case NAL_SEQUENCE_PARAMETER_SET:
 288                 g_print("nal_unit_type : SPS\n");
 289                 state |= MC_EXIST_SPS;
 290                 break;
 291         case NAL_PICTURE_PARAMETER_SET:
 292                 g_print("nal_unit_type : PPS\n");
 293                 state |= MC_EXIST_PPS;
 294                 break;
 295         case NAL_SLICE_IDR:
 296         case NAL_SEI:
 297                 g_print ("nal_unit_type : IDR\n");
 298                 state |= MC_EXIST_IDR;
 299                 break;
 300         case NAL_SLICE_NO_PARTITIONING:
 301         case NAL_SLICE_PART_A:
 302         case NAL_SLICE_PART_B:
 303         case NAL_SLICE_PART_C:
 304                 state |= MC_EXIST_SLICE;
 305                 break;
 306         default:
 307                 g_print ("nal_unit_type : %x", nal_unit_type);
 308                 break;
 309         }
 310
 311         init = CHECK_VALID_PACKET(state, MC_VALID_FIRST_SLICE) ? 1 : 0;
 312         slice = CHECK_VALID_PACKET(state, MC_EXIST_SLICE) ? 1 : 0;
 313         idr = CHECK_VALID_PACKET(state, MC_EXIST_IDR) ? 1 : 0;
 314         g_print("status : %d, slice : %d, idr : %d\n", init, slice, idr);
 315
 316         if (init || idr || slice) {
 317                 *have_frame = TRUE;
 318                 if (init) {
 319                         *data = app->data;
 320                         *size = app->offset + read;
 321                 } else {
 322                         *data = app->data+app->offset;
 323                         *size = read;
 324                 }
 325                 state = 0;
 326         } else {
 327                 *data = app->data+app->offset;
 328                 *size = read;
 329         }
 330 DONE:
 331         app->offset += read;
 332 }
 333
 334 void h263_extractor(App * app, guint8 **data, gint *size, gboolean * have_frame, gboolean *codec_data)
 335 {
 336         int len = 0;
 337         int read_size = 1, state = 1, bStart = 0;
 338         guint8 val;
 339         guint8 *pH263 = app->data + app->offset;
 340         *data = pH263;
 341         int max = app->length - app->offset;
 342
 343         while (1) {
 344                 if (len >= max) {
 345                         read_size = (len - 1);
 346                         goto DONE;
 347                 }
 348                 val = pH263[len++];
 349                 switch (state) {
 350                 case 1:
 351                         if (val == 0x00)
 352                                 state++;
 353                         break;
 354                 case 2:
 355                         if (val == 0x00)
 356                                 state++;
 357                         else
 358                                 state = 1;
 359                         break;
 360                 case 3:
 361                         state = 1;
 362                         if ((val & 0xFC) == 0x80) {
 363                                 if (bStart) {
 364                                         read_size = len - 3;
 365                                         goto DONE;
 366                                 } else {
 367                                         bStart = 1;
 368                                 }
 369                         }
 370                         break;
 371                 }
 372         }
 373  DONE:
 374         *size = read_size;
 375         app->offset += read_size;
 376         *have_frame = TRUE;
 377 }
 378
 379 void mpeg4_extractor(App * app, guint8 **data, gint *size, gboolean * have_frame, gboolean *codec_data)
 380 {
 381         int len = 0;
 382         int result = 0;
 383         int state = 1, bType = 0;
 384         guint8 val;
 385         guint8 *pMpeg4 = app->data + app->offset;
 386         *data = pMpeg4;
 387         int max = app->length - app->offset;
 388
 389         while (1) {
 390                 if (len >= max) {
 391                         result = (len - 1);
 392                         goto DONE;
 393                 }
 394
 395                 val = pMpeg4[len++];
 396
 397                 switch (state) {
 398                 case 1:
 399                         if (val == 0x00)
 400                                 state++;
 401                         break;
 402                 case 2:
 403                         if (val == 0x00)
 404                                 state++;
 405                         else
 406                                 state = 1;
 407                         break;
 408                 case 3:
 409                         if (val == 0x01)
 410                                 state++;
 411                         else
 412                                 state = 1;
 413                         break;
 414                 case 4:
 415                         state = 1;
 416                         if (val == 0xB0 || val == 0xB6) {
 417                                 if (bType == 0xB6) {
 418                                         result = len - 4;
 419                                         goto DONE;
 420                                 }
 421                                 if (!bType) {
 422                                         if (val == 0xB0)
 423                                                 *have_frame = TRUE;
 424                                 }
 425                                 bType = val;
 426                         }
 427                         break;
 428                 }
 429         }
 430  DONE:
 431         *size = result;
 432         app->offset += result;
 433         *have_frame = TRUE;
 434 }
 435
 436 /**
 437   * Extract Input data for AMR-NB/WB decoder
 438   *  - AMR-NB  : mime type ("audio/AMR")          /   8Khz / 1 ch / 16 bits
 439   *  - AMR-WB : mime type ("audio/AMR-WB")  / 16Khz / 1 ch / 16 bits
 440   **/
 441 gint write_amr_header = 1;                   /* write  magic number for AMR Header at one time */
 442 static const gchar AMR_header[] = "#!AMR\n";
 443 static const gchar AMRWB_header[] = "#!AMR-WB\n";
 444 #define AMR_NB_MIME_HDR_SIZE          6
 445 #define AMR_WB_MIME_HDR_SIZE          9
 446 static const gint block_size_nb[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
 447 static const gint block_size_wb[16] = { 17, 23, 32, 36, 40, 46, 50, 58, 60, 5, -1, -1, -1, -1, 0, 0 };
 448
 449 gint *blocksize_tbl;
 450 void amrdec_extractor(App * app, guint8 **data, gint *size, gboolean * have_frame, gboolean *codec_data)
 451 {
 452         gint readsize = 0, mode_temp;
 453         gint fsize, mode;
 454         guint8 *pAmr = app->data + app->offset;
 455         /* change the below one to frame count */
 456         if (app->offset == 0) {
 457                 if (!memcmp(pAmr, AMR_header, AMR_NB_MIME_HDR_SIZE)) {
 458                         blocksize_tbl = (int *)block_size_nb;
 459                         mode_temp = pAmr[AMR_NB_MIME_HDR_SIZE];
 460                         pAmr = pAmr + AMR_NB_MIME_HDR_SIZE;
 461                         app->offset += AMR_NB_MIME_HDR_SIZE;
 462                 } else {
 463                         if (!memcmp(pAmr, AMRWB_header, AMR_WB_MIME_HDR_SIZE)) {
 464                                 blocksize_tbl = (int *)block_size_wb;
 465                                 mode_temp = pAmr[AMR_WB_MIME_HDR_SIZE];
 466                                 pAmr = pAmr + AMR_WB_MIME_HDR_SIZE;
 467                                 app->offset += AMR_WB_MIME_HDR_SIZE;
 468                         } else {
 469                                 g_print("[ERROR] AMR-NB/WB don't detected..\n");
 470                                 return;
 471                         }
 472                 }
 473         }
 474         mode_temp = pAmr[0];
 475         if ((mode_temp & 0x83) == 0) {
 476                 mode = (mode_temp >> 3) & 0x0F; /* Yep. Retrieve the frame size */
 477                 fsize = blocksize_tbl[mode];
 478                 readsize = fsize + 1;
 479         } else {
 480                 readsize = 0;
 481                 g_print("[FAIL] Not found amr frame sync.....\n");
 482         }
 483
 484         *size = readsize;
 485         app->offset += readsize;
 486         *data = pAmr;
 487         *have_frame = TRUE;
 488 }
 489
 490 void nv12_extractor(App *app, guint8 **data, gint *size, gboolean *have_frame, gboolean *codec_data)
 491 {
 492         gint yuv_size;
 493         gint offset = app->length - app->offset;
 494
 495         yuv_size = app->width * app->height * 3 / 2;
 496
 497         if (offset >= yuv_size)
 498                 *size = offset;
 499
 500         *have_frame = TRUE;
 501         *data = app->data + app->offset;
 502
 503         if (yuv_size >= offset)
 504                 *size = offset;
 505         else
 506                 *size = yuv_size;
 507
 508         app->offset += *size;
 509 }
 510
 511 void yuv_extractor(App *app, guint8 **data, int *size, gboolean *have_frame, gboolean *codec_data)
 512 {
 513         gint yuv_size;
 514         gint offset = app->length - app->offset;
 515
 516         yuv_size = app->width * app->height * 3 / 2;
 517
 518         if (yuv_size >= offset)
 519                 *size = offset;
 520
 521         *have_frame = TRUE;
 522         *data = app->data + app->offset;
 523
 524         if (yuv_size >= offset)
 525                 *size = offset;
 526         else
 527                 *size = yuv_size;
 528
 529         app->offset += *size;
 530 }
 531
 532 void aacenc_extractor(App *app, guint8 **data, int *size, gboolean *have_frame, gboolean *codec_data)
 533 {
 534         gint read_size;
 535         gint offset = app->length - app->offset;
 536
 537         read_size = ((DEFAULT_SAMPLEBYTE * app->channel)*(app->bit/8) * 2);
 538
 539         *have_frame = TRUE;
 540         *data = app->data + app->offset;
 541
 542         if (read_size >= offset)
 543                 *size = offset;
 544         else
 545                 *size = read_size;
 546
 547         app->offset += *size;
 548 }
 549
 550 void amrenc_extractor(App *app, guint8 **data, int *size, gboolean *have_frame, gboolean *codec_data)
 551 {
 552         gint read_size;
 553         gint offset = app->length - app->offset;
 554
 555         if (app->is_amr_nb)
 556                 read_size = AMRNB_PCM_INPUT_SIZE;
 557         else
 558                 read_size = AMRWB_PCM_INPUT_SIZE;
 559
 560         *have_frame = TRUE;
 561         *data = app->data + app->offset;
 562
 563         if (read_size >= offset)
 564                 *size = offset;
 565         else
 566                 *size = read_size;
 567
 568         app->offset += *size;
 569 }
 570
 571 /**
 572  * Extract Input data for AAC decoder
 573  * (case of (LC profile) ADTS format)
 574  * codec_data : Don't need
 575  **/
 576 void aacdec_extractor(App *app, guint8 **data, int *size, gboolean *have_frame, gboolean *codec_data)
 577 {
 578         int read_size;
 579         int offset = app->length - app->offset;
 580         guint8 *pData = app->data + app->offset;
 581
 582         if ((pData != NULL) && (pData[0] == 0xff) && ((pData[1] & 0xf6) == 0xf0)) {
 583                 read_size = ((pData[3] & 0x03) << 11) | (pData[4] << 3) | ((pData[5] & 0xe0) >> 5);
 584         } else {
 585                 read_size = 0;
 586                 g_print("[FAIL] Not found aac frame sync.....\n");
 587         }
 588
 589         *have_frame = TRUE;
 590         *data = app->data + app->offset;
 591
 592         if (read_size >= offset)
 593                 *size = offset;
 594         else
 595                 *size = read_size;
 596
 597         app->offset += *size;
 598 }
 599
 600 void mp3dec_extractor(App *app, guint8 **data, int *size, gboolean *have_frame, gboolean *codec_data)
 601 {
 602         gint read_size;
 603         guint header;
 604         guint padding, bitrate, lsf = 0, layer = 0, mpg25 = 0;
 605         guint hdr_bitrate = 0, sf = 0;
 606         gint offset = app->length - app->offset;
 607         guint8 *pData = app->data + app->offset;
 608
 609         header = GST_READ_UINT32_BE(pData);
 610
 611         if (header == 0) {
 612                 g_print ("[ERROR] read header size is 0\n");
 613                 *have_frame = FALSE;
 614                 return;
 615         }
 616
 617         /* if it's not a valid sync */
 618         if ((header & 0xffe00000) != 0xffe00000) {
 619                 g_print ("[ERROR] invalid sync\n");
 620                 *have_frame = FALSE;
 621                 return;
 622         }
 623
 624         if (((header >> 19) & 3) == 0x1) {
 625                 g_print ("[ERROR] invalid MPEG version: %d\n", (header >> 19) & 3);
 626                 *have_frame = FALSE;
 627                 return;
 628         } else {
 629                 if (header & (1 << 20)) {
 630                         lsf = (header & (1 << 19)) ? 0 : 1;
 631                         mpg25 = 0;
 632                 } else {
 633                         lsf = 1;
 634                         mpg25 = 1;
 635                 }
 636         }
 637
 638         /* if it's an invalid layer */
 639         if (!((header >> 17) & 3)) {
 640                 g_print("[ERROR] invalid layer: %d\n", (header >> 17) & 3);
 641                 *have_frame = FALSE;
 642                 return;
 643         } else {
 644                 layer = 4 - ((header >> 17) & 0x3);
 645         }
 646
 647         /* if it's an invalid bitrate */
 648         if (((header >> 12) & 0xf) == 0xf) {
 649                 g_print ("[ERROR] invalid bitrate: %d\n", (header >> 12) & 0xf);
 650                 *have_frame = FALSE;
 651                 return;
 652         } else {
 653                 bitrate = (header >> 12) & 0xF;
 654                 hdr_bitrate = mp3types_bitrates[lsf][layer - 1][bitrate] * 1000;
 655                 /* The caller has ensured we have a valid header, so bitrate can't be zero here. */
 656                 if (hdr_bitrate == 0) {
 657                         *have_frame = FALSE;
 658                         return;
 659                 }
 660         }
 661
 662         /* if it's an invalid samplerate */
 663         if (((header >> 10) & 0x3) == 0x3) {
 664                 g_print ("[ERROR] invalid samplerate: %d\n", (header >> 10) & 0x3);
 665                 *have_frame = FALSE;
 666                 return;
 667         } else {
 668                 sf = (header >> 10) & 0x3;
 669                 sf = mp3types_freqs[lsf + mpg25][sf];
 670         }
 671
 672         padding = (header >> 9) & 0x1;
 673
 674         switch (layer) {
 675         case 1:
 676                 read_size = 4 * ((hdr_bitrate * 12) / sf + padding);
 677                 break;
 678         case 2:
 679                 read_size = (hdr_bitrate * 144) / sf + padding;
 680                 break;
 681         default:
 682         case 3:
 683                 read_size = (hdr_bitrate * 144) / (sf << lsf) + padding;
 684                 break;
 685         }
 686         g_print("header : %d, read : %d\n", header, read_size);
 687
 688         *have_frame = TRUE;
 689         *data = app->data + app->offset;
 690
 691         if (read_size >= offset)
 692                 *size = offset;
 693         else
 694                 *size = read_size;
 695
 696         app->offset += *size;
 697 }
 698
 699 /**
 700  * Extract Input data for AAC encoder
 701  **/
 702 /*
 703    void aacenc_extractor(App *app, guint8 **data, int *size, gboolean *have_frame)
 704    {
 705    int read_size;
 706    int offset = app->length - app->offset;
 707
 708    read_size = ((DEFAULT_SAMPLEBYTE*DEFAULT_CHANNEL)*(DEFAULT_BIT/8));
 709
 710    if (read_size >= offset)
 711  *size = offset;
 712
 713  *have_frame = TRUE;
 714  *data = app->data + app->offset;
 715
 716  if (read_size >= offset)
 717  *size = offset;
 718  else
 719  *size = read_size;
 720
 721  app->offset += *size;
 722  }
 723  */
 724 int  _configure(App *app, int codecid, int flag, gboolean *hardware, media_format_mimetype_e *codec_mime)
 725 {
 726         gboolean encoder;
 727         media_format_mimetype_e mime = 0;
 728         encoder = GET_IS_ENCODER(flag) ? 1 : 0;
 729         *hardware = GET_IS_HW(flag) ? 1 : 0;
 730         app->is_encoder = encoder;
 731
 732         switch (codecid) {
 733         case MEDIACODEC_H264:
 734                 if (encoder) {
 735                         extractor = yuv_extractor;
 736                         mime = *hardware ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
 737                         *codec_mime = MEDIA_FORMAT_H264_SP;
 738                 } else {
 739                         extractor = h264_extractor;
 740                         mime = MEDIA_FORMAT_H264_SP;
 741                 }
 742                 break;
 743         case MEDIACODEC_MPEG4:
 744                 if (encoder) {
 745                         extractor = yuv_extractor;
 746                         mime = *hardware ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
 747                         *codec_mime = MEDIA_FORMAT_MPEG4_SP;
 748                 } else {
 749                         extractor = mpeg4_extractor;
 750                         mime = MEDIA_FORMAT_MPEG4_SP;
 751                 }
 752                 break;
 753         case MEDIACODEC_H263:
 754                 if (encoder) {
 755                         extractor = yuv_extractor;
 756                         mime = *hardware ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
 757                         *codec_mime = MEDIA_FORMAT_H263;
 758                 } else {
 759                         extractor = h263_extractor;
 760                         mime = MEDIA_FORMAT_H263;
 761                 }
 762                 break;
 763         case MEDIACODEC_AAC:
 764                 if (encoder) {
 765                         extractor = aacenc_extractor;
 766                         mime = MEDIA_FORMAT_PCM_F32LE;  /* FIXME need to check according to verdor */
 767                         *codec_mime = MEDIA_FORMAT_AAC;
 768                 } else {
 769                         extractor = aacdec_extractor;
 770                         mime = MEDIA_FORMAT_AAC;
 771                 }
 772                 break;
 773         case MEDIACODEC_AAC_HE:
 774                 if (encoder) {
 775                         extractor = aacenc_extractor;
 776                         mime = MEDIA_FORMAT_PCM_F32LE;  /* FIXME need to check according to verdor */
 777                         *codec_mime = MEDIA_FORMAT_AAC_HE;
 778                 }
 779                 break;
 780         case MEDIACODEC_AAC_HE_PS:
 781                 break;
 782         case MEDIACODEC_MP3:
 783                 extractor = mp3dec_extractor;
 784                 mime = MEDIA_FORMAT_MP3;
 785                 break;
 786         case MEDIACODEC_VORBIS:
 787                 break;
 788         case MEDIACODEC_FLAC:
 789                 break;
 790         case MEDIACODEC_WMAV1:
 791                 break;
 792         case MEDIACODEC_WMAV2:
 793                 break;
 794         case MEDIACODEC_WMAPRO:
 795                 break;
 796         case MEDIACODEC_WMALSL:
 797                 break;
 798         case MEDIACODEC_AMR_NB:
 799                 if (encoder) {
 800                         extractor = amrenc_extractor;
 801                         mime = MEDIA_FORMAT_PCM_F32LE;  /* FIXME need to check according to verdor */
 802                         app->is_amr_nb = TRUE;
 803                 } else {
 804                         extractor = amrdec_extractor;
 805                         mime = MEDIA_FORMAT_AMR_NB;
 806                 }
 807                 break;
 808         case MEDIACODEC_AMR_WB:
 809                 if (encoder) {
 810                         extractor = amrenc_extractor;
 811                         mime = MEDIA_FORMAT_PCM_F32LE;  /* FIXME need to check according to verdor */
 812                         app->is_amr_nb = FALSE;
 813                 } else {
 814                         extractor = amrdec_extractor;
 815                         mime = MEDIA_FORMAT_AMR_WB;
 816                 }
 817                 break;
 818         default:
 819                 LOGE("NOT SUPPORTED!!!!");
 820                 break;
 821         }
 822         return mime;
 823 }
 824
 825 void _mediacodec_process_input(App *app)
 826 {
 827         gint i, j;
 828         gboolean have_frame = FALSE;
 829         gint ret;
 830         static guint64 pts = 0L;
 831         guint8 *buf_data_ptr = NULL;
 832         media_packet_h pkt = NULL;
 833         guint8 *tmp;
 834         gint read;
 835         gint size;
 836         gint offset;
 837         gint stride_width;
 838         gboolean codec_config = FALSE;
 839
 840         for (i = 0; i < app->frame; i++) {
 841                 g_print("----------read data------------\n");
 842
 843                 extractor(app, &tmp, &read, &have_frame, &codec_config);
 844
 845                 if (have_frame) {
 846 #ifdef USE_POOL
 847                 if (media_packet_pool_acquire_packet(pkt_pool, &pkt, -1) != MEDIA_PACKET_ERROR_NONE) {
 848                         g_print("media_packet_pool_aquire_packet failed\n");
 849                         return;
 850                 }
 851 #else
 852                 if (media_packet_create_alloc(fmt, NULL, NULL, &pkt) != MEDIA_PACKET_ERROR_NONE) {
 853                         g_print("media_packet_create_alloc failed\n");
 854                         return;
 855                 }
 856 #endif
 857
 858                         if (media_packet_set_pts(pkt, (uint64_t)(pts)) != MEDIA_PACKET_ERROR_NONE) {
 859                                 g_print("media_packet_set_pts failed\n");
 860                                 return;
 861                         }
 862
 863                         if (app->type != VIDEO_ENC) {
 864                                 media_packet_get_buffer_data_ptr(pkt, (void **)&buf_data_ptr);
 865                                 media_packet_set_buffer_size(pkt, (uint64_t)read);
 866                                 memcpy(buf_data_ptr, tmp, read);
 867                                 g_print("tmp:%p, read:%d\n", tmp, read);
 868                         } else {
 869                                 /* Y */
 870                                 media_packet_get_video_plane_data_ptr(pkt, 0, (void **)&buf_data_ptr);
 871                                 media_packet_get_video_stride_width(pkt, 0, &stride_width);
 872                                 offset = app->width*app->height;
 873
 874                                 for (j = 0; j < app->height; j++) {
 875                                         memcpy(buf_data_ptr, tmp, app->width);
 876                                         buf_data_ptr += stride_width;
 877                                         tmp += app->width;
 878                                 }
 879
 880                                 if (app->hardware == TRUE) {
 881                                         media_packet_get_video_plane_data_ptr(pkt, 1, (void **)&buf_data_ptr);
 882                                         media_packet_get_video_stride_width(pkt, 1, &stride_width);
 883                                         size = app->width * app->height / 2;
 884
 885                                         for (j = 0; j < app->height / 2; j++) {
 886                                                 memcpy(buf_data_ptr, tmp, app->width);
 887                                                 buf_data_ptr += stride_width;
 888                                                 tmp += app->width;
 889                                         }
 890                                 } else {
 891                                         /* U */
 892                                         media_packet_get_video_plane_data_ptr(pkt, 1, (void **)&buf_data_ptr);
 893                                         media_packet_get_video_stride_width(pkt, 1, &stride_width);
 894                                         size = (app->width>>1) * (app->height>>1);
 895
 896                                         for (j = 0; j < app->height/2; j++) {
 897                                                 memcpy(buf_data_ptr, tmp, app->width/2);
 898                                                 buf_data_ptr += stride_width;
 899                                                 tmp += app->width/2;
 900                                         }
 901
 902                                         /* V */
 903                                         media_packet_get_video_plane_data_ptr(pkt, 2, (void **)&buf_data_ptr);
 904                                         media_packet_get_video_stride_width(pkt, 2, &stride_width);
 905                                         offset += size;
 906
 907                                         for (j = 0; j < app->height/2; j++) {
 908                                                 memcpy(buf_data_ptr, tmp, app->width/2);
 909                                                 buf_data_ptr += stride_width;
 910                                                 tmp += app->width/2;
 911                                         }
 912
 913                                 }
 914                         }
 915                         mc_hex_dump("inbuf", tmp, 48);
 916
 917                         ret = mediacodec_process_input(app->mc_handle[0], pkt, 1000);
 918                         if (ret != MEDIACODEC_ERROR_NONE)
 919                                 return;
 920
 921                         pts += ES_DEFAULT_VIDEO_PTS_OFFSET;
 922                 }
 923         }
 924 }
 925
 926 gboolean read_data(App *app)
 927 {
 928         guint len = 0;
 929         gboolean have_frame = FALSE;
 930         gboolean codec_config = FALSE;
 931         gint ret;
 932         static guint64 pts = 0L;
 933         guint8 *buf_data_ptr = NULL;
 934         media_packet_h pkt = NULL;
 935         guint8 *tmp;
 936         gint i;
 937         gint read;
 938         gint size;
 939         gint offset;
 940         gint stride_width;
 941
 942         if (app->offset == 0) {
 943                 app->frame_count = 0;
 944                 app->start = clock();
 945         }
 946
 947         g_print("----------read data------------\n");
 948         extractor(app, &tmp, &read, &have_frame, &codec_config);
 949
 950         if (app->offset >= app->length - 4) {
 951                 /* EOS */
 952                 g_print("EOS\n");
 953                 app->finish = clock();
 954                 g_print("Average FPS = %3.3f\n", ((double)app->frame_count*1000000/(app->finish - app->start)));
 955                 g_print("---------------------------\n");
 956                 return FALSE;
 957         }
 958         g_print("length : %d, offset : %d\n", app->length, app->offset);
 959
 960         if (app->offset + len > app->length)
 961                 len = app->length - app->offset;
 962
 963         g_print("%p, %d, have_frame :%d, read: %d\n", tmp, (int)read, have_frame, read);
 964
 965         if (have_frame) {
 966 #ifdef USE_POOL
 967                 if (media_packet_pool_acquire_packet(pkt_pool, &pkt, -1) != MEDIA_PACKET_ERROR_NONE) {
 968                         g_print("media_packet_pool_aquire_packet failed\n");
 969                         return FALSE;
 970                 }
 971 #else
 972                 if (media_packet_create_alloc(fmt, NULL, NULL, &pkt) != MEDIA_PACKET_ERROR_NONE) {
 973                         g_print("media_packet_create_alloc failed\n");
 974                         return FALSE;
 975                 }
 976 #endif
 977                 if (media_packet_set_pts(pkt, (uint64_t)(pts)) != MEDIA_PACKET_ERROR_NONE) {
 978                         g_print("media_packet_set_pts failed\n");
 979                         return FALSE;
 980                 }
 981
 982
 983                 if (app->type != VIDEO_ENC) {
 984                         media_packet_get_buffer_data_ptr(pkt, (void **)&buf_data_ptr);
 985                         media_packet_set_buffer_size(pkt, (uint64_t)read);
 986
 987                         memcpy(buf_data_ptr, tmp, read);
 988                         g_print("tmp:%p, read:%d\n", tmp, read);
 989                 } else {
 990                         /* Y */
 991                         media_packet_get_video_plane_data_ptr(pkt, 0, (void **)&buf_data_ptr);
 992                         media_packet_get_video_stride_width(pkt, 0, &stride_width);
 993                         offset = app->width*app->height;
 994
 995                         for (i = 0; i < app->height; i++) {
 996                                 memcpy(buf_data_ptr, tmp, app->width);
 997                                 buf_data_ptr += stride_width;
 998                                 tmp += app->width;
 999                         }
1000
1001                         if (app->hardware == TRUE) {
1002                                 media_packet_get_video_plane_data_ptr(pkt, 1, (void **)&buf_data_ptr);
1003                                 media_packet_get_video_stride_width(pkt, 1, &stride_width);
1004                                 size = app->width * app->height>>1;
1005
1006                                 for (i = 0; i < app->height>>1; i++) {
1007                                         memcpy(buf_data_ptr, tmp, app->width);
1008                                         buf_data_ptr += stride_width;
1009                                         tmp += app->width;
1010                                 }
1011
1012                         } else {
1013                                 /* U */
1014                                 media_packet_get_video_plane_data_ptr(pkt, 1, (void **)&buf_data_ptr);
1015                                 media_packet_get_video_stride_width(pkt, 1, &stride_width);
1016                                 size = (app->width>>1) * (app->height>>1);
1017
1018                                 for (i = 0; i < app->height/2; i++) {
1019                                         memcpy(buf_data_ptr, tmp, app->width>>1);
1020                                         buf_data_ptr += stride_width;
1021                                         tmp += (app->width>>1);
1022                                 }
1023
1024                                 /* V */
1025                                 media_packet_get_video_plane_data_ptr(pkt, 2, (void **)&buf_data_ptr);
1026                                 media_packet_get_video_stride_width(pkt, 2, &stride_width);
1027                                 offset += size;
1028
1029                                 for (i = 0; i < app->height/2; i++) {
1030                                         memcpy(buf_data_ptr, tmp, app->width>>1);
1031                                         buf_data_ptr += stride_width;
1032                                         tmp += (app->width>>1);
1033                                 }
1034
1035                         }
1036                 }
1037                 mc_hex_dump("inbuf", tmp, 48);
1038
1039                 ret = mediacodec_process_input(app->mc_handle[0], pkt, 0);
1040                 if (ret != MEDIACODEC_ERROR_NONE)
1041                         return FALSE;
1042
1043                 pts += ES_DEFAULT_VIDEO_PTS_OFFSET;
1044         }
1045
1046         return TRUE;
1047 }
1048
1049 void av_feed_suspend(App *app)
1050 {
1051         g_mutex_lock(&app->thread_mutex);
1052         app->suspend = 1;
1053         g_print("suspend thread\n");
1054         g_mutex_unlock(&app->thread_mutex);
1055 }
1056
1057 void av_feed_resume(App *app)
1058 {
1059         g_mutex_lock(&app->thread_mutex);
1060         app->suspend = 0;
1061         g_print("resume thread\n");
1062         g_cond_broadcast(&app->thread_cond);
1063         g_mutex_unlock(&app->thread_mutex);
1064 }
1065
1066 #ifdef TIZEN_FEATURE_INTEGRATION
1067 gpointer av_feed_thread(gpointer data)
1068 {
1069         App *app = (App *)data;
1070         int ret = 0;
1071         gint track = -1;
1072
1073         media_packet_h packet = NULL;
1074         track = app->audio_track;
1075
1076         while (1) {
1077                 g_mutex_lock(&app->thread_mutex);
1078
1079                 while (app->suspend != 0) g_cond_wait(&app->thread_cond, &app->thread_mutex);
1080
1081                 g_mutex_unlock(&app->thread_mutex);
1082
1083                 if (app->demux_eos == 1) {
1084                         g_print("got eos!!!\n");
1085                         break;
1086                 }
1087
1088                 ret = mediademuxer_read_sample(app->demuxer, track, &packet);
1089                 if (ret != MEDIACODEC_ERROR_NONE)
1090                         return NULL;
1091
1092                 ret = mediacodec_process_input(app->mc_handle[track], packet, 0);
1093                 if (ret != MEDIACODEC_ERROR_NONE)
1094                         return NULL;
1095
1096                 app->etb++;
1097
1098         }
1099
1100         return NULL;
1101 }
1102
1103 gboolean feed_audio(App *app)
1104 {
1105         gint ret = 0;
1106         gint track = -1;
1107
1108         media_packet_h packet = NULL;
1109         track = app->audio_track;
1110
1111         g_print("read audio sample!!!\n");
1112         ret = mediademuxer_read_sample(app->demuxer, track, &packet);
1113         if (ret != MEDIACODEC_ERROR_NONE)
1114                 return FALSE;
1115
1116         ret = mediacodec_process_input(app->mc_handle[track], packet, 0);
1117         if (ret != MEDIACODEC_ERROR_NONE)
1118                 return FALSE;
1119
1120         return TRUE;
1121 }
1122
1123 gboolean feed_video(App *app)
1124 {
1125         gint ret = 0;
1126         gint track = -1;
1127
1128         media_packet_h packet = NULL;
1129         track = app->video_track;
1130
1131         g_print("read video sample!!!\n");
1132         ret = mediademuxer_read_sample(app->demuxer, track, &packet);
1133         if (ret != MEDIACODEC_ERROR_NONE)
1134                 return FALSE;
1135
1136         ret = mediacodec_process_input(app->mc_handle[track], packet, 0);
1137         if (ret != MEDIACODEC_ERROR_NONE)
1138                 return FALSE;
1139
1140         return TRUE;
1141 }
1142 #endif
1143
1144 void start_feed(App *app)
1145 {
1146         if (app->sourceid == 0) {
1147                 app->sourceid = g_idle_add((GSourceFunc)read_data, app);
1148                 g_print("start_feed\n");
1149         }
1150 }
1151
1152 void stop_feed(App *app)
1153 {
1154         if (app->sourceid != 0) {
1155                 g_source_remove(app->sourceid);
1156                 app->sourceid = 0;
1157                 g_print("stop_feed\n");
1158         }
1159 }
1160
1161 void _mediacodec_inbuf_used_cb(media_packet_h pkt, void *user_data)
1162 {
1163         App *app = (App *)user_data;
1164
1165         g_print("_mediacodec_inbuf_used_cb!!!\n");
1166 #ifdef USE_POOL
1167         media_packet_pool_release_packet(pkt_pool, pkt);
1168 #else
1169         media_packet_destroy(pkt);
1170 #endif
1171         app->ebd++;
1172
1173         return;
1174 }
1175
1176 void _audio_outbuf_available_cb(media_packet_h pkt, void *user_data)
1177 {
1178         media_packet_h out_pkt = NULL;
1179         int ret;
1180
1181         App *app = (App*)user_data;
1182
1183         g_print("_audio_outbuf_available_cb\n");
1184
1185         g_mutex_lock(&app->lock);
1186
1187         ret = mediacodec_get_output(app->mc_handle[app->audio_track], &out_pkt, 0);
1188
1189         if (ret != MEDIACODEC_ERROR_NONE)
1190                 g_print("get_output failed\n");
1191
1192         if (app->enable_dump)
1193                 output_dump(app, out_pkt);
1194
1195         app->frame_count++;
1196         app->fbd++;
1197
1198
1199         g_mutex_unlock(&app->lock);
1200
1201         media_packet_destroy(out_pkt);
1202         out_pkt = NULL;
1203         g_print("done\n");
1204
1205         return;
1206 }
1207
1208 void _video_outbuf_available_cb(media_packet_h pkt, void *user_data)
1209 {
1210         media_packet_h out_pkt = NULL;
1211         int ret;
1212
1213         App *app = (App*)user_data;
1214
1215         g_print("_video_outbuf_available_cb\n");
1216
1217         g_mutex_lock(&app->lock);
1218
1219         ret = mediacodec_get_output(app->mc_handle[app->video_track], &out_pkt, 0);
1220
1221         if (ret != MEDIACODEC_ERROR_NONE)
1222                 g_print("get_output failed\n");
1223
1224         if (app->enable_dump)
1225                 decoder_output_dump(app, out_pkt);
1226
1227         app->frame_count++;
1228         app->fbd++;
1229
1230
1231         g_mutex_unlock(&app->lock);
1232
1233         media_packet_destroy(out_pkt);
1234         out_pkt = NULL;
1235         g_print("done\n");
1236
1237         return;
1238 }
1239
1240 void _mediacodec_outbuf_available_cb(media_packet_h pkt, void *user_data)
1241 {
1242         media_packet_h out_pkt = NULL;
1243         int ret;
1244
1245         App *app = (App*)user_data;
1246
1247         g_print("_mediacodec_outbuf_available_cb\n");
1248
1249         g_mutex_lock(&app->lock);
1250
1251         ret = mediacodec_get_output(app->mc_handle[0], &out_pkt, 0);
1252
1253         if (ret != MEDIACODEC_ERROR_NONE)
1254                 g_print("get_output failed\n");
1255
1256         if (app->enable_dump) {
1257                 if (app->type == VIDEO_DEC)
1258                         decoder_output_dump(app, out_pkt);
1259                 else
1260                         output_dump(app, out_pkt);
1261         }
1262 #ifdef TIZEN_FEATURE_INTEGRATION
1263         if (app->enable_muxer) {
1264                 if (mediamuxer_write_sample(app->muxer, app->track, out_pkt) != MEDIAMUXER_ERROR_NONE)
1265                         g_print("mediamuxer_write_sample failed\n");
1266                 g_print("write sample!!!\n");
1267         }
1268 #endif
1269         app->frame_count++;
1270         app->fbd++;
1271
1272
1273         g_mutex_unlock(&app->lock);
1274
1275         media_packet_destroy(out_pkt);
1276         out_pkt = NULL;
1277         g_print("done\n");
1278
1279         return;
1280 }
1281
1282 void _mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data)
1283 {
1284         g_print("_mediacodec_buffer_status_cb %d\n", status);
1285
1286         App *app = (App*)user_data;
1287
1288         if (status == MEDIACODEC_NEED_DATA)
1289                 start_feed(app);
1290         else if (status == MEDIACODEC_ENOUGH_DATA)
1291                 stop_feed(app);
1292
1293         return;
1294 }
1295
1296 void _av_buffer_status_cb(mediacodec_status_e status, void *user_data)
1297 {
1298         g_print("_av_buffer_status_cb %d\n", status);
1299
1300         App *app = (App*)user_data;
1301
1302         if (status == MEDIACODEC_NEED_DATA)
1303                 av_feed_resume(app);
1304         else if (status == MEDIACODEC_ENOUGH_DATA)
1305                 av_feed_suspend(app);
1306
1307         return;
1308 }
1309
1310 void _mediacodec_error_cb(mediacodec_error_e error, void *user_data)
1311 {
1312         return;
1313 }
1314
1315
1316 void _mediacodec_eos_cb(void *user_data)
1317 {
1318         App *app = (App *)user_data;
1319
1320         g_print("mediacodec eos\n");
1321         g_mutex_lock(&app->eos_mutex);
1322         app->codec_eos = 1;
1323         g_mutex_unlock(&app->eos_mutex);
1324         g_cond_broadcast(&app->dst_eos_cond);
1325         return;
1326 }
1327
1328 #ifdef TIZEN_FEATURE_INTEGRATION
1329 void demuxer_error_cb(mediademuxer_error_e error, void *user_data)
1330 {
1331         g_print("Got Error %d from Mediademuxer\n", error);
1332         return;
1333 }
1334
1335 void _mediademuxer_eos_cb(int track, void *user_data)
1336 {
1337         App *app = (App *)user_data;
1338
1339         g_print("eos track : %d\n", track);
1340         av_feed_suspend(app);
1341         g_print("suspended\n");
1342         app->demux_eos = 1;
1343         av_feed_resume(app);
1344         g_cond_broadcast(&app->eos_cond);
1345
1346         return;
1347 }
1348
1349 void _mediamuxer_eos_cb(void *user_data)
1350 {
1351         if (user_data == NULL) {
1352                 g_print("invalid param");
1353                 return;
1354         }
1355
1356         App *app = (App *)user_data;
1357
1358         g_print("muxer eos\n");
1359
1360         if (mediamuxer_stop(app->muxer) != MEDIAMUXER_ERROR_NONE)
1361                 g_print(" mediamuxer_stop failed\n");
1362
1363         if (mediamuxer_unprepare(app->muxer) != MEDIAMUXER_ERROR_NONE)
1364                 g_print(" mediamuxer_unprepare failed\n");
1365
1366         if (mediamuxer_destroy(app->muxer) != MEDIAMUXER_ERROR_NONE)
1367                 g_print(" mediamuxer_destory failed\n");
1368
1369         g_print("mediamuxer destroyed\n");
1370 }
1371 #endif
1372
1373 gboolean  _foreach_cb(mediacodec_codec_type_e codec_type, void *user_data)
1374 {
1375         g_print("codec type : %x %s\n", codec_type, codec_type_to_string(codec_type));
1376         return TRUE;
1377 }
1378
1379 void _mediacodec_prepare(App *app, gboolean frame_all)
1380 {
1381         int ret;
1382         media_format_mimetype_e codec_mime;
1383         media_format_h codec_format;
1384
1385         g_print("supported codec lists -internal-\n");
1386         mediacodec_foreach_supported_codec_static((mediacodec_supported_codec_cb)_foreach_cb, app);
1387
1388         /* create instance */
1389         ret = mediacodec_create(&app->mc_handle[0]);
1390         if (ret  != MEDIACODEC_ERROR_NONE) {
1391                 g_print("mediacodec_create  failed\n");
1392                 return;
1393         }
1394 #if 0
1395         /* set codec */
1396         ret = mediacodec_set_codec(app->mc_handle[0], app->codecid, app->flag);
1397         if (ret  != MEDIACODEC_ERROR_NONE) {
1398                 g_print("mediacodec_set_codec failed\n");
1399                 return;
1400         }
1401 #endif
1402         /* get mime and link to each codec parser */
1403         app->mime = _configure(app, app->codecid, app->flag, &app->hardware, &codec_mime);
1404
1405         /* set codec info */
1406         ret = media_format_create(&fmt);
1407
1408         switch (app->type) {
1409         case VIDEO_DEC:
1410                 media_format_set_video_mime(fmt, app->mime);
1411                 media_format_set_video_width(fmt, app->width);
1412                 media_format_set_video_height(fmt, app->height);
1413
1414                 ret = mediacodec_configure_from_media_format(app->mc_handle[0], fmt, app->flag);
1415                 if (ret  != MEDIACODEC_ERROR_NONE)
1416                         g_print("mediacodec_configure failed\n");
1417                 break;
1418         case VIDEO_ENC:
1419                 media_format_set_video_mime(fmt, app->mime);
1420                 media_format_set_video_width(fmt, app->width);
1421                 media_format_set_video_height(fmt, app->height);
1422                 media_format_set_video_avg_bps(fmt, app->target_bits);
1423
1424                 media_format_create(&codec_format);
1425                 media_format_set_video_mime(codec_format, codec_mime);
1426                 media_format_set_video_width(codec_format, app->width);
1427                 media_format_set_video_height(codec_format, app->height);
1428                 media_format_set_video_avg_bps(codec_format, app->target_bits);
1429                 media_format_set_video_frame_rate(codec_format, app->fps);
1430
1431                 ret = mediacodec_configure_from_media_format(app->mc_handle[0], codec_format, app->flag);
1432                 if (ret  != MEDIACODEC_ERROR_NONE)
1433                         g_print("mediacodec_configure failed\n");
1434                 media_format_unref(codec_format);
1435                 break;
1436         case AUDIO_DEC:
1437                 media_format_set_audio_mime(fmt, app->mime);
1438                 media_format_set_audio_channel(fmt, app->channel);
1439                 media_format_set_audio_samplerate(fmt, app->samplerate);
1440                 media_format_set_audio_bit(fmt, app->bit);
1441
1442                 ret = mediacodec_configure_from_media_format(app->mc_handle[0], fmt, app->flag);
1443                 if (ret  != MEDIACODEC_ERROR_NONE)
1444                         g_print("mediacodec_configure failed\n");
1445                 break;
1446         case AUDIO_ENC:
1447                 media_format_set_audio_mime(fmt, app->mime);
1448                 media_format_set_audio_channel(fmt, app->channel);
1449                 media_format_set_audio_samplerate(fmt, app->samplerate);
1450                 media_format_set_audio_bit(fmt, app->bit);
1451
1452                 media_format_create(&codec_format);
1453                 media_format_set_audio_mime(codec_format, codec_mime);
1454                 media_format_set_audio_channel(codec_format, app->channel);
1455                 media_format_set_audio_samplerate(codec_format, app->samplerate);
1456                 media_format_set_audio_bit(codec_format, app->bit);
1457                 media_format_set_audio_avg_bps(codec_format, app->bitrate);
1458
1459                 ret = mediacodec_configure_from_media_format(app->mc_handle[0], codec_format, app->flag);
1460                 if (ret  != MEDIACODEC_ERROR_NONE)
1461                         g_print("mediacodec_set_configure failed\n");
1462                 media_format_unref(codec_format);
1463                 break;
1464         default:
1465                 g_print("invaild type\n");
1466                 break;
1467         }
1468
1469         if (ret  != MEDIACODEC_ERROR_NONE) {
1470                 g_print("mediacodec_set_xxxc(%d)_info failed\n", app->type);
1471                 return;
1472         }
1473
1474         /* set callback */
1475         g_print("supported codec lists\n");
1476         mediacodec_foreach_supported_codec(app->mc_handle[0], (mediacodec_supported_codec_cb)_foreach_cb, app);
1477         mediacodec_set_input_buffer_used_cb(app->mc_handle[0], (mediacodec_input_buffer_used_cb)_mediacodec_inbuf_used_cb, app);
1478         mediacodec_set_output_buffer_available_cb(app->mc_handle[0], (mediacodec_output_buffer_available_cb) _mediacodec_outbuf_available_cb, app);
1479         if (frame_all)
1480                 mediacodec_set_buffer_status_cb(app->mc_handle[0], (mediacodec_buffer_status_cb) _mediacodec_buffer_status_cb, app);
1481         mediacodec_set_eos_cb(app->mc_handle[0], (mediacodec_eos_cb)_mediacodec_eos_cb, app);
1482         mediacodec_set_error_cb(app->mc_handle[0], (mediacodec_error_cb)_mediacodec_error_cb, NULL);
1483
1484         /* prepare */
1485         ret = mediacodec_prepare(app->mc_handle[0]);
1486         if (ret  != MEDIACODEC_ERROR_NONE) {
1487                 g_print("mediacodec_prepare failed\n");
1488                 return;
1489         }
1490
1491 #ifdef TIZEN_FEATURE_INTEGRATION
1492         if (app->enable_muxer) {
1493                 if (mediamuxer_create(&app->muxer) != MEDIAMUXER_ERROR_NONE)
1494                         g_print("mediamuxer_create failed\n");
1495
1496                 if (mediamuxer_set_data_sink(app->muxer, "/tmp/muxtest.mp4", MEDIAMUXER_CONTAINER_FORMAT_MP4) != MEDIAMUXER_ERROR_NONE)
1497                         g_print("mediamuxer_set_data_sink failed\n");
1498
1499                 media_format_create(&app->format[0]);
1500                 if (app->type == AUDIO_ENC)
1501                         media_format_set_audio_mime(app->format[0], codec_mime);
1502                 else if (app->type == VIDEO_ENC)
1503                         media_format_set_video_mime(app->format[0], codec_mime);
1504                 else
1505                         g_print("invalid format\n");
1506
1507                 if (mediamuxer_set_eos_cb(app->muxer, _mediamuxer_eos_cb, app) != MEDIAMUXER_ERROR_NONE)
1508                         g_print("mediamuxer_set_eos_cb failed\n");
1509
1510                 if (mediamuxer_add_track(app->muxer, app->format[0], &app->track) != MEDIAMUXER_ERROR_NONE)
1511                         g_print("mediamuxer_add_track failed\n");
1512
1513                 if (mediamuxer_prepare(app->muxer) != MEDIAMUXER_ERROR_NONE)
1514                         g_print("mediamuxer_prepare failed\n");
1515
1516                 if (mediamuxer_start(app->muxer) != MEDIAMUXER_ERROR_NONE)
1517                         g_print("mediamuxer_start failed\n");
1518         }
1519 #endif
1520
1521
1522         /* get packet pool instance */
1523         ret = mediacodec_get_packet_pool(app->mc_handle[0], &pkt_pool);
1524         if (ret != MEDIA_PACKET_ERROR_NONE) {
1525                 g_print("mediacodec_get_packet_pool failed\n");
1526                 return;
1527         }
1528         g_print("\n\nmediacodec start\n\n");
1529
1530         return;
1531 }
1532
1533 void _mediacodec_enc_input_buffer_used_cb(media_packet_h pkt, void *user_data)
1534 {
1535         /* release input raw packet */
1536         media_packet_destroy(pkt);
1537 }
1538
1539 /* this callback is called when the input buffer for codec has done to use */
1540 void _mediacodec_dec_input_buffer_used_cb(media_packet_h pkt, void *user_data)
1541 {
1542         /* release input encoded packet */
1543         media_packet_destroy(pkt);
1544 }
1545
1546 void _mediacodec_enc_output_buffer_available_cb(media_packet_h pkt, void *user_data)
1547 {
1548         App *app = (App*)user_data;
1549
1550         mediacodec_h media_codec_handle = app->mc_handle[1];
1551         media_packet_h output_buf = NULL;
1552         mediacodec_get_output(media_codec_handle, &output_buf, 0);
1553         /* decode encoded camera preview */
1554         mediacodec_process_input(app->mc_handle[0], output_buf, 0);
1555 }
1556
1557 void _mediacodec_dec_output_buffer_available_cb(media_packet_h pkt, void *user_data)
1558 {
1559         App *app = (App*)user_data;
1560
1561         mediacodec_h media_codec_handle = app->mc_handle[0];
1562         media_packet_h output_buf = NULL;
1563
1564         mediacodec_get_output(media_codec_handle, &output_buf, 0);
1565
1566         if (app->enable_dump)
1567                 decoder_output_dump(app, output_buf);
1568
1569         media_packet_destroy(output_buf);
1570 }
1571
1572 void _media_packet_preview_cb(media_packet_h packet, void *user_data)
1573 {
1574         App *app = user_data;
1575         g_mutex_lock(&app->lock);
1576         mediacodec_process_input(app->mc_handle[1], packet, 0);
1577         g_mutex_unlock(&app->lock);
1578
1579         return;
1580 }
1581
1582 #ifdef TIZEN_FEATURE_INTEGRATION
1583 void _mediacodec_camera_start(App *app)
1584 {
1585         int default_format = CAMERA_PIXEL_FORMAT_NV12;
1586         app->width = 640;
1587         app->height = 480;
1588         app->hardware = TRUE;
1589
1590         /*create decoder instance and setup */
1591         mediacodec_create(&app->mc_handle[0]);
1592         mediacodec_set_codec(app->mc_handle[0], MEDIACODEC_H264, MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW);
1593         mediacodec_set_vdec_info(app->mc_handle[0], app->width, app->height);
1594         /* set callback */
1595         mediacodec_set_input_buffer_used_cb(app->mc_handle[0], _mediacodec_dec_input_buffer_used_cb, NULL);
1596         mediacodec_set_output_buffer_available_cb(app->mc_handle[0], _mediacodec_dec_output_buffer_available_cb, app);
1597         mediacodec_prepare(app->mc_handle[0]);
1598
1599         /*create encoder instance and setup */
1600         mediacodec_create(&app->mc_handle[1]);
1601         mediacodec_set_codec(app->mc_handle[1], MEDIACODEC_H264, MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW);
1602         mediacodec_set_venc_info(app->mc_handle[1], app->width, app->height, 30, 1000);
1603         /* set callback */
1604         mediacodec_set_input_buffer_used_cb(app->mc_handle[1], _mediacodec_enc_input_buffer_used_cb, NULL);
1605         mediacodec_set_output_buffer_available_cb(app->mc_handle[1], _mediacodec_enc_output_buffer_available_cb, app);
1606         mediacodec_prepare(app->mc_handle[1]);
1607
1608         /* create camera instance and setup and then start preview */
1609         camera_create(CAMERA_DEVICE_CAMERA0, &app->camera_handle);
1610         camera_set_media_packet_preview_cb(app->camera_handle, _media_packet_preview_cb, app);
1611         camera_get_preview_format(app->camera_handle, &default_format);
1612         camera_set_preview_format(app->camera_handle, default_format);
1613         camera_set_preview_resolution(app->camera_handle, app->width, app->height);
1614         camera_set_display(app->camera_handle, CAMERA_DISPLAY_TYPE_NONE, NULL);
1615         camera_start_preview(app->camera_handle);
1616
1617         return;
1618 }
1619
1620
1621 void _mediacodec_camera_stop(App *app)
1622 {
1623         camera_state_e camera_state = CAMERA_STATE_NONE;
1624
1625         camera_get_state(app->camera_handle, &camera_state);
1626         camera_stop_preview(app->camera_handle);
1627         camera_destroy(app->camera_handle);
1628
1629         mediacodec_unprepare(app->mc_handle[0]);
1630         mediacodec_unprepare(app->mc_handle[1]);
1631         mediacodec_destroy(app->mc_handle[0]);
1632         mediacodec_destroy(app->mc_handle[1]);
1633         return;
1634 }
1635 #endif
1636
1637 #ifdef TIZEN_FEATURE_INTEGRATION
1638 void _mediacodec_auto_test(App *app, char *path)
1639 {
1640         gint ret = 0;
1641         gint num_tracks = 0;
1642         gint track = 0;
1643         gint width = 0;
1644         gint height = 0;
1645         gint channel = 0;
1646         gint samplerate = 0;
1647         gint bit = 0;
1648         media_format_type_e formattype;
1649         media_format_mimetype_e video_mime;
1650         media_format_mimetype_e audio_mime;
1651         gint codec_mask = 0xFFF0;
1652         gint codec_id;
1653         app->demux_eos = 0;
1654         app->codec_eos = 0;
1655         app->etb = 0;
1656         app->ebd = 0;
1657         app->ftb = 0;
1658         app->fbd = 0;
1659
1660         ret = mediademuxer_create(&app->demuxer);
1661         if (ret != MEDIACODEC_ERROR_NONE) {
1662                 g_print("failed to create demuxer\n");
1663                 return;
1664         }
1665
1666         ret = mediademuxer_set_data_source(app->demuxer, path);
1667         if (ret != MEDIACODEC_ERROR_NONE) {
1668                 g_print("failed to mediademuxer_set_data_source\n");
1669                 return;
1670         }
1671
1672         ret = mediademuxer_set_error_cb(app->demuxer, demuxer_error_cb, app->demuxer);
1673         if (ret != MEDIACODEC_ERROR_NONE) {
1674                 g_print("failed to mediademuxer_set_error_cb\n");
1675                 return;
1676         }
1677
1678         mediademuxer_set_eos_cb(app->demuxer, _mediademuxer_eos_cb, app);
1679
1680         ret = mediademuxer_prepare(app->demuxer);
1681         if (ret != MEDIACODEC_ERROR_NONE) {
1682                 g_print("failed to prepare\n");
1683                 return;
1684         }
1685
1686
1687         ret = mediademuxer_get_track_count(app->demuxer, &num_tracks);
1688         if (ret != MEDIACODEC_ERROR_NONE) {
1689                 g_print("failed to get track\n");
1690                 return;
1691         }
1692
1693         for (track = 0; track < num_tracks; track++) {
1694                 ret = mediademuxer_get_track_info(app->demuxer, track, &app->format[track]);
1695                 if (ret != MEDIACODEC_ERROR_NONE) {
1696                         g_print("failed to get track info\n");
1697                         return;
1698                 }
1699
1700                 media_format_get_type(app->format[track], &formattype);
1701
1702                 if (!app->is_video && formattype == MEDIA_FORMAT_AUDIO) {
1703                         app->audio_track = track;
1704                         app->type = AUDIO_DEC;
1705                         media_format_get_audio_info(app->format[track], &audio_mime, &channel, &samplerate, &bit, NULL);
1706
1707                         mediademuxer_select_track(app->demuxer, track);
1708
1709                         ret = mediacodec_create(&app->mc_handle[track]);
1710                         if (ret != MEDIACODEC_ERROR_NONE) {
1711                                 g_print("failed to create mediacocec\n");
1712                                 return;
1713                         }
1714
1715                         codec_id = audio_mime & codec_mask;
1716                         g_print("auido codec_id : %x\n", codec_id);
1717
1718                         ret = mediacodec_set_codec(app->mc_handle[track], codec_id, MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW);
1719                         if (ret != MEDIACODEC_ERROR_NONE) {
1720                                 g_print("failed to set codec\n");
1721                                 return;
1722                         }
1723
1724                         ret = mediacodec_set_adec_info(app->mc_handle[track], samplerate, channel, bit);
1725                         if (ret != MEDIACODEC_ERROR_NONE) {
1726                                 g_print("failed to set adec info\n");
1727                                 return;
1728                         }
1729
1730                         mediacodec_set_buffer_status_cb(app->mc_handle[track], _av_buffer_status_cb, app);
1731                         mediacodec_set_input_buffer_used_cb(app->mc_handle[track], _mediacodec_inbuf_used_cb, app);
1732                         mediacodec_set_output_buffer_available_cb(app->mc_handle[track], _audio_outbuf_available_cb, app);
1733                         mediacodec_set_eos_cb(app->mc_handle[track], _mediacodec_eos_cb, app);
1734                         mediacodec_set_error_cb(app->mc_handle[track], _mediacodec_error_cb, NULL);
1735
1736                 } else if (app->is_video && formattype == MEDIA_FORMAT_VIDEO) {
1737                         app->video_track = track;
1738                         app->type = VIDEO_DEC;
1739                         media_format_get_video_info(app->format[track], &video_mime, &width, &height, NULL, NULL);
1740
1741                         mediademuxer_select_track(app->demuxer, track);
1742
1743                         ret = mediacodec_create(&app->mc_handle[track]);
1744                         if (ret != MEDIACODEC_ERROR_NONE) {
1745                                 g_print("failed to create mediacocec\n");
1746                                 return;
1747                         }
1748
1749                         app->width = width;
1750                         app->height = height;
1751
1752                         codec_id = video_mime & codec_mask;
1753                         g_print("video codec_id : %x\n", codec_id);
1754
1755                         ret = mediacodec_set_codec(app->mc_handle[track], codec_id, MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW);
1756                         if (ret != MEDIACODEC_ERROR_NONE) {
1757                                 g_print("failed to set codec\n");
1758                                 return;
1759                         }
1760
1761                         ret = mediacodec_set_vdec_info(app->mc_handle[track], width, height);
1762                         if (ret != MEDIACODEC_ERROR_NONE) {
1763                                 g_print("failed to set vdec info\n");
1764                                 return;
1765                         }
1766
1767                         mediacodec_set_buffer_status_cb(app->mc_handle[track], _av_buffer_status_cb, app);
1768                         mediacodec_set_input_buffer_used_cb(app->mc_handle[track], _mediacodec_inbuf_used_cb, app);
1769                         mediacodec_set_output_buffer_available_cb(app->mc_handle[track], _video_outbuf_available_cb, app);
1770                         mediacodec_set_eos_cb(app->mc_handle[track], _mediacodec_eos_cb, app);
1771                         mediacodec_set_error_cb(app->mc_handle[track], _mediacodec_error_cb, NULL);
1772                 }
1773         }
1774
1775         ret = mediademuxer_start(app->demuxer);
1776         if (ret != MEDIACODEC_ERROR_NONE) {
1777                 g_print("failed to start mediademuxer\n");
1778                 return;
1779         }
1780
1781         track = app->is_video ? app->video_track : app->audio_track;
1782         ret = mediacodec_prepare(app->mc_handle[track]);
1783         if (ret != MEDIACODEC_ERROR_NONE) {
1784                 g_print("failed to prepare mediacodec\n");
1785                 return;
1786         }
1787
1788         g_cond_init(&app->thread_cond);
1789         g_cond_init(&app->eos_cond);
1790         g_cond_init(&app->dst_eos_cond);
1791         g_mutex_init(&app->thread_mutex);
1792         g_mutex_init(&app->eos_mutex);
1793
1794         app->thread = g_thread_new("feed thread", &av_feed_thread, app);
1795         app->start = clock();
1796
1797         g_mutex_lock(&app->eos_mutex);
1798         while (app->codec_eos != 1) g_cond_wait(&app->dst_eos_cond, &app->eos_mutex);
1799         g_mutex_unlock(&app->eos_mutex);
1800         g_print("now try to destroy thread!!\n");
1801         g_thread_join(app->thread);
1802         app->finish = clock();
1803
1804         ret = mediademuxer_stop(app->demuxer);
1805         if (ret != MEDIACODEC_ERROR_NONE) {
1806                 g_print("failed to stop mediademuxer\n");
1807                 return;
1808         }
1809
1810         ret = mediademuxer_unselect_track(app->demuxer, track);
1811         if (ret != MEDIACODEC_ERROR_NONE) {
1812                 g_print("failed to unselect mediademuxer\n");
1813                 return;
1814         }
1815
1816         ret = mediacodec_unprepare(app->mc_handle[track]);
1817         if (ret != MEDIACODEC_ERROR_NONE) {
1818                 g_print("failed to unprepare mediacodec\n");
1819                 return;
1820         }
1821
1822         ret = mediacodec_destroy(app->mc_handle[track]);
1823         if (ret != MEDIACODEC_ERROR_NONE) {
1824                 g_print("failed to destroy mediacodec\n");
1825                 return;
1826         }
1827
1828         ret = mediademuxer_unprepare(app->demuxer);
1829         if (ret != MEDIACODEC_ERROR_NONE) {
1830                 g_print("failed to unprepare mediademuxer\n");
1831                 return;
1832         }
1833
1834         ret = mediademuxer_destroy(app->demuxer);
1835         if (ret != MEDIACODEC_ERROR_NONE) {
1836                 g_print("failed to destroy mediademuxer\n");
1837                 return;
1838         }
1839
1840         g_cond_clear(&app->thread_cond);
1841         g_cond_clear(&app->eos_cond);
1842         g_cond_clear(&app->dst_eos_cond);
1843         g_mutex_clear(&app->thread_mutex);
1844         g_mutex_clear(&app->eos_mutex);
1845
1846         g_print("resources are released!!!\n\n\n");
1847         g_print("-----------------------------------------------------\n");
1848         g_print("Input - queued packets : %d, finalized packets : %d\n", app->etb, app->ebd);
1849         g_print("Output - queued packets : %d, finalized packets : %d\n", app->fbd, app->fbd);
1850         g_print("Average FPS = %3.3f\n", ((double)app->fbd*1000000/(app->finish - app->start)));
1851         g_print("-----------------------------------------------------\n");
1852
1853         return;
1854 }
1855 #endif
1856
1857 void _mediacodec_unprepare(App *app)
1858 {
1859         mediacodec_unprepare(app->mc_handle[0]);
1860 }
1861
1862 void _mediacodec_destroy(App *app)
1863 {
1864         if (app == NULL) {
1865                 g_print("invalid param");
1866                 return;
1867         }
1868 #ifdef USE_POOL
1869         if (media_packet_pool_deallocate(pkt_pool) != MEDIA_PACKET_ERROR_NONE) {
1870
1871                 g_print("media_packet_pool_deallocatet failed\n");
1872                 return;
1873         }
1874
1875         if (media_packet_pool_destroy(pkt_pool) != MEDIA_PACKET_ERROR_NONE) {
1876
1877                 g_print(" media_packet_pool_destroy failed\n");
1878                 return;
1879         }
1880         g_print("media packet pool destroyed! \n");
1881 #endif
1882         mediacodec_destroy(app->mc_handle[0]);
1883 #ifdef TIZEN_FEATURE_INTEGRATION
1884         if (app->enable_muxer) {
1885                 if (mediamuxer_close_track(app->muxer, app->track) != MEDIAMUXER_ERROR_NONE)
1886                         g_print("mediamuxer_close_track failed\n");
1887         }
1888 #endif
1889 }
1890
1891 void input_filepath(char *filename, App *app)
1892 {
1893         GError *error = NULL;
1894
1895         app->obj++;
1896         app->file = g_mapped_file_new(filename, FALSE, &error);
1897         if (error) {
1898                 g_print("failed to open file : %s\n", error->message);
1899                 g_error_free(error);
1900                 return;
1901         }
1902
1903         app->length = g_mapped_file_get_length(app->file);
1904         app->data = (guint8 *)g_mapped_file_get_contents(app->file);
1905         app->offset = 0;
1906         g_print("len : %d, offset : %d, obj : %d", app->length, app->offset, app->obj);
1907
1908         return;
1909 }
1910
1911 void quit_program(App *app)
1912 {
1913                 g_mutex_clear(&app->lock);
1914                 media_format_unref(fmt);
1915                 g_main_loop_quit(app->loop);
1916                 exit(0);
1917 }
1918
1919 void reset_menu_state()
1920 {
1921         g_menu_state = CURRENT_STATUS_MAINMENU;
1922         return;
1923 }
1924
1925 void _interpret_main_menu(char *cmd, App *app)
1926 {
1927         gint len =  strlen(cmd);
1928         if (len == 1) {
1929                 if (strncmp(cmd, "a", 1) == 0)
1930                         g_menu_state = CURRENT_STATUS_FILENAME;
1931                 else if (strncmp(cmd, "o", 1) == 0)
1932                         g_menu_state = CURRENT_STATUS_GET_OUTPUT;
1933                 else if (strncmp(cmd, "q", 1) == 0)
1934                         quit_program(app);
1935                 else
1936                         g_print("unknown menu \n");
1937         } else if (len == 2) {
1938                 if (strncmp(cmd, "pr", 2) == 0)
1939                         _mediacodec_prepare(app, 0);
1940                 else if (strncmp(cmd, "pa", 2) == 0)
1941                         _mediacodec_prepare(app, 1);
1942                 else if (strncmp(cmd, "sc", 2) == 0)
1943                         g_menu_state = CURRENT_STATUS_SET_CODEC;
1944                 else if (strncmp(cmd, "vd", 2) == 0)
1945                         g_menu_state = CURRENT_STATUS_SET_VDEC_INFO;
1946                 else if (strncmp(cmd, "ve", 2) == 0)
1947                         g_menu_state = CURRENT_STATUS_SET_VENC_INFO;
1948                 else if (strncmp(cmd, "ad", 2) == 0)
1949                         g_menu_state = CURRENT_STATUS_SET_ADEC_INFO;
1950                 else if (strncmp(cmd, "ae", 2) == 0)
1951                         g_menu_state = CURRENT_STATUS_SET_AENC_INFO;
1952                 else if (strncmp(cmd, "pi", 2) == 0)
1953                         g_menu_state = CURRENT_STATUS_PROCESS_INPUT;
1954                 else if (strncmp(cmd, "un", 2) == 0)
1955                         _mediacodec_unprepare(app);
1956                 else if (strncmp(cmd, "dt", 2) == 0)
1957                         _mediacodec_destroy(app);
1958 #ifdef TIZEN_FEATURE_INTEGRATION
1959                 else if (strncmp(cmd, "cr", 2) == 0)
1960                         _mediacodec_camera_start(app);
1961                 else if (strncmp(cmd, "ct", 2) == 0)
1962                         _mediacodec_camera_stop(app);
1963                 else if (strncmp(cmd, "au", 2) == 0)
1964                         g_menu_state = CURRENT_STATUS_AUTO_TEST;
1965                 else if (strncmp(cmd, "mp", 2) == 0) {
1966                         if (!app->enable_muxer) {
1967                                 app->enable_muxer = TRUE;
1968                                 g_print("muxer enabled\n");
1969                         } else {
1970                                 app->enable_dump = FALSE;
1971                                 g_print("dump disabled\n");
1972                         }
1973                 }
1974 #endif
1975                 else if (strncmp(cmd, "dp", 2) == 0) {
1976                         if (!app->enable_dump) {
1977                                 app->enable_dump = TRUE;
1978                                 g_print("dump enabled\n");
1979                         } else {
1980                                 app->enable_dump = FALSE;
1981                                 g_print("dump disabled\n");
1982                         }
1983                 } else
1984                         display_sub_basic();
1985         } else {
1986                 g_print("unknown menu \n");
1987         }
1988
1989         return;
1990 }
1991
1992 void displaymenu(void)
1993 {
1994         if (g_menu_state == CURRENT_STATUS_MAINMENU) {
1995                 display_sub_basic();
1996         } else if (g_menu_state == CURRENT_STATUS_FILENAME) {
1997                 g_print("*** input mediapath.\n");
1998         } else if (g_menu_state == CURRENT_STATUS_SET_CODEC) {
1999                 g_print("*** Codec id : Select Codec ID Numbe  (e.g. AAC_LC = 96)\n");
2000                 g_print("               L16    =  16 (0x10)\n");
2001                 g_print("               ALAW   =  32 (0x20)\n");
2002                 g_print("               ULAW   =  48 (0x30)\n");
2003                 g_print("               AMR_NB =  64 (0x40)\n");
2004                 g_print("               AMR_WB =  65 (0x41)\n");
2005                 g_print("               G729   =  80 (0x50)\n");
2006                 g_print("               AAC_LC =  96 (0x60)\n");
2007                 g_print("               AAC_HE =  97 (0x61)\n");
2008                 g_print("               AAC_PS =  98 (0x62)\n");
2009                 g_print("               MP3    = 112 (0x70)\n");
2010                 g_print("               VORBIS = 128 (0x80)\n");
2011                 g_print("               FLAC   = 144 (0x90)\n");
2012                 g_print("               WMAV1  = 160 (0xA0)\n");
2013                 g_print("               WMAV2  = 161 (0xA1)\n");
2014                 g_print("               WMAPRO = 162 (0xA2)\n");
2015                 g_print("               WMALSL = 163 (0xA3)\n");
2016                 g_print("               -------------------\n");
2017                 g_print("               H261   = 101\n");
2018                 g_print("               H263   = 102\n");
2019                 g_print("               H264   = 103\n");
2020                 g_print("               MJPEG  = 104\n");
2021                 g_print("               MPEG1  = 105\n");
2022                 g_print("               MPEG2  = 106\n");
2023                 g_print("               MPEG4  = 107\n");
2024                 g_print("               -------------------\n");
2025                 g_print("*** Flags : Select Combination Number (e.g. DEOCDER + TYPE_SW = 10)\n");
2026                 g_print("               CODEC : ENCODER =  1       DECODER =  2\n");
2027                 g_print("               TYPE  : HW      =  4       SW      =  8\n");
2028                 g_print("*** input codec id, falgs.\n");
2029         } else if (g_menu_state == CURRENT_STATUS_SET_VDEC_INFO) {
2030                 g_print("*** input video decode configure.(width, height)\n");
2031         } else if (g_menu_state == CURRENT_STATUS_SET_VENC_INFO) {
2032                 g_print("*** input video encode configure.(width, height, fps, target_bits)\n");
2033         } else if (g_menu_state == CURRENT_STATUS_SET_ADEC_INFO) {
2034                 g_print("*** input audio decode configure.(samplerate, channel, bit (e.g. 48000,  2, 16))\n");
2035         } else if (g_menu_state == CURRENT_STATUS_SET_AENC_INFO) {
2036                 g_print("*** input audio encode configure.(samplerate, channel, bit, bitrate (e.g. 48000,  2, 16, 128000))\n");
2037         } else if (g_menu_state == CURRENT_STATUS_PROCESS_INPUT) {
2038                 g_print("*** input dec process number\n");
2039         } else if (g_menu_state == CURRENT_STATUS_GET_OUTPUT) {
2040                 g_print("*** input get output buffer number\n");
2041 #ifdef TIZEN_FEATURE_INTEGRATION
2042         } else if (g_menu_state == CURRENT_STATUS_AUTO_TEST) {
2043                 g_print("*** enter media path and select the track to decode (0 : audio, 1 : video).\n");
2044 #endif
2045         } else {
2046                 g_print("*** unknown status.\n");
2047         }
2048         g_print(" >>> ");
2049 }
2050
2051 gboolean timeout_menu_display(void* data)
2052 {
2053         displaymenu();
2054         return FALSE;
2055 }
2056
2057 void interpret(char *cmd)
2058 {
2059         App *app = &s_app;
2060         gint tmp = 0;
2061
2062         switch (g_menu_state) {
2063         case CURRENT_STATUS_MAINMENU:
2064                 _interpret_main_menu(cmd, app);
2065                 break;
2066         case CURRENT_STATUS_FILENAME:
2067                 input_filepath(cmd, app);
2068                 reset_menu_state();
2069                 break;
2070         case CURRENT_STATUS_SET_CODEC:
2071         {
2072                 static gint cnt = 0;
2073                 gchar **ptr = NULL;
2074                 switch (cnt) {
2075                 case 0:
2076                         tmp = atoi(cmd);
2077
2078                         if (tmp > 100 &&
2079                                 (tmp != 112) &&
2080                                 (tmp != 128) &&
2081                                 (tmp != 144) &&
2082                                 (tmp != 160) && (tmp != 161) && (tmp != 162) && (tmp != 163)) {
2083                                         tmp = strtol(cmd, ptr, 16);
2084                                         app->codecid = 0x2000 + ((tmp & 0xFF) << 4);
2085                         } else
2086                                 app->codecid = 0x1000 + tmp;
2087
2088                         cnt++;
2089                         break;
2090                 case 1:
2091                         app->flag = atoi(cmd);
2092                         cnt = 0;
2093                         reset_menu_state();
2094                         break;
2095                 default:
2096                         break;
2097                 }
2098         }
2099         break;
2100         case CURRENT_STATUS_SET_VDEC_INFO:
2101         {
2102                 static gint cnt = 0;
2103                 switch (cnt) {
2104                 case 0:
2105                         app->width = atoi(cmd);
2106                         cnt++;
2107                         break;
2108                 case 1:
2109                         app->height = atoi(cmd);
2110                         app->type = VIDEO_DEC;
2111
2112                         reset_menu_state();
2113                         cnt = 0;
2114                         break;
2115                 default:
2116                         break;
2117                 }
2118         }
2119         break;
2120         case CURRENT_STATUS_SET_VENC_INFO:
2121         {
2122                 static gint cnt = 0;
2123                 switch (cnt) {
2124                 case 0:
2125                         app->width = atoi(cmd);
2126                         cnt++;
2127                         break;
2128                 case 1:
2129                         app->height = atoi(cmd);
2130                         cnt++;
2131                         break;
2132                 case 2:
2133                         app->fps = atol(cmd);
2134                         cnt++;
2135                         break;
2136                 case 3:
2137                         app->target_bits = atoi(cmd);
2138                         app->type = VIDEO_ENC;
2139
2140                         reset_menu_state();
2141                         cnt = 0;
2142                         break;
2143                 default:
2144                         break;
2145                 }
2146         }
2147         break;
2148         case CURRENT_STATUS_SET_ADEC_INFO:
2149         {
2150                 static gint cnt = 0;
2151                 switch (cnt) {
2152                 case 0:
2153                         app->samplerate = atoi(cmd);
2154                         cnt++;
2155                         break;
2156                 case 1:
2157                         app->channel = atoi(cmd);
2158                         cnt++;
2159                         break;
2160                 case 2:
2161                         app->bit = atoi(cmd);
2162                         app->type = AUDIO_DEC;
2163
2164                         reset_menu_state();
2165                         cnt = 0;
2166                         break;
2167                 default:
2168                         break;
2169                 }
2170         }
2171         break;
2172         case CURRENT_STATUS_SET_AENC_INFO:
2173         {
2174                 static int cnt = 0;
2175                 switch (cnt) {
2176                 case 0:
2177                         tmp = atoi(cmd);
2178
2179                         if (tmp <= 0 || tmp > 96000) {
2180                                 g_print("Invalid value\n");
2181                                 reset_menu_state();
2182                                 break;
2183                         }
2184                         app->samplerate = tmp;
2185                         cnt++;
2186                         break;
2187                 case 1:
2188                         tmp = atoi(cmd);
2189
2190                         if (tmp <= 0 || tmp > 6) {
2191                                 g_print("Invalid value\n");
2192                                 reset_menu_state();
2193                                 break;
2194                         }
2195                         app->channel = tmp;
2196                         cnt++;
2197                         break;
2198                 case 2:
2199                         tmp = atoi(cmd);
2200
2201                         if (tmp <= 0 || tmp > 32) {
2202                                 g_print("Invalid value\n");
2203                                 reset_menu_state();
2204                                 break;
2205                         }
2206                         app->bit = tmp;
2207                         cnt++;
2208                         break;
2209                 case 3:
2210                         tmp = atoi(cmd);
2211
2212                         if (tmp <= 0 || tmp >= INT_MAX) {
2213                                 g_print(";;Invalid value\n");
2214                                 reset_menu_state();
2215                                 break;
2216                         }
2217                         app->type = AUDIO_ENC;
2218                         app->bitrate = tmp;
2219
2220                         reset_menu_state();
2221                         cnt = 0;
2222                         break;
2223                 default:
2224                         break;
2225                 }
2226         }
2227         break;
2228         case CURRENT_STATUS_PROCESS_INPUT:
2229         {
2230                 tmp = atoi(cmd);
2231
2232                 if (tmp <= 0 || tmp >= 10) {
2233                         g_print("Invalid value\n");
2234                         reset_menu_state();
2235                         break;
2236                 }
2237                 app->frame = tmp;
2238
2239                 _mediacodec_process_input(app);
2240                 reset_menu_state();
2241         }
2242         break;
2243         case CURRENT_STATUS_GET_OUTPUT:
2244         {
2245                 reset_menu_state();
2246         }
2247         break;
2248 #ifdef TIZEN_FEATURE_INTEGRATION
2249         case CURRENT_STATUS_AUTO_TEST:
2250         {
2251                 int len;
2252                 static int cnt = 0;
2253                 switch (cnt) {
2254                 case 0:
2255                         len = strlen(cmd);
2256                         strncpy(app->filepath, cmd, len + 1);
2257                         g_print("%s, %d\n", app->filepath, len);
2258                         cnt++;
2259                         break;
2260                 case 1:
2261                         app->is_video =  atoi(cmd) ? 1 : 0;
2262                         _mediacodec_auto_test(app, app->filepath);
2263                         reset_menu_state();
2264                         cnt = 0;
2265                         break;
2266                 default:
2267                         break;
2268                 }
2269         }
2270         break;
2271 #endif
2272         }
2273
2274         g_timeout_add(100, timeout_menu_display, 0);
2275 }
2276
2277 void display_sub_basic()
2278 {
2279         g_print("\n");
2280         g_print("=========================================================================================\n");
2281         g_print("                                    media codec test\n");
2282         g_print("-----------------------------------------------------------------------------------------\n");
2283         g_print("a. Create \t\t");
2284         g_print("sc. Set codec \n");
2285         g_print("vd. Set vdec info \t");
2286         g_print("ve. Set venc info \n");
2287         g_print("ad. Set adec info \t");
2288         g_print("ae. Set aenc info \n");
2289         g_print("pr. Prepare \t");
2290         g_print("pa. Prepare and process all\t\t");
2291         g_print("pi. process input with num\n");
2292         g_print("o. Get output \t\t");
2293         g_print("rb. Reset output buffer \n");
2294         g_print("un. Unprepare \t\t");
2295         g_print("dt. Destroy \t\t");
2296         g_print("q. quit test suite \n");
2297         g_print("dp. enable dump \n");
2298 #ifdef TIZEN_FEATURE_INTEGRATION
2299         g_print("mp. enable muxer \n");
2300         g_print("-----------------------------------------------------------------------------------------\n");
2301         g_print("cr. camera preview -> encoder -> decoder\n");
2302         g_print("au. integration test with mediademuxer\n");
2303         g_print("ct. quit camera test\n");
2304 #endif
2305         g_print("\n");
2306         g_print("=========================================================================================\n");
2307 }
2308
2309 gboolean input(GIOChannel *channel, GIOCondition cond, gpointer data)
2310 {
2311         gchar buf[MAX_STRING_LEN];
2312         gsize read;
2313         GError *error = NULL;
2314
2315         g_io_channel_read_chars(channel, buf, MAX_STRING_LEN, &read, &error);
2316         buf[read] = '\0';
2317         g_strstrip(buf);
2318         interpret(buf);
2319
2320         return TRUE;
2321 }
2322
2323 void mc_hex_dump(char *desc, void *addr, gint len)
2324 {
2325         int i;
2326         guint8 buff[17];
2327         guint8 *pc = (guint8 *)addr;
2328
2329         if (desc != NULL)
2330                 g_print("%s:\n", desc);
2331
2332         for (i = 0; i < len; i++) {
2333
2334                 if ((i % 16) == 0) {
2335                         if (i != 0)
2336                                 g_print("  %s\n", buff);
2337
2338                         g_print("  %04x ", i);
2339                 }
2340
2341                 g_print(" %02x", pc[i]);
2342
2343                 if ((pc[i] < 0x20) || (pc[i] > 0x7e))
2344                         buff[i % 16] = '.';
2345                 else
2346                         buff[i % 16] = pc[i];
2347                 buff[(i % 16) + 1] = '\0';
2348         }
2349
2350         while ((i % 16) != 0) {
2351                 g_print("   ");
2352                 i++;
2353         }
2354         g_print("  %s\n", buff);
2355 }
2356
2357 void decoder_output_dump(App *app, media_packet_h pkt)
2358 {
2359         guint8 *temp;
2360         int i = 0;
2361         int stride_width, stride_height;
2362         gchar filename[100] = {0};
2363         FILE *fp = NULL;
2364         int ret = 0;
2365
2366         g_snprintf(filename, MAX_STRING_LEN, "/tmp/dec_output_dump_%d_%d.yuv", app->width, app->height);
2367         fp = fopen(filename, "ab");
2368
2369         media_packet_get_video_plane_data_ptr(pkt, 0, (void **)&temp);
2370         media_packet_get_video_stride_width(pkt, 0, &stride_width);
2371         media_packet_get_video_stride_height(pkt, 0, &stride_height);
2372         g_print("stride : %d, %d\n", stride_width, stride_height);
2373
2374         for (i = 0; i < app->height; i++) {
2375                 ret = fwrite(temp, app->width, 1, fp);
2376                 temp += stride_width;
2377         }
2378
2379         if (app->hardware == TRUE) {
2380                 media_packet_get_video_plane_data_ptr(pkt, 1, (void **)&temp);
2381                 media_packet_get_video_stride_width(pkt, 1, &stride_width);
2382                 for (i = 0; i < app->height/2; i++) {
2383                         ret = fwrite(temp, app->width, 1, fp);
2384                         temp += stride_width;
2385                 }
2386         } else {
2387                 media_packet_get_video_plane_data_ptr(pkt, 1, (void **)&temp);
2388                 media_packet_get_video_stride_width(pkt, 1, &stride_width);
2389                 for (i = 0; i < app->height/2; i++) {
2390                         ret = fwrite(temp, app->width/2, 1, fp);
2391                         temp += stride_width;
2392                 }
2393
2394                 media_packet_get_video_plane_data_ptr(pkt, 2, (void **)&temp);
2395                 media_packet_get_video_stride_width(pkt, 2, &stride_width);
2396                 for (i = 0; i < app->height/2; i++) {
2397                         ret = fwrite(temp, app->width/2, 1, fp);
2398                         temp += stride_width;
2399                 }
2400         }
2401
2402         g_print("codec dec output dumped!!%d\n", ret);
2403         fclose(fp);
2404
2405 }
2406
2407 /**
2408  *  Add ADTS header at the beginning of each and every AAC packet.
2409  *  This is needed as MediaCodec encoder generates a packet of raw AAC data.
2410  *  Note the packetLen must count in the ADTS header itself.
2411  **/
2412 void add_adts_header_for_aacenc(App *app, char *buffer, int packetLen)
2413 {
2414         int profile = 2;    /* AAC LC (0x01) */
2415         int freqIdx = 3;    /* 48KHz (0x03) */
2416         int chanCfg = 2;    /* CPE (0x02) */
2417
2418         if (app->samplerate == 96000) freqIdx = 0;
2419         else if (app->samplerate == 88200) freqIdx = 1;
2420         else if (app->samplerate == 64000) freqIdx = 2;
2421         else if (app->samplerate == 48000) freqIdx = 3;
2422         else if (app->samplerate == 44100) freqIdx = 4;
2423         else if (app->samplerate == 32000) freqIdx = 5;
2424         else if (app->samplerate == 24000) freqIdx = 6;
2425         else if (app->samplerate == 22050) freqIdx = 7;
2426         else if (app->samplerate == 16000) freqIdx = 8;
2427         else if (app->samplerate == 12000) freqIdx = 9;
2428         else if (app->samplerate == 11025) freqIdx = 10;
2429         else if (app->samplerate == 8000) freqIdx = 11;
2430
2431         if ((app->channel == 1) || (app->channel == 2))
2432                 chanCfg = app->channel;
2433
2434         /* fill in ADTS data */
2435         buffer[0] = (char)0xFF;
2436         buffer[1] = (char)0xF1;
2437         buffer[2] = (char)(((profile-1)<<6) + (freqIdx<<2) +(chanCfg>>2));
2438         buffer[3] = (char)(((chanCfg&3)<<6) + (packetLen>>11));
2439         buffer[4] = (char)((packetLen&0x7FF) >> 3);
2440         buffer[5] = (char)(((packetLen&7)<<5) + 0x1F);
2441         buffer[6] = (char)0xFC;
2442 }
2443
2444 void output_dump(App *app, media_packet_h pkt)
2445 {
2446         void *temp;
2447         uint64_t buf_size;
2448         gchar filename[100] = {0};
2449         FILE *fp = NULL;
2450         int ret = 0;
2451         char adts[100] = {0, };
2452
2453         g_snprintf(filename, MAX_STRING_LEN, "/tmp/dec_output_dump_%d.out", app->type);
2454         fp = fopen(filename, "ab");
2455
2456         media_packet_get_buffer_data_ptr(pkt, &temp);
2457         media_packet_get_buffer_size(pkt, &buf_size);
2458         g_print("output data : %p, size %d\n", temp, (int)buf_size);
2459
2460         if (app->is_encoder && buf_size > 0 && app->codecid == MEDIACODEC_AAC_LC) {
2461                 add_adts_header_for_aacenc(app, adts, (buf_size + ADTS_HEADER_SIZE));
2462                 fwrite(&adts, 1, ADTS_HEADER_SIZE, fp);
2463                 g_print("adts appended\n");
2464         } else if (app->is_encoder && buf_size > 0 && app->codecid == MEDIACODEC_AMR_NB && write_amr_header == 1) {
2465                 /* This is used only AMR encoder case for adding AMR masic header in only first frame */
2466                 g_print("%s - AMR_header write in first frame\n", __func__);
2467                 fwrite(&AMR_header[0], 1, sizeof(AMR_header)   - 1, fp);         /* AMR-NB magic number */
2468                 write_amr_header = 0;
2469         }
2470
2471         fwrite(temp, (int)buf_size, 1, fp);
2472
2473         g_print("codec dec output dumped!!%d\n", ret);
2474         fclose(fp);
2475
2476 }
2477
2478 const char* codec_type_to_string(mediacodec_codec_type_e media_codec_id)
2479 {
2480         guint media_codec_id_u = (guint)media_codec_id;
2481
2482         switch (media_codec_id_u) {
2483         case MEDIACODEC_L16:
2484                 return "L16";
2485         case MEDIACODEC_ALAW:
2486                 return "ALAW";
2487         case MEDIACODEC_ULAW:
2488                 return "ULAW";
2489         case MEDIACODEC_AMR_NB:
2490                 return "AMR_NB";
2491         case MEDIACODEC_AMR_WB:
2492                 return "AMR_WB";
2493         case MEDIACODEC_G729:
2494                 return "G729";
2495         case MEDIACODEC_AAC_LC:
2496                 return "AAC_LC";
2497         case MEDIACODEC_AAC_HE:
2498                 return "AAC_HE";
2499         case MEDIACODEC_AAC_HE_PS:
2500                 return "AAC_HE_PS";
2501         case MEDIACODEC_MP3:
2502                 return "MP3";
2503         case MEDIACODEC_VORBIS:
2504                 return "VORBIS";
2505         case MEDIACODEC_FLAC:
2506                 return "FLAC";
2507         case MEDIACODEC_WMAV1:
2508                 return "WMAV1";
2509         case MEDIACODEC_WMAV2:
2510                 return "WMAV2";
2511         case MEDIACODEC_WMAPRO:
2512                 return "WMAPRO";
2513         case MEDIACODEC_WMALSL:
2514                 return "WMALSL";
2515         case MEDIACODEC_H261:
2516                 return "H261";
2517         case MEDIACODEC_H263:
2518                 return "H263";
2519         case MEDIACODEC_H264:
2520                 return "H264";
2521         case MEDIACODEC_MJPEG:
2522                 return "MJPEG";
2523         case MEDIACODEC_MPEG1:
2524                 return "MPEG1";
2525         case MEDIACODEC_MPEG2:
2526                 return "MPEG2";
2527         case MEDIACODEC_MPEG4:
2528                 return "MPEG4";
2529         case MEDIACODEC_HEVC:
2530                 return "HEVC";
2531         case MEDIACODEC_VP8:
2532                 return "VP8";
2533         case MEDIACODEC_VP9:
2534                 return "VP9";
2535         case MEDIACODEC_VC1:
2536                 return "VC1";
2537         default:
2538                 return "NONE";
2539         }
2540         return "NONE";
2541 }
2542
2543 int main(int argc, char *argv[])
2544 {
2545         GIOChannel *stdin_channel;
2546         stdin_channel = g_io_channel_unix_new(0);
2547         g_io_channel_set_flags(stdin_channel, G_IO_FLAG_NONBLOCK, NULL);
2548         g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)input, NULL);
2549
2550         App *app = &s_app;
2551
2552         g_mutex_init(&app->lock);
2553         displaymenu();
2554         app->loop = g_main_loop_new(NULL, TRUE);
2555         app->timer = g_timer_new();
2556         g_main_loop_run(app->loop);
2557
2558
2559         return 0;
2560 }