Merge branch 'tizen_line_coverage' into tizen

[platform/core/api/mediacodec.git] / src / media_codec.c

diff --git a/src/media_codec.c b/src/media_codec.c
index a78a76b..cff7fc1 100644 (file)
--- a/src/media_codec.c
+++ b/src/media_codec.c
@@ -26,9 +26,11 @@
 
 #define MC_PREALLOCATED_HANDLE_ARRAY_SIZE 16
 
-static mm_resource_manager_h resource_manager;
-static GPtrArray *mediacodec_handles;
-static GMutex mediacodec_handles_lock;
+#ifdef USE_MM_RESOURCE_MANAGER
+static mm_resource_manager_h g_mc_resource_manager;
+static GPtrArray *g_mediacodec_handles;
+static GMutex g_mediacodec_lock;
+#endif
 
 static gboolean  __mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data);
 static gboolean __mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data);
@@ -36,10 +38,12 @@ static gboolean __mediacodec_error_cb(mediacodec_error_e error, void *user_data)
 static gboolean __mediacodec_eos_cb(void *user_data);
 static gboolean __mediacodec_supported_codec_cb(mediacodec_codec_type_e codec_type, void *user_data);
 static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data);
+#ifdef USE_MM_RESOURCE_MANAGER
 static void __mediacodec_init_lib() __attribute__((constructor));
 static void __mediacodec_deinit_lib() __attribute__((destructor));
 static int __mediacodec_resource_release_cb(mm_resource_manager_h rm,
                mm_resource_manager_res_h resource_h, void *user_data);
+#endif
 
 /*
  * Internal Implementation
@@ -131,8 +135,21 @@ int mediacodec_create(mediacodec_h *mediacodec)
 
        LOGD("mediacodec_create..");
 
-       if (resource_manager == NULL)
-               return MEDIACODEC_ERROR_INTERNAL;
+#ifdef USE_MM_RESOURCE_MANAGER
+       g_mutex_lock(&g_mediacodec_lock);
+
+       if (!g_mc_resource_manager) {
+               int mm_ret = mm_resource_manager_create(MM_RESOURCE_MANAGER_APP_CLASS_MEDIA,
+                       __mediacodec_resource_release_cb, NULL, &g_mc_resource_manager);
+               if (mm_ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+                       g_mutex_unlock(&g_mediacodec_lock);
+                       LOGE("mm_resource_manager_create failed 0x%x", mm_ret);
+                       return MEDIACODEC_ERROR_INTERNAL;
+               }
+       }
+
+       g_mutex_unlock(&g_mediacodec_lock);
+#endif
 
        handle = (mediacodec_s *)malloc(sizeof(mediacodec_s));
        if (handle != NULL) {
@@ -164,9 +181,11 @@ int mediacodec_create(mediacodec_h *mediacodec)
        mc_set_buffer_status_cb(handle->mc_handle, (mediacodec_buffer_status_cb)__mediacodec_buffer_status_cb, handle);
        mc_set_supported_codec_cb(handle->mc_handle, (mediacodec_supported_codec_cb)__mediacodec_supported_codec_cb, handle);
 
-       g_mutex_lock(&mediacodec_handles_lock);
-       g_ptr_array_insert(mediacodec_handles, -1, *mediacodec);
-       g_mutex_unlock(&mediacodec_handles_lock);
+#ifdef USE_MM_RESOURCE_MANAGER
+       g_mutex_lock(&g_mediacodec_lock);
+       g_ptr_array_insert(g_mediacodec_handles, -1, *mediacodec);
+       g_mutex_unlock(&g_mediacodec_lock);
+#endif
 
        return MEDIACODEC_ERROR_NONE;
 
@@ -183,9 +202,11 @@ int mediacodec_destroy(mediacodec_h mediacodec)
                LOGD("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION); //LCOV_EXCL_LINE
                return MEDIACODEC_ERROR_INVALID_OPERATION;
        } else {
-               g_mutex_lock(&mediacodec_handles_lock);
-               g_ptr_array_remove_fast(mediacodec_handles, mediacodec);
-               g_mutex_unlock(&mediacodec_handles_lock);
+#ifdef USE_MM_RESOURCE_MANAGER
+               g_mutex_lock(&g_mediacodec_lock);
+               g_ptr_array_remove_fast(g_mediacodec_handles, mediacodec);
+               g_mutex_unlock(&g_mediacodec_lock);
+#endif
 
                handle->state = MEDIACODEC_STATE_NONE;
                free(handle);
@@ -294,11 +315,14 @@ int mediacodec_prepare(mediacodec_h mediacodec)
 {
        MEDIACODEC_INSTANCE_CHECK(mediacodec);
        mediacodec_s *handle = (mediacodec_s *)mediacodec;
+#ifdef USE_MM_RESOURCE_MANAGER
        mc_handle_t *mc_handle = (mc_handle_t *) handle->mc_handle;
        int rm_ret = MM_RESOURCE_MANAGER_ERROR_NONE;
        mm_resource_manager_res_h resource;
+#endif
        MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
 
+#ifdef USE_MM_RESOURCE_MANAGER
        if (mc_handle->is_hw && mc_handle->is_video) {
 
                if (handle->codec_resource) {
@@ -321,14 +345,14 @@ int mediacodec_prepare(mediacodec_h mediacodec)
                 * Additional info can be found in doxygen comments of mm_resource_manager.h
                 */
 //LCOV_EXCL_START
