src/media_codec_port.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20
  21 #include <dlog.h>
  22
  23 #include <media_codec.h>
  24 #include <media_codec_private.h>
  25 #include <media_codec_port.h>
  26 #include <media_codec_port_gst.h>
  27 #include <media_codec_spec_emul.h>
  28 #include <media_codec_ini.h>
  29
  30 int mc_create(MMHandleType *mediacodec)
  31 {
  32         mc_handle_t *new_mediacodec = NULL;
  33         int ret = MC_ERROR_NONE;
  34
  35         /* alloc mediacodec structure */
  36         new_mediacodec = (mc_handle_t *)g_malloc(sizeof(mc_handle_t));
  37
  38         if (!new_mediacodec) {
  39                 LOGE("Cannot allocate memory for mediacodec");
  40                 ret = MC_ERROR;
  41                 goto ERROR;
  42         }
  43         memset(new_mediacodec, 0, sizeof(mc_handle_t));
  44
  45         new_mediacodec->is_encoder = false;
  46         new_mediacodec->is_video = false;
  47         new_mediacodec->is_hw = true;
  48         new_mediacodec->is_prepared = false;
  49         new_mediacodec->codec_id = MEDIACODEC_NONE;
  50
  51         new_mediacodec->ports[0] = NULL;
  52         new_mediacodec->ports[1] = NULL;
  53
  54         new_mediacodec->num_supported_decoder = 0;
  55         new_mediacodec->num_supported_encoder = 0;
  56
  57         new_mediacodec->core = NULL;
  58         new_mediacodec->ini = &mc_ini;
  59
  60         /* load ini files */
  61         if (!mc_ini.loaded) {
  62                 ret = mc_ini_load(&mc_ini);
  63                 if (ret != MC_ERROR_NONE)
  64                         goto ERROR;
  65
  66                 mc_ini.loaded = TRUE;
  67         }
  68
  69         _mc_create_codec_map_from_ini(new_mediacodec, spec_emul);
  70
  71         /* create decoder map from ini */
  72         _mc_create_decoder_map_from_ini(new_mediacodec);
  73
  74         /* create encoder map from ini */
  75         _mc_create_encoder_map_from_ini(new_mediacodec);
  76
  77         *mediacodec = (MMHandleType)new_mediacodec;
  78
  79         return ret;
  80
  81 ERROR:
  82         g_free(new_mediacodec);
  83         return MC_INVALID_ARG;
  84 }
  85
  86 int mc_destroy(MMHandleType mediacodec)
  87 {
  88         int ret = MC_ERROR_NONE;
  89         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
  90
  91         if (!mc_handle) {
  92                 LOGE("fail invaild param\n");
  93                 return MC_INVALID_ARG;
  94         }
  95
  96         LOGD("mediacodec : %p", mediacodec);
  97
  98         if (mc_handle->core != NULL) {
  99                 if (mc_gst_unprepare(mc_handle) != MC_ERROR_NONE) {
 100                         LOGE("mc_gst_unprepare() failed");
 101                         return MC_ERROR;
 102                 }
 103         }
 104
 105         mc_handle->is_prepared = false;
 106
 107         /* free mediacodec structure */
 108         if (mc_handle) {
 109                 g_free((void *)mc_handle);
 110                 mc_handle = NULL;
 111         }
 112
 113         return ret;
 114 }
 115
 116 int mc_set_codec(MMHandleType mediacodec, mediacodec_codec_type_e codec_id, int flags)
 117 {
 118         int ret = MC_ERROR_NONE;
 119         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
 120         int i;
 121
 122         if (!mc_handle) {
 123                 LOGE("fail invaild param");
 124                 return MC_INVALID_ARG;
 125         }
 126
 127         /* Mandatory setting */
 128         if (!GET_IS_ENCODER(flags) && !GET_IS_DECODER(flags)) {
 129                 LOGE("should be encoder or decoder");
 130                 return MC_PARAM_ERROR;
 131         }
 132
 133         /* if user doesn't set codec-type, s/w codec would be set */
 134         if (!GET_IS_HW(flags) && !GET_IS_SW(flags))
 135                 flags |= MEDIACODEC_SUPPORT_TYPE_SW;
 136
 137         for (i = 0; i < mc_handle->ini->num_supported_codecs; i++) {
 138                 if ((codec_id == spec_emul[i].codec_id) && (flags == spec_emul[i].codec_type))
 139                         break;
 140         }
 141         LOGD("support_list : %d, i : %d", mc_handle->ini->num_supported_codecs, i);
 142
 143         if (i == mc_handle->ini->num_supported_codecs)
 144                 return MC_NOT_SUPPORTED;
 145
 146         mc_handle->port_type = spec_emul[i].port_type;
 147
 148         mc_handle->is_encoder = GET_IS_ENCODER(flags) ? 1 : 0;
 149         mc_handle->is_hw = GET_IS_HW(flags) ? 1 : 0;
 150         mc_handle->codec_id = codec_id;
 151         mc_handle->is_video = CHECK_BIT(codec_id, 13);
 152
 153         mc_handle->is_prepared = false;
 154
 155         LOGD("encoder : %d, hardware : %d, codec_id : %x, video : %d",
 156                         mc_handle->is_encoder, mc_handle->is_hw, mc_handle->codec_id, mc_handle->is_video);
 157
 158         return ret;
 159 }
 160
 161 int mc_set_vdec_info(MMHandleType mediacodec, int width, int height)
 162 {
 163         int ret = MC_ERROR_NONE;
 164         mc_handle_t* mc_handle = (mc_handle_t *)mediacodec;
 165
 166         if (!mc_handle) {
 167                 LOGE("fail invaild param\n");
 168                 return MC_INVALID_ARG;
 169         }
 170
 171         if ((width <= 0) || (height <= 0))
 172                 return MC_PARAM_ERROR;
 173
 174         MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && mc_handle->is_video && !mc_handle->is_encoder,
 175                         MC_INVALID_ARG, "MEDIACODEC_ERROR_INVALID_PARAMETER");
 176
 177         mc_handle->info.decoder.width = width;
 178         mc_handle->info.decoder.height = height;
 179
 180         mc_handle->is_prepared = true;
 181
 182         return ret;
 183 }
 184
 185 int mc_set_venc_info(MMHandleType mediacodec, int width, int height, int fps, int target_bits)
 186 {
 187         int ret = MC_ERROR_NONE;
 188         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
 189
 190         if (!mc_handle) {
 191                 LOGE("fail invaild param\n");
 192                 return MC_INVALID_ARG;
 193         }
 194
 195         if ((width <= 0) || (height <= 0))
 196                 return MC_PARAM_ERROR;
 197
 198         MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && mc_handle->is_video && mc_handle->is_encoder,
 199                         MC_INVALID_ARG, "MEDIACODEC_ERROR_INVALID_PARAMETER");
 200
 201         mc_handle->info.encoder.width = width;
 202         mc_handle->info.encoder.height = height;
 203         mc_handle->info.encoder.fps = fps;
 204         mc_handle->info.encoder.bitrate = target_bits * 1000;
 205         mc_handle->is_prepared = true;
 206
 207         return ret;
 208 }
 209
 210 int mc_set_adec_info(MMHandleType mediacodec, int samplerate, int channel, int bit)
 211 {
 212         int ret = MC_ERROR_NONE;
 213         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
 214
 215         if (!mc_handle) {
 216                 LOGE("fail invaild param\n");
 217                 return MC_INVALID_ARG;
 218         }
 219
 220         if ((samplerate <= 0) || (channel <= 0) || (bit <= 0))
 221                 return MC_PARAM_ERROR;
 222
 223         MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && !mc_handle->is_video && !mc_handle->is_encoder,
 224                         MC_INVALID_ARG, "MEDIACODEC_ERROR_INVALID_PARAMETER");
 225
 226         mc_handle->info.decoder.samplerate = samplerate;
 227         mc_handle->info.decoder.channel = channel;
 228         mc_handle->info.decoder.bit = bit;
 229         mc_handle->is_prepared = true;
 230
 231         return ret;
 232 }
 233
 234 int mc_set_aenc_info(MMHandleType mediacodec, int samplerate, int channel, int bit, int bitrate)
 235 {
 236         int ret = MC_ERROR_NONE;
 237         mc_handle_t * mc_handle = (mc_handle_t *) mediacodec;
 238
 239         if (!mc_handle) {
 240                 LOGE("fail invaild param\n");
 241                 return MC_INVALID_ARG;
 242         }
 243
 244         if ((samplerate <= 0) || (channel <= 0) || (bit <= 0))
 245                 return MC_PARAM_ERROR;
 246
 247         MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && !mc_handle->is_video && mc_handle->is_encoder,
 248                         MC_INVALID_ARG, "MEDIACODEC_ERROR_INVALID_PARAMETER");
 249
 250         mc_handle->info.encoder.samplerate = samplerate;
 251         mc_handle->info.encoder.channel = channel;
 252         mc_handle->info.encoder.bit = bit;
 253         mc_handle->info.encoder.bitrate = bitrate * 1000;
 254
 255         mc_handle->is_prepared = true;
 256
 257         return ret;
 258 }
 259
 260 int mc_configure(MMHandleType mediacodec, media_format_h format, int flags)
 261 {
 262         int ret = MC_ERROR_NONE;
 263         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
 264         int i;
 265         const int codec_mask = 0xFFF0;
 266         int codec_id = 0;
 267         int channel = 0;
 268         int samplerate = 0;
 269         int bit = 0;
 270         int bitrate = 0;
 271         int width = 0;
 272         int height = 0;
 273         int fps = 0;
 274         media_format_type_e type;
 275         media_format_mimetype_e mimetype;
 276
 277         if (!mc_handle) {
 278                 LOGE("fail invaild param");
 279                 return MC_INVALID_ARG;
 280         }
 281
 282         if (media_format_get_type(format, &type) != MEDIA_FORMAT_ERROR_NONE) {
 283                 LOGE("failed to retrieve type");
 284                 return MC_INVALID_ARG;
 285         }
 286
 287         if (type == MEDIA_FORMAT_AUDIO) {
 288                 media_format_get_audio_info(format, &mimetype, &channel, &samplerate, &bit, &bitrate);
 289
 290                 if (GET_IS_ENCODER(flags)) {
 291                         if ((samplerate <= 0) || (channel <= 0) || (bit <= 0) || (bitrate <= 0)) {
 292                                 LOGE("invalid pram is set : samplerate : %d, channel : %d, bit : %d, bitrate : %d",
 293                                         samplerate, channel, bit, bitrate);
 294                                 return MC_PARAM_ERROR;
 295                         }
 296
 297                         mc_handle->info.encoder.samplerate = samplerate;
 298                         mc_handle->info.encoder.channel = channel;
 299                         mc_handle->info.encoder.bit = bit;
 300                         mc_handle->info.encoder.bitrate = bitrate * 1000;
 301                 } else if (GET_IS_DECODER(flags)) {
 302                         if ((samplerate <= 0) || (channel <= 0) || (bit <= 0)) {
 303                                 LOGE("invalid pram is set : samplerate : %d, channel : %d, bit : %d",
 304                                         samplerate, channel, bit);
 305                                 return MC_PARAM_ERROR;
 306                         }
 307                         mc_handle->info.decoder.samplerate = samplerate;
 308                         mc_handle->info.decoder.channel = channel;
 309                         mc_handle->info.decoder.bit = bit;
 310                 } else {
 311                         LOGE("either an encoder or a decoder must be set");
 312                         return MC_PARAM_ERROR;
 313                 }
 314         } else if (type == MEDIA_FORMAT_VIDEO) {
 315                 media_format_get_video_info(format, &mimetype, &width, &height, &bitrate, NULL);
 316                 media_format_get_video_frame_rate(format, &fps);
 317
 318                 if (GET_IS_ENCODER(flags)) {
 319                         if ((width <= 0) || (height <= 0) || (bitrate <= 0) || (fps <= 0)) {
 320                                 LOGE("invalid pram is set : width : %d, height : %d, bitrate : %d, fps : %d",
 321                                         width, height, bitrate, fps);
 322                                 return MC_PARAM_ERROR;
 323                         }
 324
 325                         mc_handle->info.encoder.width = width;
 326                         mc_handle->info.encoder.height = height;
 327                         mc_handle->info.encoder.fps = fps;
 328                         mc_handle->info.encoder.bitrate = bitrate * 1000;
 329                 } else if (GET_IS_DECODER(flags)) {
 330                         if ((width <= 0) || (height <= 0)) {
 331                                 LOGE("invalid pram is set : width : %d, height : %d",
 332                                         width, height);
 333                                 return MC_PARAM_ERROR;
 334                         }
 335
 336                         mc_handle->info.decoder.width = width;
 337                         mc_handle->info.decoder.height = height;
 338                 } else {
 339                         LOGE("either an encoder or a decoder must be set");
 340                         return MC_PARAM_ERROR;
 341                 }
 342         } else {
 343                 LOGE("invalid format type is set");
 344                 return MC_PARAM_ERROR;
 345         }
 346
 347         if (!GET_IS_HW(flags) && !GET_IS_SW(flags))
 348                 flags |= MEDIACODEC_SUPPORT_TYPE_SW;
 349
 350         codec_id = mimetype & codec_mask;
 351
 352         for (i = 0; i < mc_handle->ini->num_supported_codecs; i++) {
 353                 if ((codec_id == spec_emul[i].codec_id) && (flags == spec_emul[i].codec_type))
 354                         break;
 355         }
 356         LOGD("support_list : %d, i : %d", mc_handle->ini->num_supported_codecs, i);
 357
 358         if (i == mc_handle->ini->num_supported_codecs)
 359                 return MC_CODEC_NOT_FOUND;
 360
 361         mc_handle->port_type = spec_emul[i].port_type;
 362
 363         mc_handle->is_encoder = GET_IS_ENCODER(flags) ? 1 : 0;
 364         mc_handle->is_hw = GET_IS_HW(flags) ? 1 : 0;
 365         mc_handle->codec_id = codec_id;
 366         mc_handle->is_video = CHECK_BIT(codec_id, 13);
 367
 368         mc_handle->is_prepared = true;
 369
 370         LOGD("encoder : %d, hardware : %d, codec_id : %x, video : %d",
 371                         mc_handle->is_encoder, mc_handle->is_hw, mc_handle->codec_id, mc_handle->is_video);
 372
 373         return ret;
 374 }
 375
 376 int mc_prepare(MMHandleType mediacodec)
 377 {
 378         int ret = MC_ERROR_NONE;
 379         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
 380
 381         if (!mc_handle) {
 382                 LOGE("fail invaild param\n");
 383                 return MC_INVALID_ARG;
 384         }
 385
 386         if (!mc_handle->is_prepared)
 387                 return MC_NOT_INITIALIZED;
 388
 389         /* setting core details */
 390         switch (mc_handle->port_type) {
 391         case MEDIACODEC_PORT_TYPE_GENERAL:
 392                 break;
 393
 394         case MEDIACODEC_PORT_TYPE_OMX:
 395                 break;
 396
 397         case MEDIACODEC_PORT_TYPE_GST:
 398                 mc_gst_prepare(mc_handle);
 399                 break;
 400
 401         default:
 402                 break;
 403         }
 404
 405         return ret;
 406 }
 407
 408 int mc_unprepare(MMHandleType mediacodec)
 409 {
 410         int ret = MC_ERROR_NONE;
 411         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 412
 413         if (!mc_handle) {
 414                 LOGE("fail invaild param\n");
 415                 return MC_INVALID_ARG;
 416         }
 417
 418         /* deinit core details */
 419         switch (mc_handle->port_type) {
 420         case MEDIACODEC_PORT_TYPE_GENERAL:
 421                 break;
 422
 423         case MEDIACODEC_PORT_TYPE_OMX:
 424                 break;
 425
 426         case MEDIACODEC_PORT_TYPE_GST:
 427                 ret = mc_gst_unprepare(mc_handle);
 428                 break;
 429
 430         default:
 431                 break;
 432         }
 433
 434         return ret;
 435 }
 436
 437 int mc_process_input(MMHandleType mediacodec, media_packet_h inbuf, uint64_t timeOutUs)
 438 {
 439         int ret = MC_ERROR_NONE;
 440
 441         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 442
 443         if (!mc_handle) {
 444                 LOGE("fail invaild param");
 445                 return MC_INVALID_ARG;
 446         }
 447
 448         if (!inbuf) {
 449                 LOGE("invaild input buffer");
 450                 return MC_INVALID_IN_BUF;
 451         }
 452
 453         switch (mc_handle->port_type) {
 454         case MEDIACODEC_PORT_TYPE_GENERAL:
 455                 break;
 456
 457         case MEDIACODEC_PORT_TYPE_OMX:
 458                 break;
 459
 460         case MEDIACODEC_PORT_TYPE_GST:
 461                 ret = mc_gst_process_input(mc_handle, inbuf, timeOutUs);
 462                 break;
 463
 464         default:
 465                 break;
 466         }
 467
 468         return ret;
 469 }
 470
 471 int mc_get_output(MMHandleType mediacodec, media_packet_h *outbuf, uint64_t timeOutUs)
 472 {
 473         int ret = MC_ERROR_NONE;
 474         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
 475
 476         if (!mc_handle) {
 477                 LOGE("fail invaild param\n");
 478                 return MC_INVALID_ARG;
 479         }
 480
 481         /* setting core details */
 482         switch (mc_handle->port_type) {
 483         case MEDIACODEC_PORT_TYPE_GENERAL:
 484                 break;
 485
 486         case MEDIACODEC_PORT_TYPE_OMX:
 487                 break;
 488
 489         case MEDIACODEC_PORT_TYPE_GST:
 490                 ret = mc_gst_get_output(mc_handle, outbuf, timeOutUs);
 491                 break;
 492
 493         default:
 494                 break;
 495         }
 496
 497         return ret;
 498 }
 499
 500 int mc_flush_buffers(MMHandleType mediacodec)
 501 {
 502         int ret = MC_ERROR_NONE;
 503         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 504
 505         if (!mc_handle) {
 506                 LOGE("fail invaild param\n");
 507                 return MC_INVALID_ARG;
 508         }
 509
 510         /* setting core details */
 511         switch (mc_handle->port_type) {
 512         case MEDIACODEC_PORT_TYPE_GENERAL:
 513                 break;
 514
 515         case MEDIACODEC_PORT_TYPE_OMX:
 516                 break;
 517
 518         case MEDIACODEC_PORT_TYPE_GST:
 519                 ret = mc_gst_flush_buffers(mc_handle);
 520                 break;
 521
 522         default:
 523                 break;
 524         }
 525
 526         return ret;
 527 }
 528
 529 int mc_get_supported_type(MMHandleType mediacodec, mediacodec_codec_type_e codec_type, bool encoder, int *support_type)
 530 {
 531         int ret = MC_ERROR_NONE;
 532         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 533         mc_codec_map_t *codec_map;
 534         int num_supported_codec = 0;
 535         int i;
 536
 537         *support_type = 0;
 538
 539         if (!mc_handle) {
 540                 LOGE("fail invaild param\n");
 541                 return MC_INVALID_ARG;
 542         }
 543
 544         codec_map = encoder ? mc_handle->encoder_map : mc_handle->decoder_map;
 545         num_supported_codec = encoder ? mc_handle->num_supported_encoder : mc_handle->num_supported_decoder;
 546
 547         for (i = 0; i < num_supported_codec; i++) {
 548                 if (codec_map[i].id == codec_type) {
 549                         if (codec_map[i].hardware)
 550                                 *support_type |= MEDIACODEC_SUPPORT_TYPE_HW;
 551                         else
 552                                 *support_type |= MEDIACODEC_SUPPORT_TYPE_SW;
 553                 }
 554         }
 555
 556         return ret;
 557 }
 558
 559 int mc_set_empty_buffer_cb(MMHandleType mediacodec, mediacodec_input_buffer_used_cb callback, void *user_data)
 560 {
 561         int ret = MC_ERROR_NONE;
 562         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 563
 564         if (!mc_handle) {
 565                 LOGE("fail invaild param\n");
 566                 return MC_INVALID_ARG;
 567         }
 568
 569         if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
 570                 LOGE("Already set mediacodec_empty_buffer_cb");
 571                 return MC_PARAM_ERROR;
 572         } else {
 573                 if (!callback)
 574                         return MC_INVALID_ARG;
 575
 576                 LOGD("Set empty buffer callback(cb = %p, data = %p)", callback, user_data);
 577
 578                 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = (mc_empty_buffer_cb) callback;
 579                 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = user_data;
 580
 581                 return MC_ERROR_NONE;
 582         }
 583
 584         return ret;
 585 }
 586
 587 int mc_unset_empty_buffer_cb(MMHandleType mediacodec)
 588 {
 589         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 590
 591         if (!mc_handle) {
 592                 LOGE("fail invaild param\n");
 593                 return MC_INVALID_ARG;
 594         }
 595
 596         mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = NULL;
 597         mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = NULL;
 598
 599         return MC_ERROR_NONE;
 600 }
 601
 602 int mc_set_fill_buffer_cb(MMHandleType mediacodec, mediacodec_output_buffer_available_cb callback, void *user_data)
 603 {
 604         int ret = MC_ERROR_NONE;
 605         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 606
 607         if (!mc_handle) {
 608                 LOGE("fail invaild param\n");
 609                 return MC_INVALID_ARG;
 610         }
 611
 612         if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) {
 613                 LOGE("Already set mediacodec_fill_buffer_cb");
 614                 return MC_PARAM_ERROR;
 615         } else {
 616                 if (!callback)
 617                         return MC_INVALID_ARG;
 618
 619                 LOGD("Set fill buffer callback(cb = %p, data = %p)", callback, user_data);
 620
 621                 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = (mc_fill_buffer_cb) callback;
 622                 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = user_data;
 623                 return MC_ERROR_NONE;
 624         }
 625
 626         return ret;
 627 }
 628
 629 int mc_unset_fill_buffer_cb(MMHandleType mediacodec)
 630 {
 631         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 632
 633         if (!mc_handle) {
 634                 LOGE("fail invaild param\n");
 635                 return MC_INVALID_ARG;
 636         }
 637
 638         mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = NULL;
 639         mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = NULL;
 640
 641         return MC_ERROR_NONE;
 642 }
 643
 644 int mc_set_error_cb(MMHandleType mediacodec, mediacodec_error_cb callback, void *user_data)
 645 {
 646         int ret = MC_ERROR_NONE;
 647         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
 648
 649         if (!mc_handle) {
 650                 LOGE("fail invaild param\n");
 651                 return MC_INVALID_ARG;
 652         }
 653
 654         if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
 655                 LOGE("Already set mediacodec_fill_buffer_cb\n");
 656                 return MC_PARAM_ERROR;
 657         } else {
 658                 if (!callback)
 659                         return MC_INVALID_ARG;
 660
 661                 LOGD("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
 662
 663                 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR] = (mc_error_cb) callback;
 664                 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_ERROR] = user_data;
 665                 return MC_ERROR_NONE;
 666         }
 667
 668         return ret;
 669 }
 670
 671 int mc_unset_error_cb(MMHandleType mediacodec)
 672 {
 673         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 674
 675         if (!mc_handle) {
 676                 LOGE("fail invaild param");
 677                 return MC_INVALID_ARG;
 678         }
 679
 680         mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR] = NULL;
 681         mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_ERROR] = NULL;
 682
 683         return MC_ERROR_NONE;
 684 }
 685
 686 int mc_set_eos_cb(MMHandleType mediacodec, mediacodec_eos_cb callback, void *user_data)
 687 {
 688         int ret = MC_ERROR_NONE;
 689         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
 690
 691         if (!mc_handle) {
 692                 LOGE("fail invaild param\n");
 693                 return MC_INVALID_ARG;
 694         }
 695
 696         if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS]) {
 697                 LOGE("Already set mediacodec_fill_buffer_cb");
 698                 return MC_PARAM_ERROR;
 699         } else {
 700                 if (!callback)
 701                         return MC_INVALID_ARG;
 702
 703                 LOGD("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
 704
 705                 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS] = (mc_eos_cb) callback;
 706                 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EOS] = user_data;
 707                 return MC_ERROR_NONE;
 708         }
 709
 710         return ret;
 711 }
 712
 713 int mc_unset_eos_cb(MMHandleType mediacodec)
 714 {
 715         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 716
 717         if (!mc_handle) {
 718                 LOGE("fail invaild param\n");
 719                 return MC_INVALID_ARG;
 720         }
 721
 722         mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS] = NULL;
 723         mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EOS] = NULL;
 724
 725         return MC_ERROR_NONE;
 726 }
 727
 728 int mc_set_buffer_status_cb(MMHandleType mediacodec, mediacodec_buffer_status_cb callback, void *user_data)
 729 {
 730         int ret = MC_ERROR_NONE;
 731         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 732
 733         if (!mc_handle) {
 734                 LOGE("fail invaild param\n");
 735                 return MC_INVALID_ARG;
 736         }
 737
 738         if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
 739                 LOGE("Already set mediacodec_need_data_cb\n");
 740                 return MC_PARAM_ERROR;
 741         } else {
 742                 if (!callback)
 743                         return MC_INVALID_ARG;
 744
 745                 LOGD("Set start feed callback(cb = %p, data = %p)\n", callback, user_data);
 746
 747                 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = (mc_buffer_status_cb) callback;
 748                 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = user_data;
 749                 return MC_ERROR_NONE;
 750         }
 751
 752         return ret;
 753 }
 754
 755 int mc_unset_buffer_status_cb(MMHandleType mediacodec)
 756 {
 757         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 758
 759         if (!mc_handle) {
 760                 LOGE("fail invaild param\n");
 761                 return MC_INVALID_ARG;
 762         }
 763
 764         mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = NULL;
 765         mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = NULL;
 766
 767         return MC_ERROR_NONE;
 768 }
 769
 770 int mc_set_supported_codec_cb(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
 771 {
 772         int ret = MC_ERROR_NONE;
 773         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 774
 775         if (!mc_handle) {
 776                 LOGE("fail invaild param\n");
 777                 return MC_INVALID_ARG;
 778         }
 779
 780         if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC]) {
 781                 LOGE("Already set mediacodec_supported_codec_cb\n");
 782                 return MC_PARAM_ERROR;
 783         } else {
 784                 if (!callback)
 785                         return MC_INVALID_ARG;
 786
 787                 LOGD("Set event handler callback(cb = %p, data = %p)", callback, user_data);
 788
 789                 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC] = (mc_supported_codec_cb) callback;
 790                 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC] = user_data;
 791                 return MC_ERROR_NONE;
 792         }
 793
 794         return ret;
 795 }
 796
 797 int _mediacodec_foreach_supported_codec(mediacodec_supported_codec_cb callback, void *user_data)
 798 {
 799         int ret = MEDIACODEC_NONE;
 800         int i;
 801         int index;
 802
 803         gboolean codec[CODEC_NR_ITEMS] = {0,};
 804
 805         for (i = 0; i < mc_ini.num_supported_codecs; i++) {
 806                 index = (int)codec_type_to_simple_enumeration(spec_emul[i].codec_id);
 807                 codec[index] = TRUE;
 808         }
 809
 810         for (i = 0; i < CODEC_NR_ITEMS; i++) {
 811                 if (codec[i]) {
 812                         index = (int)simple_to_codec_type_enumeration(i);
 813                         if (!callback(index, user_data))
 814                                 goto CALLBACK_ERROR;
 815                 }
 816         }
 817
 818         if (!callback(-1, user_data)) {
 819                 ret = MEDIACODEC_ERROR_INTERNAL;
 820                 goto CALLBACK_ERROR;
 821         }
 822
 823 CALLBACK_ERROR:
 824         LOGD("foreach callback returned error");
 825         return ret;
 826 }
 827
 828 int mc_get_packet_pool(MMHandleType mediacodec, media_packet_pool_h *pool)
 829 {
 830         int ret = MC_ERROR_NONE;
 831         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 832
 833         if (!mc_handle) {
 834                 LOGE("fail invaild param\n");
 835                 return MC_INVALID_ARG;
 836         }
 837
 838         /* setting core details */
 839         switch (mc_handle->port_type) {
 840         case MEDIACODEC_PORT_TYPE_GENERAL:
 841                 break;
 842
 843         case MEDIACODEC_PORT_TYPE_OMX:
 844                 break;
 845
 846         case MEDIACODEC_PORT_TYPE_GST:
 847                 ret = mc_gst_get_packet_pool(mc_handle, pool);
 848                 break;
 849
 850         default:
 851                 break;
 852         }
 853
 854         return ret;
 855 }
 856
 857 void _mc_create_decoder_map_from_ini(mc_handle_t *mediacodec)
 858 {
 859         int indx = 0, count = 0;
 860         int codec_list = mediacodec->ini->codec_list;
 861         for (indx = 0; indx < codec_list; indx++) {
 862                 if (strcmp(mediacodec->ini->codec[indx].codec_info[0].name, "")) {
 863                         mediacodec->decoder_map[count].id = mediacodec->ini->codec[indx].codec_id;
 864                         mediacodec->decoder_map[count].hardware = 1; /* hardware */
 865                         mediacodec->decoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[0].name;
 866                         mediacodec->decoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[0].mime;
 867                         mediacodec->decoder_map[count].type.out_format =
 868                                 _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[0].format);
 869                         count++;
 870                 }
 871
 872                 if (strcmp(mediacodec->ini->codec[indx].codec_info[2].name, "")) {
 873                         mediacodec->decoder_map[count].id = mediacodec->ini->codec[indx].codec_id;
 874                         mediacodec->decoder_map[count].hardware = 0; /* software */
 875                         mediacodec->decoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[2].name;
 876                         mediacodec->decoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[2].mime;
 877                         mediacodec->decoder_map[count].type.out_format =
 878                                 _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[2].format);
 879                         count++;
 880                 }
 881         }
 882         mediacodec->num_supported_decoder = count;
 883         return;
 884
 885 }
 886
 887 void _mc_create_encoder_map_from_ini(mc_handle_t *mediacodec)
 888 {
 889         int indx = 0, count = 0;
 890         int codec_list = mediacodec->ini->codec_list;
 891
 892         for (indx = 0; indx < codec_list; indx++) {
 893                 if (strcmp(mediacodec->ini->codec[indx].codec_info[1].name, "")) {
 894                         mediacodec->encoder_map[count].id = mediacodec->ini->codec[indx].codec_id;
 895                         mediacodec->encoder_map[count].hardware = 1;
 896                         mediacodec->encoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[1].name;
 897                         mediacodec->encoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[1].mime;
 898                         mediacodec->encoder_map[count].type.out_format =
 899                                 _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[1].format);
 900                         count++;
 901                 }
 902
 903                 if (strcmp(mediacodec->ini->codec[indx].codec_info[3].name, "")) {
 904                         mediacodec->encoder_map[count].id = mediacodec->ini->codec[indx].codec_id;
 905                         mediacodec->encoder_map[count].hardware = 0;
 906                         mediacodec->encoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[3].name;
 907                         mediacodec->encoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[3].mime;
 908                         mediacodec->encoder_map[count].type.out_format =
 909                                 _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[3].format);
 910                         count++;
 911                 }
 912         }
 913         mediacodec->num_supported_encoder = count;
 914         return;
 915
 916 }
 917 void _mc_create_codec_map_from_ini(mc_handle_t *mediacodec, mc_codec_spec_t *spec_emul)
 918 {
 919         int indx = 0, count = 0;
 920         int codec_list = mediacodec->ini->codec_list;
 921
 922         for (indx = 0; indx < codec_list; indx++) {
 923                 if (strcmp(mediacodec->ini->codec[indx].codec_info[0].name, "")) {
 924                         spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id;
 925                         spec_emul[count].codec_type =  MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW;
 926                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 927                         count++;
 928                 }
 929                 if (strcmp(mediacodec->ini->codec[indx].codec_info[1].name, "")) {
 930                         spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id;
 931                         spec_emul[count].codec_type =  MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW;
 932                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 933                         count++;
 934                 }
 935                 if (strcmp(mediacodec->ini->codec[indx].codec_info[2].name, "")) {
 936                         spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id;
 937                         spec_emul[count].codec_type =  MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW;
 938                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 939                         count++;
 940                 }
 941                 if (strcmp(mediacodec->ini->codec[indx].codec_info[3].name, "")) {
 942                         spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id;
 943                         spec_emul[count].codec_type =  MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW;
 944                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 945                         count++;
 946                 }
 947         }
 948
 949         mediacodec->ini->num_supported_codecs = count;
 950         LOGE("supported codecs :%d", count);
 951         return;
 952 }
 953
 954 void _mc_create_codec_map_from_ini_static(mc_ini_t *ini, mc_codec_spec_t *spec_emul)
 955 {
 956         int indx = 0, count = 0;
 957         int codec_list = ini->codec_list;
 958
 959         for (indx = 0; indx < codec_list; indx++) {
 960                 if (strcmp(ini->codec[indx].codec_info[0].name, "")) {
 961                         spec_emul[count].codec_id = ini->codec[indx].codec_id;
 962                         spec_emul[count].codec_type =  MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW;
 963                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 964                         count++;
 965                 }
 966                 if (strcmp(ini->codec[indx].codec_info[1].name, "")) {
 967                         spec_emul[count].codec_id = ini->codec[indx].codec_id;
 968                         spec_emul[count].codec_type =  MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW;
 969                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 970                         count++;
 971                 }
 972                 if (strcmp(ini->codec[indx].codec_info[2].name, "")) {
 973                         spec_emul[count].codec_id = ini->codec[indx].codec_id;
 974                         spec_emul[count].codec_type =  MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW;
 975                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 976                         count++;
 977                 }
 978                 if (strcmp(ini->codec[indx].codec_info[3].name, "")) {
 979                         spec_emul[count].codec_id = ini->codec[indx].codec_id;
 980                         spec_emul[count].codec_type =  MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW;
 981                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 982                         count++;
 983                 }
 984         }
 985
 986         ini->num_supported_codecs = count;
 987         LOGE("supported codecs :%d", count);
 988         return;
 989 }
 990
 991 const codec_type_e codec_type_to_simple_enumeration(mediacodec_codec_type_e media_codec_id)
 992 {
 993         guint media_codec_id_u = (guint)media_codec_id;
 994
 995         switch (media_codec_id_u) {
 996         case MEDIACODEC_L16:
 997                 return L16;
 998         case MEDIACODEC_ALAW:
 999                 return ALAW;
1000         case MEDIACODEC_ULAW:
1001                 return ULAW;
1002         case MEDIACODEC_AMR_NB:
1003                 return AMR_NB;
1004         case MEDIACODEC_AMR_WB:
1005                 return AMR_WB;
1006         case MEDIACODEC_G729:
1007                 return G729;
1008         case MEDIACODEC_AAC_LC:
1009                 return AAC_LC;
1010         case MEDIACODEC_AAC_HE:
1011                 return AAC_HE;
1012         case MEDIACODEC_AAC_HE_PS:
1013                 return AAC_HE_PS;
1014         case MEDIACODEC_MP3:
1015                 return MP3;
1016         case MEDIACODEC_VORBIS:
1017                 return VORBIS;
1018         case MEDIACODEC_FLAC:
1019                 return FLAC;
1020         case MEDIACODEC_WMAV1:
1021                 return WMAV1;
1022         case MEDIACODEC_WMAV2:
1023                 return WMAV2;
1024         case MEDIACODEC_WMAPRO:
1025                 return WMAPRO;
1026         case MEDIACODEC_WMALSL:
1027                 return WMALSL;
1028         case MEDIACODEC_H261:
1029                 return H261;
1030         case MEDIACODEC_H263:
1031                 return H263;
1032         case MEDIACODEC_H264:
1033                 return H264;
1034         case MEDIACODEC_MJPEG:
1035                 return MJPEG;
1036         case MEDIACODEC_MPEG1:
1037                 return MPEG1;
1038         case MEDIACODEC_MPEG2:
1039                 return MPEG2;
1040         case MEDIACODEC_MPEG4:
1041                 return MPEG4;
1042         case MEDIACODEC_HEVC:
1043                 return HEVC;
1044         case MEDIACODEC_VP8:
1045                 return VP8;
1046         case MEDIACODEC_VP9:
1047                 return VP9;
1048         case MEDIACODEC_VC1:
1049                 return VC1;
1050         default:
1051                 return NONE;
1052         }
1053 }
1054
1055 const codec_type_e simple_to_codec_type_enumeration(codec_type_e codec_id)
1056 {
1057         guint codec_id_u = (guint)codec_id;
1058
1059         switch (codec_id_u) {
1060         case L16:
1061                 return MEDIACODEC_L16;
1062         case ALAW:
1063                 return MEDIACODEC_ALAW;
1064         case ULAW:
1065                 return MEDIACODEC_ULAW;
1066         case AMR_NB:
1067                 return MEDIACODEC_AMR_NB;
1068         case AMR_WB:
1069                 return MEDIACODEC_AMR_WB;
1070         case G729:
1071                 return MEDIACODEC_G729;
1072         case AAC_LC:
1073                 return MEDIACODEC_AAC_LC;
1074         case AAC_HE:
1075                 return MEDIACODEC_AAC_HE;
1076         case AAC_HE_PS:
1077                 return MEDIACODEC_AAC_HE_PS;
1078         case MP3:
1079                 return MEDIACODEC_MP3;
1080         case VORBIS:
1081                 return MEDIACODEC_VORBIS;
1082         case FLAC:
1083                 return MEDIACODEC_FLAC;
1084         case WMAV1:
1085                 return MEDIACODEC_WMAV1;
1086         case WMAV2:
1087                 return MEDIACODEC_WMAV2;
1088         case WMAPRO:
1089                 return MEDIACODEC_WMAPRO;
1090         case WMALSL:
1091                 return MEDIACODEC_WMALSL;
1092         case H261:
1093                 return MEDIACODEC_H261;
1094         case H263:
1095                 return MEDIACODEC_H263;
1096         case H264:
1097                 return MEDIACODEC_H264;
1098         case MJPEG:
1099                 return MEDIACODEC_MJPEG;
1100         case MPEG1:
1101                 return MEDIACODEC_MPEG1;
1102         case MPEG2:
1103                 return MEDIACODEC_MPEG2;
1104         case MPEG4:
1105                 return MEDIACODEC_MPEG4;
1106         case HEVC:
1107                 return MEDIACODEC_HEVC;
1108         case VP8:
1109                 return MEDIACODEC_VP8;
1110         case VP9:
1111                 return MEDIACODEC_VP9;
1112         case VC1:
1113                 return MEDIACODEC_VC1;
1114         default:
1115                 return NONE;
1116         }
1117 }