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