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 #define MC_PREALLOCATED_HANDLE_ARRAY_SIZE 16
  28
  29 static mm_resource_manager_h resource_manager;
  30 static GPtrArray *mediacodec_handles;
  31 static GMutex mediacodec_handles_lock;
  32
  33 static gboolean  __mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data);
  34 static gboolean __mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data);
  35 static gboolean __mediacodec_error_cb(mediacodec_error_e error, void *user_data);
  36 static gboolean __mediacodec_eos_cb(void *user_data);
  37 static gboolean __mediacodec_supported_codec_cb(mediacodec_codec_type_e codec_type, void *user_data);
  38 static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data);
  39 static void __mediacodec_init_lib() __attribute__((constructor));
  40 static void __mediacodec_deinit_lib() __attribute__((destructor));
  41 static int __mediacodec_resource_release_cb(mm_resource_manager_h rm,
  42                 mm_resource_manager_res_h resource_h, void *user_data);
  43
  44 /*
  45  * Internal Implementation
  46  */
  47 int __convert_error_code(int code, char *func_name)
  48 {
  49         int ret = MEDIACODEC_ERROR_INVALID_OPERATION;
  50         char *msg = "MEDIACOODEC_INVALID_OPERATION";
  51
  52         switch (code) {
  53         case MC_ERROR_NONE:
  54                 ret = MEDIACODEC_ERROR_NONE;
  55                 msg = "MEDIACODEC_ERROR_NONE";
  56                 break;
  57         case MC_PARAM_ERROR:
  58         case MC_INVALID_ARG:
  59                 ret = MEDIACODEC_ERROR_INVALID_PARAMETER;
  60                 msg = "MEDIACODEC_ERROR_INVALID_PARAMETER";
  61                 break;
  62         case MC_PERMISSION_DENIED:
  63                 ret = MEDIACODEC_ERROR_PERMISSION_DENIED;
  64                 msg = "MEDIACODEC_ERROR_PERMISSION_DENIED";
  65                 break;
  66         case MC_INVALID_STATUS:
  67                 ret = MEDIACODEC_ERROR_INVALID_STATE;
  68                 msg = "MEDIACODEC_ERROR_INVALID_STATE";
  69                 break;
  70         case MC_NOT_SUPPORTED:
  71                 ret = MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE;
  72                 msg = "MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE";
  73                 break;
  74         case MC_ERROR:
  75         case MC_INTERNAL_ERROR:
  76         case MC_HW_ERROR:
  77                 ret = MEDIACODEC_ERROR_INVALID_OPERATION;
  78                 msg = "MEDIACODEC_ERROR_INVALID_OPERATION";
  79                 break;
  80         case MC_INVALID_STREAM:
  81                 ret = MEDIACODEC_ERROR_INVALID_STREAM;
  82                 msg = "MEDIACODEC_ERROR_INVALID_STREAM";
  83                 break;
  84         case MC_CODEC_NOT_FOUND:
  85                 ret = MEDIACODEC_ERROR_CODEC_NOT_FOUND;
  86                 msg = "MEDIACODEC_ERROR_CODEC_NOT_FOUND";
  87                 break;
  88         case MC_ERROR_DECODE:
  89                 ret = MEDIACODEC_ERROR_DECODE;
  90                 msg = "MEDIACODEC_ERROR_DECODE";
  91                 break;
  92         case MC_INVALID_IN_BUF:
  93                 ret = MEDIACODEC_ERROR_INVALID_INBUFFER;
  94                 msg = "MEDIACODEC_ERROR_INVALID_INBUFFER";
  95                 break;
  96         case MC_INVALID_OUT_BUF:
  97                 ret = MEDIACODEC_ERROR_INVALID_OUTBUFFER;
  98                 msg = "MEDIACODEC_ERROR_INVALID_OUTBUFFER";
  99                 break;
 100         case MC_NOT_INITIALIZED:
 101                 ret = MEDIACODEC_ERROR_NOT_INITIALIZED;
 102                 msg = "MEDIACODEC_ERROR_NOT_INITIALIZED";
 103                 break;
 104         case MC_OUTPUT_BUFFER_EMPTY:
 105         case MC_OUTPUT_BUFFER_OVERFLOW:
 106                 ret = MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE;
 107                 msg = "MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE";
 108                 break;
 109         case MC_OUT_OF_MEMORY:
 110                 ret = MEDIACODEC_ERROR_OUT_OF_MEMORY;
 111                 msg = "MEDIACODEC_ERROR_OUT_OF_MEMORY";
 112                 break;
 113         default:
 114                 ret = MEDIACODEC_ERROR_INTERNAL;
 115                 msg = "MEDIACODEC_ERROR_INTERNAL";
 116                 break;
 117         }
 118         LOGD("[%s] %s(0x%08x) : core fw error(0x%x)", func_name, msg, ret, code);
 119         return ret;
 120 }
 121
 122 /*
 123  *  Public Implementation
 124  */
 125
 126 int mediacodec_create(mediacodec_h *mediacodec)
 127 {
 128         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 129         mediacodec_s *handle;
 130         int ret;
 131
 132         LOGD("mediacodec_create..");
 133
 134         if (resource_manager == NULL)
 135                 return MEDIACODEC_ERROR_INTERNAL;
 136
 137         handle = (mediacodec_s *)malloc(sizeof(mediacodec_s));
 138         if (handle != NULL) {
 139                 memset(handle, 0 , sizeof(mediacodec_s));
 140         } else {
 141                 LOGE("MEDIACODEC_ERROR_OUT_OF_MEMORY(0x%08x)", MEDIACODEC_ERROR_OUT_OF_MEMORY);
 142                 return MEDIACODEC_ERROR_OUT_OF_MEMORY;
 143         }
 144
 145         ret = mc_create(&handle->mc_handle);
 146         if (ret != MEDIACODEC_ERROR_NONE) {
 147                 LOGE("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION);
 148                 handle->state = MEDIACODEC_STATE_NONE;
 149                 g_free(handle->mc_handle);
 150                 g_free(handle);
 151                 handle = NULL;
 152                 return MEDIACODEC_ERROR_INVALID_OPERATION;
 153         } else {
 154                 *mediacodec = (mediacodec_h)handle;
 155                 handle->state = MEDIACODEC_STATE_IDLE;
 156                 LOGD("new handle : %p", *mediacodec);
 157         }
 158
 159         /* set callback */
 160         mc_set_empty_buffer_cb(handle->mc_handle, (mediacodec_input_buffer_used_cb)__mediacodec_empty_buffer_cb, handle);
 161         mc_set_fill_buffer_cb(handle->mc_handle, (mediacodec_output_buffer_available_cb)__mediacodec_fill_buffer_cb, handle);
 162         mc_set_error_cb(handle->mc_handle, (mediacodec_error_cb)__mediacodec_error_cb, handle);
 163         mc_set_eos_cb(handle->mc_handle, (mediacodec_eos_cb)__mediacodec_eos_cb, handle);
 164         mc_set_buffer_status_cb(handle->mc_handle, (mediacodec_buffer_status_cb)__mediacodec_buffer_status_cb, handle);
 165         mc_set_supported_codec_cb(handle->mc_handle, (mediacodec_supported_codec_cb)__mediacodec_supported_codec_cb, handle);
 166
 167         g_mutex_lock(&mediacodec_handles_lock);
 168         g_ptr_array_insert(mediacodec_handles, -1, *mediacodec);
 169         g_mutex_unlock(&mediacodec_handles_lock);
 170
 171         return MEDIACODEC_ERROR_NONE;
 172
 173 }
 174
 175 int mediacodec_destroy(mediacodec_h mediacodec)
 176 {
 177         LOGD("[%s] Start, handle to destroy : %p", __FUNCTION__, mediacodec);
 178         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 179         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 180
 181         int ret = mc_destroy(handle->mc_handle);
 182         if (ret != MEDIACODEC_ERROR_NONE) {
 183                 LOGD("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION);
 184                 return MEDIACODEC_ERROR_INVALID_OPERATION;
 185         } else {
 186                 g_mutex_lock(&mediacodec_handles_lock);
 187                 g_ptr_array_remove_fast(mediacodec_handles, mediacodec);
 188                 g_mutex_unlock(&mediacodec_handles_lock);
 189
 190                 handle->state = MEDIACODEC_STATE_NONE;
 191                 free(handle);
 192                 handle = NULL;
 193                 return MEDIACODEC_ERROR_NONE;
 194         }
 195 }
 196
 197 int mediacodec_set_codec(mediacodec_h mediacodec, mediacodec_codec_type_e codec_id, int flags)
 198 {
 199         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 200         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 201         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 202
 203         int ret = mc_set_codec(handle->mc_handle, codec_id, flags);
 204
 205         if (ret != MEDIACODEC_ERROR_NONE) {
 206                 return __convert_error_code(ret, (char *)__FUNCTION__);
 207         } else {
 208                 handle->state = MEDIACODEC_STATE_IDLE;
 209                 return MEDIACODEC_ERROR_NONE;
 210         }
 211 }
 212
 213 int mediacodec_set_vdec_info(mediacodec_h mediacodec, int width, int height)
 214 {
 215         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 216         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 217         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 218
 219         int ret = mc_set_vdec_info(handle->mc_handle, width, height);
 220
 221         if (ret != MEDIACODEC_ERROR_NONE) {
 222                 return __convert_error_code(ret, (char *)__FUNCTION__);
 223         } else {
 224                 handle->state = MEDIACODEC_STATE_IDLE;
 225                 return MEDIACODEC_ERROR_NONE;
 226         }
 227 }
 228
 229 int mediacodec_set_venc_info(mediacodec_h mediacodec, int width, int height, int fps, int target_bits)
 230 {
 231         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 232         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 233         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 234
 235         int ret = mc_set_venc_info(handle->mc_handle, width, height, fps, target_bits);
 236
 237         if (ret != MEDIACODEC_ERROR_NONE) {
 238                 return __convert_error_code(ret, (char *)__FUNCTION__);
 239         } else {
 240                 handle->state = MEDIACODEC_STATE_IDLE;
 241                 return MEDIACODEC_ERROR_NONE;
 242         }
 243 }
 244
 245 int mediacodec_set_adec_info(mediacodec_h mediacodec, int samplerate, int channel, int bit)
 246 {
 247         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 248         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 249         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 250
 251         int ret = mc_set_adec_info(handle->mc_handle, samplerate, channel, bit);
 252
 253         if (ret != MEDIACODEC_ERROR_NONE) {
 254                 return __convert_error_code(ret, (char *)__FUNCTION__);
 255         } else {
 256                 handle->state = MEDIACODEC_STATE_IDLE;
 257                 return MEDIACODEC_ERROR_NONE;
 258         }
 259 }
 260
 261 int mediacodec_set_aenc_info(mediacodec_h mediacodec, int samplerate, int channel, int bit, int bitrate)
 262 {
 263         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 264         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 265         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 266
 267         int ret = mc_set_aenc_info(handle->mc_handle, samplerate, channel, bit, bitrate);
 268
 269         if (ret != MEDIACODEC_ERROR_NONE) {
 270                 return __convert_error_code(ret, (char *)__FUNCTION__);
 271         } else {
 272                 handle->state = MEDIACODEC_STATE_IDLE;
 273                 return MEDIACODEC_ERROR_NONE;
 274         }
 275 }
 276
 277 int mediacodec_configure_from_media_format(mediacodec_h mediacodec, media_format_h format, int flags)
 278 {
 279         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 280         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 281         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 282
 283         int ret = mc_configure(handle->mc_handle, format, flags);
 284
 285         if (ret != MEDIACODEC_ERROR_NONE) {
 286                 return __convert_error_code(ret, (char *)__FUNCTION__);
 287         } else {
 288                 handle->state = MEDIACODEC_STATE_IDLE;
 289                 return MEDIACODEC_ERROR_NONE;
 290         }
 291 }
 292
 293 int mediacodec_prepare(mediacodec_h mediacodec)
 294 {
 295         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 296         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 297         mc_handle_t *mc_handle = (mc_handle_t *) handle->mc_handle;
 298         int rm_ret = MM_RESOURCE_MANAGER_ERROR_NONE;
 299         mm_resource_manager_res_h resource;
 300         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 301
 302         if (mc_handle->is_hw && mc_handle->is_video) {
 303
 304                 if (handle->codec_resource) {
 305                         LOGE("Codec resource is tried to be acquired twice\n");
 306                         return MC_INTERNAL_ERROR;
 307                 }
 308
 309                 /*
 310                  * TODO
 311                  * Currently volume of requested resource is set to 1. Default
 312                  * capacity for video encoder/decoder is 1 too. The actual capacity
 313                  * should be set in mmfw-sysconf > mmfw_resource_manager.ini.
 314                  * If different encode/decode operation needs different volume of
 315                  * video encoder/decoder, '1' in the following
 316                  * mm_resource_manager_mark_for_acquire function should be set to
 317                  * corresponding value.
 318                  * If that value depends on platform where it's executed,
 319                  * MM_RESOURCE_MANAGER_RES_TYPE_COND_* and
 320                  * mm_resource_manager_get_res_type_volume() can be used.
 321                  * Additional info can be found in doxygen comments of mm_resource_manager.h
 322                  */
 323                 rm_ret = mm_resource_manager_mark_for_acquire(resource_manager,
 324                                 mc_handle->is_encoder ?
 325                                 MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_ENCODER :
 326                                 MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_DECODER,
 327                                 1, &resource);
 328                 if (rm_ret != MM_RESOURCE_MANAGER_ERROR_NONE)
 329                         switch (rm_ret) {
 330                         case MM_RESOURCE_MANAGER_ERROR_NOT_SUPPORTED:
 331                                 return MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE;
 332                         case MM_RESOURCE_MANAGER_ERROR_NOT_ENOUGH:
 333                                 return MEDIACODEC_ERROR_RESOURCE_OVERLOADED;
 334                         default:
 335                                 return MEDIACODEC_ERROR_INTERNAL;
 336                         }
 337
 338                 rm_ret = mm_resource_manager_commit(resource_manager);
 339                 if (rm_ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
 340                         mm_resource_manager_mark_for_release(resource_manager, resource);
 341                         switch (rm_ret) {
 342                         case MM_RESOURCE_MANAGER_ERROR_LOW_PRIORITY:
 343                                 return MEDIACODEC_ERROR_RESOURCE_OVERLOADED;
 344                         default:
 345                                 return MEDIACODEC_ERROR_INTERNAL;
 346                         }
 347                 }
 348
 349                 handle->codec_resource = resource;
 350         }
 351
 352         int ret = mc_prepare(handle->mc_handle);
 353
 354         if (ret != MEDIACODEC_ERROR_NONE) {
 355                 return __convert_error_code(ret, (char *)__FUNCTION__);
 356         } else {
 357                 handle->state = MEDIACODEC_STATE_READY;
 358                 return MEDIACODEC_ERROR_NONE;
 359         }
 360 }
 361
 362 int mediacodec_unprepare(mediacodec_h mediacodec)
 363 {
 364         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 365         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 366
 367         int ret = mc_unprepare(handle->mc_handle);
 368
 369         if (ret != MEDIACODEC_ERROR_NONE) {
 370                 return __convert_error_code(ret, (char *)__FUNCTION__);
 371         } else {
 372                 if (handle->codec_resource != NULL) {
 373                         mm_resource_manager_mark_for_release(resource_manager,
 374                                         handle->codec_resource);
 375                         handle->codec_resource = NULL;
 376                         mm_resource_manager_commit(resource_manager);
 377                 } else {
 378                         LOGD("No codec resource to release. Probably resource release cb called\n");
 379                 }
 380
 381                 handle->state = MEDIACODEC_STATE_IDLE;
 382                 return MEDIACODEC_ERROR_NONE;
 383         }
 384 }
 385
 386 int mediacodec_process_input(mediacodec_h mediacodec, media_packet_h inbuf, uint64_t timeOutUs)
 387 {
 388         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 389         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 390         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
 391
 392         int ret = mc_process_input(handle->mc_handle, inbuf, timeOutUs);
 393
 394         if (ret != MEDIACODEC_ERROR_NONE)
 395                 return __convert_error_code(ret, (char *)__FUNCTION__);
 396         else
 397                 return MEDIACODEC_ERROR_NONE;
 398 }
 399
 400 int mediacodec_get_output(mediacodec_h mediacodec, media_packet_h *outbuf, uint64_t timeOutUs)
 401 {
 402         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 403         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 404         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
 405
 406         int ret = mc_get_output(handle->mc_handle, outbuf, timeOutUs);
 407
 408         if (ret != MEDIACODEC_ERROR_NONE)
 409                 return __convert_error_code(ret, (char *)__FUNCTION__);
 410         else
 411                 return MEDIACODEC_ERROR_NONE;
 412 }
 413
 414 int mediacodec_flush_buffers(mediacodec_h mediacodec)
 415 {
 416         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 417         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 418
 419         int ret = mc_flush_buffers(handle->mc_handle);
 420
 421         if (ret != MEDIACODEC_ERROR_NONE)
 422                 return __convert_error_code(ret, (char *)__FUNCTION__);
 423         else
 424                 return MEDIACODEC_ERROR_NONE;
 425 }
 426
 427 int mediacodec_get_supported_type(mediacodec_h mediacodec, mediacodec_codec_type_e codec_type, bool encoder, int *support_type)
 428 {
 429         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 430         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 431         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 432
 433         int ret = mc_get_supported_type(handle->mc_handle, codec_type, encoder, support_type);
 434
 435         if (ret != MEDIACODEC_ERROR_NONE)
 436                 return __convert_error_code(ret, (char *)__FUNCTION__);
 437         else
 438                 handle->state = MEDIACODEC_STATE_IDLE;
 439
 440         return MEDIACODEC_ERROR_NONE;
 441 }
 442
 443 int mediacodec_set_input_buffer_used_cb(mediacodec_h mediacodec, mediacodec_input_buffer_used_cb callback, void *user_data)
 444 {
 445         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 446         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 447         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 448
 449         handle->empty_buffer_cb = callback;
 450         handle->empty_buffer_cb_userdata = user_data;
 451
 452         LOGD("set empty_buffer_cb(%p)", callback);
 453
 454         return MEDIACODEC_ERROR_NONE;
 455 }
 456
 457 int mediacodec_unset_input_buffer_used_cb(mediacodec_h mediacodec)
 458 {
 459         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 460         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 461
 462         handle->empty_buffer_cb = NULL;
 463         handle->empty_buffer_cb_userdata = NULL;
 464
 465         return MEDIACODEC_ERROR_NONE;
 466 }
 467
 468
 469 int mediacodec_set_output_buffer_available_cb(mediacodec_h mediacodec, mediacodec_output_buffer_available_cb callback, void *user_data)
 470 {
 471         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 472         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 473         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 474
 475         handle->fill_buffer_cb = callback;
 476         handle->fill_buffer_cb_userdata = user_data;
 477
 478         LOGD("set fill_buffer_cb(%p)", callback);
 479
 480         return MEDIACODEC_ERROR_NONE;
 481
 482 }
 483
 484 int mediacodec_unset_output_buffer_available_cb(mediacodec_h mediacodec)
 485 {
 486         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 487         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 488
 489         handle->fill_buffer_cb = NULL;
 490         handle->fill_buffer_cb_userdata = NULL;
 491
 492         return MEDIACODEC_ERROR_NONE;
 493 }
 494
 495 int mediacodec_set_error_cb(mediacodec_h mediacodec, mediacodec_error_cb callback, void *user_data)
 496 {
 497         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 498         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 499         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 500
 501         handle->error_cb = callback;
 502         handle->error_cb_userdata = user_data;
 503
 504         LOGD("set error_cb(%p)", callback);
 505
 506         return MEDIACODEC_ERROR_NONE;
 507
 508 }
 509
 510 int mediacodec_unset_error_cb(mediacodec_h mediacodec)
 511 {
 512         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 513         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 514
 515         handle->error_cb = NULL;
 516         handle->error_cb_userdata = NULL;
 517
 518         return MEDIACODEC_ERROR_NONE;
 519 }
 520
 521 int mediacodec_set_eos_cb(mediacodec_h mediacodec, mediacodec_eos_cb callback, void *user_data)
 522 {
 523         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 524         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 525         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 526
 527         handle->eos_cb = callback;
 528         handle->eos_cb_userdata = user_data;
 529
 530         LOGD("set eos_cb(%p)", callback);
 531
 532         return MEDIACODEC_ERROR_NONE;
 533
 534 }
 535
 536 int mediacodec_unset_eos_cb(mediacodec_h mediacodec)
 537 {
 538         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 539         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 540
 541         handle->eos_cb = NULL;
 542         handle->eos_cb_userdata = NULL;
 543
 544         return MEDIACODEC_ERROR_NONE;
 545 }
 546
 547 int mediacodec_set_buffer_status_cb(mediacodec_h mediacodec, mediacodec_buffer_status_cb callback, void *user_data)
 548 {
 549         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 550         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 551         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 552
 553         handle->buffer_status_cb = callback;
 554         handle->buffer_status_cb_userdata = user_data;
 555
 556         LOGD("set buffer_status_cb(%p)", callback);
 557
 558         return MEDIACODEC_ERROR_NONE;
 559
 560 }
 561
 562 int mediacodec_unset_buffer_status_cb(mediacodec_h mediacodec)
 563 {
 564         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 565         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 566
 567         handle->buffer_status_cb = NULL;
 568         handle->buffer_status_cb_userdata = NULL;
 569
 570         return MEDIACODEC_ERROR_NONE;
 571 }
 572
 573 int mediacodec_foreach_supported_codec(mediacodec_h mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
 574 {
 575         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 576         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 577
 578         handle->supported_codec_cb = callback;
 579         handle->supported_codec_cb_userdata = user_data;
 580
 581         LOGD("set supported_codec_cb(%p)", callback);
 582         int ret = _mediacodec_foreach_supported_codec(callback, handle);
 583
 584         if (ret != MEDIACODEC_ERROR_NONE)
 585                 return __convert_error_code(ret, (char *)__FUNCTION__);
 586         else
 587                 return MEDIACODEC_ERROR_NONE;
 588
 589         return MEDIACODEC_ERROR_NONE;
 590
 591 }
 592
 593 int mediacodec_get_packet_pool(mediacodec_h mediacodec, media_packet_pool_h *pkt_pool)
 594 {
 595         MEDIACODEC_INSTANCE_CHECK(mediacodec);
 596         mediacodec_s *handle = (mediacodec_s *)mediacodec;
 597         MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
 598         int ret = mc_get_packet_pool(handle->mc_handle, pkt_pool);
 599
 600         if (ret != MEDIACODEC_ERROR_NONE)
 601                 return MEDIACODEC_ERROR_INVALID_OPERATION;
 602         else
 603                 return MEDIACODEC_ERROR_NONE;
 604 }
 605
 606 static gboolean __mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data)
 607 {
 608         if (user_data == NULL || pkt == NULL)
 609                 return 0;
 610
 611         mediacodec_s *handle = (mediacodec_s *)user_data;
 612
 613         if (handle->empty_buffer_cb)
 614                 ((mediacodec_input_buffer_used_cb)handle->empty_buffer_cb)(pkt, handle->empty_buffer_cb_userdata);
 615
 616         return 1;
 617 }
 618
 619 static gboolean  __mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data)
 620 {
 621         if (user_data == NULL || pkt == NULL)
 622                 return 0;
 623
 624         mediacodec_s *handle = (mediacodec_s *)user_data;
 625
 626         if (handle->fill_buffer_cb)
 627                 ((mediacodec_output_buffer_available_cb)handle->fill_buffer_cb)(pkt, handle->fill_buffer_cb_userdata);
 628
 629         return 1;
 630 }
 631
 632 static gboolean __mediacodec_error_cb(mediacodec_error_e error, void *user_data)
 633 {
 634         if (user_data == NULL)
 635                 return 0;
 636
 637         mediacodec_s *handle = (mediacodec_s *)user_data;
 638
 639         if (handle->error_cb)
 640                 ((mediacodec_error_cb)handle->error_cb)(error, handle->error_cb_userdata);
 641
 642         return 1;
 643 }
 644
 645 static gboolean __mediacodec_eos_cb(void *user_data)
 646 {
 647         if (user_data == NULL)
 648                 return 0;
 649
 650         mediacodec_s *handle = (mediacodec_s *)user_data;
 651
 652         if (handle->eos_cb)
 653                 ((mediacodec_eos_cb)handle->eos_cb)(handle->eos_cb_userdata);
 654
 655         return 1;
 656 }
 657
 658 static gboolean __mediacodec_supported_codec_cb(mediacodec_codec_type_e codec_type, void *user_data)
 659 {
 660         if (user_data == NULL)
 661                 return 0;
 662
 663         mediacodec_s *handle = (mediacodec_s *)user_data;
 664
 665         if (handle->supported_codec_cb)
 666                 return ((mediacodec_supported_codec_cb)handle->supported_codec_cb)(codec_type, handle->supported_codec_cb_userdata);
 667
 668         return false;
 669 }
 670
 671 static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data)
 672 {
 673         if (user_data == NULL)
 674                 return 0;
 675
 676         mediacodec_s *handle = (mediacodec_s *)user_data;
 677
 678         if (handle->buffer_status_cb)
 679                 ((mediacodec_buffer_status_cb)handle->buffer_status_cb)(status, handle->buffer_status_cb_userdata);
 680
 681         return 1;
 682 }
 683
 684
 685 static int __mediacodec_resource_release_cb(mm_resource_manager_h rm,
 686                 mm_resource_manager_res_h resource_h, void *user_data)
 687 {
 688         int i;
 689         mediacodec_s *handle;
 690
 691         g_mutex_lock(&mediacodec_handles_lock);
 692         for (i = 0; i < mediacodec_handles->len; i++) {
 693                 handle = g_ptr_array_index(mediacodec_handles, i);
 694                 if (handle->codec_resource == resource_h) {
 695                         /*
 696                          * TODO
 697                          * The resource release cb is asynchronous, so mediacodec_unprepare might be
 698                          * called in this thread and in the main thread at the same time.
 699                          * Mutex lock/unlock should be added in the body of mediacodec_unprepare() to
 700                          * avoid the race condition.
 701                          */
 702                         handle->codec_resource = NULL;
 703                         mediacodec_unprepare((mediacodec_h)handle);
 704                         __mediacodec_error_cb(MEDIACODEC_ERROR_RESOURCE_OVERLOADED, handle);
 705                         break;
 706                 }
 707         }
 708         g_mutex_unlock(&mediacodec_handles_lock);
 709
 710         return FALSE;
 711 }
 712
 713 static void __mediacodec_init_lib()
 714 {
 715         mediacodec_handles = g_ptr_array_sized_new(MC_PREALLOCATED_HANDLE_ARRAY_SIZE);
 716         mm_resource_manager_create(MM_RESOURCE_MANAGER_APP_CLASS_MEDIA,
 717                         __mediacodec_resource_release_cb, NULL, &resource_manager);
 718 }
 719
 720 static void __mediacodec_deinit_lib()
 721 {
 722         if (resource_manager != NULL)
 723                 mm_resource_manager_destroy(resource_manager);
 724         g_ptr_array_unref(mediacodec_handles);
 725 }