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