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