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
  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_prepare(MMHandleType mediacodec)
 261 {
 262         int ret = MC_ERROR_NONE;
 263         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
 264
 265         if (!mc_handle) {
 266                 LOGE("fail invaild param\n");
 267                 return MC_INVALID_ARG;
 268         }
 269
 270         if (!mc_handle->is_prepared)
 271                 return MC_NOT_INITIALIZED;
 272
 273         /* setting core details */
 274         switch (mc_handle->port_type) {
 275         case MEDIACODEC_PORT_TYPE_GENERAL:
 276                 break;
 277
 278         case MEDIACODEC_PORT_TYPE_OMX:
 279                 break;
 280
 281         case MEDIACODEC_PORT_TYPE_GST:
 282                 mc_gst_prepare(mc_handle);
 283                 break;
 284
 285         default:
 286                 break;
 287         }
 288
 289         return ret;
 290 }
 291
 292 int mc_unprepare(MMHandleType mediacodec)
 293 {
 294         int ret = MC_ERROR_NONE;
 295         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 296
 297         if (!mc_handle) {
 298                 LOGE("fail invaild param\n");
 299                 return MC_INVALID_ARG;
 300         }
 301
 302         /* deinit core details */
 303         switch (mc_handle->port_type) {
 304         case MEDIACODEC_PORT_TYPE_GENERAL:
 305                 break;
 306
 307         case MEDIACODEC_PORT_TYPE_OMX:
 308                 break;
 309
 310         case MEDIACODEC_PORT_TYPE_GST:
 311                 ret = mc_gst_unprepare(mc_handle);
 312                 break;
 313
 314         default:
 315                 break;
 316         }
 317
 318         return ret;
 319 }
 320
 321 int mc_process_input(MMHandleType mediacodec, media_packet_h inbuf, uint64_t timeOutUs)
 322 {
 323         int ret = MC_ERROR_NONE;
 324
 325         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 326
 327         if (!mc_handle) {
 328                 LOGE("fail invaild param");
 329                 return MC_INVALID_ARG;
 330         }
 331
 332         if (!inbuf) {
 333                 LOGE("invaild input buffer");
 334                 return MC_INVALID_IN_BUF;
 335         }
 336
 337         switch (mc_handle->port_type) {
 338         case MEDIACODEC_PORT_TYPE_GENERAL:
 339                 break;
 340
 341         case MEDIACODEC_PORT_TYPE_OMX:
 342                 break;
 343
 344         case MEDIACODEC_PORT_TYPE_GST:
 345                 ret = mc_gst_process_input(mc_handle, inbuf, timeOutUs);
 346                 break;
 347
 348         default:
 349                 break;
 350         }
 351
 352         return ret;
 353 }
 354
 355 int mc_get_output(MMHandleType mediacodec, media_packet_h *outbuf, uint64_t timeOutUs)
 356 {
 357         int ret = MC_ERROR_NONE;
 358         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
 359
 360         if (!mc_handle) {
 361                 LOGE("fail invaild param\n");
 362                 return MC_INVALID_ARG;
 363         }
 364
 365         /* setting core details */
 366         switch (mc_handle->port_type) {
 367         case MEDIACODEC_PORT_TYPE_GENERAL:
 368                 break;
 369
 370         case MEDIACODEC_PORT_TYPE_OMX:
 371                 break;
 372
 373         case MEDIACODEC_PORT_TYPE_GST:
 374                 ret = mc_gst_get_output(mc_handle, outbuf, timeOutUs);
 375                 break;
 376
 377         default:
 378                 break;
 379         }
 380
 381         return ret;
 382 }
 383
 384 int mc_flush_buffers(MMHandleType mediacodec)
 385 {
 386         int ret = MC_ERROR_NONE;
 387         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 388
 389         if (!mc_handle) {
 390                 LOGE("fail invaild param\n");
 391                 return MC_INVALID_ARG;
 392         }
 393
 394         /* setting core details */
 395         switch (mc_handle->port_type) {
 396         case MEDIACODEC_PORT_TYPE_GENERAL:
 397                 break;
 398
 399         case MEDIACODEC_PORT_TYPE_OMX:
 400                 break;
 401
 402         case MEDIACODEC_PORT_TYPE_GST:
 403                 ret = mc_gst_flush_buffers(mc_handle);
 404                 break;
 405
 406         default:
 407                 break;
 408         }
 409
 410         return ret;
 411 }
 412
 413 int mc_get_supported_type(MMHandleType mediacodec, mediacodec_codec_type_e codec_type, bool encoder, int *support_type)
 414 {
 415         int ret = MC_ERROR_NONE;
 416         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 417         mc_codec_map_t *codec_map;
 418         int num_supported_codec = 0;
 419         int i;
 420
 421         *support_type = 0;
 422
 423         if (!mc_handle) {
 424                 LOGE("fail invaild param\n");
 425                 return MC_INVALID_ARG;
 426         }
 427
 428         codec_map = encoder ? mc_handle->encoder_map : mc_handle->decoder_map;
 429         num_supported_codec = encoder ? mc_handle->num_supported_encoder : mc_handle->num_supported_decoder;
 430
 431         for (i = 0; i < num_supported_codec; i++) {
 432                 if (codec_map[i].id == codec_type) {
 433                         if (codec_map[i].hardware)
 434                                 *support_type |= MEDIACODEC_SUPPORT_TYPE_HW;
 435                         else
 436                                 *support_type |= MEDIACODEC_SUPPORT_TYPE_SW;
 437                 }
 438         }
 439
 440         return ret;
 441 }
 442
 443 int mc_set_empty_buffer_cb(MMHandleType mediacodec, mediacodec_input_buffer_used_cb callback, void *user_data)
 444 {
 445         int ret = MC_ERROR_NONE;
 446         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 447
 448         if (!mc_handle) {
 449                 LOGE("fail invaild param\n");
 450                 return MC_INVALID_ARG;
 451         }
 452
 453         if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
 454                 LOGE("Already set mediacodec_empty_buffer_cb");
 455                 return MC_PARAM_ERROR;
 456         } else {
 457                 if (!callback)
 458                         return MC_INVALID_ARG;
 459
 460                 LOGD("Set empty buffer callback(cb = %p, data = %p)", callback, user_data);
 461
 462                 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = (mc_empty_buffer_cb) callback;
 463                 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = user_data;
 464
 465                 return MC_ERROR_NONE;
 466         }
 467
 468         return ret;
 469 }
 470
 471 int mc_unset_empty_buffer_cb(MMHandleType mediacodec)
 472 {
 473         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 474
 475         if (!mc_handle) {
 476                 LOGE("fail invaild param\n");
 477                 return MC_INVALID_ARG;
 478         }
 479
 480         mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = NULL;
 481         mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = NULL;
 482
 483         return MC_ERROR_NONE;
 484 }
 485
 486 int mc_set_fill_buffer_cb(MMHandleType mediacodec, mediacodec_output_buffer_available_cb callback, void *user_data)
 487 {
 488         int ret = MC_ERROR_NONE;
 489         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 490
 491         if (!mc_handle) {
 492                 LOGE("fail invaild param\n");
 493                 return MC_INVALID_ARG;
 494         }
 495
 496         if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) {
 497                 LOGE("Already set mediacodec_fill_buffer_cb");
 498                 return MC_PARAM_ERROR;
 499         } else {
 500                 if (!callback)
 501                         return MC_INVALID_ARG;
 502
 503                 LOGD("Set fill buffer callback(cb = %p, data = %p)", callback, user_data);
 504
 505                 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = (mc_fill_buffer_cb) callback;
 506                 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = user_data;
 507                 return MC_ERROR_NONE;
 508         }
 509
 510         return ret;
 511 }
 512
 513 int mc_unset_fill_buffer_cb(MMHandleType mediacodec)
 514 {
 515         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 516
 517         if (!mc_handle) {
 518                 LOGE("fail invaild param\n");
 519                 return MC_INVALID_ARG;
 520         }
 521
 522         mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = NULL;
 523         mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = NULL;
 524
 525         return MC_ERROR_NONE;
 526 }
 527
 528 int mc_set_error_cb(MMHandleType mediacodec, mediacodec_error_cb callback, void *user_data)
 529 {
 530         int ret = MC_ERROR_NONE;
 531         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
 532
 533         if (!mc_handle) {
 534                 LOGE("fail invaild param\n");
 535                 return MC_INVALID_ARG;
 536         }
 537
 538         if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
 539                 LOGE("Already set mediacodec_fill_buffer_cb\n");
 540                 return MC_PARAM_ERROR;
 541         } else {
 542                 if (!callback)
 543                         return MC_INVALID_ARG;
 544
 545                 LOGD("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
 546
 547                 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR] = (mc_error_cb) callback;
 548                 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_ERROR] = user_data;
 549                 return MC_ERROR_NONE;
 550         }
 551
 552         return ret;
 553 }
 554
 555 int mc_unset_error_cb(MMHandleType mediacodec)
 556 {
 557         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 558
 559         if (!mc_handle) {
 560                 LOGE("fail invaild param");
 561                 return MC_INVALID_ARG;
 562         }
 563
 564         mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR] = NULL;
 565         mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_ERROR] = NULL;
 566
 567         return MC_ERROR_NONE;
 568 }
 569
 570 int mc_set_eos_cb(MMHandleType mediacodec, mediacodec_eos_cb callback, void *user_data)
 571 {
 572         int ret = MC_ERROR_NONE;
 573         mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
 574
 575         if (!mc_handle) {
 576                 LOGE("fail invaild param\n");
 577                 return MC_INVALID_ARG;
 578         }
 579
 580         if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS]) {
 581                 LOGE("Already set mediacodec_fill_buffer_cb");
 582                 return MC_PARAM_ERROR;
 583         } else {
 584                 if (!callback)
 585                         return MC_INVALID_ARG;
 586
 587                 LOGD("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
 588
 589                 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS] = (mc_eos_cb) callback;
 590                 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EOS] = user_data;
 591                 return MC_ERROR_NONE;
 592         }
 593
 594         return ret;
 595 }
 596
 597 int mc_unset_eos_cb(MMHandleType mediacodec)
 598 {
 599         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 600
 601         if (!mc_handle) {
 602                 LOGE("fail invaild param\n");
 603                 return MC_INVALID_ARG;
 604         }
 605
 606         mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS] = NULL;
 607         mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EOS] = NULL;
 608
 609         return MC_ERROR_NONE;
 610 }
 611
 612 int mc_set_buffer_status_cb(MMHandleType mediacodec, mediacodec_buffer_status_cb callback, void *user_data)
 613 {
 614         int ret = MC_ERROR_NONE;
 615         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 616
 617         if (!mc_handle) {
 618                 LOGE("fail invaild param\n");
 619                 return MC_INVALID_ARG;
 620         }
 621
 622         if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
 623                 LOGE("Already set mediacodec_need_data_cb\n");
 624                 return MC_PARAM_ERROR;
 625         } else {
 626                 if (!callback)
 627                         return MC_INVALID_ARG;
 628
 629                 LOGD("Set start feed callback(cb = %p, data = %p)\n", callback, user_data);
 630
 631                 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = (mc_buffer_status_cb) callback;
 632                 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = user_data;
 633                 return MC_ERROR_NONE;
 634         }
 635
 636         return ret;
 637 }
 638
 639 int mc_unset_buffer_status_cb(MMHandleType mediacodec)
 640 {
 641         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 642
 643         if (!mc_handle) {
 644                 LOGE("fail invaild param\n");
 645                 return MC_INVALID_ARG;
 646         }
 647
 648         mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = NULL;
 649         mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS] = NULL;
 650
 651         return MC_ERROR_NONE;
 652 }
 653
 654 int mc_set_supported_codec_cb(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
 655 {
 656         int ret = MC_ERROR_NONE;
 657         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 658
 659         if (!mc_handle) {
 660                 LOGE("fail invaild param\n");
 661                 return MC_INVALID_ARG;
 662         }
 663
 664         if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC]) {
 665                 LOGE("Already set mediacodec_supported_codec_cb\n");
 666                 return MC_PARAM_ERROR;
 667         } else {
 668                 if (!callback)
 669                         return MC_INVALID_ARG;
 670
 671                 LOGD("Set event handler callback(cb = %p, data = %p)", callback, user_data);
 672
 673                 mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC] = (mc_supported_codec_cb) callback;
 674                 mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC] = user_data;
 675                 return MC_ERROR_NONE;
 676         }
 677
 678         return ret;
 679 }
 680
 681 int _mediacodec_foreach_supported_codec(mediacodec_supported_codec_cb callback, void *user_data)
 682 {
 683         int ret = MEDIACODEC_NONE;
 684         int i;
 685         int index;
 686
 687         gboolean codec[CODEC_NR_ITEMS] = {0,};
 688
 689         for (i = 0; i < mc_ini.num_supported_codecs; i++) {
 690                 index = codec_type_to_simple_enumeration(spec_emul[i].codec_id);
 691                 codec[index] = TRUE;
 692         }
 693
 694         for (i = 0; i < CODEC_NR_ITEMS; i++) {
 695                 if (codec[i]) {
 696                         index = simple_to_codec_type_enumeration(i);
 697                         if (!callback(index, user_data)) {
 698                                 goto CALLBACK_ERROR;
 699                         }
 700                 }
 701         }
 702
 703         if (!callback(-1, user_data)) {
 704                 ret = MEDIACODEC_ERROR_INTERNAL;
 705                 goto CALLBACK_ERROR;
 706         }
 707
 708 CALLBACK_ERROR:
 709         LOGD("foreach callback returned error");
 710         return ret;
 711 }
 712
 713 int mc_get_packet_pool(MMHandleType mediacodec, media_packet_pool_h *pool)
 714 {
 715         int ret = MC_ERROR_NONE;
 716         mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
 717
 718         if (!mc_handle) {
 719                 LOGE("fail invaild param\n");
 720                 return MC_INVALID_ARG;
 721         }
 722
 723         /* setting core details */
 724         switch (mc_handle->port_type) {
 725         case MEDIACODEC_PORT_TYPE_GENERAL:
 726                 break;
 727
 728         case MEDIACODEC_PORT_TYPE_OMX:
 729                 break;
 730
 731         case MEDIACODEC_PORT_TYPE_GST:
 732                 ret = mc_gst_get_packet_pool(mc_handle, pool);
 733                 break;
 734
 735         default:
 736                 break;
 737         }
 738
 739         return ret;
 740 }
 741
 742 void _mc_create_decoder_map_from_ini(mc_handle_t *mediacodec)
 743 {
 744         int indx = 0, count = 0;
 745         int codec_list = mediacodec->ini->codec_list;
 746         for (indx = 0; indx < codec_list; indx++) {
 747                 if (strcmp(mediacodec->ini->codec[indx].codec_info[0].name, "")) {
 748                         mediacodec->decoder_map[count].id = mediacodec->ini->codec[indx].codec_id;
 749                         mediacodec->decoder_map[count].hardware = 1; /* hardware */
 750                         mediacodec->decoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[0].name;
 751                         mediacodec->decoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[0].mime;
 752                         mediacodec->decoder_map[count].type.out_format =
 753                                 _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[0].format);
 754                         count++;
 755                 }
 756
 757                 if (strcmp(mediacodec->ini->codec[indx].codec_info[2].name, "")) {
 758                         mediacodec->decoder_map[count].id = mediacodec->ini->codec[indx].codec_id;
 759                         mediacodec->decoder_map[count].hardware = 0; /* software */
 760                         mediacodec->decoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[2].name;
 761                         mediacodec->decoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[2].mime;
 762                         mediacodec->decoder_map[count].type.out_format =
 763                                 _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[2].format);
 764                         count++;
 765                 }
 766         }
 767         mediacodec->num_supported_decoder = count;
 768         return;
 769
 770 }
 771
 772 void _mc_create_encoder_map_from_ini(mc_handle_t *mediacodec)
 773 {
 774         int indx = 0, count = 0;
 775         int codec_list = mediacodec->ini->codec_list;
 776
 777         for (indx = 0; indx < codec_list; indx++) {
 778                 if (strcmp(mediacodec->ini->codec[indx].codec_info[1].name, "")) {
 779                         mediacodec->encoder_map[count].id = mediacodec->ini->codec[indx].codec_id;
 780                         mediacodec->encoder_map[count].hardware = 1;
 781                         mediacodec->encoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[1].name;
 782                         mediacodec->encoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[1].mime;
 783                         mediacodec->encoder_map[count].type.out_format =
 784                                 _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[1].format);
 785                         count++;
 786                 }
 787
 788                 if (strcmp(mediacodec->ini->codec[indx].codec_info[3].name, "")) {
 789                         mediacodec->encoder_map[count].id = mediacodec->ini->codec[indx].codec_id;
 790                         mediacodec->encoder_map[count].hardware = 0;
 791                         mediacodec->encoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[3].name;
 792                         mediacodec->encoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[3].mime;
 793                         mediacodec->encoder_map[count].type.out_format =
 794                                 _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[3].format);
 795                         count++;
 796                 }
 797         }
 798         mediacodec->num_supported_encoder = count;
 799         return;
 800
 801 }
 802 void _mc_create_codec_map_from_ini(mc_handle_t *mediacodec, mc_codec_spec_t *spec_emul)
 803 {
 804         int indx = 0, count = 0;
 805         int codec_list = mediacodec->ini->codec_list;
 806
 807         for (indx = 0; indx < codec_list; indx++) {
 808                 if (strcmp(mediacodec->ini->codec[indx].codec_info[0].name, "")) {
 809                         spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id;
 810                         spec_emul[count].codec_type =  MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW;
 811                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 812                         count++;
 813                 }
 814                 if (strcmp(mediacodec->ini->codec[indx].codec_info[1].name, "")) {
 815                         spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id;
 816                         spec_emul[count].codec_type =  MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW;
 817                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 818                         count++;
 819                 }
 820                 if (strcmp(mediacodec->ini->codec[indx].codec_info[2].name, "")) {
 821                         spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id;
 822                         spec_emul[count].codec_type =  MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW;
 823                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 824                         count++;
 825                 }
 826                 if (strcmp(mediacodec->ini->codec[indx].codec_info[3].name, "")) {
 827                         spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id;
 828                         spec_emul[count].codec_type =  MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW;
 829                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 830                         count++;
 831                 }
 832         }
 833
 834         mediacodec->ini->num_supported_codecs = count;
 835         LOGE("supported codecs :%d", count);
 836         return;
 837 }
 838
 839 void _mc_create_codec_map_from_ini_static(mc_ini_t *ini, mc_codec_spec_t *spec_emul)
 840 {
 841         int indx = 0, count = 0;
 842         int codec_list = ini->codec_list;
 843
 844         for (indx = 0; indx < codec_list; indx++) {
 845                 if (strcmp(ini->codec[indx].codec_info[0].name, "")) {
 846                         spec_emul[count].codec_id = ini->codec[indx].codec_id;
 847                         spec_emul[count].codec_type =  MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW;
 848                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 849                         count++;
 850                 }
 851                 if (strcmp(ini->codec[indx].codec_info[1].name, "")) {
 852                         spec_emul[count].codec_id = ini->codec[indx].codec_id;
 853                         spec_emul[count].codec_type =  MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW;
 854                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 855                         count++;
 856                 }
 857                 if (strcmp(ini->codec[indx].codec_info[2].name, "")) {
 858                         spec_emul[count].codec_id = ini->codec[indx].codec_id;
 859                         spec_emul[count].codec_type =  MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW;
 860                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 861                         count++;
 862                 }
 863                 if (strcmp(ini->codec[indx].codec_info[3].name, "")) {
 864                         spec_emul[count].codec_id = ini->codec[indx].codec_id;
 865                         spec_emul[count].codec_type =  MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW;
 866                         spec_emul[count].port_type =  MEDIACODEC_PORT_TYPE_GST;
 867                         count++;
 868                 }
 869         }
 870
 871         ini->num_supported_codecs = count;
 872         LOGE("supported codecs :%d", count);
 873         return;
 874 }
 875
 876 const int codec_type_to_simple_enumeration(mediacodec_codec_type_e media_codec_id)
 877 {
 878         guint media_codec_id_u = (guint)media_codec_id;
 879
 880         switch (media_codec_id_u) {
 881         case MEDIACODEC_L16:
 882                 return L16;
 883         case MEDIACODEC_ALAW:
 884                 return ALAW;
 885         case MEDIACODEC_ULAW:
 886                 return ULAW;
 887         case MEDIACODEC_AMR_NB:
 888                 return AMR_NB;
 889         case MEDIACODEC_AMR_WB:
 890                 return AMR_WB;
 891         case MEDIACODEC_G729:
 892                 return G729;
 893         case MEDIACODEC_AAC_LC:
 894                 return AAC_LC;
 895         case MEDIACODEC_AAC_HE:
 896                 return AAC_HE;
 897         case MEDIACODEC_AAC_HE_PS:
 898                 return AAC_HE_PS;
 899         case MEDIACODEC_MP3:
 900                 return MP3;
 901         case MEDIACODEC_VORBIS:
 902                 return VORBIS;
 903         case MEDIACODEC_FLAC:
 904                 return FLAC;
 905         case MEDIACODEC_WMAV1:
 906                 return WMAV1;
 907         case MEDIACODEC_WMAV2:
 908                 return WMAV2;
 909         case MEDIACODEC_WMAPRO:
 910                 return WMAPRO;
 911         case MEDIACODEC_WMALSL:
 912                 return WMALSL;
 913         case MEDIACODEC_H261:
 914                 return H261;
 915         case MEDIACODEC_H263:
 916                 return H263;
 917         case MEDIACODEC_H264:
 918                 return H264;
 919         case MEDIACODEC_MJPEG:
 920                 return MJPEG;
 921         case MEDIACODEC_MPEG1:
 922                 return MPEG1;
 923         case MEDIACODEC_MPEG2:
 924                 return MPEG2;
 925         case MEDIACODEC_MPEG4:
 926                 return MPEG4;
 927         case MEDIACODEC_HEVC:
 928                 return HEVC;
 929         case MEDIACODEC_VP8:
 930                 return VP8;
 931         case MEDIACODEC_VP9:
 932                 return VP9;
 933         case MEDIACODEC_VC1:
 934                 return VC1;
 935         default:
 936                 return NONE;
 937         }
 938 }
 939
 940 const int simple_to_codec_type_enumeration(codec_type_e codec_id)
 941 {
 942         guint codec_id_u = (guint)codec_id;
 943
 944         switch (codec_id_u) {
 945         case L16:
 946                 return MEDIACODEC_L16;
 947         case ALAW:
 948                 return MEDIACODEC_ALAW;
 949         case ULAW:
 950                 return MEDIACODEC_ULAW;
 951         case AMR_NB:
 952                 return MEDIACODEC_AMR_NB;
 953         case AMR_WB:
 954                 return MEDIACODEC_AMR_WB;
 955         case G729:
 956                 return MEDIACODEC_G729;
 957         case AAC_LC:
 958                 return MEDIACODEC_AAC_LC;
 959         case AAC_HE:
 960                 return MEDIACODEC_AAC_HE;
 961         case AAC_HE_PS:
 962                 return MEDIACODEC_AAC_HE_PS;
 963         case MP3:
 964                 return MEDIACODEC_MP3;
 965         case VORBIS:
 966                 return MEDIACODEC_VORBIS;
 967         case FLAC:
 968                 return MEDIACODEC_FLAC;
 969         case WMAV1:
 970                 return MEDIACODEC_WMAV1;
 971         case WMAV2:
 972                 return MEDIACODEC_WMAV2;
 973         case WMAPRO:
 974                 return MEDIACODEC_WMAPRO;
 975         case WMALSL:
 976                 return MEDIACODEC_WMALSL;
 977         case H261:
 978                 return MEDIACODEC_H261;
 979         case H263:
 980                 return MEDIACODEC_H263;
 981         case H264:
 982                 return MEDIACODEC_H264;
 983         case MJPEG:
 984                 return MEDIACODEC_MJPEG;
 985         case MPEG1:
 986                 return MEDIACODEC_MPEG1;
 987         case MPEG2:
 988                 return MEDIACODEC_MPEG2;
 989         case MPEG4:
 990                 return MEDIACODEC_MPEG4;
 991         case HEVC:
 992                 return MEDIACODEC_HEVC;
 993         case VP8:
 994                 return MEDIACODEC_VP8;
 995         case VP9:
 996                 return MEDIACODEC_VP9;
 997         case VC1:
 998                 return MEDIACODEC_VC1;
 999         default:
1000                 return NONE;
1001         }
1002 }