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