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