[Release version 0.10.66] Update code for mrp control

Change-Id: Ia4344dc2b70da8373c286217dd64743a3a1dadbc
Signed-off-by: Jeongmo Yang <jm80.yang@samsung.com>

diff --git a/packaging/libmm-camcorder.spec b/packaging/libmm-camcorder.spec
index 453ff0f..ef054c6 100644 (file)
--- a/packaging/libmm-camcorder.spec
+++ b/packaging/libmm-camcorder.spec
@@ -1,6 +1,6 @@
 Name:       libmm-camcorder
 Summary:    Camera and recorder library
-Version:    0.10.65
+Version:    0.10.66
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0

diff --git a/src/include/mm_camcorder_resource.h b/src/include/mm_camcorder_resource.h
index 04aa39b..d399a1c 100644 (file)
--- a/src/include/mm_camcorder_resource.h
+++ b/src/include/mm_camcorder_resource.h
@@ -41,13 +41,14 @@ typedef struct {
        bool is_connected;
        void *user_data;
        int acquire_count;
+       int acquire_remain;
 } MMCamcorderResourceManager;
 
 int _mmcamcorder_resource_manager_init(MMCamcorderResourceManager *resource_manager, void *user_data);
+int _mmcamcorder_resource_create_resource_set(MMCamcorderResourceManager *resource_manager);
 int _mmcamcorder_resource_manager_prepare(MMCamcorderResourceManager *resource_manager, MMCamcorderResourceType resource_type);
 int _mmcamcorder_resource_manager_acquire(MMCamcorderResourceManager *resource_manager);
 int _mmcamcorder_resource_manager_release(MMCamcorderResourceManager *resource_manager);
-int _mmcamcorder_resource_manager_unprepare(MMCamcorderResourceManager *resource_manager);
 int _mmcamcorder_resource_manager_deinit(MMCamcorderResourceManager *resource_manager);
 
 #ifdef __cplusplus

diff --git a/src/mm_camcorder_internal.c b/src/mm_camcorder_internal.c
index 076f2ac..c14a0d1 100644 (file)
--- a/src/mm_camcorder_internal.c
+++ b/src/mm_camcorder_internal.c
@@ -114,9 +114,6 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
        const char *ConfCtrlFile = NULL;
        mmf_camcorder_t *hcamcorder = NULL;
        type_element *EvasSurfaceElement = NULL;
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
-       gint64 end_time = 0;
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 
        _mmcam_dbg_log("Entered");
 
@@ -521,6 +518,8 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
        _MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
 
        if (hcamcorder->resource_manager.is_connected == FALSE) {
+               gint64 end_time = 0;
+
                /* wait for resource manager connected */
                _mmcam_dbg_log("resource manager is not connected. wait for signal...");
 
@@ -536,6 +535,11 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
                }
        }
 
+       ret = _mmcamcorder_resource_create_resource_set(&hcamcorder->resource_manager);
+       if (ret != MM_ERROR_NONE) {
+               goto _ERR_DEFAULT_VALUE_INIT;
+       }
+
        _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
 #endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 
@@ -720,9 +724,13 @@ int _mmcamcorder_destroy(MMHandleType handle)
 
 #ifdef _MMCAMCORDER_MURPHY_SUPPORT
        /* de-initialize resource manager */
+       _MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
+
        ret = _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager);
        if (ret != MM_ERROR_NONE)
                _mmcam_dbg_err("failed to de-initialize resource manager 0x%x", ret);
+
+       _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
 #endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 
        /* Remove idle function which is not called yet */
@@ -1130,9 +1138,6 @@ int _mmcamcorder_realize(MMHandleType handle)
 
        if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) {
                int dpm_camera_state = DPM_ALLOWED;
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
-               gint64 end_time = 0;
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 
                /* check camera policy from DPM */
                if (hcamcorder->dpm_policy) {
@@ -1182,12 +1187,12 @@ int _mmcamcorder_realize(MMHandleType handle)
 
                        _mmcam_dbg_err("could not acquire resources");
 
-                       _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager);
-
                        goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
                }
 
-               if (hcamcorder->resource_manager.acquire_count > 0) {
+               if (hcamcorder->resource_manager.acquire_remain > 0) {
+                       gint64 end_time = 0;
+
                        _mmcam_dbg_warn("wait for resource state change");
 
                        /* wait for resource state change */
@@ -1254,10 +1259,6 @@ _ERR_CAMCORDER_CMD:
                } else if (ret_resource != MM_ERROR_NONE) {
                        _mmcam_dbg_err("failed to release resource, ret_resource(0x%x)", ret_resource);
                }
-
-               ret_resource = _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager);
-               if (ret_resource != MM_ERROR_NONE)
-                       _mmcam_dbg_err("failed to unprepare resource manager, ret_resource(0x%x)", ret_resource);
        }
 #endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 
