X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_internal.c;h=5d4f841e64df74229db4a0940896a617831d2a6a;hb=refs%2Ftags%2Faccepted%2Ftizen%2Fcommon%2F20160513.123242;hp=efd0781bdb380c3a7b64115ef74c5c746be53185;hpb=35b5a6c84ff9425fc4bc02e20fc47edb5dcc6a1d;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git diff --git a/src/mm_camcorder_internal.c b/src/mm_camcorder_internal.c index efd0781..5d4f841 100644 --- a/src/mm_camcorder_internal.c +++ b/src/mm_camcorder_internal.c @@ -39,25 +39,24 @@ #include #include +#include +#include + +#include -/*--------------------------------------------------------------------------------------- -| GLOBAL VARIABLE DEFINITIONS for internal | ----------------------------------------------------------------------------------------*/ -int g_mm_camcorder_type = -255; -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; /*--------------------------------------------------------------------------------------- | LOCAL VARIABLE DEFINITIONS for internal | ---------------------------------------------------------------------------------------*/ #define __MMCAMCORDER_CMD_ITERATE_MAX 3 -#define __MMCAMCORDER_SET_GST_STATE_TIMEOUT 3 +#define __MMCAMCORDER_SET_GST_STATE_TIMEOUT 5 +#define __MMCAMCORDER_FORCE_STOP_TRY_COUNT 30 +#define __MMCAMCORDER_FORCE_STOP_WAIT_TIME 100000 /* us */ #define __MMCAMCORDER_SOUND_WAIT_TIMEOUT 3 -#define __MMCAMCORDER_PATH_CAMERA_RESOURCE "/usr/share/sounds/mm-camcorder/camera_resource" -#define __MMCAMCORDER_PATH_RECORDER_RESOURCE "/usr/share/sounds/mm-camcorder/recorder_resource" +#define __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN 64 + +#define DPM_ALLOWED 1 +#define DPM_DISALLOWED 0 /*--------------------------------------------------------------------------------------- @@ -74,14 +73,10 @@ 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_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 | =======================================================================================*/ @@ -89,101 +84,6 @@ static void _mmcamcorder_constructor() __attribute__((constructor)); | GLOBAL FUNCTION DEFINITIONS: | ---------------------------------------------------------------------------------------*/ - -static void __mm_camcorder_signal_handler(int signo) -{ - pid_t my_pid = getpid(); - pid_t vconf_recorder_pid = -1; - pid_t vconf_camera_pid = -1; - int vconf_flash_state = VCONFKEY_CAMERA_FLASH_STATE_OFF; - - _mmcam_dbg_warn("start - signo [%d], pid [%d], device type [%d]", signo, my_pid, g_mm_camcorder_type); - - /* reset vconf key */ - switch (g_mm_camcorder_type) { - case MM_VIDEO_DEVICE_NONE: - vconf_get_int(VCONFKEY_RECORDER_PID, (int *)&vconf_recorder_pid); - if (my_pid == vconf_recorder_pid) { - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL); - vconf_set_int(VCONFKEY_RECORDER_PID, -1); - _mmcam_dbg_warn("set recorder state NULL"); - } else { - _mmcam_dbg_warn("different pid : my[%d] vconf[%d]", my_pid, vconf_recorder_pid); - } - break; - case MM_VIDEO_DEVICE_CAMERA0: - case MM_VIDEO_DEVICE_CAMERA1: - vconf_get_int(VCONFKEY_CAMERA_FLASH_STATE, &vconf_flash_state); - vconf_get_int(VCONFKEY_CAMERA_PID, (int *)&vconf_camera_pid); - if (my_pid == vconf_camera_pid && - vconf_flash_state == VCONFKEY_CAMERA_FLASH_STATE_ON) { - vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, VCONFKEY_CAMERA_FLASH_STATE_OFF); - vconf_set_int(VCONFKEY_CAMERA_PID, -1); - _mmcam_dbg_warn("set camera flash state OFF"); - } - - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL); - _mmcam_dbg_warn("set camera state NULL"); - break; - default: - _mmcam_dbg_warn("unknown type [%d]", g_mm_camcorder_type); - break; - } - - /* 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) { @@ -195,8 +95,8 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) int rcmd_dpy_rotation = MM_DISPLAY_ROTATION_270; int play_capture_sound = TRUE; int camera_device_count = MM_VIDEO_DEVICE_NUM; + int camera_default_flip = MM_FLIP_NONE; int camera_facing_direction = MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR; - int resource_fd = -1; char *err_attr_name = NULL; const char *ConfCtrlFile = NULL; mmf_camcorder_t *hcamcorder = NULL; @@ -218,34 +118,41 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) hcamcorder->sub_context = NULL; hcamcorder->target_state = MM_CAMCORDER_STATE_NULL; hcamcorder->capture_in_recording = FALSE; - - pthread_mutex_init(&((hcamcorder->mtsafe).lock), NULL); - pthread_cond_init(&((hcamcorder->mtsafe).cond), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).cmd_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).asm_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).state_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).gst_state_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).gst_encode_state_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).message_cb_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).vcapture_cb_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).vstream_cb_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).astream_cb_lock), NULL); - - pthread_mutex_init(&(hcamcorder->sound_lock), NULL); - pthread_cond_init(&(hcamcorder->sound_cond), NULL); - pthread_mutex_init(&(hcamcorder->restart_preview_lock), NULL); + hcamcorder->session_type = MM_SESSION_TYPE_MEDIA; + + g_mutex_init(&(hcamcorder->mtsafe).lock); + g_cond_init(&(hcamcorder->mtsafe).cond); + g_mutex_init(&(hcamcorder->mtsafe).cmd_lock); + g_mutex_init(&(hcamcorder->mtsafe).asm_lock); + g_mutex_init(&(hcamcorder->mtsafe).state_lock); + g_mutex_init(&(hcamcorder->mtsafe).gst_state_lock); + g_mutex_init(&(hcamcorder->mtsafe).gst_encode_state_lock); + g_mutex_init(&(hcamcorder->mtsafe).message_cb_lock); + g_mutex_init(&(hcamcorder->mtsafe).vcapture_cb_lock); + g_mutex_init(&(hcamcorder->mtsafe).vstream_cb_lock); + g_mutex_init(&(hcamcorder->mtsafe).astream_cb_lock); + + g_mutex_init(&hcamcorder->restart_preview_lock); /* Sound mutex/cond init */ - pthread_mutex_init(&(hcamcorder->snd_info.open_mutex), NULL); - pthread_cond_init(&(hcamcorder->snd_info.open_cond), NULL); + g_mutex_init(&hcamcorder->snd_info.open_mutex); + g_cond_init(&hcamcorder->snd_info.open_cond); + g_mutex_init(&hcamcorder->snd_info.play_mutex); + g_cond_init(&hcamcorder->snd_info.play_cond); /* init for sound thread */ - pthread_mutex_init(&(hcamcorder->task_thread_lock), NULL); - pthread_cond_init(&(hcamcorder->task_thread_cond), NULL); + g_mutex_init(&hcamcorder->task_thread_lock); + g_cond_init(&hcamcorder->task_thread_cond); hcamcorder->task_thread_state = _MMCAMCORDER_SOUND_STATE_NONE; /* create task thread */ - pthread_create(&(hcamcorder->task_thread), NULL, _mmcamcorder_util_task_thread_func, (void *)hcamcorder); + hcamcorder->task_thread = g_thread_try_new("MMCAM_TASK_THREAD", + (GThreadFunc)_mmcamcorder_util_task_thread_func, (gpointer)hcamcorder, NULL); + if (hcamcorder->task_thread == NULL) { + _mmcam_dbg_err("_mmcamcorder_create::failed to create task thread"); + ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION; + goto _ERR_DEFAULT_VALUE_INIT; + } if (info->videodev_type < MM_VIDEO_DEVICE_NONE || info->videodev_type >= MM_VIDEO_DEVICE_NUM) { @@ -258,34 +165,38 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) hcamcorder->device_type = info->videodev_type; _mmcam_dbg_warn("Device Type : %d", hcamcorder->device_type); - if (hcamcorder->device_type == MM_VIDEO_DEVICE_NONE) { - resource_fd = open(__MMCAMCORDER_PATH_RECORDER_RESOURCE, O_RDONLY); - } else { - resource_fd = open(__MMCAMCORDER_PATH_CAMERA_RESOURCE, O_RDONLY); - } + if (MM_ERROR_NONE == _mm_session_util_read_information(-1, &hcamcorder->session_type, &hcamcorder->session_flags)) { + _mmcam_dbg_log("use sound focus function."); + hcamcorder->sound_focus_register = TRUE; - if (resource_fd < 0) { - _mmcam_dbg_log("open error %s : cur %d",strerror(errno),errno); - if(errno == EPERM || errno == EACCES) { - ret = MM_ERROR_COMMON_INVALID_PERMISSION; - } else { - ret = MM_ERROR_CAMCORDER_INTERNAL; + if (MM_ERROR_NONE != mm_sound_focus_get_id(&hcamcorder->sound_focus_id)) { + _mmcam_dbg_err("mm_sound_focus_get_uniq failed"); + ret = MM_ERROR_POLICY_BLOCKED; + goto _ERR_DEFAULT_VALUE_INIT; } - goto _ERR_DEFAULT_VALUE_INIT; + + if (MM_ERROR_NONE != mm_sound_register_focus_for_session(hcamcorder->sound_focus_id, + getpid(), + "media", + _mmcamcorder_sound_focus_cb, + hcamcorder)) { + _mmcam_dbg_err("mm_sound_register_focus failed"); + ret = MM_ERROR_POLICY_BLOCKED; + goto _ERR_DEFAULT_VALUE_INIT; + } + + _mmcam_dbg_log("mm_sound_register_focus done - id %d, session type %d, flags 0x%x", + hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags); } else { - close(resource_fd); - resource_fd = -1; - _mmcam_dbg_warn("permission check done"); + _mmcam_dbg_log("_mm_session_util_read_information failed. skip sound focus function."); + hcamcorder->sound_focus_register = FALSE; } /* 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; - goto _ERR_AFTER_ASM_REGISTER; + 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; } hcamcorder->attributes = _mmcamcorder_alloc_attribute((MMHandleType)hcamcorder, info); @@ -293,7 +204,7 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) _mmcam_dbg_err("_mmcamcorder_create::alloc attribute error."); ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION; - goto _ERR_AFTER_ASM_REGISTER; + goto _ERR_DEFAULT_VALUE_INIT; } if (info->videodev_type != MM_VIDEO_DEVICE_NONE) { @@ -322,30 +233,32 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) default: _mmcam_dbg_err( "Not supported camera type." ); ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED; - goto _ERR_AFTER_ASM_REGISTER; + goto _ERR_DEFAULT_VALUE_INIT; } _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_AFTER_ASM_REGISTER; - } - ret = _mmcamcorder_init_convert_table((MMHandleType)hcamcorder); if (ret != MM_ERROR_NONE) { _mmcam_dbg_warn("converting table initialize error!!"); + ret = MM_ERROR_CAMCORDER_INTERNAL; + goto _ERR_DEFAULT_VALUE_INIT; } - ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder); + 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; + goto _ERR_DEFAULT_VALUE_INIT; } /* Get device info, recommend preview fmt and display rotation from INI */ @@ -417,6 +330,15 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) _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); + if (camera_facing_direction == 1) { + if (rcmd_dpy_rotation == MM_DISPLAY_ROTATION_270 || rcmd_dpy_rotation == MM_DISPLAY_ROTATION_90) { + camera_default_flip = MM_FLIP_VERTICAL; + } else { + camera_default_flip = MM_FLIP_HORIZONTAL; + } + _mmcam_dbg_log("camera_default_flip : [%d]",camera_default_flip); + } + mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name, MMCAM_CAMERA_DEVICE_COUNT, camera_device_count, MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction, @@ -427,12 +349,14 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) MMCAM_SUPPORT_ZERO_COPY_FORMAT, hcamcorder->use_zero_copy_format, MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB, hcamcorder->support_media_packet_preview_cb, MMCAM_CAMERA_FPS, fps_info.int_array.def, + MMCAM_DISPLAY_FLIP, camera_default_flip, "capture-sound-enable", play_capture_sound, 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; } /* Get default value of brightness */ @@ -441,14 +365,38 @@ 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; } _mmcam_dbg_log("Default brightness : %d", hcamcorder->brightness_default); } else { _mmcam_dbg_log( "Disable Configure Control system." ); hcamcorder->conf_ctrl = NULL; } + + /* get DPM context for camera 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; + } + + /* add DPM camera policy changed callback */ + 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); + } + + _mmcam_dbg_log("DPM context %p, policy %p", hcamcorder->dpm_context, hcamcorder->dpm_policy); } else { _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, @@ -459,16 +407,37 @@ 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_err("there is no audio device"); + ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED; + goto _ERR_DEFAULT_VALUE_INIT; + } + } + + /* initialize resource manager */ + ret = _mmcamcorder_resource_manager_init(&hcamcorder->resource_manager, (void *)hcamcorder); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("failed to initialize resource manager"); + ret = MM_ERROR_CAMCORDER_INTERNAL; + goto _ERR_DEFAULT_VALUE_INIT; } + traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:CREATE:INIT_GSTREAMER"); + ret = __mmcamcorder_gstreamer_init(hcamcorder->conf_main); + + traceEnd(TTRACE_TAG_CAMERA); + if (!ret) { _mmcam_dbg_err( "Failed to initialize gstreamer!!" ); ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED; - goto _ERR_AFTER_ASM_REGISTER; + goto _ERR_DEFAULT_VALUE_INIT; } /* Make some attributes as read-only type */ @@ -522,41 +491,77 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) _mmcam_dbg_log("created handle %p", hcamcorder); - /* set device type */ - g_mm_camcorder_type = info->videodev_type; - *handle = (MMHandleType)hcamcorder; return MM_ERROR_NONE; -_ERR_AFTER_ASM_REGISTER: - _ERR_DEFAULT_VALUE_INIT: + /* de-initialize resource manager */ + _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager); + + /* 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)) { + _mmcam_dbg_err("mm_sound_unregister_focus[id %d] failed", hcamcorder->sound_focus_id); + } else { + _mmcam_dbg_log("mm_sound_unregister_focus[id %d] done", hcamcorder->sound_focus_id); + } + } else { + _mmcam_dbg_warn("no need to unregister sound focus[%d, id %d]", + 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); + hcamcorder->attributes = 0; + } + /* Release lock, cond */ - pthread_mutex_destroy(&((hcamcorder->mtsafe).lock)); - pthread_cond_destroy(&((hcamcorder->mtsafe).cond)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).cmd_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).asm_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_encode_state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).message_cb_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).vcapture_cb_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).vstream_cb_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).astream_cb_lock)); - - pthread_mutex_destroy(&(hcamcorder->sound_lock)); - pthread_cond_destroy(&(hcamcorder->sound_cond)); - pthread_mutex_destroy(&(hcamcorder->snd_info.open_mutex)); - pthread_cond_destroy(&(hcamcorder->snd_info.open_cond)); - pthread_mutex_destroy(&(hcamcorder->restart_preview_lock)); + g_mutex_clear(&(hcamcorder->mtsafe).lock); + g_cond_clear(&(hcamcorder->mtsafe).cond); + g_mutex_clear(&(hcamcorder->mtsafe).cmd_lock); + g_mutex_clear(&(hcamcorder->mtsafe).asm_lock); + g_mutex_clear(&(hcamcorder->mtsafe).state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).gst_state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).gst_encode_state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).message_cb_lock); + g_mutex_clear(&(hcamcorder->mtsafe).vcapture_cb_lock); + g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock); + g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock); + + g_mutex_clear(&hcamcorder->snd_info.open_mutex); + g_cond_clear(&hcamcorder->snd_info.open_cond); + 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) { @@ -570,15 +575,16 @@ _ERR_DEFAULT_VALUE_INIT: } if (hcamcorder->task_thread) { - pthread_mutex_lock(&(hcamcorder->task_thread_lock)); + g_mutex_lock(&hcamcorder->task_thread_lock); _mmcam_dbg_log("send signal for task thread exit"); hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT; - pthread_cond_signal(&(hcamcorder->task_thread_cond)); - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); - pthread_join(hcamcorder->task_thread, NULL); + g_cond_signal(&hcamcorder->task_thread_cond); + g_mutex_unlock(&hcamcorder->task_thread_lock); + g_thread_join(hcamcorder->task_thread); + hcamcorder->task_thread = NULL; } - pthread_mutex_destroy(&(hcamcorder->task_thread_lock)); - pthread_cond_destroy(&(hcamcorder->task_thread_cond)); + g_mutex_clear(&hcamcorder->task_thread_lock); + g_cond_clear(&hcamcorder->task_thread_cond); /* Release handle */ memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t)); @@ -618,33 +624,14 @@ int _mmcamcorder_destroy(MMHandleType handle) } /* set exit state for sound thread */ - pthread_mutex_lock(&(hcamcorder->task_thread_lock)); + g_mutex_lock(&hcamcorder->task_thread_lock); _mmcam_dbg_log("send signal for task thread exit"); hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT; - pthread_cond_signal(&(hcamcorder->task_thread_cond)); - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); + g_cond_signal(&hcamcorder->task_thread_cond); + g_mutex_unlock(&hcamcorder->task_thread_lock); - pthread_mutex_lock(&(hcamcorder->sound_lock)); - while (hcamcorder->capture_sound_count > 0) { - struct timespec timeout; - struct timeval tv; - - gettimeofday(&tv, NULL); - timeout.tv_sec = tv.tv_sec + __MMCAMCORDER_SOUND_WAIT_TIMEOUT; - timeout.tv_nsec = tv.tv_usec * 1000; - - _mmcam_dbg_warn("capture_sound_count[%d] is not zero. wait signal...", - hcamcorder->capture_sound_count); - - if (!pthread_cond_timedwait(&(hcamcorder->sound_cond), &(hcamcorder->sound_lock), &timeout)) { - _mmcam_dbg_warn("signal received. check again..."); - } else { - hcamcorder->capture_sound_count = 0; - _mmcam_dbg_err("capture sound completion wait time out"); - break; - } - } - pthread_mutex_unlock(&(hcamcorder->sound_lock)); + /* wait for completion of sound play */ + _mmcamcorder_sound_solo_play_wait(handle); /* Release SubContext and pipeline */ if (hcamcorder->sub_context) { @@ -656,6 +643,12 @@ int _mmcamcorder_destroy(MMHandleType handle) hcamcorder->sub_context = NULL; } + /* 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); + } + /* Remove idle function which is not called yet */ if (hcamcorder->setting_event_id) { _mmcam_dbg_log("Remove remaining idle function"); @@ -663,29 +656,6 @@ int _mmcamcorder_destroy(MMHandleType handle) hcamcorder->setting_event_id = 0; } - /* check current strobe mode */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - pid_t my_pid = getpid(); - int camera_pid = -1; - vconf_get_int(VCONFKEY_CAMERA_PID, &camera_pid); - - if (camera_pid > -1 && my_pid == camera_pid) { - int strobe_mode = MM_CAMCORDER_STROBE_MODE_OFF; - - vconf_set_int(VCONFKEY_CAMERA_PID, -1); - _mmcam_dbg_log("reset camera pid"); - - mm_camcorder_get_attributes(handle, NULL, - MMCAM_STROBE_MODE, &strobe_mode, - NULL); - if (strobe_mode != MM_CAMCORDER_STROBE_MODE_OFF) { - /* set OFF state of vconf key */ - vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, VCONFKEY_CAMERA_FLASH_STATE_OFF); - _mmcam_dbg_log("reset flash state"); - } - } - } - /* Remove attributes */ if (hcamcorder->attributes) { _mmcamcorder_dealloc_attribute(handle, hcamcorder->attributes); @@ -710,6 +680,20 @@ int _mmcamcorder_destroy(MMHandleType handle) /* Remove messages which are not called yet */ _mmcamcorder_remove_message_all(handle); + /* unregister sound focus */ + if (hcamcorder->sound_focus_register && hcamcorder->sound_focus_id > 0) { + if (mm_sound_unregister_focus(hcamcorder->sound_focus_id) != MM_ERROR_NONE) { + _mmcam_dbg_err("mm_sound_unregister_focus[id %d] failed", + hcamcorder->sound_focus_id); + } else { + _mmcam_dbg_log("mm_sound_unregister_focus[id %d] done", + hcamcorder->sound_focus_id); + } + } else { + _mmcam_dbg_log("no need to unregister sound focus.[%d, id %d]", + hcamcorder->sound_focus_register, hcamcorder->sound_focus_id); + } + /* release model_name */ if (hcamcorder->model_name) { free(hcamcorder->model_name); @@ -721,32 +705,53 @@ 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"); - pthread_join(hcamcorder->task_thread, NULL); + g_thread_join(hcamcorder->task_thread); + hcamcorder->task_thread = NULL; _MMCAMCORDER_UNLOCK_CMD(hcamcorder); /* Release lock, cond */ - pthread_mutex_destroy(&((hcamcorder->mtsafe).lock)); - pthread_cond_destroy(&((hcamcorder->mtsafe).cond)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).cmd_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).asm_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_encode_state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).message_cb_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).vcapture_cb_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).vstream_cb_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).astream_cb_lock)); - - pthread_mutex_destroy(&(hcamcorder->sound_lock)); - pthread_cond_destroy(&(hcamcorder->sound_cond)); - pthread_mutex_destroy(&(hcamcorder->snd_info.open_mutex)); - pthread_cond_destroy(&(hcamcorder->snd_info.open_cond)); - pthread_mutex_destroy(&(hcamcorder->restart_preview_lock)); - pthread_mutex_destroy(&(hcamcorder->task_thread_lock)); - pthread_cond_destroy(&(hcamcorder->task_thread_cond)); + g_mutex_clear(&(hcamcorder->mtsafe).lock); + g_cond_clear(&(hcamcorder->mtsafe).cond); + g_mutex_clear(&(hcamcorder->mtsafe).cmd_lock); + g_mutex_clear(&(hcamcorder->mtsafe).asm_lock); + g_mutex_clear(&(hcamcorder->mtsafe).state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).gst_state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).gst_encode_state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).message_cb_lock); + g_mutex_clear(&(hcamcorder->mtsafe).vcapture_cb_lock); + g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock); + g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock); + + g_mutex_clear(&hcamcorder->snd_info.open_mutex); + g_cond_clear(&hcamcorder->snd_info.open_cond); + g_mutex_clear(&hcamcorder->restart_preview_lock); + g_mutex_clear(&hcamcorder->task_thread_lock); + g_cond_clear(&hcamcorder->task_thread_cond); /* Release handle */ memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t)); @@ -771,13 +776,18 @@ _ERR_CAMCORDER_CMD_PRECON: 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; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); @@ -810,42 +820,67 @@ 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, - NULL); + MMCAM_DISPLAY_SURFACE, &display_surface_type, + MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate, + NULL); + + /* sound focus */ + if (hcamcorder->sound_focus_register) { + mm_camcorder_get_attributes(handle, NULL, + MMCAM_PID_FOR_SOUND_FOCUS, &pid_for_sound_focus, + NULL); + + if (pid_for_sound_focus == 0) { + pid_for_sound_focus = getpid(); + _mmcam_dbg_warn("pid for sound focus is not set, use my pid %d", pid_for_sound_focus); + } - /* set camera/recorder state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; + /* acquire sound focus or set sound focus watch callback */ + hcamcorder->acquired_focus = 0; + hcamcorder->sound_focus_watch_id = 0; - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - if (vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN)) { - _mmcam_dbg_log("VCONF ERROR %s : cur %d",strerror(errno),errno); - if(errno == EPERM || errno == EACCES) { - ret = MM_ERROR_COMMON_INVALID_PERMISSION; + /* check session flags */ + if (hcamcorder->session_flags & MM_SESSION_OPTION_PAUSE_OTHERS) { + /* acquire sound focus */ + _mmcam_dbg_log("PAUSE_OTHERS - acquire sound focus"); + + ret_sound = mm_sound_acquire_focus(0, FOCUS_FOR_BOTH, NULL); + if (ret_sound != MM_ERROR_NONE) { + _mmcam_dbg_err("mm_sound_acquire_focus failed [0x%x]", ret_sound); + + /* TODO: MM_ERROR_POLICY_BLOCKED_BY_CALL, MM_ERROR_POLICY_BLOCKED_BY_ALARM*/ + ret = MM_ERROR_POLICY_BLOCKED; goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - } - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN); - } else { - int vconf_recorder_state = 0; - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - if (vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED)) { - _mmcam_dbg_log("VCONF ERROR %s : cur %d",strerror(errno),errno); - if (errno == EPERM || errno == EACCES) { - ret = MM_ERROR_COMMON_INVALID_PERMISSION; + hcamcorder->acquired_focus = FOCUS_FOR_BOTH; + } else if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) { + /* do nothing */ + _mmcam_dbg_log("SESSION_UNINTERRUPTIBLE - do nothing for sound focus"); + } else { + /* set sound focus watch callback */ + _mmcam_dbg_log("ETC - set sound focus watch callback - pid %d", pid_for_sound_focus); + + ret_sound = mm_sound_set_focus_watch_callback_for_session(pid_for_sound_focus, + FOCUS_FOR_BOTH, + (mm_sound_focus_changed_watch_cb)_mmcamcorder_sound_focus_watch_cb, + hcamcorder, + &hcamcorder->sound_focus_watch_id); + if (ret_sound != MM_ERROR_NONE) { + _mmcam_dbg_err("mm_sound_set_focus_watch_callback failed [0x%x]", ret_sound); + + /* TODO: MM_ERROR_POLICY_BLOCKED_BY_CALL, MM_ERROR_POLICY_BLOCKED_BY_ALARM*/ + ret = MM_ERROR_POLICY_BLOCKED; goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - } - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED); + _mmcam_dbg_log("sound focus watch cb id %d", hcamcorder->sound_focus_watch_id); + } + } else { + _mmcam_dbg_log("no need to register sound focus"); } + /* alloc sub context */ hcamcorder->sub_context = _mmcamcorder_alloc_subcontext(hcamcorder->type); if(!hcamcorder->sub_context) { @@ -874,8 +909,8 @@ int _mmcamcorder_realize(MMHandleType handle) } switch (display_surface_type) { - case MM_DISPLAY_SURFACE_X: - videosink_element_type = strdup("VideosinkElementX"); + case MM_DISPLAY_SURFACE_OVERLAY: + videosink_element_type = strdup("VideosinkElementOverlay"); break; case MM_DISPLAY_SURFACE_EVAS: videosink_element_type = strdup("VideosinkElementEvas"); @@ -886,8 +921,18 @@ int _mmcamcorder_realize(MMHandleType handle) case MM_DISPLAY_SURFACE_NULL: videosink_element_type = strdup("VideosinkElementNull"); 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"); + } else + videosink_element_type = strdup("VideosinkElementRemote"); + break; default: - videosink_element_type = strdup("VideosinkElementX"); + videosink_element_type = strdup("VideosinkElementOverlay"); break; } @@ -924,8 +969,58 @@ int _mmcamcorder_realize(MMHandleType handle) &(hcamcorder->sub_context->SensorEncodedCapture)); _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 (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..."); + } + + /* prepare resource manager for camera */ + ret = _mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, 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; + } + + /* 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_OVERLAY) { + ret = _mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, 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)) { + _mmcam_dbg_err("could not acquire resources"); + _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager); + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + } + /* create pipeline */ + traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:REALIZE:CREATE_PIPELINE"); + ret = _mmcamcorder_create_pipeline(handle, hcamcorder->type); + + traceEnd(TTRACE_TAG_CAMERA); + if (ret != MM_ERROR_NONE) { /* check internal error of gstreamer */ if (hcamcorder->error_code != MM_ERROR_NONE) { @@ -955,30 +1050,46 @@ int _mmcamcorder_realize(MMHandleType handle) return MM_ERROR_NONE; _ERR_CAMCORDER_CMD: - /* rollback camera state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL); - } else { - int vconf_recorder_state = 0; - - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL); - - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_NULL); + /* release hw resources */ + if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) { + 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"); + } + 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); + } } _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: _MMCAMCORDER_UNLOCK_CMD(hcamcorder); + if (hcamcorder->sound_focus_register) { + if (hcamcorder->sound_focus_watch_id > 0) { + if (mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id) != MM_ERROR_NONE) { + _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback[id %d] failed", + hcamcorder->sound_focus_watch_id); + } else { + _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback[id %d] done", + hcamcorder->sound_focus_watch_id); + } + } + + if (hcamcorder->acquired_focus > 0) { + if (mm_sound_release_focus(0, hcamcorder->acquired_focus, NULL) != MM_ERROR_NONE) { + _mmcam_dbg_err("mm_sound_release_focus[focus %d] failed", + hcamcorder->acquired_focus); + } else { + _mmcam_dbg_err("mm_sound_release_focus[focus %d] done", + hcamcorder->acquired_focus); + } + } + } + _ERR_CAMCORDER_CMD_PRECON: _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)", hcamcorder->type, state, ret); @@ -1026,29 +1137,63 @@ int _mmcamcorder_unrealize(MMHandleType handle) hcamcorder->sub_context = NULL; } + 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"); + ret = MM_ERROR_NONE; + } else if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("failed to release resource, ret(0x%x)", ret); + ret = MM_ERROR_CAMCORDER_INTERNAL; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + ret = _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("failed to unprepare resource manager, ret(0x%x)", ret); + } + } + /* Deinitialize main context member */ hcamcorder->command = NULL; + _mmcam_dbg_log("focus register %d, session flag 0x%x, state_change_by_system %d", + hcamcorder->sound_focus_register, hcamcorder->session_flags, hcamcorder->state_change_by_system); - /* set camera state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL); + /* release sound focus or unset sound focus watch callback */ + if (hcamcorder->sound_focus_register) { + int ret_sound = MM_ERROR_NONE; - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL); - } else { - int vconf_recorder_state = 0; + _mmcam_dbg_log("state_change_by_system %d, session flag 0x%x, acquired_focus %d, sound_focus_id %d, sound_focus_watch_id %d", + hcamcorder->state_change_by_system, hcamcorder->session_flags, hcamcorder->acquired_focus, + hcamcorder->sound_focus_id, hcamcorder->sound_focus_watch_id); - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL); + if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_ASM && + hcamcorder->sound_focus_watch_id > 0) { + ret_sound = mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id); + if (ret_sound != MM_ERROR_NONE) { + _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback failed [0x%x]", + ret_sound); + } else { + _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback done"); + } + } else { + _mmcam_dbg_warn("no need to unset watch callback.[state_change_by_system %d, sound_focus_watch_id %d]", + hcamcorder->state_change_by_system, hcamcorder->sound_focus_watch_id); + } - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_NULL); + if (hcamcorder->acquired_focus > 0) { + ret_sound = mm_sound_release_focus(0, hcamcorder->acquired_focus, NULL); + if (ret_sound != MM_ERROR_NONE) { + _mmcam_dbg_warn("mm_sound_release_focus failed [0x%x]", + ret_sound); + } else { + _mmcam_dbg_log("mm_sound_release_focus done"); + } + } else { + _mmcam_dbg_warn("no need to release focus - current acquired focus %d", + hcamcorder->acquired_focus); + } } _MMCAMCORDER_UNLOCK_CMD(hcamcorder); @@ -1107,6 +1252,19 @@ int _mmcamcorder_start(MMHandleType handle) /* set attributes related sensor */ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { + /* init for gdbus */ + hcamcorder->gdbus_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL); + if (hcamcorder->gdbus_conn == NULL) { + _mmcam_dbg_err("failed to get gdbus"); + ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + + g_mutex_init(&hcamcorder->gdbus_info_sound.sync_mutex); + g_cond_init(&hcamcorder->gdbus_info_sound.sync_cond); + g_mutex_init(&hcamcorder->gdbus_info_solo_sound.sync_mutex); + g_cond_init(&hcamcorder->gdbus_info_solo_sound.sync_cond); + _mmcamcorder_set_attribute_to_camsensor(handle); } @@ -1122,24 +1280,21 @@ int _mmcamcorder_start(MMHandleType handle) _mmcamcorder_set_state(handle, state_TO); - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* check camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - - /* set camera state to vconf key */ - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: + if (hcamcorder->gdbus_conn) { + g_object_unref(hcamcorder->gdbus_conn); + hcamcorder->gdbus_conn = NULL; + + g_mutex_clear(&hcamcorder->gdbus_info_sound.sync_mutex); + g_cond_clear(&hcamcorder->gdbus_info_sound.sync_cond); + g_mutex_clear(&hcamcorder->gdbus_info_solo_sound.sync_mutex); + g_cond_clear(&hcamcorder->gdbus_info_solo_sound.sync_cond); + } + _MMCAMCORDER_UNLOCK_CMD(hcamcorder); _ERR_CAMCORDER_CMD_PRECON: @@ -1195,16 +1350,31 @@ int _mmcamcorder_stop(MMHandleType handle) _mmcamcorder_set_state(handle, state_TO); if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* check camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); + g_mutex_lock(&hcamcorder->gdbus_info_sound.sync_mutex); + if (hcamcorder->gdbus_info_sound.subscribe_id > 0) { + _mmcam_dbg_warn("subscribe_id[%u] is remained. remove it.", + hcamcorder->gdbus_info_sound.subscribe_id); + g_dbus_connection_signal_unsubscribe(hcamcorder->gdbus_conn, + hcamcorder->gdbus_info_sound.subscribe_id); + } + g_mutex_unlock(&hcamcorder->gdbus_info_sound.sync_mutex); + + g_mutex_lock(&hcamcorder->gdbus_info_solo_sound.sync_mutex); + if (hcamcorder->gdbus_info_solo_sound.subscribe_id > 0) { + _mmcam_dbg_warn("subscribe_id[%u] is remained. remove it.", + hcamcorder->gdbus_info_solo_sound.subscribe_id); + g_dbus_connection_signal_unsubscribe(hcamcorder->gdbus_conn, + hcamcorder->gdbus_info_solo_sound.subscribe_id); + } + g_mutex_unlock(&hcamcorder->gdbus_info_solo_sound.sync_mutex); - /* set camera state to vconf key */ - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN); + g_object_unref(hcamcorder->gdbus_conn); + hcamcorder->gdbus_conn = NULL; - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN); + g_mutex_clear(&hcamcorder->gdbus_info_sound.sync_mutex); + g_cond_clear(&hcamcorder->gdbus_info_sound.sync_cond); + g_mutex_clear(&hcamcorder->gdbus_info_solo_sound.sync_mutex); + g_cond_clear(&hcamcorder->gdbus_info_solo_sound.sync_cond); } _MMCAMCORDER_UNLOCK_CMD(hcamcorder); @@ -1264,7 +1434,19 @@ int _mmcamcorder_capture_start(MMHandleType handle) ret = MM_ERROR_CAMCORDER_DEVICE_BUSY; goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } else { - hcamcorder->capture_in_recording = TRUE; + g_mutex_lock(&hcamcorder->task_thread_lock); + if (hcamcorder->task_thread_state == _MMCAMCORDER_TASK_THREAD_STATE_NONE) { + hcamcorder->capture_in_recording = TRUE; + hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_CHECK_CAPTURE_IN_RECORDING; + _mmcam_dbg_log("send signal for capture in recording"); + g_cond_signal(&hcamcorder->task_thread_cond); + g_mutex_unlock(&hcamcorder->task_thread_lock); + } else { + _mmcam_dbg_err("task thread busy : %d", hcamcorder->task_thread_state); + g_mutex_unlock(&hcamcorder->task_thread_lock); + ret = MM_ERROR_CAMCORDER_INVALID_STATE; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } } } @@ -1361,6 +1543,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); @@ -1388,6 +1571,18 @@ int _mmcamcorder_record(MMHandleType handle) /* initialize error code */ hcamcorder->error_code = MM_ERROR_NONE; + /* check mic policy from DPM */ + 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..."); + } + ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_RECORD); if (ret != MM_ERROR_NONE) { /* check internal error of gstreamer */ @@ -1400,27 +1595,6 @@ int _mmcamcorder_record(MMHandleType handle) _mmcamcorder_set_state(handle, state_TO); - /* set camera state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_RECORDING); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING); - } else { - int vconf_recorder_state = 0; - - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_RECORDING); - - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_RECORDING); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; @@ -1481,27 +1655,6 @@ int _mmcamcorder_pause(MMHandleType handle) _mmcamcorder_set_state(handle, state_TO); - /* set camera state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE); - } else { - int vconf_recorder_state = 0; - - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_RECORDING_PAUSE); - - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_RECORDING_PAUSE); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; @@ -1554,27 +1707,6 @@ int _mmcamcorder_commit(MMHandleType handle) goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - /* set camera state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW); - } else { - int vconf_recorder_state = 0; - - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED); - - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); _mmcamcorder_set_state(handle,state_TO); @@ -1631,27 +1763,6 @@ int _mmcamcorder_cancel(MMHandleType handle) _mmcamcorder_set_state(handle, state_TO); - /* set camera state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW); - } else { - int vconf_recorder_state = 0; - - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED); - - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; @@ -1840,6 +1951,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; } @@ -2152,7 +2264,7 @@ __mmcamcorder_gstreamer_init(camera_conf * conf) /* release */ for (i = 0; i < *argc; i++) { if (argv[i]) { - free(argv[i]); + g_free(argv[i]); argv[i] = NULL; } } @@ -2223,8 +2335,27 @@ void _mmcamcorder_set_state(MMHandleType handle, int state) _mmcam_dbg_log("set state[%d] and send state-changed message", state); - msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED; - msg.param.state.code = MM_ERROR_NONE; + /* To discern who changes the state */ + switch (hcamcorder->state_change_by_system) { + case _MMCAMCORDER_STATE_CHANGE_BY_ASM: + msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM; + msg.param.state.code = hcamcorder->interrupt_code; + break; + case _MMCAMCORDER_STATE_CHANGE_BY_RM: + 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; + msg.param.state.code = MM_ERROR_NONE; + break; + } + msg.param.state.previous = old_state; msg.param.state.current = state; @@ -2272,32 +2403,29 @@ _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)); - pthread_mutex_init(&(sc->info_video->size_check_lock), NULL); + g_mutex_init(&sc->info_video->size_check_lock); break; } @@ -2334,19 +2462,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) { - pthread_mutex_destroy(&(sc->info_video->size_check_lock)); - free(sc->info_video); - sc->info_video = NULL; + g_mutex_clear(&sc->info_video->size_check_lock); } + SAFE_G_FREE(sc->info_video); if (sc->element) { free(sc->element); sc->element = NULL; @@ -2388,21 +2509,15 @@ 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; - } - pthread_mutex_destroy(&(sc->info_video->size_check_lock)); + SAFE_G_FREE(sc->info_video->filename); + g_mutex_clear(&sc->info_video->size_check_lock); free(sc->info_video); sc->info_video = NULL; } 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; } @@ -2474,17 +2589,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: @@ -2730,13 +2852,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; } @@ -2744,7 +2863,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++) { @@ -2768,8 +2887,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; @@ -2797,7 +2915,7 @@ GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder); if (sc && sc->info_image) { /* play capture sound */ - _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE); + _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE01, FALSE); } } @@ -2851,20 +2969,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; @@ -2872,13 +2997,192 @@ GstBusSyncReply _mmcamcorder_audio_pipeline_bus_sync_callback(GstBus *bus, GstMe } g_error_free(err); - } return GST_BUS_PASS; } +void _mmcamcorder_sound_focus_cb(int id, mm_sound_focus_type_e focus_type, + mm_sound_focus_state_e focus_state, const char *reason_for_change, + const char *additional_info, void *user_data) +{ + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data); + int current_state = MM_CAMCORDER_STATE_NONE; + + mmf_return_if_fail((MMHandleType)hcamcorder); + + 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_log("sound focus callback : focus state %d, reason %s", + focus_state, reason_for_change ? reason_for_change : "N/A"); + + if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) { + _mmcam_dbg_warn("session flag is UNINTERRUPTIBLE. do nothing."); + return; + } + + _MMCAMCORDER_LOCK_ASM(hcamcorder); + + /* set value to inform a status is changed by asm */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_ASM; + + /* check the reason */ + if (!strncmp(reason_for_change, "ringtone-voip", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) || + !strncmp(reason_for_change, "ringtone-call", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) || + !strncmp(reason_for_change, "voip", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) || + !strncmp(reason_for_change, "call-voice", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN)) { + hcamcorder->interrupt_code = MM_MSG_CODE_INTERRUPTED_BY_CALL_START; + } else if (!strncmp(reason_for_change, "alarm", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN)) { + hcamcorder->interrupt_code = MM_MSG_CODE_INTERRUPTED_BY_ALARM_START; + } else { + hcamcorder->interrupt_code = MM_MSG_CODE_INTERRUPTED_BY_MEDIA; + } + + if (focus_state == FOCUS_IS_RELEASED) { + hcamcorder->acquired_focus &= ~focus_type; + + _mmcam_dbg_log("FOCUS is released [type %d, remained focus %d] : Stop pipeline[state:%d]", + focus_type, hcamcorder->acquired_focus, current_state); + + __mmcamcorder_force_stop(hcamcorder); + + _mmcam_dbg_log("Finish opeartion. Pipeline is released"); + } else if (focus_state == FOCUS_IS_ACQUIRED) { + _MMCamcorderMsgItem msg; + + hcamcorder->acquired_focus |= focus_type; + + _mmcam_dbg_log("FOCUS is acquired [type %d, new focus %d]", + focus_type, hcamcorder->acquired_focus); + + msg.id = MM_MESSAGE_READY_TO_RESUME; + _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg); + + _mmcam_dbg_log("Finish opeartion"); + } else { + _mmcam_dbg_log("unknown focus state %d", focus_state); + } + + /* restore value */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL; + + _MMCAMCORDER_UNLOCK_ASM(hcamcorder); + + return; +} + + +void _mmcamcorder_sound_focus_watch_cb(mm_sound_focus_type_e focus_type, mm_sound_focus_state_e focus_state, + const char *reason_for_change, const char *additional_info, void *user_data) +{ + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data); + int current_state = MM_CAMCORDER_STATE_NONE; + + mmf_return_if_fail(hcamcorder); + + 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_log("sound focus watch callback : focus state %d, reason %s", + focus_state, reason_for_change ? reason_for_change : "N/A"); + + if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) { + _mmcam_dbg_warn("session flag is UNINTERRUPTIBLE. do nothing."); + return; + } + + _MMCAMCORDER_LOCK_ASM(hcamcorder); + + /* set value to inform a status is changed by asm */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_ASM; + + /* check the reason */ + if (!strncmp(reason_for_change, "ringtone-voip", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) || + !strncmp(reason_for_change, "ringtone-call", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) || + !strncmp(reason_for_change, "voip", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) || + !strncmp(reason_for_change, "call-voice", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN)) { + hcamcorder->interrupt_code = MM_MSG_CODE_INTERRUPTED_BY_CALL_START; + } else if (!strncmp(reason_for_change, "alarm", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN)) { + hcamcorder->interrupt_code = MM_MSG_CODE_INTERRUPTED_BY_ALARM_START; + } else { + hcamcorder->interrupt_code = MM_MSG_CODE_INTERRUPTED_BY_MEDIA; + } + + if (focus_state == FOCUS_IS_RELEASED) { + _MMCamcorderMsgItem msg; + + _mmcam_dbg_log("other process's FOCUS is acquired"); + + msg.id = MM_MESSAGE_READY_TO_RESUME; + _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg); + + _mmcam_dbg_log("Finish opeartion"); + } else if (focus_state == FOCUS_IS_ACQUIRED) { + _mmcam_dbg_log("other process's FOCUS is released : Stop pipeline[state:%d]", current_state); + + __mmcamcorder_force_stop(hcamcorder); + + _mmcam_dbg_log("Finish opeartion. Pipeline is released"); + } else { + _mmcam_dbg_log("unknown focus state %d", focus_state); + } + + /* restore value */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL; + + _MMCAMCORDER_UNLOCK_ASM(hcamcorder); + + return; +} + + +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; @@ -2919,7 +3223,11 @@ int _mmcamcorder_create_pipeline(MMHandleType handle, int type) pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst; if (type != MM_CAMCORDER_MODE_AUDIO) { + traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:REALIZE:SET_READY_TO_PIPELINE"); + ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY); + + traceEnd(TTRACE_TAG_CAMERA); } #ifdef _MMCAMCORDER_GET_DEVICE_INFO if (!_mmcamcorder_get_device_info(handle)) { @@ -3057,7 +3365,7 @@ int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstSta GstStateChangeReturn setChangeReturn = GST_STATE_CHANGE_FAILURE; GstStateChangeReturn getChangeReturn = GST_STATE_CHANGE_FAILURE; GstClockTime get_timeout = __MMCAMCORDER_SET_GST_STATE_TIMEOUT * GST_SECOND; - pthread_mutex_t *state_lock = NULL; + GMutex *state_lock = NULL; mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED); sc = MMF_CAMCORDER_SUBCONTEXT(handle); @@ -3071,7 +3379,7 @@ int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstSta state_lock = &_MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle); } - pthread_mutex_lock(state_lock); + g_mutex_lock(state_lock); for (k = 0; k < _MMCAMCORDER_STATE_SET_COUNT; k++) { setChangeReturn = gst_element_set_state(pipeline, target_state); @@ -3086,7 +3394,7 @@ int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstSta /* if we reached the final target state, exit */ if (pipeline_state == target_state) { _mmcam_dbg_log("Set state to %d - DONE", target_state); - pthread_mutex_unlock(state_lock); + g_mutex_unlock(state_lock); return MM_ERROR_NONE; } break; @@ -3094,12 +3402,12 @@ int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstSta _mmcam_dbg_log("status=GST_STATE_CHANGE_ASYNC."); break; default: - pthread_mutex_unlock(state_lock); + g_mutex_unlock(state_lock); _mmcam_dbg_log("status=GST_STATE_CHANGE_FAILURE."); return MM_ERROR_CAMCORDER_GST_STATECHANGE; } - pthread_mutex_unlock(state_lock); + g_mutex_unlock(state_lock); _mmcam_dbg_err("timeout of gst_element_get_state()!!"); @@ -3109,7 +3417,7 @@ int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstSta usleep(_MMCAMCORDER_STATE_CHECK_INTERVAL); } - pthread_mutex_unlock(state_lock); + g_mutex_unlock(state_lock); _mmcam_dbg_err("Failure. gst_element_set_state timeout!!"); @@ -3162,11 +3470,117 @@ void _mmcamcorder_video_current_framerate_init(MMHandleType handle) } +void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) +{ + int i = 0; + int loop = 0; + int itr_cnt = 0; + int result = MM_ERROR_NONE; + int cmd_try_count = 0; + int current_state = MM_CAMCORDER_STATE_NONE; + + mmf_return_if_fail(hcamcorder); + + /* check command running */ + do { + if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) { + if (cmd_try_count++ < __MMCAMCORDER_FORCE_STOP_TRY_COUNT) { + _mmcam_dbg_warn("Another command is running. try again after %d ms", __MMCAMCORDER_FORCE_STOP_WAIT_TIME/1000); + usleep(__MMCAMCORDER_FORCE_STOP_WAIT_TIME); + } else { + _mmcam_dbg_err("wait timeout"); + break; + } + } else { + _MMCAMCORDER_UNLOCK_CMD(hcamcorder); + break; + } + } while (TRUE); + + current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); + + _mmcam_dbg_warn("Force STOP MMFW Camcorder"); + + for (loop = 0 ; current_state > MM_CAMCORDER_STATE_NULL && loop < __MMCAMCORDER_CMD_ITERATE_MAX * 3 ; loop++) { + itr_cnt = __MMCAMCORDER_CMD_ITERATE_MAX; + switch (current_state) { + case MM_CAMCORDER_STATE_CAPTURING: + { + _MMCamcorderSubContext *sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder); + _MMCamcorderImageInfo *info = NULL; + + mmf_return_if_fail(sc); + mmf_return_if_fail((info = sc->info_image)); + + _mmcam_dbg_warn("Stop capturing."); + + /* if caturing isn't finished, waiting for 2 sec to finish real capture operation. check 'info->capturing'. */ + mm_camcorder_set_attributes((MMHandleType)hcamcorder, NULL, + MMCAM_CAPTURE_BREAK_CONTINUOUS_SHOT, TRUE, + NULL); + + for (i = 0; i < 20 && info->capturing; i++) { + usleep(100000); + } + + if (i == 20) { + _mmcam_dbg_err("Timeout. Can't check stop capturing."); + } + + while ((itr_cnt--) && ((result = _mmcamcorder_capture_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) { + _mmcam_dbg_warn("Can't stop capturing.(%x)", result); + } + + break; + } + case MM_CAMCORDER_STATE_RECORDING: + case MM_CAMCORDER_STATE_PAUSED: + { + _mmcam_dbg_warn("Stop recording."); + + while ((itr_cnt--) && ((result = _mmcamcorder_commit((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) { + _mmcam_dbg_warn("Can't commit.(%x)", result); + } + break; + } + case MM_CAMCORDER_STATE_PREPARE: + { + _mmcam_dbg_warn("Stop preview."); + + while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) { + _mmcam_dbg_warn("Can't stop preview.(%x)", result); + } + break; + } + case MM_CAMCORDER_STATE_READY: + { + _mmcam_dbg_warn("unrealize"); + + if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE) { + _mmcam_dbg_warn("Can't unrealize.(%x)", result); + } + break; + } + case MM_CAMCORDER_STATE_NULL: + default: + _mmcam_dbg_warn("Already stopped."); + break; + } + + current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); + } + + _mmcam_dbg_warn( "Done." ); + + return; +} + + static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage *message, GError *error) { 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); @@ -3221,10 +3635,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; } @@ -3328,6 +3744,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) { @@ -3519,3 +3969,31 @@ static gint __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMe return MM_ERROR_NONE; } + +int _mmcamcorder_get_video_caps(MMHandleType handle, char **caps) +{ + GstPad *pad = NULL; + GstCaps *sink_caps = NULL; + _MMCamcorderSubContext *sc = NULL; + + sc = MMF_CAMCORDER_SUBCONTEXT(handle); + _mmcam_dbg_warn("Entered "); + pad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "sink"); + if(!pad) { + _mmcam_dbg_err("static pad is NULL"); + return MM_ERROR_CAMCORDER_INVALID_STATE; + } + + sink_caps = gst_pad_get_current_caps(pad); + gst_object_unref( pad ); + if(!sink_caps) { + _mmcam_dbg_err("fail to get caps"); + return MM_ERROR_CAMCORDER_INVALID_STATE; + } + + *caps = gst_caps_to_string(sink_caps); + _mmcam_dbg_err("video caps : %s", *caps); + gst_caps_unref(sink_caps); + + return MM_ERROR_NONE; +}