-               rm_ret = mm_resource_manager_mark_for_acquire(resource_manager,
+               rm_ret = mm_resource_manager_mark_for_acquire(g_mc_resource_manager,
                                mc_handle->is_encoder ?
                                MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_ENCODER :
                                MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_DECODER,
                                1, &resource);
-               if (rm_ret != MM_RESOURCE_MANAGER_ERROR_NONE)
-                       switch (rm_ret) {
+               if (rm_ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
                        LOGE("Failed to acquire resource manager %x", rm_ret);
+                       switch (rm_ret) {
                        case MM_RESOURCE_MANAGER_ERROR_NOT_SUPPORTED:
                                return MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE;
                        case MM_RESOURCE_MANAGER_ERROR_NOT_ENOUGH:
@@ -336,16 +360,18 @@ int mediacodec_prepare(mediacodec_h mediacodec)
                        default:
                                return MEDIACODEC_ERROR_INTERNAL;
                        }
+               }
 
-               rm_ret = mm_resource_manager_commit(resource_manager);
+               rm_ret = mm_resource_manager_commit(g_mc_resource_manager);
                if (rm_ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
-                       mm_resource_manager_mark_for_release(resource_manager, resource);
+                       mm_resource_manager_mark_for_release(g_mc_resource_manager, resource);
                        LOGE("Failed to commit resource manager : %x", rm_ret);
                        return MEDIACODEC_ERROR_INTERNAL;
                }
                handle->codec_resource = resource;
 //LCOV_EXCL_STOP
        }
+#endif
 
        int ret = mc_prepare(handle->mc_handle);
 
@@ -361,21 +387,24 @@ int mediacodec_unprepare(mediacodec_h mediacodec)
 {
        MEDIACODEC_INSTANCE_CHECK(mediacodec);
        mediacodec_s *handle = (mediacodec_s *)mediacodec;
+#ifdef USE_MM_RESOURCE_MANAGER
        int rm_ret = MM_RESOURCE_MANAGER_ERROR_NONE;
+#endif
 
        int ret = mc_unprepare(handle->mc_handle);
 
        if (ret != MEDIACODEC_ERROR_NONE) {
                return __convert_error_code(ret, (char *)__FUNCTION__);
        } else {
+#ifdef USE_MM_RESOURCE_MANAGER
                if (handle->codec_resource != NULL) {
 //LCOV_EXCL_START
-                       mm_resource_manager_mark_for_release(resource_manager,
+                       mm_resource_manager_mark_for_release(g_mc_resource_manager,
                                        handle->codec_resource);
                        handle->codec_resource = NULL;
-                       rm_ret = mm_resource_manager_commit(resource_manager);
+                       rm_ret = mm_resource_manager_commit(g_mc_resource_manager);
                        if (rm_ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
-                               mm_resource_manager_mark_for_release(resource_manager, handle->codec_resource);
+                               mm_resource_manager_mark_for_release(g_mc_resource_manager, handle->codec_resource);
                                switch (rm_ret) {
                                case MM_RESOURCE_MANAGER_ERROR_LOW_PRIORITY:
                                        return MEDIACODEC_ERROR_RESOURCE_OVERLOADED;
@@ -387,6 +416,7 @@ int mediacodec_unprepare(mediacodec_h mediacodec)
                } else {
                        LOGD("No codec resource to release. Probably resource release cb called\n");
                }
+#endif
 
                handle->state = MEDIACODEC_STATE_IDLE;
                return MEDIACODEC_ERROR_NONE;
@@ -691,6 +721,7 @@ static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *
        return 1;
 }
 
+#ifdef USE_MM_RESOURCE_MANAGER
 //LCOV_EXCL_START
 static int __mediacodec_resource_release_cb(mm_resource_manager_h rm,
                mm_resource_manager_res_h resource_h, void *user_data)
@@ -698,9 +729,9 @@ static int __mediacodec_resource_release_cb(mm_resource_manager_h rm,
        int i;
        mediacodec_s *handle;
 
-       g_mutex_lock(&mediacodec_handles_lock);
-       for (i = 0; i < mediacodec_handles->len; i++) {
-               handle = g_ptr_array_index(mediacodec_handles, i);
+       g_mutex_lock(&g_mediacodec_lock);
+       for (i = 0; i < g_mediacodec_handles->len; i++) {
+               handle = g_ptr_array_index(g_mediacodec_handles, i);
                if (handle->codec_resource == resource_h) {
                        /*
                         * TODO
@@ -715,26 +746,34 @@ static int __mediacodec_resource_release_cb(mm_resource_manager_h rm,
                        break;
                }
        }
-       g_mutex_unlock(&mediacodec_handles_lock);
+       g_mutex_unlock(&g_mediacodec_lock);
 
        return FALSE;
 }
 //LCOV_EXCL_STOP
 
+
 static void __mediacodec_init_lib()
 {
-       mediacodec_handles = g_ptr_array_sized_new(MC_PREALLOCATED_HANDLE_ARRAY_SIZE);
+       LOGD("START");
 
-       if (MM_RESOURCE_MANAGER_ERROR_NONE != mm_resource_manager_create(MM_RESOURCE_MANAGER_APP_CLASS_MEDIA,
-                       __mediacodec_resource_release_cb, NULL, &resource_manager)) {
-               LOGE("Failed to initialize resource manager");  //LCOV_EXCL_LINE
-               g_ptr_array_unref(mediacodec_handles);
-       }
+       g_mutex_init(&g_mediacodec_lock);
+       g_mediacodec_handles = g_ptr_array_sized_new(MC_PREALLOCATED_HANDLE_ARRAY_SIZE);
+
+       LOGD("DONE");
 }
 
 static void __mediacodec_deinit_lib()
 {
-       if (resource_manager != NULL)
-               mm_resource_manager_destroy(resource_manager);
-       g_ptr_array_unref(mediacodec_handles);
+       LOGD("START");
+
+       if (g_mc_resource_manager != NULL)
+               mm_resource_manager_destroy(g_mc_resource_manager);
+
+       g_ptr_array_unref(g_mediacodec_handles);
+       g_mutex_clear(&g_mediacodec_lock);
+
+       LOGD("DONE");
 }
+#endif
+