@@ -1350,7 +1351,13 @@ int _mmcamcorder_unrealize(MMHandleType handle)
        }
 
 #ifdef _MMCAMCORDER_MURPHY_SUPPORT
-       if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) {
+       if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE &&
+               hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_RM) {
+               gint64 end_time = 0;
+
+               _mmcam_dbg_log("lock resource");
+               _MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
+
                /* release resource */
                ret = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
                if (ret == MM_ERROR_RESOURCE_INVALID_STATE) {
@@ -1359,14 +1366,24 @@ int _mmcamcorder_unrealize(MMHandleType handle)
                } else if (ret != MM_ERROR_NONE) {
                        _mmcam_dbg_err("failed to release resource, ret(0x%x)", ret);
                        ret = MM_ERROR_CAMCORDER_INTERNAL;
+
+                       _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
+                       _mmcam_dbg_log("unlock resource");
+
                        goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
                }
-               _MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
-               ret = _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager);
+
+               if (hcamcorder->resource_manager.acquire_remain < hcamcorder->resource_manager.acquire_count) {
+                       /* wait for resource release */
+                       _mmcam_dbg_log("resource is not released all. wait for signal...");
+
+                       end_time = g_get_monotonic_time() + (__MMCAMCORDER_RESOURCE_WAIT_TIME * G_TIME_SPAN_SECOND);
+
+                       _MMCAMCORDER_RESOURCE_WAIT_UNTIL(hcamcorder, end_time);
+               }
 
                _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
-               if (ret != MM_ERROR_NONE)
-                       _mmcam_dbg_err("failed to unprepare resource manager, ret(0x%x)", ret);
+               _mmcam_dbg_log("unlock resource");
        }
 #endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 

diff --git a/src/mm_camcorder_resource.c b/src/mm_camcorder_resource.c
index aea6271..baea539 100644 (file)
--- a/src/mm_camcorder_resource.c
+++ b/src/mm_camcorder_resource.c
@@ -165,14 +165,31 @@ static void __mmcamcorder_resource_set_state_callback(mrp_res_context_t *cx, con
                                res->name, __mmcamcorder_resource_state_to_str(res->state));
 
                        if (res->state == MRP_RES_RESOURCE_ACQUIRED) {
-                               camcorder->resource_manager.acquire_count--;
+                               camcorder->resource_manager.acquire_remain--;
 
-                               if (camcorder->resource_manager.acquire_count <= 0) {
+                               if (camcorder->resource_manager.acquire_remain <= 0) {
                                        _mmcam_dbg_log("send signal - resource acquire done");
                                        _MMCAMCORDER_RESOURCE_SIGNAL(camcorder);
                                } else {
                                        _mmcam_dbg_warn("remained acquire count %d",
-                                               camcorder->resource_manager.acquire_count);
+                                               camcorder->resource_manager.acquire_remain);
+                               }
+                       } else if (res->state == MRP_RES_RESOURCE_LOST) {
+                               camcorder->resource_manager.acquire_remain++;
+
+                               if (camcorder->resource_manager.acquire_remain >= camcorder->resource_manager.acquire_count) {
+                                       _mmcam_dbg_log("resource release done");
+
+                                       if (camcorder->state > MM_CAMCORDER_STATE_NULL) {
+                                               _mmcam_dbg_log("send resource signal");
+                                               _MMCAMCORDER_RESOURCE_SIGNAL(camcorder);
+                                       } else {
+                                               _mmcam_dbg_log("skip resource signal - state %d", camcorder->state);
+                                       }
+                               } else {
+                                       _mmcam_dbg_warn("acquired %d, lost %d",
+                                               camcorder->resource_manager.acquire_count,
+                                               camcorder->resource_manager.acquire_remain);
                                }
                        }
                }
@@ -237,7 +254,7 @@ static void __mmcamcorder_resource_release_cb(mrp_res_context_t *cx, const mrp_r
        return;
 }
 
