src/media_codec.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 #include <media_codec.h>
  21 #include <media_codec_private.h>
  22 #include <media_codec_port.h>
  23 #include <system_info.h>
  24
  25 #include <dlog.h>
  26
  27 static gboolean  __mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data);
  28 static gboolean __mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data);
  29 static gboolean __mediacodec_error_cb(mediacodec_error_e error, void *user_data);
  30 static gboolean __mediacodec_eos_cb(void *user_data);
  31 static gboolean __mediacodec_supported_codec_cb(mediacodec_codec_type_e codec_type, void *user_data);
  32 static int __mediacodec_check_system_info_feature_supported();
  33 static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data);
  34
  35
  36 /*
  37 * Internal Implementation
  38 */
  39 int __convert_error_code(int code, char* func_name)
  40 {
  41     int ret = MEDIACODEC_ERROR_INVALID_OPERATION;
  42     char* msg = "MEDIACOODEC_INVALID_OPERATION";
  43     switch(code)
  44     {
  45         case MC_ERROR_NONE:
  46             ret = MEDIACODEC_ERROR_NONE;
  47             msg = "MEDIACODEC_ERROR_NONE";
  48             break;
  49         case MC_PARAM_ERROR:
  50         case MC_INVALID_ARG:
  51             ret = MEDIACODEC_ERROR_INVALID_PARAMETER;
  52             msg = "MEDIACODEC_ERROR_INVALID_PARAMETER";
  53             break;
  54         case MC_PERMISSION_DENIED:
  55             ret = MEDIACODEC_ERROR_PERMISSION_DENIED;
  56             msg = "MEDIACODEC_ERROR_PERMISSION_DENIED";
  57             break;
  58         case MC_INVALID_STATUS:
  59             ret = MEDIACODEC_ERROR_INVALID_STATE;
  60             msg = "MEDIACODEC_ERROR_INVALID_STATE";
  61             break;
  62         case MC_NOT_SUPPORTED:
  63             ret = MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE;
  64             msg = "MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE";
  65             break;
  66         case MC_ERROR:
  67         case MC_INTERNAL_ERROR:
  68         case MC_HW_ERROR:
  69             ret = MEDIACODEC_ERROR_INVALID_OPERATION;
  70             msg = "MEDIACODEC_ERROR_INVALID_OPERATION";
  71             break;
  72         case MC_INVALID_STREAM:
  73             ret = MEDIACODEC_ERROR_INVALID_STREAM;
  74             msg = "MEDIACODEC_ERROR_INVALID_STREAM";
  75             break;
  76         case MC_CODEC_NOT_FOUND:
  77             ret = MEDIACODEC_ERROR_CODEC_NOT_FOUND;
  78             msg = "MEDIACODEC_ERROR_CODEC_NOT_FOUND";
  79             break;
  80         case MC_ERROR_DECODE:
  81             ret = MEDIACODEC_ERROR_DECODE;
  82             msg = "MEDIACODEC_ERROR_DECODE";
  83             break;
  84         case MC_INVALID_IN_BUF:
  85             ret = MEDIACODEC_ERROR_INVALID_INBUFFER;
  86             msg = "MEDIACODEC_ERROR_INVALID_INBUFFER";
  87             break;
  88         case MC_INVALID_OUT_BUF:
  89             ret = MEDIACODEC_ERROR_INVALID_OUTBUFFER;
  90             msg = "MEDIACODEC_ERROR_INVALID_OUTBUFFER";
  91             break;
  92         case MC_NOT_INITIALIZED:
  93             ret = MEDIACODEC_ERROR_NOT_INITIALIZED;
  94             msg = "MEDIACODEC_ERROR_NOT_INITIALIZED";
  95             break;
  96         case MC_OUTPUT_BUFFER_EMPTY:
  97         case MC_OUTPUT_BUFFER_OVERFLOW:
  98             ret = MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE;
  99             msg = "MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE";
 100             break;
 101         default:
 102             ret = MEDIACODEC_ERROR_INTERNAL;
 103             msg = "MEDIACODEC_ERROR_INTERNAL";
 104             break;
 105     }
 106     LOGD("[%s] %s(0x%08x) : core fw error(0x%x)", func_name, msg, ret, code);
 107     return ret;
 108 }
 109
 110 bool __mediacodec_state_validate(mediacodec_h mediacodec, mediacodec_state_e threshold)
 111 {
 112     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 113
 114     if(handle->state < threshold)
 115         return FALSE;
 116     return TRUE;
 117 }
 118
 119 static int __mediacodec_check_system_info_feature_supported()
 120 {
 121     bool bValue = false;
 122     int nRetVal = false;
 123
 124     nRetVal = system_info_get_platform_bool("http://tizen.org/feature/mediacodec", &bValue);
 125
 126     if ( nRetVal != SYSTEM_INFO_ERROR_NONE )
 127     {
 128         LOGE("[%s] SYSTEM_INFO_ERROR : ", __FUNCTION__);
 129         return false;
 130     }
 131
 132     if ( false == bValue )
 133     {
 134         LOGI("system_info_get_platform_bool returned Unsupported feature capability\n");
 135     }
 136     else
 137     {
 138         LOGI("system_info_get_platform_bool returned Supported status feature\n");
 139     }
 140
 141     return bValue;
 142 }
 143
 144 /*
 145  *  Public Implementation
 146  */
 147
 148 int mediacodec_create(mediacodec_h *mediacodec)
 149 {
 150     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 151     mediacodec_s *handle;
 152     int ret;
 153
 154     LOGD ("mediacodec_create..\n");
 155
 156     handle = (mediacodec_s*)malloc( sizeof(mediacodec_s));
 157     if (handle != NULL)
 158     {
 159         memset(handle, 0 , sizeof(mediacodec_s));
 160     }
 161     else
 162     {
 163         LOGE("MEDIACODEC_ERROR_OUT_OF_MEMORY(0x%08x)", MEDIACODEC_ERROR_OUT_OF_MEMORY);
 164         return MEDIACODEC_ERROR_OUT_OF_MEMORY;
 165     }
 166
 167     ret = mc_create(&handle->mc_handle);
 168     if (ret != MEDIACODEC_ERROR_NONE)
 169     {
 170         LOGE("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION);
 171         handle->state = MEDIACODEC_STATE_NONE;
 172         free(handle);
 173         handle = NULL;
 174         return MEDIACODEC_ERROR_INVALID_OPERATION;
 175     }
 176     else
 177     {
 178         *mediacodec = (mediacodec_h) handle;
 179         handle->state = MEDIACODEC_STATE_IDLE;
 180         LOGD("new handle : %p", *mediacodec);
 181     }
 182
 183     /* set callback */
 184     mc_set_empty_buffer_cb(handle->mc_handle, (mediacodec_input_buffer_used_cb)__mediacodec_empty_buffer_cb, handle);
 185     mc_set_fill_buffer_cb(handle->mc_handle, (mediacodec_output_buffer_available_cb)__mediacodec_fill_buffer_cb, handle);
 186     mc_set_error_cb(handle->mc_handle, (mediacodec_error_cb)__mediacodec_error_cb, handle);
 187     mc_set_eos_cb(handle->mc_handle, (mediacodec_eos_cb)__mediacodec_eos_cb, handle);
 188     mc_set_buffer_status_cb(handle->mc_handle, (mediacodec_buffer_status_cb)__mediacodec_buffer_status_cb, handle);
 189     mc_set_supported_codec_cb(handle->mc_handle, (mediacodec_supported_codec_cb)__mediacodec_supported_codec_cb, handle);
 190
 191     return MEDIACODEC_ERROR_NONE;
 192
 193 }
 194
 195 int mediacodec_destroy(mediacodec_h mediacodec)
 196 {
 197     LOGD ("[%s] Start, handle to destroy : %p", __FUNCTION__, mediacodec);
 198     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 199     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 200
 201     int ret = mc_destroy(handle->mc_handle);
 202     if (ret != MEDIACODEC_ERROR_NONE) {
 203         LOGD("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION);
 204         return MEDIACODEC_ERROR_INVALID_OPERATION;
 205     }
 206     else
 207     {
 208         handle->state = MEDIACODEC_STATE_NONE;
 209         free(handle);
 210         handle = NULL;
 211         return MEDIACODEC_ERROR_NONE;
 212     }
 213 }
 214
 215 int mediacodec_set_codec(mediacodec_h mediacodec, mediacodec_codec_type_e codec_id, mediacodec_support_type_e flags)
 216 {
 217     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 218     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 219     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 220
 221     int ret = mc_set_codec(handle->mc_handle, codec_id, flags);
 222
 223     if (ret != MEDIACODEC_ERROR_NONE)
 224     {
 225         return __convert_error_code(ret,(char*)__FUNCTION__);
 226     }
 227     else
 228     {
 229         handle->state = MEDIACODEC_STATE_IDLE;
 230         return MEDIACODEC_ERROR_NONE;
 231     }
 232 }
 233
 234 int mediacodec_set_vdec_info(mediacodec_h mediacodec, int width, int height)
 235 {
 236     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 237     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 238     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 239
 240     int ret = mc_set_vdec_info(handle->mc_handle, width, height);
 241
 242     if (ret != MEDIACODEC_ERROR_NONE)
 243     {
 244         return __convert_error_code(ret,(char*)__FUNCTION__);
 245     }
 246     else
 247     {
 248         handle->state = MEDIACODEC_STATE_IDLE;
 249         return MEDIACODEC_ERROR_NONE;
 250     }
 251 }
 252
 253 int mediacodec_set_venc_info(mediacodec_h mediacodec, int width, int height, int fps, int target_bits)
 254 {
 255     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 256     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 257     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 258
 259     int ret = mc_set_venc_info(handle->mc_handle, width, height, fps, target_bits);
 260
 261     if (ret != MEDIACODEC_ERROR_NONE)
 262     {
 263         return __convert_error_code(ret,(char*)__FUNCTION__);
 264     }
 265     else
 266     {
 267         handle->state = MEDIACODEC_STATE_IDLE;
 268         return MEDIACODEC_ERROR_NONE;
 269     }
 270 }
 271
 272 int mediacodec_set_adec_info(mediacodec_h mediacodec, int samplerate, int channel, int bit)
 273 {
 274     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 275     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 276     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 277
 278     int ret = mc_set_adec_info(handle->mc_handle, samplerate, channel, bit);
 279
 280     if (ret != MEDIACODEC_ERROR_NONE)
 281     {
 282         return __convert_error_code(ret,(char*)__FUNCTION__);
 283     }
 284     else
 285     {
 286         handle->state = MEDIACODEC_STATE_IDLE;
 287         return MEDIACODEC_ERROR_NONE;
 288     }
 289 }
 290
 291 int mediacodec_set_aenc_info(mediacodec_h mediacodec, int samplerate, int channel, int bit, int bitrate)
 292 {
 293     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 294     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 295     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 296
 297     int ret = mc_set_aenc_info(handle->mc_handle, samplerate, channel, bit, bitrate);
 298
 299     if (ret != MEDIACODEC_ERROR_NONE)
 300     {
 301         return __convert_error_code(ret,(char*)__FUNCTION__);
 302     }
 303     else
 304     {
 305         handle->state = MEDIACODEC_STATE_IDLE;
 306         return MEDIACODEC_ERROR_NONE;
 307     }
 308 }
 309
 310 int mediacodec_prepare(mediacodec_h mediacodec)
 311 {
 312     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 313     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 314     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 315
 316     int ret = mc_prepare(handle->mc_handle);
 317
 318     if (ret != MEDIACODEC_ERROR_NONE)
 319     {
 320         return __convert_error_code(ret,(char*)__FUNCTION__);
 321     }
 322     else
 323     {
 324         handle->state = MEDIACODEC_STATE_READY;
 325         return MEDIACODEC_ERROR_NONE;
 326     }
 327 }
 328
 329 int mediacodec_unprepare(mediacodec_h mediacodec)
 330 {
 331     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 332     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 333
 334     int ret = mc_unprepare(handle->mc_handle);
 335
 336     if (ret != MEDIACODEC_ERROR_NONE)
 337     {
 338         return __convert_error_code(ret,(char*)__FUNCTION__);
 339     }
 340     else
 341     {
 342         handle->state = MEDIACODEC_STATE_IDLE;
 343         return MEDIACODEC_ERROR_NONE;
 344     }
 345 }
 346
 347 int mediacodec_process_input(mediacodec_h mediacodec, media_packet_h inbuf, uint64_t timeOutUs)
 348 {
 349     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 350     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 351     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
 352
 353     int ret = mc_process_input(handle->mc_handle, inbuf, timeOutUs);
 354
 355     if (ret != MEDIACODEC_ERROR_NONE)
 356     {
 357         return __convert_error_code(ret,(char*)__FUNCTION__);
 358     }
 359     else
 360     {
 361         return MEDIACODEC_ERROR_NONE;
 362     }
 363 }
 364
 365 int mediacodec_get_output(mediacodec_h mediacodec, media_packet_h *outbuf, uint64_t timeOutUs)
 366 {
 367     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 368     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 369     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
 370
 371     int ret = mc_get_output(handle->mc_handle, outbuf, timeOutUs);
 372
 373     if (ret != MEDIACODEC_ERROR_NONE)
 374     {
 375         return __convert_error_code(ret,(char*)__FUNCTION__);
 376     }
 377     else
 378     {
 379         return MEDIACODEC_ERROR_NONE;
 380     }
 381 }
 382
 383 int mediacodec_flush_buffers (mediacodec_h mediacodec)
 384 {
 385     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 386     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 387
 388     int ret = mc_flush_buffers(handle->mc_handle);
 389
 390     if (ret != MEDIACODEC_ERROR_NONE)
 391     {
 392         return __convert_error_code(ret,(char*)__FUNCTION__);
 393     }
 394     else
 395     {
 396         handle->state = MEDIACODEC_STATE_IDLE;
 397         return MEDIACODEC_ERROR_NONE;
 398     }
 399 }
 400
 401 int mediacodec_get_supported_type(mediacodec_h mediacodec, mediacodec_codec_type_e codec_type, bool encoder, int *support_type)
 402 {
 403     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 404     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 405     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 406
 407     int ret = mc_get_supported_type(handle->mc_handle, codec_type, encoder, support_type);
 408
 409     if (ret != MEDIACODEC_ERROR_NONE)
 410     {
 411         return __convert_error_code(ret,(char*)__FUNCTION__);
 412     }
 413     else
 414     {
 415         handle->state = MEDIACODEC_STATE_IDLE;
 416         return MEDIACODEC_ERROR_NONE;
 417     }
 418 }
 419
 420 int mediacodec_set_input_buffer_used_cb(mediacodec_h mediacodec, mediacodec_input_buffer_used_cb callback, void* user_data)
 421 {
 422     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 423     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 424     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 425
 426     handle->empty_buffer_cb = callback;
 427     handle->empty_buffer_cb_userdata = user_data;
 428
 429     LOGD("set empty_buffer_cb(%p)", callback);
 430
 431     return MEDIACODEC_ERROR_NONE;
 432 }
 433
 434 int mediacodec_unset_input_buffer_used_cb(mediacodec_h mediacodec)
 435 {
 436     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 437     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 438
 439     handle->empty_buffer_cb = NULL;
 440     handle->empty_buffer_cb_userdata = NULL;
 441
 442     return MEDIACODEC_ERROR_NONE;
 443 }
 444
 445
 446 int mediacodec_set_output_buffer_available_cb(mediacodec_h mediacodec, mediacodec_output_buffer_available_cb callback, void* user_data)
 447 {
 448     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 449     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 450     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 451
 452     handle->fill_buffer_cb = callback;
 453     handle->fill_buffer_cb_userdata = user_data;
 454
 455     LOGD("set fill_buffer_cb(%p)", callback);
 456
 457     return MEDIACODEC_ERROR_NONE;
 458
 459 }
 460
 461 int mediacodec_unset_output_buffer_available_cb(mediacodec_h mediacodec)
 462 {
 463     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 464     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 465
 466     handle->fill_buffer_cb = NULL;
 467     handle->fill_buffer_cb_userdata = NULL;
 468
 469     return MEDIACODEC_ERROR_NONE;
 470 }
 471
 472 int mediacodec_set_error_cb(mediacodec_h mediacodec, mediacodec_error_cb callback, void* user_data)
 473 {
 474     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 475     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 476     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 477
 478     handle->error_cb = callback;
 479     handle->error_cb_userdata = user_data;
 480
 481     LOGD("set error_cb(%p)", callback);
 482
 483     return MEDIACODEC_ERROR_NONE;
 484
 485 }
 486
 487 int mediacodec_unset_error_cb(mediacodec_h mediacodec)
 488 {
 489     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 490     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 491
 492     handle->error_cb = NULL;
 493     handle->error_cb_userdata = NULL;
 494
 495     return MEDIACODEC_ERROR_NONE;
 496 }
 497
 498 int mediacodec_set_eos_cb(mediacodec_h mediacodec, mediacodec_eos_cb callback, void* user_data)
 499 {
 500     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 501     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 502     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 503
 504     handle->eos_cb = callback;
 505     handle->eos_cb_userdata = user_data;
 506
 507     LOGD("set eos_cb(%p)", callback);
 508
 509     return MEDIACODEC_ERROR_NONE;
 510
 511 }
 512
 513 int mediacodec_unset_eos_cb(mediacodec_h mediacodec)
 514 {
 515     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 516     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 517
 518     handle->eos_cb = NULL;
 519     handle->eos_cb_userdata = NULL;
 520
 521     return MEDIACODEC_ERROR_NONE;
 522 }
 523
 524 int mediacodec_set_buffer_status_cb(mediacodec_h mediacodec, mediacodec_buffer_status_cb callback, void* user_data)
 525 {
 526     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 527     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 528     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 529
 530     handle->buffer_status_cb = callback;
 531     handle->buffer_status_cb_userdata = user_data;
 532
 533     LOGD("set buffer_status_cb(%p)", callback);
 534
 535     return MEDIACODEC_ERROR_NONE;
 536
 537 }
 538
 539 int mediacodec_unset_buffer_status_cb(mediacodec_h mediacodec)
 540 {
 541     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 542     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 543
 544     handle->buffer_status_cb = NULL;
 545     handle->buffer_status_cb_userdata = NULL;
 546
 547     return MEDIACODEC_ERROR_NONE;
 548 }
 549
 550 int mediacodec_foreach_supported_codec(mediacodec_h mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
 551 {
 552     MEDIACODEC_INSTANCE_CHECK(mediacodec);
 553     mediacodec_s * handle = (mediacodec_s *) mediacodec;
 554     MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 555
 556     handle->supported_codec_cb = callback;
 557     handle->supported_codec_cb_userdata = user_data;
 558
 559     LOGD("set supported_codec_cb(%p)", callback);
 560     _mediacodec_foreach_supported_codec(handle->mc_handle, callback, handle);
 561
 562     return MEDIACODEC_ERROR_NONE;
 563
 564 }
 565
 566 static gboolean __mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data)
 567 {
 568     if(user_data == NULL || pkt == NULL)
 569         return 0;
 570
 571     mediacodec_s * handle = (mediacodec_s *) user_data;
 572
 573     if ( handle->empty_buffer_cb )
 574     {
 575         ((mediacodec_input_buffer_used_cb)handle->empty_buffer_cb)(pkt, handle->empty_buffer_cb_userdata);
 576     }
 577
 578     return 1;
 579 }
 580
 581 static gboolean  __mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data)
 582 {
 583     if(user_data == NULL || pkt == NULL)
 584         return 0;
 585
 586     mediacodec_s * handle = (mediacodec_s *) user_data;
 587
 588     if ( handle->fill_buffer_cb )
 589     {
 590         ((mediacodec_output_buffer_available_cb)handle->fill_buffer_cb)(pkt, handle->fill_buffer_cb_userdata);
 591     }
 592
 593     return 1;
 594 }
 595
 596 static gboolean __mediacodec_error_cb(mediacodec_error_e error, void *user_data)
 597 {
 598     if(user_data == NULL)
 599         return 0;
 600
 601     mediacodec_s * handle = (mediacodec_s *) user_data;
 602
 603     if ( handle->error_cb )
 604     {
 605         ((mediacodec_error_cb)handle->error_cb)(error, handle->error_cb_userdata);
 606     }
 607
 608     return 1;
 609 }
 610
 611 static gboolean __mediacodec_eos_cb(void *user_data)
 612 {
 613     if(user_data == NULL)
 614         return 0;
 615
 616     mediacodec_s * handle = (mediacodec_s *) user_data;
 617
 618     if ( handle->eos_cb )
 619     {
 620         ((mediacodec_eos_cb)handle->eos_cb)(handle->eos_cb_userdata);
 621     }
 622
 623     return 1;
 624 }
 625
 626 static gboolean __mediacodec_supported_codec_cb(mediacodec_codec_type_e codec_type, void *user_data)
 627 {
 628     if(user_data == NULL)
 629         return 0;
 630
 631     mediacodec_s * handle = (mediacodec_s *) user_data;
 632
 633     if ( handle->supported_codec_cb )
 634     {
 635         return ((mediacodec_supported_codec_cb)handle->supported_codec_cb)(codec_type, handle->supported_codec_cb_userdata);
 636     }
 637     return false;
 638 }
 639
 640 static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data)
 641 {
 642     if(user_data == NULL)
 643         return 0;
 644
 645     mediacodec_s * handle = (mediacodec_s *) user_data;
 646
 647     if ( handle->buffer_status_cb )
 648     {
 649         ((mediacodec_buffer_status_cb)handle->buffer_status_cb)(status, handle->buffer_status_cb_userdata);
 650     }
 651
 652     return 1;
 653 }
 654