X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_internal.c;h=0baf5d9ff341fe4d823731ac7c9ef2cfabcadc32;hb=b9c04567203ab4ac2bb98db26ac2a697da3cb2e0;hp=990f8d4dc5d180415e77539e04a4258f7edd18c1;hpb=bc1aa0fd5892ccb5f4aeeaa5e92f849d12478e69;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git diff --git a/src/mm_camcorder_internal.c b/src/mm_camcorder_internal.c index 990f8d4..0baf5d9 100644 --- a/src/mm_camcorder_internal.c +++ b/src/mm_camcorder_internal.c @@ -42,16 +42,13 @@ #include #include +#ifdef _MMCAMCORDER_MURPHY_SUPPORT #include +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ -/*--------------------------------------------------------------------------------------- -| GLOBAL VARIABLE DEFINITIONS for internal | ----------------------------------------------------------------------------------------*/ -struct sigaction mm_camcorder_int_old_action; -struct sigaction mm_camcorder_abrt_old_action; -struct sigaction mm_camcorder_segv_old_action; -struct sigaction mm_camcorder_term_old_action; -struct sigaction mm_camcorder_sys_old_action; +#ifdef _MMCAMCORDER_RM_SUPPORT +#include +#endif /* _MMCAMCORDER_RM_SUPPORT */ /*--------------------------------------------------------------------------------------- | LOCAL VARIABLE DEFINITIONS for internal | @@ -63,6 +60,9 @@ struct sigaction mm_camcorder_sys_old_action; #define __MMCAMCORDER_SOUND_WAIT_TIMEOUT 3 #define __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN 64 +#define DPM_ALLOWED 1 +#define DPM_DISALLOWED 0 + /*--------------------------------------------------------------------------------------- | LOCAL FUNCTION PROTOTYPES: | @@ -78,13 +78,14 @@ static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int cod static gint __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMessage *message , GError *error); static gboolean __mmcamcorder_handle_gst_warning(MMHandleType handle, GstMessage *message, GError *error); +#ifdef _MMCAMCORDER_RM_SUPPORT +rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src, + rm_device_request_s *info, void *cb_data); +#endif /* _MMCAMCORDER_RM_SUPPORT */ #ifdef _MMCAMCORDER_USE_SET_ATTR_CB static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data); #endif /* _MMCAMCORDER_USE_SET_ATTR_CB */ -static void __mm_camcorder_signal_handler(int signo); -static void _mmcamcorder_constructor() __attribute__((constructor)); - /*======================================================================================= | FUNCTION DEFINITIONS | =======================================================================================*/ @@ -92,66 +93,6 @@ static void _mmcamcorder_constructor() __attribute__((constructor)); | GLOBAL FUNCTION DEFINITIONS: | ---------------------------------------------------------------------------------------*/ - -static void __mm_camcorder_signal_handler(int signo) -{ - pid_t my_pid = getpid(); - - _mmcam_dbg_warn("start - signo [%d], pid [%d]", signo, my_pid); - - /* call old signal handler */ - switch (signo) { - case SIGINT: - sigaction(SIGINT, &mm_camcorder_int_old_action, NULL); - raise(signo); - break; - case SIGABRT: - sigaction(SIGABRT, &mm_camcorder_abrt_old_action, NULL); - raise(signo); - break; - case SIGSEGV: - sigaction(SIGSEGV, &mm_camcorder_segv_old_action, NULL); - raise(signo); - break; - case SIGTERM: - sigaction(SIGTERM, &mm_camcorder_term_old_action, NULL); - raise(signo); - break; - case SIGSYS: - sigaction(SIGSYS, &mm_camcorder_sys_old_action, NULL); - raise(signo); - break; - default: - break; - } - - _mmcam_dbg_warn("done"); - - return; -} - - -static void _mmcamcorder_constructor() -{ - struct sigaction mm_camcorder_action; - mm_camcorder_action.sa_handler = __mm_camcorder_signal_handler; - mm_camcorder_action.sa_flags = SA_NOCLDSTOP; - - _mmcam_dbg_warn("start"); - - sigemptyset(&mm_camcorder_action.sa_mask); - - sigaction(SIGINT, &mm_camcorder_action, &mm_camcorder_int_old_action); - sigaction(SIGABRT, &mm_camcorder_action, &mm_camcorder_abrt_old_action); - sigaction(SIGSEGV, &mm_camcorder_action, &mm_camcorder_segv_old_action); - sigaction(SIGTERM, &mm_camcorder_action, &mm_camcorder_term_old_action); - sigaction(SIGSYS, &mm_camcorder_action, &mm_camcorder_sys_old_action); - - _mmcam_dbg_warn("done"); - - return; -} - /* Internal command functions {*/ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) { @@ -191,6 +132,7 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) g_mutex_init(&(hcamcorder->mtsafe).lock); g_cond_init(&(hcamcorder->mtsafe).cond); g_mutex_init(&(hcamcorder->mtsafe).cmd_lock); + g_cond_init(&(hcamcorder->mtsafe).cmd_cond); g_mutex_init(&(hcamcorder->mtsafe).asm_lock); g_mutex_init(&(hcamcorder->mtsafe).state_lock); g_mutex_init(&(hcamcorder->mtsafe).gst_state_lock); @@ -261,12 +203,9 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) } /* Get Camera Configure information from Camcorder INI file */ - _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &hcamcorder->conf_main); - - if (!(hcamcorder->conf_main)) { - _mmcam_dbg_err( "Failed to get configure(main) info." ); - - ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE; + ret = _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &hcamcorder->conf_main); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("Failed to get configure(main) info."); goto _ERR_DEFAULT_VALUE_INIT; } @@ -278,6 +217,19 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) goto _ERR_DEFAULT_VALUE_INIT; } + /* get DPM context for camera/microphone restriction */ + hcamcorder->dpm_context = dpm_context_create(); + if (hcamcorder->dpm_context) { + hcamcorder->dpm_policy = dpm_context_acquire_restriction_policy(hcamcorder->dpm_context); + if (hcamcorder->dpm_policy == NULL) { + _mmcam_dbg_err("dpm_context_acquire_restriction_policy failed"); + dpm_context_destroy(hcamcorder->dpm_context); + hcamcorder->dpm_context = NULL; + } + } + + _mmcam_dbg_warn("DPM context %p, policy %p", hcamcorder->dpm_context, hcamcorder->dpm_policy); + if (info->videodev_type != MM_VIDEO_DEVICE_NONE) { _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, @@ -309,17 +261,15 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) _mmcam_dbg_log("videodev_type : [%d], ConfCtrlPath : [%s]", info->videodev_type, ConfCtrlFile); - _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_CTRL, ConfCtrlFile, &hcamcorder->conf_ctrl); + ret = _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_CTRL, ConfCtrlFile, &hcamcorder->conf_ctrl); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("Failed to get configure(control) info."); + goto _ERR_DEFAULT_VALUE_INIT; + } /* _mmcamcorder_conf_print_info(&hcamcorder->conf_main); _mmcamcorder_conf_print_info(&hcamcorder->conf_ctrl); */ - if (!(hcamcorder->conf_ctrl)) { - _mmcam_dbg_err( "Failed to get configure(control) info." ); - ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE; - goto _ERR_DEFAULT_VALUE_INIT; - } - ret = _mmcamcorder_init_convert_table((MMHandleType)hcamcorder); if (ret != MM_ERROR_NONE) { _mmcam_dbg_warn("converting table initialize error!!"); @@ -327,7 +277,7 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) goto _ERR_DEFAULT_VALUE_INIT; } - ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, MM_CAMCONVERT_CATEGORY_CAMERA|MM_CAMCONVERT_CATEGORY_DISPLAY); + ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, MM_CAMCONVERT_CATEGORY_ALL); if (ret != MM_ERROR_NONE) { _mmcam_dbg_warn("converting table initialize error!!"); ret = MM_ERROR_CAMCORDER_INTERNAL; @@ -392,6 +342,12 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) "SupportMediaPacketPreviewCb", &(hcamcorder->support_media_packet_preview_cb)); + /* Get UseVideoconvert value from INI */ + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, + CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT, + "UseVideoconvert", + &hcamcorder->use_videoconvert); + ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, MMCAM_CAMERA_WIDTH, &resolution_width, MMCAM_CAMERA_HEIGHT, &resolution_height, @@ -399,9 +355,10 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) mm_camcorder_get_fps_list_by_resolution((MMHandleType)hcamcorder, resolution_width, resolution_height, &fps_info); - _mmcam_dbg_log("UseZeroCopyFormat : %d", hcamcorder->use_zero_copy_format); - _mmcam_dbg_log("SupportMediaPacketPreviewCb : %d", hcamcorder->support_media_packet_preview_cb); - _mmcam_dbg_log("res : %d X %d, Default FPS by resolution : %d", resolution_width, resolution_height, fps_info.int_array.def); + _mmcam_dbg_log("UseZeroCopyFormat %d, UseVideoconvert %d, SupportMediaPacketPreviewCb %d", + hcamcorder->use_zero_copy_format, hcamcorder->use_videoconvert, hcamcorder->support_media_packet_preview_cb); + _mmcam_dbg_log("res : %d X %d, Default FPS by resolution : %d", + resolution_width, resolution_height, fps_info.int_array.def); if (camera_facing_direction == 1) { if (rcmd_dpy_rotation == MM_DISPLAY_ROTATION_270 || rcmd_dpy_rotation == MM_DISPLAY_ROTATION_90) { @@ -409,7 +366,7 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) } else { camera_default_flip = MM_FLIP_HORIZONTAL; } - _mmcam_dbg_log("camera_default_flip : [%d]",camera_default_flip); + _mmcam_dbg_log("camera_default_flip : [%d]", camera_default_flip); } mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name, @@ -427,8 +384,7 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) NULL); if (err_attr_name) { _mmcam_dbg_err("Set %s FAILED.", err_attr_name); - free(err_attr_name); - err_attr_name = NULL; + SAFE_FREE(err_attr_name); ret = MM_ERROR_CAMCORDER_INTERNAL; goto _ERR_DEFAULT_VALUE_INIT; } @@ -439,8 +395,7 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) NULL); if (err_attr_name) { _mmcam_dbg_err("Get brightness FAILED."); - free(err_attr_name); - err_attr_name = NULL; + SAFE_FREE(err_attr_name); ret = MM_ERROR_CAMCORDER_INTERNAL; goto _ERR_DEFAULT_VALUE_INIT; } @@ -449,6 +404,18 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) _mmcam_dbg_log( "Disable Configure Control system." ); hcamcorder->conf_ctrl = NULL; } + + /* add DPM camera policy changed callback */ + if (hcamcorder->dpm_context) { + if (dpm_context_add_policy_changed_cb(hcamcorder->dpm_context, + "camera", _mmcamcorder_dpm_camera_policy_changed_cb, + (void *)hcamcorder, &hcamcorder->dpm_camera_cb_id) != DPM_ERROR_NONE) { + _mmcam_dbg_err("add DPM changed cb failed, keep going..."); + hcamcorder->dpm_camera_cb_id = 0; + } + + _mmcam_dbg_log("DPM camera changed cb id %d", hcamcorder->dpm_camera_cb_id); + } } else { _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, @@ -459,20 +426,20 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) NULL); if (err_attr_name) { _mmcam_dbg_err("Set %s FAILED.", err_attr_name); - free(err_attr_name); - err_attr_name = NULL; + SAFE_FREE(err_attr_name); ret = MM_ERROR_CAMCORDER_INTERNAL; goto _ERR_DEFAULT_VALUE_INIT; } ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, MM_CAMCONVERT_CATEGORY_AUDIO); if (ret != MM_ERROR_NONE) { - _mmcam_dbg_warn("init attribute from configure error : 0x%x", ret); - ret = MM_ERROR_CAMCORDER_INTERNAL; + _mmcam_dbg_err("there is no audio device"); + ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED; goto _ERR_DEFAULT_VALUE_INIT; } } +#ifdef _MMCAMCORDER_MURPHY_SUPPORT /* initialize resource manager */ ret = _mmcamcorder_resource_manager_init(&hcamcorder->resource_manager, (void *)hcamcorder); if (ret != MM_ERROR_NONE) { @@ -480,6 +447,7 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) ret = MM_ERROR_CAMCORDER_INTERNAL; goto _ERR_DEFAULT_VALUE_INIT; } +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:CREATE:INIT_GSTREAMER"); @@ -549,6 +517,11 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) return MM_ERROR_NONE; _ERR_DEFAULT_VALUE_INIT: +#ifdef _MMCAMCORDER_MURPHY_SUPPORT + /* de-initialize resource manager */ + _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager); +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ + /* unregister sound focus */ if (hcamcorder->sound_focus_register && hcamcorder->sound_focus_id > 0) { if (MM_ERROR_NONE != mm_sound_unregister_focus(hcamcorder->sound_focus_id)) { @@ -561,6 +534,28 @@ _ERR_DEFAULT_VALUE_INIT: hcamcorder->sound_focus_register, hcamcorder->sound_focus_id); } + /* release DPM related handle */ + if (hcamcorder->dpm_context) { + _mmcam_dbg_log("release DPM context %p, camera changed cb id %d", + hcamcorder->dpm_context, hcamcorder->dpm_camera_cb_id); + + /* remove camera policy changed callback */ + if (hcamcorder->dpm_camera_cb_id > 0) { + dpm_context_remove_policy_changed_cb(hcamcorder->dpm_context, hcamcorder->dpm_camera_cb_id); + hcamcorder->dpm_camera_cb_id = 0; + } else { + _mmcam_dbg_warn("invalid dpm camera cb id %d", hcamcorder->dpm_camera_cb_id); + } + + if (hcamcorder->dpm_policy) { + dpm_context_release_restriction_policy(hcamcorder->dpm_context, hcamcorder->dpm_policy); + hcamcorder->dpm_policy = NULL; + } + + dpm_context_destroy(hcamcorder->dpm_context); + hcamcorder->dpm_context = NULL; + } + /* Remove attributes */ if (hcamcorder->attributes) { _mmcamcorder_dealloc_attribute((MMHandleType)hcamcorder, hcamcorder->attributes); @@ -571,6 +566,7 @@ _ERR_DEFAULT_VALUE_INIT: g_mutex_clear(&(hcamcorder->mtsafe).lock); g_cond_clear(&(hcamcorder->mtsafe).cond); g_mutex_clear(&(hcamcorder->mtsafe).cmd_lock); + g_cond_clear(&(hcamcorder->mtsafe).cmd_cond); g_mutex_clear(&(hcamcorder->mtsafe).asm_lock); g_mutex_clear(&(hcamcorder->mtsafe).state_lock); g_mutex_clear(&(hcamcorder->mtsafe).gst_state_lock); @@ -585,11 +581,11 @@ _ERR_DEFAULT_VALUE_INIT: g_mutex_clear(&hcamcorder->restart_preview_lock); if (hcamcorder->conf_ctrl) { - _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl); + _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_ctrl); } if (hcamcorder->conf_main) { - _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_main); + _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_main); } if (hcamcorder->model_name) { @@ -627,6 +623,9 @@ int _mmcamcorder_destroy(MMHandleType handle) int ret = MM_ERROR_NONE; int state = MM_CAMCORDER_STATE_NONE; int state_FROM = MM_CAMCORDER_STATE_NULL; +#ifdef _MMCAMCORDER_RM_SUPPORT + int iret = RM_OK; +#endif /* _MMCAMCORDER_RM_SUPPORT */ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); @@ -671,11 +670,13 @@ int _mmcamcorder_destroy(MMHandleType handle) hcamcorder->sub_context = NULL; } +#ifdef _MMCAMCORDER_MURPHY_SUPPORT /* de-initialize resource manager */ 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); } +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ /* Remove idle function which is not called yet */ if (hcamcorder->setting_event_id) { @@ -721,6 +722,14 @@ int _mmcamcorder_destroy(MMHandleType handle) _mmcam_dbg_log("no need to unregister sound focus.[%d, id %d]", hcamcorder->sound_focus_register, hcamcorder->sound_focus_id); } +#ifdef _MMCAMCORDER_RM_SUPPORT + if (hcamcorder->rm_handle != 0) { + iret = rm_unregister(hcamcorder->rm_handle); + if (iret != RM_OK) + _mmcam_dbg_err("rm_unregister() failed"); + hcamcorder->rm_handle = 0; + } +#endif /* _MMCAMCORDER_RM_SUPPORT */ /* release model_name */ if (hcamcorder->model_name) { @@ -733,6 +742,28 @@ int _mmcamcorder_destroy(MMHandleType handle) hcamcorder->software_version = NULL; } + /* release DPM related handle */ + if (hcamcorder->dpm_context) { + _mmcam_dbg_log("release DPM context %p, camera changed cb id %d", + hcamcorder->dpm_context, hcamcorder->dpm_camera_cb_id); + + /* remove camera policy changed callback */ + if (hcamcorder->dpm_camera_cb_id > 0) { + dpm_context_remove_policy_changed_cb(hcamcorder->dpm_context, hcamcorder->dpm_camera_cb_id); + hcamcorder->dpm_camera_cb_id = 0; + } else { + _mmcam_dbg_warn("invalid dpm camera cb id %d", hcamcorder->dpm_camera_cb_id); + } + + if (hcamcorder->dpm_policy) { + dpm_context_release_restriction_policy(hcamcorder->dpm_context, hcamcorder->dpm_policy); + hcamcorder->dpm_policy = NULL; + } + + dpm_context_destroy(hcamcorder->dpm_context); + hcamcorder->dpm_context = NULL; + } + /* join task thread */ _mmcam_dbg_log("task thread join"); g_thread_join(hcamcorder->task_thread); @@ -744,6 +775,7 @@ int _mmcamcorder_destroy(MMHandleType handle) g_mutex_clear(&(hcamcorder->mtsafe).lock); g_cond_clear(&(hcamcorder->mtsafe).cond); g_mutex_clear(&(hcamcorder->mtsafe).cmd_lock); + g_cond_clear(&(hcamcorder->mtsafe).cmd_cond); g_mutex_clear(&(hcamcorder->mtsafe).asm_lock); g_mutex_clear(&(hcamcorder->mtsafe).state_lock); g_mutex_clear(&(hcamcorder->mtsafe).gst_state_lock); @@ -783,17 +815,19 @@ int _mmcamcorder_realize(MMHandleType handle) { int ret = MM_ERROR_NONE; int ret_sound = MM_ERROR_NONE; - int ret_resource = MM_ERROR_NONE; int state = MM_CAMCORDER_STATE_NONE; int state_FROM = MM_CAMCORDER_STATE_NULL; int state_TO = MM_CAMCORDER_STATE_READY; - int display_surface_type = MM_DISPLAY_SURFACE_X; + int display_surface_type = MM_DISPLAY_SURFACE_OVERLAY; int pid_for_sound_focus = 0; double motion_rate = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE; char *videosink_element_type = NULL; const char *videosink_name = NULL; char *socket_path = NULL; int socket_path_len; +#ifdef _MMCAMCORDER_RM_SUPPORT + int iret = RM_OK; +#endif /* _MMCAMCORDER_RM_SUPPORT */ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); @@ -826,10 +860,9 @@ int _mmcamcorder_realize(MMHandleType handle) _mmcam_dbg_log("Profile mode [%d]", hcamcorder->type); mm_camcorder_get_attributes(handle, NULL, - MMCAM_DISPLAY_SURFACE, &display_surface_type, - MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate, - MMCAM_DISPLAY_SOCKET_PATH, &socket_path, &socket_path_len, - NULL); + MMCAM_DISPLAY_SURFACE, &display_surface_type, + MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate, + NULL); /* sound focus */ if (hcamcorder->sound_focus_register) { @@ -887,6 +920,79 @@ int _mmcamcorder_realize(MMHandleType handle) _mmcam_dbg_log("no need to register sound focus"); } +#ifdef _MMCAMCORDER_RM_SUPPORT + int preview_format = MM_PIXEL_FORMAT_NV12; + int qret = RM_OK; + int qret_avail = RM_OK; + rm_consumer_info rci; + int app_pid = 0; + int resource_count = 0; + + mm_camcorder_get_attributes(handle, NULL, + MMCAM_PID_FOR_SOUND_FOCUS, &app_pid, + NULL); + rci.app_pid = app_pid; + aul_app_get_appid_bypid(rci.app_pid, rci.app_id, sizeof(rci.app_id)); + + /* RM register */ + if (hcamcorder->rm_handle == 0) { + iret = rm_register((rm_resource_cb)_mmcamcorder_rm_callback, (void*)hcamcorder, + &(hcamcorder->rm_handle), &rci); + if (iret != RM_OK) { + _mmcam_dbg_err("rm_register fail"); + ret = MM_ERROR_POLICY_BLOCKED; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + } + + mm_camcorder_get_attributes(handle, NULL, + MMCAM_CAMERA_FORMAT, &preview_format, + NULL); + + if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO && preview_format == MM_PIXEL_FORMAT_ENCODED_H264) { + + resource_count = 0; + memset(&hcamcorder->request_resources, 0x0, sizeof(rm_category_request_s)); + memset(&hcamcorder->returned_devices, 0x0, sizeof(rm_device_return_s)); + hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE; + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER; + _mmcam_dbg_log("request video decoder resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]); + + resource_count++; + hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE; + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER; + hcamcorder->request_resources.request_num = resource_count + 1; + _mmcam_dbg_log("request scaler resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]); + + + qret = rm_query(hcamcorder->rm_handle, RM_QUERY_ALLOCATION, &(hcamcorder->request_resources), &qret_avail); + + if (qret != RM_OK || qret_avail != RM_OK) { + _mmcam_dbg_log("Resource manager main device request fail"); + + resource_count = 0; + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER_SUB; + _mmcam_dbg_log("request video decoder resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]); + + resource_count++; + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER_SUB; + _mmcam_dbg_log("request scaler resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]); + } + + resource_count++; + hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE; + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_CAMERA; + hcamcorder->request_resources.request_num = resource_count + 1; + _mmcam_dbg_log("request camera resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]); + + iret = rm_allocate_resources(hcamcorder->rm_handle, &(hcamcorder->request_resources), &hcamcorder->returned_devices); + if (iret != RM_OK) { + _mmcam_dbg_err("Resource allocation request failed"); + ret = MM_ERROR_POLICY_BLOCKED; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + } +#endif /* _MMCAMCORDER_RM_SUPPORT */ /* alloc sub context */ hcamcorder->sub_context = _mmcamcorder_alloc_subcontext(hcamcorder->type); @@ -915,30 +1021,32 @@ int _mmcamcorder_realize(MMHandleType handle) _mmcam_dbg_warn("SupportDualStream [%d]", hcamcorder->sub_context->info_video->support_dual_stream); } - if (socket_path == NULL) { - _mmcam_dbg_warn("Socket Path is not properly set, -> to NullSink."); + switch (display_surface_type) { + case MM_DISPLAY_SURFACE_OVERLAY: + videosink_element_type = strdup("VideosinkElementOverlay"); + break; + case MM_DISPLAY_SURFACE_EVAS: + videosink_element_type = strdup("VideosinkElementEvas"); + break; + case MM_DISPLAY_SURFACE_GL: + videosink_element_type = strdup("VideosinkElementGL"); + break; + case MM_DISPLAY_SURFACE_NULL: videosink_element_type = strdup("VideosinkElementNull"); - } else { - switch (display_surface_type) { - case MM_DISPLAY_SURFACE_X: - videosink_element_type = strdup("VideosinkElementX"); - break; - case MM_DISPLAY_SURFACE_EVAS: - videosink_element_type = strdup("VideosinkElementEvas"); - break; - case MM_DISPLAY_SURFACE_GL: - videosink_element_type = strdup("VideosinkElementGL"); - break; - case MM_DISPLAY_SURFACE_NULL: + break; + case MM_DISPLAY_SURFACE_REMOTE: + mm_camcorder_get_attributes(handle, NULL, + MMCAM_DISPLAY_SOCKET_PATH, &socket_path, &socket_path_len, + NULL); + if (socket_path == NULL) { + _mmcam_dbg_warn("REMOTE surface, but socket path is NULL -> to NullSink"); videosink_element_type = strdup("VideosinkElementNull"); - break; - case MM_DISPLAY_SURFACE_REMOTE: + } else videosink_element_type = strdup("VideosinkElementRemote"); - break; - default: - videosink_element_type = strdup("VideosinkElementX"); - break; - } + break; + default: + videosink_element_type = strdup("VideosinkElementOverlay"); + break; } /* check string of videosink element */ @@ -975,8 +1083,27 @@ int _mmcamcorder_realize(MMHandleType handle) _mmcam_dbg_log("Support sensor encoded capture : %d", hcamcorder->sub_context->SensorEncodedCapture); if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) { + int dpm_camera_state = DPM_ALLOWED; + + /* check camera policy from DPM */ + if (hcamcorder->dpm_policy) { + if (dpm_restriction_get_camera_state(hcamcorder->dpm_policy, &dpm_camera_state) == DPM_ERROR_NONE) { + _mmcam_dbg_log("DPM camera state %d", dpm_camera_state); + if (dpm_camera_state == DPM_DISALLOWED) { + _mmcam_dbg_err("CAMERA DISALLOWED by DPM"); + ret = MM_ERROR_COMMON_INVALID_PERMISSION; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + } else { + _mmcam_dbg_err("get DPM camera state failed, keep going..."); + } + } else { + _mmcam_dbg_warn("NULL dpm_policy"); + } +#ifdef _MMCAMCORDER_MURPHY_SUPPORT /* prepare resource manager for camera */ - if((_mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, RESOURCE_TYPE_CAMERA))) { + ret = _mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, MM_CAMCORDER_RESOURCE_TYPE_CAMERA); + if (ret != MM_ERROR_NONE) { _mmcam_dbg_err("could not prepare for camera resource"); ret = MM_ERROR_CAMCORDER_INTERNAL; goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; @@ -984,21 +1111,25 @@ int _mmcamcorder_realize(MMHandleType handle) /* prepare resource manager for "video_overlay only if display surface is X" */ mm_camcorder_get_attributes(handle, NULL, - MMCAM_DISPLAY_SURFACE, &display_surface_type, - NULL); - if(display_surface_type == MM_DISPLAY_SURFACE_X) { - if((_mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, RESOURCE_TYPE_VIDEO_OVERLAY))) { + MMCAM_DISPLAY_SURFACE, &display_surface_type, + NULL); + + if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) { + ret = _mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, MM_CAMCORDER_RESOURCE_TYPE_VIDEO_OVERLAY); + if(ret != MM_ERROR_NONE) { _mmcam_dbg_err("could not prepare for video overlay resource"); ret = MM_ERROR_CAMCORDER_INTERNAL; goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } } + /* acquire resources */ - if((hcamcorder->resource_manager.rset && _mmcamcorder_resource_manager_acquire(&hcamcorder->resource_manager))) { + if (hcamcorder->resource_manager.rset && _mmcamcorder_resource_manager_acquire(&hcamcorder->resource_manager)) { _mmcam_dbg_err("could not acquire resources"); _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager); goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ } /* create pipeline */ @@ -1037,9 +1168,10 @@ int _mmcamcorder_realize(MMHandleType handle) return MM_ERROR_NONE; _ERR_CAMCORDER_CMD: +#ifdef _MMCAMCORDER_MURPHY_SUPPORT /* release hw resources */ if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) { - ret_resource = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager); + int ret_resource = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager); if (ret_resource == MM_ERROR_RESOURCE_INVALID_STATE) { _mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource"); } @@ -1051,6 +1183,7 @@ _ERR_CAMCORDER_CMD: _mmcam_dbg_err("failed to unprepare resource manager, ret_resource(0x%x)", ret_resource); } } +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: _MMCAMCORDER_UNLOCK_CMD(hcamcorder); @@ -1076,6 +1209,27 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: } } } +#ifdef _MMCAMCORDER_RM_SUPPORT + if (hcamcorder->rm_handle) { + if (hcamcorder->returned_devices.allocated_num > 0) { + int idx = 0; + rm_device_request_s requested; + memset(&requested, 0x0, sizeof(rm_device_request_s)); + requested.request_num = hcamcorder->returned_devices.allocated_num; + for (idx = 0; idx < requested.request_num; idx++) { + requested.device_id[idx] = hcamcorder->returned_devices.device_id[idx]; + } + iret = rm_deallocate_resources(hcamcorder->rm_handle, &requested); + if (iret != RM_OK) + _mmcam_dbg_err("Resource deallocation request failed "); + } + /* unregister RM */ + int ires = rm_unregister(hcamcorder->rm_handle); + if (ires != RM_OK) + _mmcam_dbg_err("rm_unregister() failed"); + hcamcorder->rm_handle = 0; + } +#endif /* _MMCAMCORDER_RM_SUPPORT*/ _ERR_CAMCORDER_CMD_PRECON: _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)", @@ -1124,7 +1278,9 @@ int _mmcamcorder_unrealize(MMHandleType handle) hcamcorder->sub_context = NULL; } +#ifdef _MMCAMCORDER_MURPHY_SUPPORT if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) { + /* release resource */ ret = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager); if (ret == MM_ERROR_RESOURCE_INVALID_STATE) { _mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource"); @@ -1139,6 +1295,23 @@ int _mmcamcorder_unrealize(MMHandleType handle) _mmcam_dbg_err("failed to unprepare resource manager, ret(0x%x)", ret); } } +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ + +#ifdef _MMCAMCORDER_RM_SUPPORT + if (hcamcorder->rm_handle && (hcamcorder->returned_devices.allocated_num > 0)) { + int iret = RM_OK; + int idx = 0; + rm_device_request_s requested; + memset(&requested, 0x0, sizeof(rm_device_request_s)); + requested.request_num = hcamcorder->returned_devices.allocated_num; + for (idx = 0; idx < requested.request_num; idx++) { + requested.device_id[idx] = hcamcorder->returned_devices.device_id[idx]; + } + iret = rm_deallocate_resources(hcamcorder->rm_handle, &requested); + if (iret != RM_OK) + _mmcam_dbg_err("Resource deallocation request failed "); + } +#endif /* _MMCAMCORDER_RM_SUPPORT*/ /* Deinitialize main context member */ hcamcorder->command = NULL; @@ -1529,6 +1702,7 @@ int _mmcamcorder_record(MMHandleType handle) int state_FROM1 = MM_CAMCORDER_STATE_PREPARE; int state_FROM2 = MM_CAMCORDER_STATE_PAUSED; int state_TO = MM_CAMCORDER_STATE_RECORDING; + int dpm_mic_state = DPM_ALLOWED; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); @@ -1556,6 +1730,22 @@ int _mmcamcorder_record(MMHandleType handle) /* initialize error code */ hcamcorder->error_code = MM_ERROR_NONE; + /* check mic policy from DPM */ + if (hcamcorder->dpm_policy) { + if (dpm_restriction_get_microphone_state(hcamcorder->dpm_policy, &dpm_mic_state) == DPM_ERROR_NONE) { + _mmcam_dbg_log("DPM mic state %d", dpm_mic_state); + if (dpm_mic_state == DPM_DISALLOWED) { + _mmcam_dbg_err("MIC DISALLOWED by DPM"); + ret = MM_ERROR_COMMON_INVALID_PERMISSION; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + } else { + _mmcam_dbg_err("get DPM mic state failed, keep going..."); + } + } else { + _mmcam_dbg_warn("NULL dpm_policy"); + } + ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_RECORD); if (ret != MM_ERROR_NONE) { /* check internal error of gstreamer */ @@ -1924,6 +2114,7 @@ int _mmcamcorder_init_focusing(MMHandleType handle) control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); if (control == NULL) { _mmcam_dbg_err("cast CAMERA_CONTROL failed"); + _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_CAMCORDER_INTERNAL; } @@ -2317,6 +2508,10 @@ void _mmcamcorder_set_state(MMHandleType handle, int state) msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_RM; msg.param.state.code = MM_ERROR_NONE; break; + case _MMCAMCORDER_STATE_CHANGE_BY_DPM: + msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY; + msg.param.state.code = MM_ERROR_NONE; + break; case _MMCAMCORDER_STATE_CHANGE_NORMAL: default: msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED; @@ -2371,31 +2566,28 @@ _MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type) /* alloc info for each mode */ switch (type) { case MM_CAMCORDER_MODE_AUDIO: - sc->info_audio = malloc( sizeof(_MMCamcorderAudioInfo)); + sc->info_audio = g_malloc0( sizeof(_MMCamcorderAudioInfo)); if(!sc->info_audio) { _mmcam_dbg_err("Failed to alloc info structure"); goto ALLOC_SUBCONTEXT_FAILED; } - memset(sc->info_audio, 0x00, sizeof(_MMCamcorderAudioInfo)); break; case MM_CAMCORDER_MODE_VIDEO_CAPTURE: default: - sc->info_image = malloc( sizeof(_MMCamcorderImageInfo)); + sc->info_image = g_malloc0( sizeof(_MMCamcorderImageInfo)); if(!sc->info_image) { _mmcam_dbg_err("Failed to alloc info structure"); goto ALLOC_SUBCONTEXT_FAILED; } - memset(sc->info_image, 0x00, sizeof(_MMCamcorderImageInfo)); /* init sound status */ sc->info_image->sound_status = _SOUND_STATUS_INIT; - sc->info_video = malloc( sizeof(_MMCamcorderVideoInfo)); + sc->info_video = g_malloc0( sizeof(_MMCamcorderVideoInfo)); if(!sc->info_video) { _mmcam_dbg_err("Failed to alloc info structure"); goto ALLOC_SUBCONTEXT_FAILED; } - memset(sc->info_video, 0x00, sizeof(_MMCamcorderVideoInfo)); g_mutex_init(&sc->info_video->size_check_lock); break; } @@ -2433,19 +2625,12 @@ _MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type) ALLOC_SUBCONTEXT_FAILED: if (sc) { - if (sc->info_audio) { - free(sc->info_audio); - sc->info_audio = NULL; - } - if (sc->info_image) { - free(sc->info_image); - sc->info_image = NULL; - } + SAFE_G_FREE(sc->info_audio); + SAFE_G_FREE(sc->info_image); if (sc->info_video) { g_mutex_clear(&sc->info_video->size_check_lock); - free(sc->info_video); - sc->info_video = NULL; } + SAFE_G_FREE(sc->info_video); if (sc->element) { free(sc->element); sc->element = NULL; @@ -2487,10 +2672,7 @@ void _mmcamcorder_dealloc_subcontext(_MMCamcorderSubContext *sc) if (sc->info_video) { _mmcam_dbg_log("release info_video"); - if (sc->info_video->filename) { - free(sc->info_video->filename); - sc->info_video->filename = NULL; - } + SAFE_G_FREE(sc->info_video->filename); g_mutex_clear(&sc->info_video->size_check_lock); free(sc->info_video); sc->info_video = NULL; @@ -2498,10 +2680,7 @@ void _mmcamcorder_dealloc_subcontext(_MMCamcorderSubContext *sc) if (sc->info_audio) { _mmcam_dbg_log("release info_audio"); - if (sc->info_audio->filename) { - free(sc->info_audio->filename); - sc->info_audio->filename = NULL; - } + SAFE_G_FREE(sc->info_audio->filename); free(sc->info_audio); sc->info_audio = NULL; } @@ -2573,17 +2752,24 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi } case GST_MESSAGE_ERROR: { - GError *err; - gchar *debug; - gst_message_parse_error(message, &err, &debug); + GError *err = NULL; + gchar *debug = NULL; - _mmcam_dbg_err ("GSTERR: %s", err->message); - _mmcam_dbg_err ("Error Debug: %s", debug); + gst_message_parse_error(message, &err, &debug); __mmcamcorder_handle_gst_error((MMHandleType)hcamcorder, message, err); - g_error_free (err); - g_free (debug); + if (err) { + _mmcam_dbg_err("GSTERR: %s", err->message); + g_error_free(err); + err = NULL; + } + + if (debug) { + _mmcam_dbg_err("Error Debug: %s", debug); + g_free(debug); + debug = NULL; + } break; } case GST_MESSAGE_WARNING: @@ -2829,13 +3015,10 @@ GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage goto DROP_MESSAGE; } - cam_fd_info = (MMCamFaceDetectInfo *)malloc(sizeof(MMCamFaceDetectInfo)); + cam_fd_info = (MMCamFaceDetectInfo *)g_malloc(sizeof(MMCamFaceDetectInfo)); if (cam_fd_info == NULL) { _mmcam_dbg_warn("cam_fd_info alloc failed"); - - free(fd_info); - fd_info = NULL; - + SAFE_FREE(fd_info); goto DROP_MESSAGE; } @@ -2843,7 +3026,7 @@ GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage cam_fd_info->num_of_faces = fd_info->num_of_faces; if (cam_fd_info->num_of_faces > 0) { - cam_fd_info->face_info = (MMCamFaceInfo *)malloc(sizeof(MMCamFaceInfo) * cam_fd_info->num_of_faces); + cam_fd_info->face_info = (MMCamFaceInfo *)g_malloc(sizeof(MMCamFaceInfo) * cam_fd_info->num_of_faces); if (cam_fd_info->face_info) { /* set information of each face */ for (i = 0 ; i < fd_info->num_of_faces ; i++) { @@ -2867,8 +3050,7 @@ GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage _mmcam_dbg_warn("MMCamFaceInfo alloc failed"); /* free allocated memory that is not sent */ - free(cam_fd_info); - cam_fd_info = NULL; + SAFE_G_FREE(cam_fd_info); } } else { cam_fd_info->face_info = NULL; @@ -2950,20 +3132,27 @@ GstBusSyncReply _mmcamcorder_audio_pipeline_bus_sync_callback(GstBus *bus, GstMe if (err->domain == GST_RESOURCE_ERROR && GST_ELEMENT_CAST(message->src) == element) { _MMCamcorderMsgItem msg; + switch (err->code) { case GST_RESOURCE_ERROR_OPEN_READ_WRITE: case GST_RESOURCE_ERROR_OPEN_WRITE: _mmcam_dbg_err("audio device [open failed]"); - hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION; + /* post error to application */ hcamcorder->error_occurs = TRUE; + hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION; + msg.id = MM_MESSAGE_CAMCORDER_ERROR; msg.param.code = hcamcorder->error_code; + + _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg); + _mmcam_dbg_err(" error : sc->error_occurs %d", hcamcorder->error_occurs); + g_error_free(err); - _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg); gst_message_unref(message); message = NULL; + return GST_BUS_DROP; default: break; @@ -2971,7 +3160,6 @@ GstBusSyncReply _mmcamcorder_audio_pipeline_bus_sync_callback(GstBus *bus, GstMe } g_error_free(err); - } return GST_BUS_PASS; @@ -3059,7 +3247,7 @@ void _mmcamcorder_sound_focus_watch_cb(mm_sound_focus_type_e focus_type, mm_soun mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data); int current_state = MM_CAMCORDER_STATE_NONE; - mmf_return_if_fail((MMHandleType)hcamcorder); + mmf_return_if_fail(hcamcorder); current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); if (current_state <= MM_CAMCORDER_STATE_NONE || @@ -3121,6 +3309,43 @@ void _mmcamcorder_sound_focus_watch_cb(mm_sound_focus_type_e focus_type, mm_soun } +void _mmcamcorder_dpm_camera_policy_changed_cb(const char *name, const char *value, void *user_data) +{ + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data); + int current_state = MM_CAMCORDER_STATE_NONE; + + mmf_return_if_fail(hcamcorder); + mmf_return_if_fail(value); + + current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); + if (current_state <= MM_CAMCORDER_STATE_NONE || + current_state >= MM_CAMCORDER_STATE_NUM) { + _mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state); + return; + } + + _mmcam_dbg_warn("camera policy [%s], current state [%d]", value, current_state); + + if (!strcmp(value, "disallowed")) { + _MMCAMCORDER_LOCK_ASM(hcamcorder); + + /* set value to inform a status is changed by DPM */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_DPM; + + __mmcamcorder_force_stop(hcamcorder); + + /* restore value */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL; + + _MMCAMCORDER_UNLOCK_ASM(hcamcorder); + } + + _mmcam_dbg_warn("done"); + + return; +} + + int _mmcamcorder_create_pipeline(MMHandleType handle, int type) { int ret = MM_ERROR_NONE; @@ -3328,6 +3553,7 @@ int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstSta switch (getChangeReturn) { case GST_STATE_CHANGE_NO_PREROLL: _mmcam_dbg_log("status=GST_STATE_CHANGE_NO_PREROLL."); + /* fall through */ case GST_STATE_CHANGE_SUCCESS: /* if we reached the final target state, exit */ if (pipeline_state == target_state) { @@ -3518,7 +3744,7 @@ static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage * { mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderMsgItem msg; - gchar *msg_src_element; + gchar *msg_src_element = NULL; _MMCamcorderSubContext *sc = NULL; return_val_if_fail(hcamcorder, FALSE); @@ -3573,10 +3799,12 @@ static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage * } #endif /* _MMCAMCORDER_SKIP_GST_FLOW_ERROR */ - /* post error to application */ - hcamcorder->error_occurs = TRUE; - msg.id = MM_MESSAGE_CAMCORDER_ERROR; - _mmcamcorder_send_message(handle, &msg); + /* post error to application except RESTRICTED case */ + if (msg.param.code != MM_ERROR_POLICY_RESTRICTED) { + hcamcorder->error_occurs = TRUE; + msg.id = MM_MESSAGE_CAMCORDER_ERROR; + _mmcamcorder_send_message(handle, &msg); + } return TRUE; } @@ -3680,6 +3908,40 @@ static gint __mmcamcorder_gst_handle_resource_error(MMHandleType handle, int cod } } + /* audiosrc */ + element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst); + if (GST_ELEMENT_CAST(message->src) == element) { + if (code == GST_RESOURCE_ERROR_FAILED) { + int ret = MM_ERROR_NONE; + int current_state = MM_CAMCORDER_STATE_NONE; + + _mmcam_dbg_err("DPM mic DISALLOWED - current state %d", current_state); + + _MMCAMCORDER_LOCK_ASM(hcamcorder); + + current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); + if (current_state >= MM_CAMCORDER_STATE_RECORDING) { + /* set value to inform a status is changed by DPM */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_DPM; + + ret = _mmcamcorder_commit((MMHandleType)hcamcorder); + _mmcam_dbg_log("commit result : 0x%x", ret); + + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("commit failed, cancel it"); + ret = _mmcamcorder_cancel((MMHandleType)hcamcorder); + } + } + + /* restore value */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL; + + _MMCAMCORDER_UNLOCK_ASM(hcamcorder); + + return MM_ERROR_POLICY_RESTRICTED; + } + } + /* encodebin */ element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst); if (GST_ELEMENT_CAST(message->src) == element) { @@ -3899,3 +4161,45 @@ int _mmcamcorder_get_video_caps(MMHandleType handle, char **caps) return MM_ERROR_NONE; } +#ifdef _MMCAMCORDER_RM_SUPPORT +rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src, + rm_device_request_s *info, void* cb_data) +{ + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(cb_data); + int current_state = MM_CAMCORDER_STATE_NONE; + rm_cb_result cb_res = RM_CB_RESULT_OK; + + mmf_return_val_if_fail((MMHandleType)hcamcorder, RM_CB_RESULT_OK); + + current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); + if (current_state <= MM_CAMCORDER_STATE_NONE || + current_state >= MM_CAMCORDER_STATE_NUM) { + _mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state); + } + + _MMCAMCORDER_LOCK_ASM(hcamcorder); + + /* set value to inform a status is changed by RM */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_RM; + + /* set RM event code for sending it to application */ + hcamcorder->interrupt_code = event_src; + + _mmcam_dbg_log("RM conflict callback : event code 0x%x", event_src); + switch (event_src) { + case RM_CALLBACK_TYPE_RESOURCE_CONFLICT: + case RM_CALLBACK_TYPE_RESOURCE_CONFLICT_UD: + __mmcamcorder_force_stop(hcamcorder); + break; + default: + break; + } + + /* restore value */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL; + + _MMCAMCORDER_UNLOCK_ASM(hcamcorder); + + return cb_res; +} +#endif /* _MMCAMCORDER_RM_SUPPORT */ \ No newline at end of file