-static int __mmcamcorder_resource_create_resource_set(MMCamcorderResourceManager *resource_manager)
+int _mmcamcorder_resource_create_resource_set(MMCamcorderResourceManager *resource_manager)
 {
        if (resource_manager->rset) {
                _mmcam_dbg_err(" - resource set was already created");
@@ -255,6 +272,8 @@ static int __mmcamcorder_resource_create_resource_set(MMCamcorderResourceManager
        if (!mrp_res_set_autorelease(TRUE, resource_manager->rset))
                _mmcam_dbg_warn(" - could not set autorelease flag!");
 
+       _mmcam_dbg_log("done");
+
        return MM_ERROR_NONE;
 }
 
@@ -271,6 +290,7 @@ static int __mmcamcorder_resource_include_resource(MMCamcorderResourceManager *r
        }
 
        resource_manager->acquire_count++;
+       resource_manager->acquire_remain = resource_manager->acquire_count;
 
        _mmcam_dbg_log(" - count[%d] include resource[%s]",
                resource_manager->acquire_count, resource_name);
@@ -302,39 +322,32 @@ int _mmcamcorder_resource_manager_init(MMCamcorderResourceManager *resource_mana
        MMCAMCORDER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
 
        resource_manager->mloop = mrp_mainloop_glib_get(g_main_loop_new(NULL, TRUE));
-       if (resource_manager->mloop) {
-               resource_manager->context = mrp_res_create(resource_manager->mloop, __mmcamcorder_resource_state_callback, user_data);
-               if (resource_manager->context == NULL) {
-                       _mmcam_dbg_err(" - could not get context for resource manager");
-                       mrp_mainloop_destroy(resource_manager->mloop);
-                       resource_manager->mloop = NULL;
-                       return MM_ERROR_RESOURCE_INTERNAL;
-               }
-               resource_manager->user_data = user_data;
-       } else {
-               _mmcam_dbg_err("- could not get mainloop for resource manager");
+       if (!resource_manager->mloop) {
+               _mmcam_dbg_err("failed to get mainloop for mrp");
                return MM_ERROR_RESOURCE_INTERNAL;
        }
 
+       resource_manager->context = mrp_res_create(resource_manager->mloop, __mmcamcorder_resource_state_callback, user_data);
+       if (!resource_manager->context) {
+               _mmcam_dbg_err("could not get context for mrp");
+               mrp_mainloop_destroy(resource_manager->mloop);
+               resource_manager->mloop = NULL;
+               return MM_ERROR_RESOURCE_INTERNAL;
+       }
+
+       resource_manager->user_data = user_data;
+
+       _mmcam_dbg_log("done");
+
        return MM_ERROR_NONE;
 }
 
 int _mmcamcorder_resource_manager_prepare(MMCamcorderResourceManager *resource_manager, MMCamcorderResourceType resource_type)
 {
-       int ret = MM_ERROR_NONE;
        MMCAMCORDER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
        MMCAMCORDER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager);
 
-       if (!resource_manager->rset)
-               ret = __mmcamcorder_resource_create_resource_set(resource_manager);
-
-       if (ret == MM_ERROR_NONE) {
-               ret = __mmcamcorder_resource_include_resource(resource_manager, mm_camcorder_resource_str[resource_type]);
-       } else {
-               _mmcam_dbg_err("failed to create resource set 0x%x", ret);
-       }
-
-       return ret;
+       return __mmcamcorder_resource_include_resource(resource_manager, mm_camcorder_resource_str[resource_type]);
 }
 
 int _mmcamcorder_resource_manager_acquire(MMCamcorderResourceManager *resource_manager)
@@ -391,28 +404,10 @@ int _mmcamcorder_resource_manager_release(MMCamcorderResourceManager *resource_m
        return ret;
 }
 
-int _mmcamcorder_resource_manager_unprepare(MMCamcorderResourceManager *resource_manager)
-{
-       int ret = MM_ERROR_NONE;
-       MMCAMCORDER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
-       MMCAMCORDER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager);
-
-       if (resource_manager->rset == NULL) {
-               _mmcam_dbg_err("- could not unprepare for resource_manager, _mmcamcorder_resource_manager_prepare() first");
-               ret = MM_ERROR_RESOURCE_INVALID_STATE;
-       } else {
-               mrp_res_delete_resource_set(resource_manager->rset);
-               resource_manager->rset = NULL;
-               _mmcam_dbg_log("delete resource set done");
-       }
-
-       return ret;
-}
 
 int _mmcamcorder_resource_manager_deinit(MMCamcorderResourceManager *resource_manager)
 {
        MMCAMCORDER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
-       MMCAMCORDER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager);
 
        if (resource_manager->rset) {
                if (resource_manager->rset->state == MRP_RES_RESOURCE_ACQUIRED) {