X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_internal.c;h=0ffdb412893bfcd0952999ba31adc89fb73dde7c;hb=d87e2b311e862b5aaf3490e42efd3a6f67d839b4;hp=5b80a1ec6c694964330006eeb2c451644ebaceb0;hpb=02d194fc29293eede2e332206f7b2066ce2b28a9;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git diff --git a/src/mm_camcorder_internal.c b/src/mm_camcorder_internal.c index 5b80a1e..0ffdb41 100644 --- a/src/mm_camcorder_internal.c +++ b/src/mm_camcorder_internal.c @@ -23,6 +23,7 @@ | INCLUDE FILES | ========================================================================================*/ #include +#include #include #include #include @@ -40,10 +41,6 @@ #include -#ifdef _MMCAMCORDER_MURPHY_SUPPORT -#include -#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ - #ifdef _MMCAMCORDER_RM_SUPPORT #include #endif /* _MMCAMCORDER_RM_SUPPORT */ @@ -57,20 +54,22 @@ #define __MMCAMCORDER_FORCE_STOP_WAIT_TIME 100000 /* us */ #define __MMCAMCORDER_SOUND_WAIT_TIMEOUT 3 #define __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN 64 +#define __MMCAMCORDER_CONF_FILENAME_LENGTH 32 #define DPM_ALLOWED 1 #define DPM_DISALLOWED 0 -#ifdef _MMCAMCORDER_MURPHY_SUPPORT -#define __MMCAMCORDER_RESOURCE_WAIT_TIME 3 -#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ - - /*--------------------------------------------------------------------------------------- | LOCAL FUNCTION PROTOTYPES: | ---------------------------------------------------------------------------------------*/ /* STATIC INTERNAL FUNCTION */ -static gboolean __mmcamcorder_gstreamer_init(camera_conf * conf); +static gint __mmcamcorder_init_handle(mmf_camcorder_t **hcamcorder, int device_type); +static void __mmcamcorder_deinit_handle(mmf_camcorder_t *hcamcorder); +static gint __mmcamcorder_init_configure_video_capture(mmf_camcorder_t *hcamcorder); +static gint __mmcamcorder_init_configure_audio(mmf_camcorder_t *hcamcorder); +static void __mmcamcorder_deinit_configure(mmf_camcorder_t *hcamcorder); +static gboolean __mmcamcorder_init_gstreamer(camera_conf *conf); +static void __mmcamcorder_get_system_info(mmf_camcorder_t *hcamcorder); static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage *message, GError *error); static gint __mmcamcorder_gst_handle_stream_error(MMHandleType handle, int code, GstMessage *message); @@ -79,10 +78,13 @@ static gint __mmcamcorder_gst_handle_library_error(MMHandleType handle, int static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, GstMessage *message); 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_MM_RM_SUPPORT +static int __mmcamcorder_resource_release_cb(mm_resource_manager_h rm, + mm_resource_manager_res_h res, void *user_data); +#endif /* _MMCAMCORDER_MM_RM_SUPPORT */ #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); +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); @@ -91,16 +93,223 @@ static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data); /*======================================================================================= | FUNCTION DEFINITIONS | =======================================================================================*/ -/*--------------------------------------------------------------------------------------- -| GLOBAL FUNCTION DEFINITIONS: | ----------------------------------------------------------------------------------------*/ +static gint __mmcamcorder_init_handle(mmf_camcorder_t **hcamcorder, int device_type) +{ + int ret = MM_ERROR_NONE; + mmf_camcorder_t *new_handle = NULL; -/* Internal command functions {*/ -int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) + if (!hcamcorder) { + _mmcam_dbg_err("NULL handle"); + return MM_ERROR_CAMCORDER_INVALID_ARGUMENT; + } + + /* Create mmf_camcorder_t handle and initialize every variable */ + new_handle = (mmf_camcorder_t *)malloc(sizeof(mmf_camcorder_t)); + if (!new_handle) { + _mmcam_dbg_err("new handle allocation failed"); + return MM_ERROR_CAMCORDER_LOW_MEMORY; + } + + memset(new_handle, 0x00, sizeof(mmf_camcorder_t)); + + /* set device type */ + new_handle->device_type = device_type; + + _mmcam_dbg_warn("Device Type : %d", new_handle->device_type); + + new_handle->type = MM_CAMCORDER_MODE_VIDEO_CAPTURE; + new_handle->state = MM_CAMCORDER_STATE_NONE; + new_handle->old_state = MM_CAMCORDER_STATE_NONE; + new_handle->capture_in_recording = FALSE; + + /* init mutex and cond */ + g_mutex_init(&(new_handle->mtsafe).lock); + g_cond_init(&(new_handle->mtsafe).cond); + g_mutex_init(&(new_handle->mtsafe).cmd_lock); + g_cond_init(&(new_handle->mtsafe).cmd_cond); + g_mutex_init(&(new_handle->mtsafe).interrupt_lock); + g_mutex_init(&(new_handle->mtsafe).state_lock); + g_mutex_init(&(new_handle->mtsafe).gst_state_lock); + g_mutex_init(&(new_handle->mtsafe).gst_encode_state_lock); + g_mutex_init(&(new_handle->mtsafe).message_cb_lock); + g_mutex_init(&(new_handle->mtsafe).vcapture_cb_lock); + g_mutex_init(&(new_handle->mtsafe).vstream_cb_lock); + g_mutex_init(&(new_handle->mtsafe).astream_cb_lock); + g_mutex_init(&(new_handle->mtsafe).mstream_cb_lock); +#ifdef _MMCAMCORDER_MM_RM_SUPPORT + g_mutex_init(&(new_handle->mtsafe).resource_lock); +#endif /* _MMCAMCORDER_MM_RM_SUPPORT */ + + g_mutex_init(&new_handle->restart_preview_lock); + + g_mutex_init(&new_handle->snd_info.open_mutex); + g_cond_init(&new_handle->snd_info.open_cond); + g_mutex_init(&new_handle->snd_info.play_mutex); + g_cond_init(&new_handle->snd_info.play_cond); + + g_mutex_init(&new_handle->task_thread_lock); + g_cond_init(&new_handle->task_thread_cond); + new_handle->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE; + + if (device_type != MM_VIDEO_DEVICE_NONE) { + new_handle->gdbus_info_sound.mm_handle = new_handle; + g_mutex_init(&new_handle->gdbus_info_sound.sync_mutex); + g_cond_init(&new_handle->gdbus_info_sound.sync_cond); + + new_handle->gdbus_info_solo_sound.mm_handle = new_handle; + g_mutex_init(&new_handle->gdbus_info_solo_sound.sync_mutex); + g_cond_init(&new_handle->gdbus_info_solo_sound.sync_cond); + } + + /* create task thread */ + new_handle->task_thread = g_thread_try_new("MMCAM_TASK_THREAD", + (GThreadFunc)_mmcamcorder_util_task_thread_func, (gpointer)new_handle, NULL); + if (new_handle->task_thread == NULL) { + _mmcam_dbg_err("_mmcamcorder_create::failed to create task thread"); + ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION; + goto _INIT_HANDLE_FAILED; + } + + /* Get Camera Configure information from Camcorder INI file */ + ret = _mmcamcorder_conf_get_info((MMHandleType)new_handle, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &new_handle->conf_main); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("Failed to get configure(main) info."); + goto _INIT_HANDLE_FAILED; + } + + /* allocate attribute */ + new_handle->attributes = _mmcamcorder_alloc_attribute((MMHandleType)new_handle); + if (!new_handle->attributes) { + ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION; + goto _INIT_HANDLE_FAILED; + } + + *hcamcorder = new_handle; + + _mmcam_dbg_log("new handle %p", new_handle); + + return MM_ERROR_NONE; + +_INIT_HANDLE_FAILED: + __mmcamcorder_deinit_handle(new_handle); + return ret; +} + + +static void __mmcamcorder_deinit_handle(mmf_camcorder_t *hcamcorder) +{ + if (!hcamcorder) { + _mmcam_dbg_err("NULL handle"); + return; + } + + /* Remove exif info */ + if (hcamcorder->exif_info) { + mm_exif_destory_exif_info(hcamcorder->exif_info); + hcamcorder->exif_info = NULL; + } + + /* remove attributes */ + if (hcamcorder->attributes) { + _mmcamcorder_dealloc_attribute((MMHandleType)hcamcorder, hcamcorder->attributes); + hcamcorder->attributes = 0; + } + + /* Release configure info */ + __mmcamcorder_deinit_configure(hcamcorder); + + /* remove task thread */ + if (hcamcorder->task_thread) { + 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; + g_cond_signal(&hcamcorder->task_thread_cond); + g_mutex_unlock(&hcamcorder->task_thread_lock); + g_thread_join(hcamcorder->task_thread); + hcamcorder->task_thread = NULL; + } + + /* Release lock, cond */ + 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).interrupt_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->mtsafe).mstream_cb_lock); +#ifdef _MMCAMCORDER_MM_RM_SUPPORT + g_mutex_clear(&(hcamcorder->mtsafe).resource_lock); +#endif /* _MMCAMCORDER_MM_RM_SUPPORT */ + + 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->device_type != MM_VIDEO_DEVICE_NONE) { + 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); + } + + g_mutex_clear(&hcamcorder->task_thread_lock); + g_cond_clear(&hcamcorder->task_thread_cond); + + if (hcamcorder->model_name) + free(hcamcorder->model_name); + + if (hcamcorder->software_version) + free(hcamcorder->software_version); + + /* Release handle */ + memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t)); + + free(hcamcorder); + + return; +} + + +static void __mmcamcorder_get_system_info(mmf_camcorder_t *hcamcorder) +{ + int ret = 0; + + if (!hcamcorder) { + _mmcam_dbg_err("NULL handle"); + return; + } + + /* get shutter sound policy */ + vconf_get_int(VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY, &hcamcorder->shutter_sound_policy); + _mmcam_dbg_log("current shutter sound policy : %d", hcamcorder->shutter_sound_policy); + + /* get model name */ + ret = system_info_get_platform_string("http://tizen.org/system/model_name", &hcamcorder->model_name); + + _mmcam_dbg_warn("model name [%s], ret 0x%x", + hcamcorder->model_name ? hcamcorder->model_name : "NULL", ret); + + /* get software version */ + ret = system_info_get_platform_string("http://tizen.org/system/build.string", &hcamcorder->software_version); + + _mmcam_dbg_warn("software version [%s], ret 0x%x", + hcamcorder->software_version ? hcamcorder->software_version : "NULL", ret); + + return; +} + + +static gint __mmcamcorder_init_configure_video_capture(mmf_camcorder_t *hcamcorder) { int ret = MM_ERROR_NONE; - int sys_info_ret = SYSTEM_INFO_ERROR_NONE; - int UseConfCtrl = 0; + int resolution_width = 0; + int resolution_height = 0; int rcmd_fmt_capture = MM_PIXEL_FORMAT_YUYV; int rcmd_fmt_recording = MM_PIXEL_FORMAT_NV12; int rcmd_dpy_rotation = MM_DISPLAY_ROTATION_270; @@ -109,283 +318,261 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) int camera_default_flip = MM_FLIP_NONE; int camera_facing_direction = MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR; char *err_attr_name = NULL; - const char *ConfCtrlFile = NULL; - mmf_camcorder_t *hcamcorder = NULL; - type_element *EvasSurfaceElement = NULL; + char conf_file_name[__MMCAMCORDER_CONF_FILENAME_LENGTH] = {'\0',}; + MMCamAttrsInfo fps_info; - _mmcam_dbg_log("Entered"); + if (!hcamcorder) { + _mmcam_dbg_err("NULL handle"); + return MM_ERROR_CAMCORDER_NOT_INITIALIZED; + } - mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); - mmf_return_val_if_fail(info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); + snprintf(conf_file_name, sizeof(conf_file_name), "%s%d.ini", + CONFIGURE_CTRL_FILE_PREFIX, hcamcorder->device_type); - /* Create mmf_camcorder_t handle and initialize every variable */ - hcamcorder = (mmf_camcorder_t *)malloc(sizeof(mmf_camcorder_t)); - mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_LOW_MEMORY); - memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t)); + _mmcam_dbg_log("Load control configure file [%d][%s]", hcamcorder->device_type, conf_file_name); - /* init values */ - hcamcorder->type = 0; - hcamcorder->state = MM_CAMCORDER_STATE_NONE; - hcamcorder->sub_context = NULL; - hcamcorder->target_state = MM_CAMCORDER_STATE_NULL; - hcamcorder->capture_in_recording = FALSE; - 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_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); - 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->mtsafe).mstream_cb_lock); -#ifdef _MMCAMCORDER_MURPHY_SUPPORT - g_cond_init(&(hcamcorder->mtsafe).resource_cond); - g_mutex_init(&(hcamcorder->mtsafe).resource_lock); -#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ - - g_mutex_init(&hcamcorder->restart_preview_lock); - - /* Sound mutex/cond init */ - 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 */ - g_mutex_init(&hcamcorder->task_thread_lock); - g_cond_init(&hcamcorder->task_thread_cond); - hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE; - - if (info->videodev_type != MM_VIDEO_DEVICE_NONE) { - /* init for gdbus */ - hcamcorder->gdbus_info_sound.mm_handle = hcamcorder; - g_mutex_init(&hcamcorder->gdbus_info_sound.sync_mutex); - g_cond_init(&hcamcorder->gdbus_info_sound.sync_cond); - - hcamcorder->gdbus_info_solo_sound.mm_handle = hcamcorder; - g_mutex_init(&hcamcorder->gdbus_info_solo_sound.sync_mutex); - g_cond_init(&hcamcorder->gdbus_info_solo_sound.sync_cond); + ret = _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, + CONFIGURE_TYPE_CTRL, (const char *)conf_file_name, &hcamcorder->conf_ctrl); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("Failed to get configure(control) info."); + return ret; + } +/* + _mmcamcorder_conf_print_info(&hcamcorder->conf_main); + _mmcamcorder_conf_print_info(&hcamcorder->conf_ctrl); +*/ + ret = _mmcamcorder_init_convert_table((MMHandleType)hcamcorder); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_warn("converting table initialize error!!"); + return MM_ERROR_CAMCORDER_INTERNAL; } - /* create task thread */ - 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; + ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, MM_CAMCONVERT_CATEGORY_ALL); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_warn("attribute initialize from configure error!!"); + return MM_ERROR_CAMCORDER_INTERNAL; } - if (info->videodev_type < MM_VIDEO_DEVICE_NONE || - info->videodev_type >= MM_VIDEO_DEVICE_NUM) { - _mmcam_dbg_err("_mmcamcorder_create::video device type is out of range."); - ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT; - goto _ERR_DEFAULT_VALUE_INIT; + /* Get device info, recommend preview fmt and display rotation from INI */ + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, + CONFIGURE_CATEGORY_CTRL_CAMERA, + "RecommendPreviewFormatCapture", + &rcmd_fmt_capture); + + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, + CONFIGURE_CATEGORY_CTRL_CAMERA, + "RecommendPreviewFormatRecord", + &rcmd_fmt_recording); + + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, + CONFIGURE_CATEGORY_CTRL_CAMERA, + "RecommendDisplayRotation", + &rcmd_dpy_rotation); + + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, + CONFIGURE_CATEGORY_MAIN_CAPTURE, + "PlayCaptureSound", + &play_capture_sound); + + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, + CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, + "DeviceCount", + &camera_device_count); + + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, + CONFIGURE_CATEGORY_CTRL_CAMERA, + "FacingDirection", + &camera_facing_direction); + + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, + CONFIGURE_CATEGORY_CTRL_EFFECT, + "BrightnessStepDenominator", + &hcamcorder->brightness_step_denominator); + + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, + CONFIGURE_CATEGORY_CTRL_CAPTURE, + "SupportZSL", + &hcamcorder->support_zsl_capture); + + _mmcam_dbg_log("Recommend fmt[cap:%d,rec:%d], dpy rot %d, cap snd %d, dev cnt %d, cam facing dir %d, step denom %d, support zsl %d", + rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation, + play_capture_sound, camera_device_count, camera_facing_direction, + hcamcorder->brightness_step_denominator, hcamcorder->support_zsl_capture); + + /* Get UseZeroCopyFormat value from INI */ + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, + CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, + "UseZeroCopyFormat", + &hcamcorder->use_zero_copy_format); + + /* Get SupportUserBuffer value from INI */ + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, + CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, + "SupportUserBuffer", + &hcamcorder->support_user_buffer); + + /* Get SupportMediaPacketPreviewCb value from INI */ + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, + CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, + "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, + NULL); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("get attribute[resolution] error"); + return MM_ERROR_CAMCORDER_INTERNAL; } - /* set device type */ - hcamcorder->device_type = info->videodev_type; - _mmcam_dbg_warn("Device Type : %d", hcamcorder->device_type); + ret = mm_camcorder_get_fps_list_by_resolution((MMHandleType)hcamcorder, resolution_width, resolution_height, &fps_info); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("get fps list failed with [%dx%d]", resolution_width, resolution_height); + return MM_ERROR_CAMCORDER_INTERNAL; + } - /* Get Camera Configure information from Camcorder INI file */ - ret = _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &hcamcorder->conf_main); + _mmcam_dbg_log("ZeroCopy %d, UserBuffer %d, Videoconvert %d, MPPreviewCb %d", + hcamcorder->use_zero_copy_format, hcamcorder->support_user_buffer, + 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) + camera_default_flip = MM_FLIP_VERTICAL; + else + camera_default_flip = MM_FLIP_HORIZONTAL; + + _mmcam_dbg_log("camera_default_flip : [%d]", camera_default_flip); + } + + ret = mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name, + MMCAM_CAMERA_DEVICE_COUNT, camera_device_count, + MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction, + MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture, + MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording, + MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation, + MMCAM_SUPPORT_ZSL_CAPTURE, hcamcorder->support_zsl_capture, + MMCAM_SUPPORT_ZERO_COPY_FORMAT, hcamcorder->use_zero_copy_format, + MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB, hcamcorder->support_media_packet_preview_cb, + MMCAM_SUPPORT_USER_BUFFER, hcamcorder->support_user_buffer, + MMCAM_CAMERA_FPS, fps_info.int_array.def, + MMCAM_DISPLAY_FLIP, camera_default_flip, + MMCAM_CAPTURE_SOUND_ENABLE, play_capture_sound, + NULL); if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("Failed to get configure(main) info."); - goto _ERR_DEFAULT_VALUE_INIT; + _mmcam_dbg_err("[0x%x] Set %s FAILED.", ret, err_attr_name ? err_attr_name : "[UNKNOWN]"); + SAFE_FREE(err_attr_name); + return MM_ERROR_CAMCORDER_INTERNAL; } - hcamcorder->attributes = _mmcamcorder_alloc_attribute((MMHandleType)hcamcorder, info); - if (!(hcamcorder->attributes)) { - _mmcam_dbg_err("_mmcamcorder_create::alloc attribute error."); + /* Get default value of brightness */ + ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, + MMCAM_FILTER_BRIGHTNESS, &hcamcorder->brightness_default, + NULL); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("Get brightness FAILED."); + return MM_ERROR_CAMCORDER_INTERNAL; + } - ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION; - goto _ERR_DEFAULT_VALUE_INIT; + _mmcam_dbg_log("Default brightness : %d", hcamcorder->brightness_default); + + return ret; +} + + +static gint __mmcamcorder_init_configure_audio(mmf_camcorder_t *hcamcorder) +{ + int ret = MM_ERROR_NONE; + int camera_device_count = 0; + + if (!hcamcorder) { + _mmcam_dbg_err("NULL handle"); + return MM_ERROR_CAMCORDER_NOT_INITIALIZED; } - /* get DPM handle for camera/microphone restriction */ - hcamcorder->dpm_handle = dpm_manager_create(); + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, + CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, + "DeviceCount", + &camera_device_count); - _mmcam_dbg_warn("DPM handle %p", hcamcorder->dpm_handle); + ret = mm_camcorder_set_attributes((MMHandleType)hcamcorder, NULL, + MMCAM_CAMERA_DEVICE_COUNT, camera_device_count, + NULL); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("Set device count FAILED"); + return MM_ERROR_CAMCORDER_INTERNAL; + } - if (info->videodev_type != MM_VIDEO_DEVICE_NONE) { - _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, - "UseConfCtrl", &UseConfCtrl); + 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"); + return MM_ERROR_CAMCORDER_NOT_SUPPORTED; + } - if (UseConfCtrl) { - int resolution_width = 0; - int resolution_height = 0; - MMCamAttrsInfo fps_info; + return ret; +} - _mmcam_dbg_log("Enable Configure Control system."); - switch (info->videodev_type) { - case MM_VIDEO_DEVICE_CAMERA0: - _mmcamcorder_conf_get_value_string((MMHandleType)hcamcorder, hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, - "ConfCtrlFile0", &ConfCtrlFile); - break; - case MM_VIDEO_DEVICE_CAMERA1: - _mmcamcorder_conf_get_value_string((MMHandleType)hcamcorder, hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, - "ConfCtrlFile1", &ConfCtrlFile); - break; - default: - _mmcam_dbg_err("Not supported camera type."); - ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED; - goto _ERR_DEFAULT_VALUE_INIT; - } +static void __mmcamcorder_deinit_configure(mmf_camcorder_t *hcamcorder) +{ + if (!hcamcorder) { + _mmcam_dbg_err("NULL handle"); + return; + } - _mmcam_dbg_log("videodev_type : [%d], ConfCtrlPath : [%s]", info->videodev_type, ConfCtrlFile); + if (hcamcorder->conf_ctrl) + _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &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); -*/ - 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; - } + if (hcamcorder->conf_main) + _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_main); - 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; - } + return; +} - /* Get device info, recommend preview fmt and display rotation from INI */ - _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, - CONFIGURE_CATEGORY_CTRL_CAMERA, - "RecommendPreviewFormatCapture", - &rcmd_fmt_capture); - - _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, - CONFIGURE_CATEGORY_CTRL_CAMERA, - "RecommendPreviewFormatRecord", - &rcmd_fmt_recording); - - _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, - CONFIGURE_CATEGORY_CTRL_CAMERA, - "RecommendDisplayRotation", - &rcmd_dpy_rotation); - - _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_CAPTURE, - "PlayCaptureSound", - &play_capture_sound); - - _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, - "DeviceCount", - &camera_device_count); - - _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, - CONFIGURE_CATEGORY_CTRL_CAMERA, - "FacingDirection", - &camera_facing_direction); - - _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, - CONFIGURE_CATEGORY_CTRL_EFFECT, - "BrightnessStepDenominator", - &hcamcorder->brightness_step_denominator); - - _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, - CONFIGURE_CATEGORY_CTRL_CAPTURE, - "SupportZSL", - &hcamcorder->support_zsl_capture); - - _mmcam_dbg_log("Recommend fmt[cap:%d,rec:%d], dpy rot %d, cap snd %d, dev cnt %d, cam facing dir %d, step denom %d, support zsl %d", - rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation, - play_capture_sound, camera_device_count, camera_facing_direction, - hcamcorder->brightness_step_denominator, hcamcorder->support_zsl_capture); - - /* Get UseZeroCopyFormat value from INI */ - _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, - "UseZeroCopyFormat", - &(hcamcorder->use_zero_copy_format)); - - /* Get SupportMediaPacketPreviewCb value from INI */ - _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, - "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, - NULL); - mm_camcorder_get_fps_list_by_resolution((MMHandleType)hcamcorder, resolution_width, resolution_height, &fps_info); +/*--------------------------------------------------------------------------------------- +| GLOBAL FUNCTION DEFINITIONS: | +---------------------------------------------------------------------------------------*/ +/* Internal command functions {*/ +int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) +{ + int ret = MM_ERROR_NONE; + mmf_camcorder_t *hcamcorder = NULL; - _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); + _mmcam_dbg_log("Entered"); - 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; + mmf_return_val_if_fail(handle && info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); - _mmcam_dbg_log("camera_default_flip : [%d]", camera_default_flip); - } + /* check device type */ + if (info->videodev_type < MM_VIDEO_DEVICE_NONE || + info->videodev_type >= MM_VIDEO_DEVICE_NUM) { + _mmcam_dbg_err("video device type[%d] is out of range.", info->videodev_type); + return MM_ERROR_CAMCORDER_INVALID_ARGUMENT; + } - mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name, - MMCAM_CAMERA_DEVICE_COUNT, camera_device_count, - MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction, - MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture, - MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording, - MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation, - MMCAM_SUPPORT_ZSL_CAPTURE, hcamcorder->support_zsl_capture, - 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); - SAFE_FREE(err_attr_name); - ret = MM_ERROR_CAMCORDER_INTERNAL; - goto _ERR_DEFAULT_VALUE_INIT; - } + /* init handle */ + ret = __mmcamcorder_init_handle(&hcamcorder, info->videodev_type); + if (ret != MM_ERROR_NONE) + return ret; - /* Get default value of brightness */ - mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_attr_name, - MMCAM_FILTER_BRIGHTNESS, &hcamcorder->brightness_default, - NULL); - if (err_attr_name) { - _mmcam_dbg_err("Get brightness FAILED."); - 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 handle for camera/microphone restriction */ + hcamcorder->dpm_handle = dpm_manager_create(); + + _mmcam_dbg_warn("DPM handle %p", hcamcorder->dpm_handle); + + if (hcamcorder->device_type != MM_VIDEO_DEVICE_NONE) { + ret = __mmcamcorder_init_configure_video_capture(hcamcorder); + if (ret != MM_ERROR_NONE) { + goto _ERR_DEFAULT_VALUE_INIT; } /* add DPM camera policy changed callback */ @@ -399,43 +586,28 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) _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, - "DeviceCount", - &camera_device_count); - mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name, - MMCAM_CAMERA_DEVICE_COUNT, camera_device_count, - NULL); - if (err_attr_name) { - _mmcam_dbg_err("Set %s FAILED.", err_attr_name); - SAFE_FREE(err_attr_name); +#ifdef _MMCAMCORDER_MM_RM_SUPPORT + /* initialize resource manager */ + ret = mm_resource_manager_create(MM_RESOURCE_MANAGER_APP_CLASS_MEDIA, + __mmcamcorder_resource_release_cb, hcamcorder, + &hcamcorder->resource_manager); + if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) { + _mmcam_dbg_err("failed to initialize resource manager"); ret = MM_ERROR_CAMCORDER_INTERNAL; goto _ERR_DEFAULT_VALUE_INIT; } - - ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, MM_CAMCONVERT_CATEGORY_AUDIO); +#endif /* _MMCAMCORDER_MM_RM_SUPPORT */ + } else { + ret = __mmcamcorder_init_configure_audio(hcamcorder); if (ret != MM_ERROR_NONE) { - _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) { - _mmcam_dbg_err("failed to initialize resource manager"); - ret = MM_ERROR_CAMCORDER_INTERNAL; - goto _ERR_DEFAULT_VALUE_INIT; + goto _ERR_DEFAULT_VALUE_INIT; + } } -#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:CREATE:INIT_GSTREAMER"); - ret = __mmcamcorder_gstreamer_init(hcamcorder->conf_main); + ret = __mmcamcorder_init_gstreamer(hcamcorder->conf_main); traceEnd(TTRACE_TAG_CAMERA); @@ -451,69 +623,8 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) /* Disable attributes in each model */ _mmcamcorder_set_disabled_attributes((MMHandleType)hcamcorder); - /* Get videosink name for evas surface */ - _mmcamcorder_conf_get_element((MMHandleType)hcamcorder, hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT, - "VideosinkElementEvas", - &EvasSurfaceElement); - if (EvasSurfaceElement) { - int attr_index = 0; - const char *evassink_name = NULL; - mmf_attribute_t *item_evassink_name = NULL; - mmf_attrs_t *attrs = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(hcamcorder); - - _mmcamcorder_conf_get_value_element_name(EvasSurfaceElement, &evassink_name); - mm_attrs_get_index((MMHandleType)attrs, MMCAM_DISPLAY_EVAS_SURFACE_SINK, &attr_index); - item_evassink_name = &attrs->items[attr_index]; - mmf_attribute_set_string(item_evassink_name, evassink_name, strlen(evassink_name)); - mmf_attribute_commit(item_evassink_name); - - _mmcam_dbg_log("Evassink name : %s", evassink_name); - } - - /* get shutter sound policy */ - vconf_get_int(VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY, &hcamcorder->shutter_sound_policy); - _mmcam_dbg_log("current shutter sound policy : %d", hcamcorder->shutter_sound_policy); - - /* get model name */ - sys_info_ret = system_info_get_platform_string("http://tizen.org/system/model_name", &hcamcorder->model_name); - if (hcamcorder->model_name) { - _mmcam_dbg_log("model name [%s], sys_info_ret 0x%x", hcamcorder->model_name, sys_info_ret); - } else { - _mmcam_dbg_warn("failed get model name, sys_info_ret 0x%x", sys_info_ret); - } - - /* get software version */ - sys_info_ret = system_info_get_platform_string("http://tizen.org/system/build.string", &hcamcorder->software_version); - if (hcamcorder->software_version) { - _mmcam_dbg_log("software version [%s], sys_info_ret 0x%d", hcamcorder->software_version, sys_info_ret); - } else { - _mmcam_dbg_warn("failed get software version, sys_info_ret 0x%x", sys_info_ret); - } - -#ifdef _MMCAMCORDER_MURPHY_SUPPORT - _MMCAMCORDER_LOCK_RESOURCE(hcamcorder); - - if (hcamcorder->resource_manager.is_connected == FALSE) { - gint64 end_time = 0; - - /* wait for resource manager connected */ - _mmcam_dbg_log("resource manager is not connected. wait for signal..."); - - end_time = g_get_monotonic_time() + (__MMCAMCORDER_RESOURCE_WAIT_TIME * G_TIME_SPAN_SECOND); - - if (_MMCAMCORDER_RESOURCE_WAIT_UNTIL(hcamcorder, end_time)) { - _mmcam_dbg_warn("signal received"); - } else { - _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); - _mmcam_dbg_err("timeout"); - ret = MM_ERROR_RESOURCE_INTERNAL; - goto _ERR_DEFAULT_VALUE_INIT; - } - } - - _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); -#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ + /* get system information */ + __mmcamcorder_get_system_info(hcamcorder); /* Set initial state */ _mmcamcorder_set_state((MMHandleType)hcamcorder, MM_CAMCORDER_STATE_NULL); @@ -525,10 +636,11 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) return MM_ERROR_NONE; _ERR_DEFAULT_VALUE_INIT: -#ifdef _MMCAMCORDER_MURPHY_SUPPORT +#ifdef _MMCAMCORDER_MM_RM_SUPPORT /* de-initialize resource manager */ - _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager); -#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ + if (hcamcorder->resource_manager != NULL) + mm_resource_manager_destroy(hcamcorder->resource_manager); +#endif /* _MMCAMCORDER_MM_RM_SUPPORT */ /* release DPM related handle */ if (hcamcorder->dpm_handle) { @@ -547,73 +659,11 @@ _ERR_DEFAULT_VALUE_INIT: hcamcorder->dpm_handle = NULL; } - /* Remove attributes */ - if (hcamcorder->attributes) { - _mmcamcorder_dealloc_attribute((MMHandleType)hcamcorder, hcamcorder->attributes); - hcamcorder->attributes = 0; - } - - /* Release lock, cond */ - 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); - 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->mtsafe).mstream_cb_lock); -#ifdef _MMCAMCORDER_MURPHY_SUPPORT - g_cond_clear(&(hcamcorder->mtsafe).resource_cond); - g_mutex_clear(&(hcamcorder->mtsafe).resource_lock); -#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ - - g_mutex_clear(&hcamcorder->snd_info.open_mutex); - g_cond_clear(&hcamcorder->snd_info.open_cond); - g_mutex_clear(&hcamcorder->restart_preview_lock); - - if (info->videodev_type != MM_VIDEO_DEVICE_NONE) { - 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); - } - - if (hcamcorder->conf_ctrl) - _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_ctrl); - - if (hcamcorder->conf_main) - _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_main); - - if (hcamcorder->model_name) { - free(hcamcorder->model_name); - hcamcorder->model_name = NULL; - } - - if (hcamcorder->software_version) { - free(hcamcorder->software_version); - hcamcorder->software_version = NULL; - } - - if (hcamcorder->task_thread) { - 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; - g_cond_signal(&hcamcorder->task_thread_cond); - g_mutex_unlock(&hcamcorder->task_thread_lock); - g_thread_join(hcamcorder->task_thread); - hcamcorder->task_thread = NULL; - } - g_mutex_clear(&hcamcorder->task_thread_lock); - g_cond_clear(&hcamcorder->task_thread_cond); + /* release configure info */ + __mmcamcorder_deinit_configure(hcamcorder); - /* Release handle */ - memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t)); - free(hcamcorder); + /* deinitialize handle */ + __mmcamcorder_deinit_handle(hcamcorder); return ret; } @@ -652,13 +702,6 @@ int _mmcamcorder_destroy(MMHandleType handle) goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - /* set exit state for sound thread */ - 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; - g_cond_signal(&hcamcorder->task_thread_cond); - g_mutex_unlock(&hcamcorder->task_thread_lock); - /* remove kept, but not used sink element in attribute */ mm_camcorder_get_attributes(handle, NULL, MMCAM_DISPLAY_REUSE_ELEMENT, &sink_element, &sink_element_size, @@ -684,16 +727,18 @@ int _mmcamcorder_destroy(MMHandleType handle) hcamcorder->sub_context = NULL; } -#ifdef _MMCAMCORDER_MURPHY_SUPPORT +#ifdef _MMCAMCORDER_MM_RM_SUPPORT /* de-initialize resource manager */ _MMCAMCORDER_LOCK_RESOURCE(hcamcorder); - ret = _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager); - if (ret != MM_ERROR_NONE) - _mmcam_dbg_err("failed to de-initialize resource manager 0x%x", ret); + if (hcamcorder->resource_manager != NULL) { + ret = mm_resource_manager_destroy(hcamcorder->resource_manager); + if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) + _mmcam_dbg_err("failed to de-initialize resource manager 0x%x", ret); + } _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); -#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ +#endif /* _MMCAMCORDER_MM_RM_SUPPORT */ /* Remove idle function which is not called yet */ if (hcamcorder->setting_event_id) { @@ -702,51 +747,9 @@ int _mmcamcorder_destroy(MMHandleType handle) hcamcorder->setting_event_id = 0; } - /* Remove attributes */ - if (hcamcorder->attributes) { - _mmcamcorder_dealloc_attribute(handle, hcamcorder->attributes); - hcamcorder->attributes = 0; - } - - /* Remove exif info */ - if (hcamcorder->exif_info) { - mm_exif_destory_exif_info(hcamcorder->exif_info); - hcamcorder->exif_info = NULL; - } - - /* Release configure info */ - if (hcamcorder->conf_ctrl) - _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl); - - if (hcamcorder->conf_main) - _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_main); - /* Remove messages which are not called yet */ _mmcamcorder_remove_message_all(handle); - /* unset remained watch cb */ - if (hcamcorder->sound_focus_watch_id > 0) { - mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id); - _mmcam_dbg_warn("unset sound focus watch cb [id %d] done", hcamcorder->sound_focus_watch_id); - hcamcorder->sound_focus_watch_id = 0; - } - - /* unregister sound focus and unsubscribe sound signal */ - _mmcam_dbg_log("sound focus id %d, sound signal subscribe id %u", - hcamcorder->sound_focus_id, hcamcorder->sound_focus_subscribe_id); - - if (hcamcorder->sound_focus_id > 0) { - mm_sound_unregister_focus(hcamcorder->sound_focus_id); - _mmcam_dbg_log("unregister sound focus done"); - hcamcorder->sound_focus_id = 0; - } - - if (hcamcorder->sound_focus_subscribe_id > 0) { - mm_sound_unsubscribe_signal(hcamcorder->sound_focus_subscribe_id); - _mmcam_dbg_log("unsubscribe sound signal done"); - hcamcorder->sound_focus_subscribe_id = 0; - } - #ifdef _MMCAMCORDER_RM_SUPPORT if (hcamcorder->rm_handle != 0) { iret = rm_unregister(hcamcorder->rm_handle); @@ -756,17 +759,6 @@ int _mmcamcorder_destroy(MMHandleType handle) } #endif /* _MMCAMCORDER_RM_SUPPORT */ - /* release model_name */ - if (hcamcorder->model_name) { - free(hcamcorder->model_name); - hcamcorder->model_name = NULL; - } - - if (hcamcorder->software_version) { - free(hcamcorder->software_version); - hcamcorder->software_version = NULL; - } - /* release DPM handle */ if (hcamcorder->dpm_handle) { _mmcam_dbg_log("release DPM handle %p, camera changed cb id %d", @@ -784,48 +776,9 @@ int _mmcamcorder_destroy(MMHandleType handle) hcamcorder->dpm_handle = NULL; } - /* join task thread */ - _mmcam_dbg_log("task thread join"); - g_thread_join(hcamcorder->task_thread); - hcamcorder->task_thread = NULL; - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); - /* Release lock, cond */ - 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); - 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->mtsafe).mstream_cb_lock); -#ifdef _MMCAMCORDER_MURPHY_SUPPORT - g_cond_clear(&(hcamcorder->mtsafe).resource_cond); - g_mutex_clear(&(hcamcorder->mtsafe).resource_lock); -#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ - - 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); - - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - 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); - } - - /* Release handle */ - memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t)); - free(hcamcorder); + __mmcamcorder_deinit_handle(hcamcorder); return MM_ERROR_NONE; @@ -845,10 +798,8 @@ _ERR_CAMCORDER_CMD_PRECON: int _mmcamcorder_realize(MMHandleType handle) { int ret = MM_ERROR_NONE; - int ret_sound = MM_ERROR_NONE; int state = MM_CAMCORDER_STATE_NONE; 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; @@ -908,63 +859,6 @@ int _mmcamcorder_realize(MMHandleType handle) MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate, NULL); - /* sound focus */ - if (hcamcorder->sound_focus_register) { - /* acquire sound focus or set sound focus watch callback */ - 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(hcamcorder->sound_focus_id, FOCUS_FOR_BOTH, NULL); - if (ret_sound != MM_ERROR_NONE) { - _mmcam_dbg_err("mm_sound_acquire_focus failed [0x%x]", ret_sound); - - ret = MM_ERROR_POLICY_BLOCKED; - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; - } - - 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 { - /* unset remained watch cb */ - if (hcamcorder->sound_focus_watch_id > 0) { - mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id); - _mmcam_dbg_warn("unset sound focus watch cb [id %d] done", hcamcorder->sound_focus_watch_id); - hcamcorder->sound_focus_watch_id = 0; - } - - /* set sound focus watch callback */ - 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); - } - - _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); - - ret = MM_ERROR_POLICY_BLOCKED; - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; - } - - _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) { @@ -1076,144 +970,132 @@ int _mmcamcorder_realize(MMHandleType handle) _mmcam_dbg_warn("NULL dpm_handle"); } -#ifdef _MMCAMCORDER_MURPHY_SUPPORT - ret = _mmcamcorder_resource_create_resource_set(&hcamcorder->resource_manager); - if (ret != MM_ERROR_NONE) { - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; - } - - hcamcorder->resource_manager.acquire_count = 0; - +#ifdef _MMCAMCORDER_MM_RM_SUPPORT + _MMCAMCORDER_LOCK_RESOURCE(hcamcorder); /* prepare resource manager for 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; + if (hcamcorder->camera_resource == NULL) { + ret = mm_resource_manager_mark_for_acquire(hcamcorder->resource_manager, + MM_RESOURCE_MANAGER_RES_TYPE_CAMERA, + 1, + &hcamcorder->camera_resource); + if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) { + _mmcam_dbg_err("could not prepare for camera resource"); + ret = MM_ERROR_RESOURCE_INTERNAL; + _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + } else { + _mmcam_dbg_log("camera already acquired"); } /* prepare resource manager for "video_overlay only if display surface is X" */ 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; + if (hcamcorder->video_overlay_resource == NULL) { + ret = mm_resource_manager_mark_for_acquire(hcamcorder->resource_manager, + MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_OVERLAY, + MM_RESOURCE_MANAGER_RES_VOLUME_FULL, + &hcamcorder->video_overlay_resource); + if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) { + _mmcam_dbg_err("could not prepare for overlay resource"); + ret = MM_ERROR_RESOURCE_INTERNAL; + _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + } else { + _mmcam_dbg_log("overlay already acquired"); } } /* acquire resources */ - _MMCAMCORDER_LOCK_RESOURCE(hcamcorder); - - ret = _mmcamcorder_resource_manager_acquire(&hcamcorder->resource_manager); - if (ret != MM_ERROR_NONE) { - _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); - + ret = mm_resource_manager_commit(hcamcorder->resource_manager); + if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) { _mmcam_dbg_err("could not acquire resources"); - + ret = MM_ERROR_RESOURCE_INTERNAL; + _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - - if (hcamcorder->resource_manager.acquire_remain > 0) { - gint64 end_time = 0; - - _mmcam_dbg_warn("wait for resource state change"); - - /* wait for resource state change */ - end_time = g_get_monotonic_time() + (__MMCAMCORDER_RESOURCE_WAIT_TIME * G_TIME_SPAN_SECOND); - - if (_MMCAMCORDER_RESOURCE_WAIT_UNTIL(hcamcorder, end_time)) { - _mmcam_dbg_warn("signal received"); - } else { - _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); - _mmcam_dbg_err("timeout"); - ret = MM_ERROR_RESOURCE_INTERNAL; - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; - } - } else { - _mmcam_dbg_log("already all acquired"); - } - _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); -#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ +#endif /* _MMCAMCORDER_MM_RM_SUPPORT */ #ifdef _MMCAMCORDER_RM_SUPPORT - 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; + if (display_surface_type != MM_DISPLAY_SURFACE_NULL) { + mm_camcorder_get_attributes(handle, NULL, + MMCAM_CLIENT_PID, &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_RESOURCE_INTERNAL; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } } - } - mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_FORMAT, &preview_format, - NULL); + mm_camcorder_get_attributes(handle, NULL, + MMCAM_CAMERA_FORMAT, &preview_format, + NULL); - resource_count = 0; - memset(&hcamcorder->request_resources, 0x0, sizeof(rm_category_request_s)); - memset(&hcamcorder->returned_devices, 0x0, sizeof(rm_device_return_s)); + resource_count = 0; + memset(&hcamcorder->request_resources, 0x0, sizeof(rm_category_request_s)); + memset(&hcamcorder->returned_devices, 0x0, sizeof(rm_device_return_s)); - if (preview_format == MM_PIXEL_FORMAT_ENCODED_H264) { - hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE; - hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER; + if (preview_format == MM_PIXEL_FORMAT_ENCODED_H264) { + hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE; + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER; - _mmcam_dbg_log("request dec rsc - category 0x%x", RM_CATEGORY_VIDEO_DECODER); + _mmcam_dbg_log("request dec rsc - category 0x%x", RM_CATEGORY_VIDEO_DECODER); - resource_count++; - } + resource_count++; + } - if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) { - hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE; - hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER; + if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) { + hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE; + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER; - _mmcam_dbg_log("request scaler rsc - category 0x%x", RM_CATEGORY_SCALER); + _mmcam_dbg_log("request scaler rsc - category 0x%x", RM_CATEGORY_SCALER); - resource_count++; - } + resource_count++; + } - hcamcorder->request_resources.request_num = resource_count; + hcamcorder->request_resources.request_num = resource_count; - if (resource_count > 0) { - qret = rm_query(hcamcorder->rm_handle, RM_QUERY_ALLOCATION, &(hcamcorder->request_resources), &qret_avail); - if (qret != RM_OK || qret_avail != 1) { - _mmcam_dbg_log("rm query failed. retry with sub devices"); + if (resource_count > 0) { + qret = rm_query(hcamcorder->rm_handle, RM_QUERY_ALLOCATION, &(hcamcorder->request_resources), &qret_avail); + if (qret != RM_OK || qret_avail != 1) { + _mmcam_dbg_log("rm query failed. retry with sub devices"); - resource_count = 0; + resource_count = 0; - if (preview_format == MM_PIXEL_FORMAT_ENCODED_H264) { - hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER_SUB; - _mmcam_dbg_log("request dec rsc - category 0x%x", RM_CATEGORY_VIDEO_DECODER_SUB); - resource_count++; - } + if (preview_format == MM_PIXEL_FORMAT_ENCODED_H264) { + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER_SUB; + _mmcam_dbg_log("request dec rsc - category 0x%x", RM_CATEGORY_VIDEO_DECODER_SUB); + resource_count++; + } - if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) { - hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER_SUB; - _mmcam_dbg_log("request scaler rsc - category 0x%x", RM_CATEGORY_SCALER_SUB); - resource_count++; + if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) { + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER_SUB; + _mmcam_dbg_log("request scaler rsc - category 0x%x", RM_CATEGORY_SCALER_SUB); + resource_count++; + } } } - } - hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE; - hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_CAMERA; + 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 rsc - category 0x%x", RM_CATEGORY_CAMERA); + hcamcorder->request_resources.request_num = resource_count + 1; + _mmcam_dbg_log("request camera rsc - category 0x%x", RM_CATEGORY_CAMERA); - 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; + 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_RESOURCE_INTERNAL; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } } #endif /* _MMCAMCORDER_RM_SUPPORT */ } @@ -1254,17 +1136,24 @@ int _mmcamcorder_realize(MMHandleType handle) return MM_ERROR_NONE; _ERR_CAMCORDER_CMD: -#ifdef _MMCAMCORDER_MURPHY_SUPPORT +#ifdef _MMCAMCORDER_MM_RM_SUPPORT /* release hw resources */ + _MMCAMCORDER_LOCK_RESOURCE(hcamcorder); if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) { - 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"); - } else if (ret_resource != MM_ERROR_NONE) { - _mmcam_dbg_err("failed to release resource, ret_resource(0x%x)", ret_resource); + if (hcamcorder->camera_resource != NULL) { + mm_resource_manager_mark_for_release(hcamcorder->resource_manager, + hcamcorder->camera_resource); + hcamcorder->camera_resource = NULL; } + if (hcamcorder->video_overlay_resource != NULL) { + mm_resource_manager_mark_for_release(hcamcorder->resource_manager, + hcamcorder->video_overlay_resource); + hcamcorder->video_overlay_resource = NULL; + } + mm_resource_manager_commit(hcamcorder->resource_manager); } -#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ + _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); +#endif /* _MMCAMCORDER_MM_RM_SUPPORT */ #ifdef _MMCAMCORDER_RM_SUPPORT if (hcamcorder->rm_handle) { if (hcamcorder->returned_devices.allocated_num > 0) { @@ -1291,18 +1180,6 @@ _ERR_CAMCORDER_CMD: _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: _MMCAMCORDER_UNLOCK_CMD(hcamcorder); - if (hcamcorder->sound_focus_watch_id > 0) { - mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id); - _mmcam_dbg_warn("unset sound focus watch cb [id %d] done", hcamcorder->sound_focus_watch_id); - hcamcorder->sound_focus_watch_id = 0; - } - - if (hcamcorder->acquired_focus > 0) { - mm_sound_release_focus(hcamcorder->sound_focus_id, hcamcorder->acquired_focus, NULL); - _mmcam_dbg_warn("release sound focus [focus %d] done", hcamcorder->acquired_focus); - hcamcorder->acquired_focus = 0; - } - _ERR_CAMCORDER_CMD_PRECON: _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)", hcamcorder->type, state, ret); @@ -1347,20 +1224,42 @@ int _mmcamcorder_unrealize(MMHandleType handle) hcamcorder->sub_context = NULL; } -#ifdef _MMCAMCORDER_MURPHY_SUPPORT - if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE && - hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_RM) { - gint64 end_time = 0; +#ifdef _MMCAMCORDER_MM_RM_SUPPORT + _MMCAMCORDER_LOCK_RESOURCE(hcamcorder); + _mmcam_dbg_warn("lock resource - cb calling %d", hcamcorder->is_release_cb_calling); + + if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE && + hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_RM && + hcamcorder->is_release_cb_calling == FALSE) { + + /* release resource */ + if (hcamcorder->camera_resource != NULL) { + ret = mm_resource_manager_mark_for_release(hcamcorder->resource_manager, + hcamcorder->camera_resource); + if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) { + _mmcam_dbg_err("could not mark camera resource for release"); + ret = MM_ERROR_CAMCORDER_INTERNAL; + _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); + _mmcam_dbg_log("unlock resource"); + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + } + + if (hcamcorder->video_overlay_resource != NULL) { + ret = mm_resource_manager_mark_for_release(hcamcorder->resource_manager, + hcamcorder->video_overlay_resource); + if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) { + _mmcam_dbg_err("could not mark overlay resource for release"); + ret = MM_ERROR_CAMCORDER_INTERNAL; + _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); + _mmcam_dbg_log("unlock resource"); + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + } - _mmcam_dbg_log("lock resource"); - _MMCAMCORDER_LOCK_RESOURCE(hcamcorder); + ret = mm_resource_manager_commit(hcamcorder->resource_manager); - /* 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) { + if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) { _mmcam_dbg_err("failed to release resource, ret(0x%x)", ret); ret = MM_ERROR_CAMCORDER_INTERNAL; @@ -1368,21 +1267,18 @@ int _mmcamcorder_unrealize(MMHandleType handle) _mmcam_dbg_log("unlock resource"); goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } else { + if (hcamcorder->camera_resource != NULL) + hcamcorder->camera_resource = NULL; + if (hcamcorder->video_overlay_resource != NULL) + hcamcorder->video_overlay_resource = NULL; } + } - if (hcamcorder->resource_manager.acquire_remain < hcamcorder->resource_manager.acquire_count) { - /* wait for resource release */ - _mmcam_dbg_log("resource is not released all. wait for signal..."); - - end_time = g_get_monotonic_time() + (__MMCAMCORDER_RESOURCE_WAIT_TIME * G_TIME_SPAN_SECOND); - - _MMCAMCORDER_RESOURCE_WAIT_UNTIL(hcamcorder, end_time); - } + _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); - _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); - _mmcam_dbg_log("unlock resource"); - } -#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ + _mmcam_dbg_warn("unlock resource"); +#endif /* _MMCAMCORDER_MM_RM_SUPPORT */ #ifdef _MMCAMCORDER_RM_SUPPORT if (hcamcorder->rm_handle && (hcamcorder->returned_devices.allocated_num > 0)) { @@ -1403,32 +1299,6 @@ int _mmcamcorder_unrealize(MMHandleType handle) /* 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); - - /* release sound focus or unset sound focus watch callback */ - _mmcam_dbg_log("by_system %d, flag 0x%x, acquired_focus %d, focus_id %d, watch_id %d", - hcamcorder->state_change_by_system, hcamcorder->session_flags, hcamcorder->acquired_focus, - hcamcorder->sound_focus_id, hcamcorder->sound_focus_watch_id); - - if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_FOCUS) { - if (hcamcorder->sound_focus_watch_id > 0) { - mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id); - _mmcam_dbg_warn("unset sound focus watch cb [id %d] done", hcamcorder->sound_focus_watch_id); - hcamcorder->sound_focus_watch_id = 0; - } - - if (hcamcorder->acquired_focus > 0) { - mm_sound_release_focus(hcamcorder->sound_focus_id, hcamcorder->acquired_focus, NULL); - _mmcam_dbg_warn("release sound focus [focus %d] done", hcamcorder->acquired_focus); - hcamcorder->acquired_focus = 0; - } - } else { - _mmcam_dbg_warn("state change by focus. so, no need to unset watch callback"); - /* acquired focus will be released automatically */ - hcamcorder->acquired_focus = 0; - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); _mmcamcorder_set_state(handle, MM_CAMCORDER_STATE_NULL); @@ -1496,6 +1366,10 @@ int _mmcamcorder_start(MMHandleType handle) _mmcamcorder_set_state(handle, MM_CAMCORDER_STATE_PREPARE); + /* set attributes related sensor - after start preview */ + if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) + _mmcamcorder_set_attribute_to_camsensor2(handle); + _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; @@ -1649,7 +1523,7 @@ int _mmcamcorder_capture_start(MMHandleType handle) _MMCAMCORDER_UNLOCK_CMD(hcamcorder); /* Init break continuous shot attr */ - if (mm_camcorder_set_attributes(handle, NULL, "capture-break-cont-shot", 0, NULL) != MM_ERROR_NONE) + if (mm_camcorder_set_attributes(handle, NULL, MMCAM_CAPTURE_BREAK_CONTINUOUS_SHOT, 0, NULL) != MM_ERROR_NONE) _mmcam_dbg_warn("capture-break-cont-shot set 0 failed"); return MM_ERROR_NONE; @@ -1724,15 +1598,18 @@ int _mmcamcorder_record(MMHandleType handle) int dpm_mic_state = DPM_ALLOWED; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + _MMCamcorderSubContext *sc = NULL; _mmcam_dbg_log(""); - if (!hcamcorder) { + if (!hcamcorder || !MMF_CAMCORDER_SUBCONTEXT(hcamcorder)) { _mmcam_dbg_err("Not initialized"); ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED; return ret; } + sc = MMF_CAMCORDER_SUBCONTEXT(handle); + if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) { _mmcam_dbg_err("Another command is running."); ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING; @@ -1749,8 +1626,15 @@ int _mmcamcorder_record(MMHandleType handle) /* initialize error code */ hcamcorder->error_code = MM_ERROR_NONE; + /* get audio disable */ + mm_camcorder_get_attributes(handle, NULL, + MMCAM_AUDIO_DISABLE, &sc->audio_disable, + NULL); + + sc->audio_disable |= sc->is_modified_rate; + /* check mic policy from DPM */ - if (hcamcorder->dpm_handle) { + if (hcamcorder->dpm_handle && sc->audio_disable == FALSE) { if (dpm_restriction_get_microphone_state(hcamcorder->dpm_handle, &dpm_mic_state) == DPM_ERROR_NONE) { _mmcam_dbg_log("DPM mic state %d", dpm_mic_state); if (dpm_mic_state == DPM_DISALLOWED) { @@ -1765,7 +1649,8 @@ int _mmcamcorder_record(MMHandleType handle) _mmcam_dbg_err("get DPM mic state failed, keep going..."); } } else { - _mmcam_dbg_warn("NULL dpm_handle"); + _mmcam_dbg_warn("skip dpm check - handle %p, audio disable %d", + hcamcorder->dpm_handle, sc->audio_disable); } ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_RECORD); @@ -2003,10 +1888,7 @@ int _mmcamcorder_set_video_stream_callback(MMHandleType handle, mm_camcorder_vid if (callback == NULL) _mmcam_dbg_warn("Video Stream Callback is disabled, because application sets it to NULL"); - if (!_MMCAMCORDER_TRYLOCK_VSTREAM_CALLBACK(hcamcorder)) { - _mmcam_dbg_warn("Application's video stream callback is running now"); - return MM_ERROR_CAMCORDER_INVALID_CONDITION; - } + _MMCAMCORDER_LOCK_VSTREAM_CALLBACK(hcamcorder); hcamcorder->vstream_cb = callback; hcamcorder->vstream_cb_param = user_data; @@ -2395,8 +2277,7 @@ int _mmcamcorder_stop_focusing(MMHandleType handle) /*----------------------------------------------- | CAMCORDER INTERNAL LOCAL | -----------------------------------------------*/ -static gboolean -__mmcamcorder_gstreamer_init(camera_conf * conf) +static gboolean __mmcamcorder_init_gstreamer(camera_conf *conf) { static const int max_argc = 10; int i = 0; @@ -2503,6 +2384,23 @@ int _mmcamcorder_get_state(MMHandleType handle) } +int _mmcamcorder_get_state2(MMHandleType handle, int *state, int *old_state) +{ + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + + mmf_return_val_if_fail(hcamcorder && state && old_state, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); + + _MMCAMCORDER_LOCK_STATE(handle); + + *state = hcamcorder->state; + *old_state = hcamcorder->old_state; + + _MMCAMCORDER_UNLOCK_STATE(handle); + + return MM_ERROR_NONE; +} + + void _mmcamcorder_set_state(MMHandleType handle, int state) { int old_state; @@ -2518,16 +2416,12 @@ void _mmcamcorder_set_state(MMHandleType handle, int state) old_state = hcamcorder->state; if (old_state != state) { hcamcorder->state = state; - hcamcorder->target_state = state; + hcamcorder->old_state = old_state; - _mmcam_dbg_log("set state[%d] and send state-changed message", state); + _mmcam_dbg_log("set state[%d -> %d] and send state-changed message", old_state, state); /* To discern who changes the state */ switch (hcamcorder->state_change_by_system) { - case _MMCAMCORDER_STATE_CHANGE_BY_FOCUS: - 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; @@ -2556,20 +2450,6 @@ void _mmcamcorder_set_state(MMHandleType handle, int state) } -int _mmcamcorder_get_async_state(MMHandleType handle) -{ - int state; - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - - _MMCAMCORDER_LOCK_STATE(handle); - state = hcamcorder->target_state; - - _MMCAMCORDER_UNLOCK_STATE(handle); - - return state; -} - - _MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type) { int i; @@ -2640,7 +2520,7 @@ _MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type) } sc->fourcc = 0x80000000; - sc->cam_stability_count = 0; + sc->frame_stability_count = 0; sc->drop_vframe = 0; sc->pass_first_vframe = 0; sc->is_modified_rate = FALSE; @@ -2813,8 +2693,12 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst; if (message->src == (GstObject*)pipeline) { vnewstate = gst_structure_get_value(gst_message_get_structure(message), "new-state"); - newstate = (GstState)vnewstate->data[0].v_int; - _mmcam_dbg_log("GST_MESSAGE_STATE_CHANGED[%s]", gst_element_state_get_name(newstate)); + if (vnewstate) { + newstate = (GstState)vnewstate->data[0].v_int; + _mmcam_dbg_log("GST_MESSAGE_STATE_CHANGED[%s]", gst_element_state_get_name(newstate)); + } else { + _mmcam_dbg_warn("get new state failed from msg"); + } } } } @@ -3256,180 +3140,6 @@ DROP_MESSAGE: } -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, - int option, 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_FOCUS; - - /* 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_signal_callback(mm_sound_signal_name_t signal, int value, void *user_data) -{ - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data); - - mmf_return_if_fail(hcamcorder); - - _mmcam_dbg_log("sound signal %d - value %d", signal, value); - - _MMCAMCORDER_LOCK_ASM(hcamcorder); - - if (signal == MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS && value == 1) { - _mmcam_dbg_log("watch cb id %d", hcamcorder->sound_focus_watch_id); - - /* unregister watch callback */ - if (hcamcorder->sound_focus_watch_id > 0) { - mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id); - _mmcam_dbg_log("unset watch cb done"); - hcamcorder->sound_focus_watch_id = 0; - } - } - - /* reset flag not to run sound focus related code since now */ - hcamcorder->sound_focus_register = FALSE; - - _MMCAMCORDER_UNLOCK_ASM(hcamcorder); - - _mmcam_dbg_warn("done"); - - return; -} - - -void _mmcamcorder_sound_focus_watch_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(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 : id %d, focus state %d, reason %s", - id, 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_FOCUS; - - /* 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 released"); - - 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 acquired : 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); @@ -3447,17 +3157,11 @@ void _mmcamcorder_dpm_camera_policy_changed_cb(const char *name, const char *val _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_LOCK_INTERRUPT(hcamcorder); - __mmcamcorder_force_stop(hcamcorder); + __mmcamcorder_force_stop(hcamcorder, _MMCAMCORDER_STATE_CHANGE_BY_DPM); - /* restore value */ - hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL; - - _MMCAMCORDER_UNLOCK_ASM(hcamcorder); + _MMCAMCORDER_UNLOCK_INTERRUPT(hcamcorder); _mmcamcorder_request_dpm_popup(hcamcorder->gdbus_conn, "camera"); } @@ -3475,7 +3179,7 @@ int _mmcamcorder_create_pipeline(MMHandleType handle, int type) _MMCamcorderSubContext *sc = NULL; GstElement *pipeline = NULL; - _mmcam_dbg_log("handle : %x, type : %d", handle, type); + _mmcam_dbg_log("handle : %p, type : %d", handle, type); mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED); @@ -3605,18 +3309,6 @@ void _mmcamcorder_destroy_pipeline(MMHandleType handle, int type) } -int _mmcamcorder_gst_set_state_async(MMHandleType handle, GstElement *pipeline, GstState target_state) -{ - GstStateChangeReturn setChangeReturn = GST_STATE_CHANGE_FAILURE; - - _MMCAMCORDER_LOCK_GST_STATE(handle); - setChangeReturn = gst_element_set_state(pipeline, target_state); - _MMCAMCORDER_UNLOCK_GST_STATE(handle); - - return setChangeReturn; -} - - #ifdef _MMCAMCORDER_USE_SET_ATTR_CB static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data) { @@ -3753,7 +3445,7 @@ void _mmcamcorder_video_current_framerate_init(MMHandleType handle) } -void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) +void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder, int state_change_by_system) { int i = 0; int loop = 0; @@ -3761,6 +3453,7 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) int result = MM_ERROR_NONE; int cmd_try_count = 0; int current_state = MM_CAMCORDER_STATE_NONE; + _MMCamcorderMsgItem msg; mmf_return_if_fail(hcamcorder); @@ -3782,7 +3475,34 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); - _mmcam_dbg_warn("Force STOP MMFW Camcorder"); + _mmcam_dbg_warn("Force STOP MMFW Camcorder by %d", state_change_by_system); + + /* set state_change_by_system for state change message */ + hcamcorder->state_change_by_system = state_change_by_system; + + if (current_state >= MM_CAMCORDER_STATE_READY) { + _mmcam_dbg_warn("send state change started message to notify"); + + memset(&msg, 0x0, sizeof(_MMCamcorderMsgItem)); + + switch (state_change_by_system) { + case _MMCAMCORDER_STATE_CHANGE_BY_RM: + msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_RM; + break; + case _MMCAMCORDER_STATE_CHANGE_BY_DPM: + msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_SECURITY; + break; + default: + break; + } + + if (msg.id != 0) { + msg.param.state.code = hcamcorder->interrupt_code; + _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg); + } else { + _mmcam_dbg_err("should not be reached here %d", state_change_by_system); + } + } for (loop = 0 ; current_state > MM_CAMCORDER_STATE_NULL && loop < __MMCAMCORDER_CMD_ITERATE_MAX * 3 ; loop++) { itr_cnt = __MMCAMCORDER_CMD_ITERATE_MAX; @@ -3829,9 +3549,8 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) { _mmcam_dbg_warn("Stop preview."); - while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) { + while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) _mmcam_dbg_warn("Can't stop preview.(%x)", result); - } break; } @@ -3839,13 +3558,11 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) { _mmcam_dbg_warn("unrealize"); - if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE) { + 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; @@ -3854,6 +3571,9 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); } + /* restore */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL; + _mmcam_dbg_warn("Done."); return; @@ -3867,8 +3587,8 @@ static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage * gchar *msg_src_element = NULL; _MMCamcorderSubContext *sc = NULL; - return_val_if_fail(hcamcorder, FALSE); - return_val_if_fail(error, FALSE); + mmf_return_val_if_fail(hcamcorder, FALSE); + mmf_return_val_if_fail(error, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); mmf_return_val_if_fail(sc, FALSE); @@ -3980,7 +3700,7 @@ static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, G static gint __mmcamcorder_gst_handle_library_error(MMHandleType handle, int code, GstMessage *message) { mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED); + mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED); _mmcam_dbg_log(""); @@ -4035,7 +3755,7 @@ static gint __mmcamcorder_gst_handle_resource_error(MMHandleType handle, int cod _mmcam_dbg_err("DPM mic DISALLOWED - current state %d", current_state); - _MMCAMCORDER_LOCK_ASM(hcamcorder); + _MMCAMCORDER_LOCK_INTERRUPT(hcamcorder); current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); if (current_state >= MM_CAMCORDER_STATE_RECORDING) { @@ -4054,7 +3774,7 @@ static gint __mmcamcorder_gst_handle_resource_error(MMHandleType handle, int cod /* restore value */ hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL; - _MMCAMCORDER_UNLOCK_ASM(hcamcorder); + _MMCAMCORDER_UNLOCK_INTERRUPT(hcamcorder); _mmcamcorder_request_dpm_popup(hcamcorder->gdbus_conn, "microphone"); @@ -4170,8 +3890,8 @@ static gboolean __mmcamcorder_handle_gst_warning(MMHandleType handle, GstMessage gchar *debug = NULL; GError *err = NULL; - return_val_if_fail(hcamcorder, FALSE); - return_val_if_fail(error, FALSE); + mmf_return_val_if_fail(hcamcorder, FALSE); + mmf_return_val_if_fail(error, FALSE); _mmcam_dbg_log(""); @@ -4271,6 +3991,59 @@ void _mmcamcorder_emit_signal(MMHandleType handle, const char *object_name, } +#ifdef _MMCAMCORDER_MM_RM_SUPPORT +static int __mmcamcorder_resource_release_cb(mm_resource_manager_h rm, + mm_resource_manager_res_h res, void *user_data) +{ + mmf_camcorder_t *hcamcorder = (mmf_camcorder_t *) user_data; + + mmf_return_val_if_fail(hcamcorder, FALSE); + + _mmcam_dbg_warn("enter"); + + _MMCAMCORDER_LOCK_RESOURCE(hcamcorder); + + /* set flag for resource release callback */ + hcamcorder->is_release_cb_calling = TRUE; + + _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); + + _MMCAMCORDER_LOCK_INTERRUPT(hcamcorder); + + if (res == hcamcorder->video_encoder_resource) { + /* Stop video recording */ + if (_mmcamcorder_commit((MMHandleType)hcamcorder) != MM_ERROR_NONE) { + _mmcam_dbg_err("commit failed, cancel it"); + _mmcamcorder_cancel((MMHandleType)hcamcorder); + } + } else { + /* Stop camera */ + __mmcamcorder_force_stop(hcamcorder, _MMCAMCORDER_STATE_CHANGE_BY_RM); + } + + _MMCAMCORDER_UNLOCK_INTERRUPT(hcamcorder); + + _MMCAMCORDER_LOCK_RESOURCE(hcamcorder); + + if (res == hcamcorder->camera_resource) + hcamcorder->camera_resource = NULL; + else if (res == hcamcorder->video_overlay_resource) + hcamcorder->video_overlay_resource = NULL; + else if (res == hcamcorder->video_encoder_resource) + hcamcorder->video_encoder_resource = NULL; + + /* restore flag for resource release callback */ + hcamcorder->is_release_cb_calling = FALSE; + + _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder); + + _mmcam_dbg_warn("leave"); + + return FALSE; +} +#endif /* _MMCAMCORDER_MM_RM_SUPPORT */ + + #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) @@ -4282,14 +4055,10 @@ rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src, 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); + _mmcam_dbg_warn("current state %d (handle %p)", current_state, hcamcorder); - /* set value to inform a status is changed by RM */ - hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_RM; + _MMCAMCORDER_LOCK_INTERRUPT(hcamcorder); /* set RM event code for sending it to application */ hcamcorder->interrupt_code = event_src; @@ -4298,17 +4067,68 @@ rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src, switch (event_src) { case RM_CALLBACK_TYPE_RESOURCE_CONFLICT: case RM_CALLBACK_TYPE_RESOURCE_CONFLICT_UD: - __mmcamcorder_force_stop(hcamcorder); + __mmcamcorder_force_stop(hcamcorder, _MMCAMCORDER_STATE_CHANGE_BY_RM); break; default: break; } - /* restore value */ - hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL; - - _MMCAMCORDER_UNLOCK_ASM(hcamcorder); + _MMCAMCORDER_UNLOCK_INTERRUPT(hcamcorder); return cb_res; } #endif /* _MMCAMCORDER_RM_SUPPORT */ + + +int _mmcamcorder_manage_external_storage_state(MMHandleType handle, int storage_state) +{ + int ret = MM_ERROR_NONE; + int current_state = MM_CAMCORDER_STATE_NONE; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + _MMCamcorderMsgItem msg; + + mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); + + _mmcam_dbg_warn("storage state %d", storage_state); + + /* check storage state */ + if (storage_state != STORAGE_STATE_UNMOUNTABLE && + storage_state != STORAGE_STATE_REMOVED) { + _mmcam_dbg_warn("nothing to do"); + return MM_ERROR_NONE; + } + + _MMCAMCORDER_LOCK_INTERRUPT(hcamcorder); + + /* check recording state */ + current_state = _mmcamcorder_get_state(handle); + + _mmcam_dbg_warn("current_state %d", current_state); + + if (current_state < MM_CAMCORDER_STATE_RECORDING) { + _mmcam_dbg_warn("no recording now"); + goto _MANAGE_DONE; + } + + /* check storage type */ + if (hcamcorder->storage_info.type != STORAGE_TYPE_EXTERNAL) { + _mmcam_dbg_warn("external storage is not used"); + goto _MANAGE_DONE; + } + + /* cancel recording */ + ret = _mmcamcorder_cancel(handle); + + /* send error message */ + msg.id = MM_MESSAGE_CAMCORDER_ERROR; + msg.param.code = MM_ERROR_OUT_OF_STORAGE; + + _mmcamcorder_send_message(handle, &msg); + +_MANAGE_DONE: + _MMCAMCORDER_UNLOCK_INTERRUPT(hcamcorder); + + _mmcam_dbg_warn("done - ret 0x%x", ret); + + return ret; +}