X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_internal.c;h=0ce2f6836fcaaeed8d9edcbd9ec3634d4db5a450;hb=c43cdfa7e6afebaa24c6b9c835f72a91a3dd7424;hp=78c26ae7a20685f92b699f63598c34d940916745;hpb=c958b0a9e3a03d5fb4e8dc2531cd5e3e4ce5ffa8;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git diff --git a/src/mm_camcorder_internal.c b/src/mm_camcorder_internal.c index 78c26ae..0ce2f68 100644 --- a/src/mm_camcorder_internal.c +++ b/src/mm_camcorder_internal.c @@ -24,9 +24,11 @@ ========================================================================================*/ #include #include +#include #include #include #include +#include #include #include "mm_camcorder_internal.h" @@ -36,20 +38,31 @@ #include #include +#include #include #include -#include -/*--------------------------------------------------------------------------------------- -| GLOBAL VARIABLE DEFINITIONS for internal | ----------------------------------------------------------------------------------------*/ +#ifdef _MMCAMCORDER_MURPHY_SUPPORT +#include +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ + +#ifdef _MMCAMCORDER_RM_SUPPORT +#include +#endif /* _MMCAMCORDER_RM_SUPPORT */ /*--------------------------------------------------------------------------------------- | LOCAL VARIABLE DEFINITIONS for internal | ---------------------------------------------------------------------------------------*/ #define __MMCAMCORDER_CMD_ITERATE_MAX 3 -#define __MMCAMCORDER_SECURITY_HANDLE_DEFAULT -1 #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_FOCUS_CHANGE_REASON_LEN 64 + +#define DPM_ALLOWED 1 +#define DPM_DISALLOWED 0 + /*--------------------------------------------------------------------------------------- | LOCAL FUNCTION PROTOTYPES: | @@ -65,16 +78,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); -static int __mmcamcorder_asm_get_event_type(int sessionType); -static void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder); -static void __mmcamcorder_force_resume(mmf_camcorder_t *hcamcorder); -ASM_cb_result_t _mmcamcorder_asm_callback_sh(int handle, ASM_event_sources_t event_src, - ASM_sound_commands_t command, - unsigned int sound_status, void *cb_data); -ASM_cb_result_t _mmcamcorder_asm_callback_ex(int handle, ASM_event_sources_t event_src, - ASM_sound_commands_t command, - unsigned int sound_status, void *cb_data); - +#ifdef _MMCAMCORDER_RM_SUPPORT +rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src, + rm_device_request_s *info, void *cb_data); +#endif /* _MMCAMCORDER_RM_SUPPORT */ #ifdef _MMCAMCORDER_USE_SET_ATTR_CB static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data); #endif /* _MMCAMCORDER_USE_SET_ATTR_CB */ @@ -90,19 +97,18 @@ static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data); int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) { int ret = MM_ERROR_NONE; + int sys_info_ret = SYSTEM_INFO_ERROR_NONE; int UseConfCtrl = 0; - int sessionType = MM_SESSION_TYPE_SHARE; - int errorcode = MM_ERROR_NONE; int rcmd_fmt_capture = MM_PIXEL_FORMAT_YUYV; int rcmd_fmt_recording = MM_PIXEL_FORMAT_NV12; 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; char *err_attr_name = NULL; - char *ConfCtrlFile = NULL; + const char *ConfCtrlFile = NULL; mmf_camcorder_t *hcamcorder = NULL; - ASM_resource_t mm_resource = ASM_RESOURCE_NONE; type_element *EvasSurfaceElement = NULL; _mmcam_dbg_log("Entered"); @@ -120,29 +126,43 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) hcamcorder->state = MM_CAMCORDER_STATE_NONE; hcamcorder->sub_context = NULL; hcamcorder->target_state = MM_CAMCORDER_STATE_NULL; - - /* thread - for g_mutex_new() */ - if (!g_thread_supported()) { - g_thread_init(NULL); - } - - (hcamcorder->mtsafe).lock = g_mutex_new(); - (hcamcorder->mtsafe).cond = g_cond_new(); - - (hcamcorder->mtsafe).cmd_lock = g_mutex_new(); - (hcamcorder->mtsafe).state_lock = g_mutex_new(); - (hcamcorder->mtsafe).gst_state_lock = g_mutex_new(); - (hcamcorder->mtsafe).message_cb_lock = g_mutex_new(); - (hcamcorder->mtsafe).vcapture_cb_lock = g_mutex_new(); - (hcamcorder->mtsafe).vstream_cb_lock = g_mutex_new(); - (hcamcorder->mtsafe).astream_cb_lock = g_mutex_new(); - - pthread_mutex_init(&(hcamcorder->sound_lock), NULL); - pthread_cond_init(&(hcamcorder->sound_cond), 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->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 */ + 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 */ + 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) { @@ -151,151 +171,203 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) goto _ERR_DEFAULT_VALUE_INIT; } - /* Check and register ASM */ - if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) { - _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going..."); - sessionType = MM_SESSION_TYPE_SHARE; - } + /* set device type */ + hcamcorder->device_type = info->videodev_type; + _mmcam_dbg_warn("Device Type : %d", hcamcorder->device_type); - /* Call will not be interrupted. so does not need callback function */ - if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) { - int pid = -1; /* process id of itself */ + 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; - /* set SHARE session */ - if (!ASM_register_sound(pid, &(hcamcorder->asm_handle_sh), ASM_EVENT_SHARE_MMCAMCORDER, ASM_STATE_NONE, - (ASM_sound_cb_t)_mmcamcorder_asm_callback_sh, - (void*)hcamcorder, mm_resource, &errorcode)) { - _mmcam_dbg_err("SHARE ASM_register_sound() failed[%x]", errorcode); - ret = MM_ERROR_POLICY_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; } - /* set EXCLUSIVE session */ - if (!ASM_register_sound(pid, &(hcamcorder->asm_handle_ex), ASM_EVENT_EXCLUSIVE_MMCAMCORDER, ASM_STATE_NONE, - (ASM_sound_cb_t)_mmcamcorder_asm_callback_ex, - (void*)hcamcorder, mm_resource, &errorcode)) { - _mmcam_dbg_err("EXCLUSIVE ASM_register_sound() failed[%x]", errorcode); - ret = MM_ERROR_POLICY_INTERNAL; + 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("ASM handle - SHARE %d, EXCLUSIVE %d", - hcamcorder->asm_handle_sh, hcamcorder->asm_handle_ex); + _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 { + _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 */ - __ta__( " _mmcamcorder_conf_get_info main", - _mmcamcorder_conf_get_info(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_AUDIO_BLOCKED; + 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; } - __ta__(" _mmcamcorder_alloc_attribute", hcamcorder->attributes = _mmcamcorder_alloc_attribute((MMHandleType)hcamcorder, info); - ); if (!(hcamcorder->attributes)) { _mmcam_dbg_err("_mmcamcorder_create::alloc attribute error."); - + ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION; - goto _ERR_AUDIO_BLOCKED; + goto _ERR_DEFAULT_VALUE_INIT; } + /* get DPM context for camera/microphone restriction */ + hcamcorder->dpm_context = dpm_context_create(); + if (hcamcorder->dpm_context) { + hcamcorder->dpm_policy = dpm_context_acquire_restriction_policy(hcamcorder->dpm_context); + if (hcamcorder->dpm_policy == NULL) { + _mmcam_dbg_err("dpm_context_acquire_restriction_policy failed"); + dpm_context_destroy(hcamcorder->dpm_context); + hcamcorder->dpm_context = NULL; + } + } + + _mmcam_dbg_warn("DPM context %p, policy %p", hcamcorder->dpm_context, hcamcorder->dpm_policy); + if (info->videodev_type != MM_VIDEO_DEVICE_NONE) { - _mmcamcorder_conf_get_value_int(hcamcorder->conf_main, + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, "UseConfCtrl", &UseConfCtrl); if (UseConfCtrl) { + int resolution_width = 0; + int resolution_height = 0; + MMCamAttrsInfo fps_info; + _mmcam_dbg_log( "Enable Configure Control system." ); -#if 1 + switch (info->videodev_type) { case MM_VIDEO_DEVICE_CAMERA0: - _mmcamcorder_conf_get_value_string(hcamcorder->conf_main, + _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(hcamcorder->conf_main, + _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_ALLOC_ATTRIBUTE; + goto _ERR_DEFAULT_VALUE_INIT; } _mmcam_dbg_log("videodev_type : [%d], ConfCtrlPath : [%s]", info->videodev_type, ConfCtrlFile); - __ta__( " _mmcamcorder_conf_get_info ctrl", - _mmcamcorder_conf_get_info(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); */ -#else - _mmcamcorder_conf_query_info(CONFIGURE_TYPE_CTRL, info->videodev_type, &hcamcorder->conf_ctrl); -#endif - if (!(hcamcorder->conf_ctrl)) { - _mmcam_dbg_err( "Failed to get configure(control) info." ); - ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE; - goto _ERR_ALLOC_ATTRIBUTE; - } - - __ta__( " _mmcamcorder_init_convert_table", 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; } - __ta__( " _mmcamcorder_init_attr_from_configure", - 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 */ - _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl, + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, CONFIGURE_CATEGORY_CTRL_CAMERA, "RecommendPreviewFormatCapture", &rcmd_fmt_capture); - _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl, + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, CONFIGURE_CATEGORY_CTRL_CAMERA, "RecommendPreviewFormatRecord", &rcmd_fmt_recording); - _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl, + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, CONFIGURE_CATEGORY_CTRL_CAMERA, "RecommendDisplayRotation", &rcmd_dpy_rotation); - _mmcamcorder_conf_get_value_int(hcamcorder->conf_main, + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, CONFIGURE_CATEGORY_MAIN_CAPTURE, "PlayCaptureSound", &play_capture_sound); - _mmcamcorder_conf_get_value_int(hcamcorder->conf_main, + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, "DeviceCount", &camera_device_count); - _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl, + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl, CONFIGURE_CATEGORY_CTRL_CAMERA, "FacingDirection", &camera_facing_direction); - _mmcam_dbg_log("Recommend fmt[cap:%d,rec:%d], dpy rot[%d], cap snd[%d], dev cnt[%d], cam facing dir[%d]", + _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); + 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); + + _mmcam_dbg_log("UseZeroCopyFormat %d, UseVideoconvert %d, SupportMediaPacketPreviewCb %d", + hcamcorder->use_zero_copy_format, hcamcorder->use_videoconvert, hcamcorder->support_media_packet_preview_cb); + _mmcam_dbg_log("res : %d X %d, Default FPS by resolution : %d", + resolution_width, resolution_height, fps_info.int_array.def); + + if (camera_facing_direction == 1) { + if (rcmd_dpy_rotation == MM_DISPLAY_ROTATION_270 || rcmd_dpy_rotation == MM_DISPLAY_ROTATION_90) { + 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, @@ -303,64 +375,106 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) 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); - free(err_attr_name); - err_attr_name = NULL; + SAFE_FREE(err_attr_name); + ret = MM_ERROR_CAMCORDER_INTERNAL; + goto _ERR_DEFAULT_VALUE_INIT; } - /* Get UseZeroCopyFormat value from INI */ - _mmcamcorder_conf_get_value_int(hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, - "UseZeroCopyFormat", - &(hcamcorder->use_zero_copy_format)); - _mmcam_dbg_log("UseZeroCopyFormat : %d", hcamcorder->use_zero_copy_format); - } - else - { + /* 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; } + + /* add DPM camera policy changed callback */ + if (hcamcorder->dpm_context) { + if (dpm_context_add_policy_changed_cb(hcamcorder->dpm_context, + "camera", _mmcamcorder_dpm_camera_policy_changed_cb, + (void *)hcamcorder, &hcamcorder->dpm_camera_cb_id) != DPM_ERROR_NONE) { + _mmcam_dbg_err("add DPM changed cb failed, keep going..."); + hcamcorder->dpm_camera_cb_id = 0; + } + + _mmcam_dbg_log("DPM camera changed cb id %d", hcamcorder->dpm_camera_cb_id); + } + } else { + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, + CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, + "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); + 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; + } + } + +#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; } +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ + + traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:CREATE:INIT_GSTREAMER"); - __ta__( " __mmcamcorder_gstreamer_init", 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_ALLOC_ATTRIBUTE; + goto _ERR_DEFAULT_VALUE_INIT; } /* Make some attributes as read-only type */ - __ta__( " _mmcamcorder_lock_readonly_attributes", _mmcamcorder_lock_readonly_attributes((MMHandleType)hcamcorder); - ); /* Disable attributes in each model */ - __ta__( " _mmcamcorder_set_disabled_attributes", _mmcamcorder_set_disabled_attributes((MMHandleType)hcamcorder); - ); - - /* Determine state change as sync or async */ - _mmcamcorder_conf_get_value_int(hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_GENERAL, - "SyncStateChange", - &hcamcorder->sync_state_change ); - if (!(hcamcorder->sync_state_change)) { - _mmcamcorder_create_command_loop((MMHandleType)hcamcorder); - } /* Get videosink name for evas surface */ - _mmcamcorder_conf_get_element(hcamcorder->conf_main, + _mmcamcorder_conf_get_element((MMHandleType)hcamcorder, hcamcorder->conf_main, CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT, "VideosinkElementEvas", &EvasSurfaceElement); if (EvasSurfaceElement) { int attr_index = 0; - char *evassink_name = NULL; + const char *evassink_name = NULL; mmf_attribute_t *item_evassink_name = NULL; mmf_attrs_t *attrs = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(hcamcorder); @@ -377,53 +491,129 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) 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); + } + /* Set initial state */ _mmcamcorder_set_state((MMHandleType)hcamcorder, MM_CAMCORDER_STATE_NULL); - _mmcam_dbg_log("_mmcamcorder_set_state"); + + _mmcam_dbg_log("created handle %p", hcamcorder); *handle = (MMHandleType)hcamcorder; return MM_ERROR_NONE; -_ERR_ALLOC_ATTRIBUTE: -_ERR_AUDIO_BLOCKED: - /* unregister audio session manager */ - { - errorcode = MM_ERROR_NONE; - if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) { - _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going..."); - sessionType = MM_SESSION_TYPE_SHARE; +_ERR_DEFAULT_VALUE_INIT: +#ifdef _MMCAMCORDER_MURPHY_SUPPORT + /* de-initialize resource manager */ + _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager); +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ + + /* unregister sound focus */ + if (hcamcorder->sound_focus_register && hcamcorder->sound_focus_id > 0) { + if (MM_ERROR_NONE != mm_sound_unregister_focus(hcamcorder->sound_focus_id)) { + _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((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) { - /* unregister SHARE session */ - if (!ASM_unregister_sound(hcamcorder->asm_handle_sh, ASM_EVENT_SHARE_MMCAMCORDER, &errorcode)) { - _mmcam_dbg_err("ASM_unregister_sound() SHARE failed(hdl:%p, stype:%d, err:%x)", - (void*)hcamcorder->asm_handle_sh, sessionType, errorcode); - } - /* unregister EXCLUSIVE session */ - if (!ASM_unregister_sound(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER, &errorcode)) { - _mmcam_dbg_err("ASM_unregister_sound() EXCLUSIVE failed(hdl:%p, stype:%d, err:%x)", - (void*)hcamcorder->asm_handle_ex, sessionType, errorcode); - } + 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; } -_ERR_DEFAULT_VALUE_INIT: - g_mutex_free ((hcamcorder->mtsafe).lock); - g_cond_free ((hcamcorder->mtsafe).cond); - g_mutex_free ((hcamcorder->mtsafe).cmd_lock); - g_mutex_free ((hcamcorder->mtsafe).state_lock); - g_mutex_free ((hcamcorder->mtsafe).gst_state_lock); + /* 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->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( &hcamcorder->conf_ctrl ); + _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_ctrl); } if (hcamcorder->conf_main) { - _mmcamcorder_conf_release_info( &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 handle */ + memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t)); + free(hcamcorder); + return ret; } @@ -433,9 +623,9 @@ int _mmcamcorder_destroy(MMHandleType handle) int ret = MM_ERROR_NONE; int state = MM_CAMCORDER_STATE_NONE; int state_FROM = MM_CAMCORDER_STATE_NULL; - int state_TO = MM_CAMCORDER_STATE_NONE; - int sessionType = MM_SESSION_TYPE_SHARE; - int errorcode = MM_ERROR_NONE; +#ifdef _MMCAMCORDER_RM_SUPPORT + int iret = RM_OK; +#endif /* _MMCAMCORDER_RM_SUPPORT */ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); @@ -460,25 +650,34 @@ int _mmcamcorder_destroy(MMHandleType handle) goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - /* Set async state */ - ret = _mmcamcorder_set_async_state(handle, state_TO); - if (ret < 0) { - _mmcam_dbg_err("Can't set async state"); - 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); + + /* wait for completion of sound play */ + _mmcamcorder_sound_solo_play_wait(handle); /* Release SubContext and pipeline */ if (hcamcorder->sub_context) { if (hcamcorder->sub_context->element) { - __ta__(" _mmcamcorder_destroy_pipeline", _mmcamcorder_destroy_pipeline(handle, hcamcorder->type); - ); } _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context); hcamcorder->sub_context = NULL; } +#ifdef _MMCAMCORDER_MURPHY_SUPPORT + /* de-initialize resource manager */ + ret = _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("failed to de-initialize resource manager 0x%x", ret); + } +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ + /* Remove idle function which is not called yet */ if (hcamcorder->setting_event_id) { _mmcam_dbg_log("Remove remaining idle function"); @@ -488,7 +687,7 @@ int _mmcamcorder_destroy(MMHandleType handle) /* Remove attributes */ if (hcamcorder->attributes) { - _mmcamcorder_dealloc_attribute(hcamcorder->attributes); + _mmcamcorder_dealloc_attribute(handle, hcamcorder->attributes); hcamcorder->attributes = 0; } @@ -499,85 +698,98 @@ int _mmcamcorder_destroy(MMHandleType handle) } - /* Remove command loop when async state change mode */ - if (!hcamcorder->sync_state_change) { - _mmcamcorder_destroy_command_loop(handle); - } - /* Release configure info */ if (hcamcorder->conf_ctrl) { - _mmcamcorder_conf_release_info( &hcamcorder->conf_ctrl ); + _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl); } if (hcamcorder->conf_main) { - _mmcamcorder_conf_release_info( &hcamcorder->conf_main ); + _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_main); } /* Remove messages which are not called yet */ - _mmcamcroder_remove_message_all(handle); + _mmcamcorder_remove_message_all(handle); - /* Unregister ASM */ - if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) { - _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going..."); - sessionType = MM_SESSION_TYPE_SHARE; + /* 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); + } +#ifdef _MMCAMCORDER_RM_SUPPORT + if (hcamcorder->rm_handle != 0) { + iret = rm_unregister(hcamcorder->rm_handle); + if (iret != RM_OK) + _mmcam_dbg_err("rm_unregister() failed"); + hcamcorder->rm_handle = 0; + } +#endif /* _MMCAMCORDER_RM_SUPPORT */ + + /* release model_name */ + if (hcamcorder->model_name) { + free(hcamcorder->model_name); + hcamcorder->model_name = NULL; + } + + if (hcamcorder->software_version) { + free(hcamcorder->software_version); + hcamcorder->software_version = NULL; } - if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) { - /* unregister SHARE session */ - if (!ASM_unregister_sound(hcamcorder->asm_handle_sh, ASM_EVENT_SHARE_MMCAMCORDER, &errorcode)) { - _mmcam_dbg_err("SHARE ASM_unregister_sound() failed(hdl:%p, err:%x)", - (void*)hcamcorder->asm_handle_sh, errorcode); + + /* 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); } - /* unregister EXCLUSIVE session */ - if (!ASM_unregister_sound(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER, &errorcode)) { - _mmcam_dbg_err("EXCLUSIVE ASM_unregister_sound() failed(hdl:%p, err:%x)", - (void*)hcamcorder->asm_handle_ex, errorcode); + if (hcamcorder->dpm_policy) { + dpm_context_release_restriction_policy(hcamcorder->dpm_context, hcamcorder->dpm_policy); + hcamcorder->dpm_policy = NULL; } + + dpm_context_destroy(hcamcorder->dpm_context); + hcamcorder->dpm_context = NULL; } + /* join task thread */ + _mmcam_dbg_log("task thread join"); + g_thread_join(hcamcorder->task_thread); + hcamcorder->task_thread = NULL; + _MMCAMCORDER_UNLOCK_CMD(hcamcorder); /* Release lock, cond */ - if ((hcamcorder->mtsafe).lock) { - g_mutex_free ((hcamcorder->mtsafe).lock); - (hcamcorder->mtsafe).lock = NULL; - } - if ((hcamcorder->mtsafe).cond) { - g_cond_free ((hcamcorder->mtsafe).cond); - (hcamcorder->mtsafe).cond = NULL; - } - if ((hcamcorder->mtsafe).cmd_lock) { - g_mutex_free ((hcamcorder->mtsafe).cmd_lock); - (hcamcorder->mtsafe).cmd_lock = NULL; - } - if ((hcamcorder->mtsafe).state_lock) { - g_mutex_free ((hcamcorder->mtsafe).state_lock); - (hcamcorder->mtsafe).state_lock = NULL; - } - if ((hcamcorder->mtsafe).gst_state_lock) { - g_mutex_free ((hcamcorder->mtsafe).gst_state_lock); - (hcamcorder->mtsafe).gst_state_lock = NULL; - } - if ((hcamcorder->mtsafe).message_cb_lock) { - g_mutex_free ((hcamcorder->mtsafe).message_cb_lock); - (hcamcorder->mtsafe).message_cb_lock = NULL; - } - if ((hcamcorder->mtsafe).vcapture_cb_lock) { - g_mutex_free ((hcamcorder->mtsafe).vcapture_cb_lock); - (hcamcorder->mtsafe).vcapture_cb_lock = NULL; - } - if ((hcamcorder->mtsafe).vstream_cb_lock) { - g_mutex_free ((hcamcorder->mtsafe).vstream_cb_lock); - (hcamcorder->mtsafe).vstream_cb_lock = NULL; - } - if ((hcamcorder->mtsafe).astream_cb_lock) { - g_mutex_free ((hcamcorder->mtsafe).astream_cb_lock); - (hcamcorder->mtsafe).astream_cb_lock = NULL; - } - - 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)); + 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->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)); @@ -602,19 +814,24 @@ _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 state_FROM = MM_CAMCORDER_STATE_NULL; int state_TO = MM_CAMCORDER_STATE_READY; - int sessionType = MM_SESSION_TYPE_SHARE; - int errorcode = MM_ERROR_NONE; - 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; - char *videosink_name = NULL; + const char *videosink_name = NULL; + char *socket_path = NULL; + int socket_path_len; +#ifdef _MMCAMCORDER_RM_SUPPORT + int iret = RM_OK; +#endif /* _MMCAMCORDER_RM_SUPPORT */ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - _mmcam_dbg_log(""); + /*_mmcam_dbg_log("");*/ if (!hcamcorder) { _mmcam_dbg_err("Not initialized"); @@ -622,13 +839,6 @@ int _mmcamcorder_realize(MMHandleType handle) return ret; } - /* Check quick-device-close for emergency */ - if (hcamcorder->quick_device_close) { - _mmcam_dbg_err("_mmcamcorder_realize can't be called!!!!"); - ret = MM_ERROR_CAMCORDER_DEVICE; - goto _ERR_CAMCORDER_CMD_PRECON; - } - if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) { _mmcam_dbg_err("Another command is running."); ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING; @@ -642,59 +852,147 @@ int _mmcamcorder_realize(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; + mm_camcorder_get_attributes(handle, NULL, + MMCAM_MODE, &hcamcorder->type, + NULL); + + /* Get profile mode */ + _mmcam_dbg_log("Profile mode [%d]", hcamcorder->type); - /* 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_OPEN); + mm_camcorder_get_attributes(handle, 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); + } - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN); - } + /* acquire sound focus or set sound focus watch callback */ + hcamcorder->acquired_focus = 0; + hcamcorder->sound_focus_watch_id = 0; - /* Set async state */ - ret = _mmcamcorder_set_async_state(handle, state_TO); - if (ret < 0) { - _mmcam_dbg_err("Can't set async state"); - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + /* 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; + } + + 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("sound focus watch cb id %d", hcamcorder->sound_focus_watch_id); + } + } else { + _mmcam_dbg_log("no need to register sound focus"); } +#ifdef _MMCAMCORDER_RM_SUPPORT + int preview_format = MM_PIXEL_FORMAT_NV12; + int qret = RM_OK; + int qret_avail = RM_OK; + rm_consumer_info rci; + int app_pid = 0; + int resource_count = 0; + mm_camcorder_get_attributes(handle, NULL, - MMCAM_MODE, &hcamcorder->type, - MMCAM_DISPLAY_SURFACE, &display_surface_type, - MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate, + 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; + } + } - /* Get profile mode */ - _mmcam_dbg_log("Profile mode set is (%d)", hcamcorder->type); - - /* Check and make SHARE session as PLAYING */ - if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) { - _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going..."); - sessionType = MM_SESSION_TYPE_SHARE; - } - if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) { - ASM_resource_t mm_resource = ASM_RESOURCE_NONE; - - switch (hcamcorder->type) { - case MM_CAMCORDER_MODE_AUDIO: - mm_resource = ASM_RESOURCE_NONE; - break; - case MM_CAMCORDER_MODE_VIDEO_CAPTURE: - default: - mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER; - break; + mm_camcorder_get_attributes(handle, NULL, + MMCAM_CAMERA_FORMAT, &preview_format, + NULL); + + if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO && preview_format == MM_PIXEL_FORMAT_ENCODED_H264) { + + resource_count = 0; + memset(&hcamcorder->request_resources, 0x0, sizeof(rm_category_request_s)); + memset(&hcamcorder->returned_devices, 0x0, sizeof(rm_device_return_s)); + hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE; + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER; + _mmcam_dbg_log("request video decoder resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]); + + resource_count++; + hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE; + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER; + hcamcorder->request_resources.request_num = resource_count + 1; + _mmcam_dbg_log("request scaler resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]); + + + qret = rm_query(hcamcorder->rm_handle, RM_QUERY_ALLOCATION, &(hcamcorder->request_resources), &qret_avail); + + if (qret != RM_OK || qret_avail != RM_OK) { + _mmcam_dbg_log("Resource manager main device request fail"); + + resource_count = 0; + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER_SUB; + _mmcam_dbg_log("request video decoder resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]); + + resource_count++; + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER_SUB; + _mmcam_dbg_log("request scaler resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]); } - if (!ASM_set_sound_state(hcamcorder->asm_handle_sh, ASM_EVENT_SHARE_MMCAMCORDER, - ASM_STATE_PLAYING, mm_resource, &errorcode)) { - _mmcam_dbg_err("Set state to playing failed 0x%x", errorcode); + resource_count++; + hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE; + hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_CAMERA; + hcamcorder->request_resources.request_num = resource_count + 1; + _mmcam_dbg_log("request camera resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]); + + iret = rm_allocate_resources(hcamcorder->rm_handle, &(hcamcorder->request_resources), &hcamcorder->returned_devices); + if (iret != RM_OK) { + _mmcam_dbg_err("Resource allocation request failed"); ret = MM_ERROR_POLICY_BLOCKED; goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; - } + } } +#endif /* _MMCAMCORDER_RM_SUPPORT */ /* alloc sub context */ hcamcorder->sub_context = _mmcamcorder_alloc_subcontext(hcamcorder->type); @@ -708,14 +1006,24 @@ int _mmcamcorder_realize(MMHandleType handle) hcamcorder->sub_context->is_modified_rate = TRUE; } - _mmcamcorder_conf_get_value_int(hcamcorder->conf_main, + _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main, CONFIGURE_CATEGORY_MAIN_CAPTURE, "UseEncodebin", &(hcamcorder->sub_context->bencbin_capture)); + _mmcam_dbg_warn("UseEncodebin [%d]", hcamcorder->sub_context->bencbin_capture); + + if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { + /* get dual stream support info */ + _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main, + CONFIGURE_CATEGORY_MAIN_RECORD, + "SupportDualStream", + &(hcamcorder->sub_context->info_video->support_dual_stream)); + _mmcam_dbg_warn("SupportDualStream [%d]", hcamcorder->sub_context->info_video->support_dual_stream); + } 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"); @@ -726,14 +1034,24 @@ 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; } /* check string of videosink element */ if (videosink_element_type) { - _mmcamcorder_conf_get_element(hcamcorder->conf_main, + _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main, CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT, videosink_element_type, &hcamcorder->sub_context->VideosinkElement); @@ -743,29 +1061,88 @@ int _mmcamcorder_realize(MMHandleType handle) _mmcam_dbg_warn("strdup failed(display_surface_type %d). Use default X type", display_surface_type); - _mmcamcorder_conf_get_element(hcamcorder->conf_main, + _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main, CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT, _MMCAMCORDER_DEFAULT_VIDEOSINK_TYPE, - &hcamcorder->sub_context->VideosinkElement ); + &hcamcorder->sub_context->VideosinkElement); } _mmcamcorder_conf_get_value_element_name(hcamcorder->sub_context->VideosinkElement, &videosink_name); _mmcam_dbg_log("Videosink name : %s", videosink_name); - _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl, + /* get videoconvert element */ + _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main, + CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT, + "VideoconvertElement", + &hcamcorder->sub_context->VideoconvertElement); + + _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_ctrl, CONFIGURE_CATEGORY_CTRL_CAPTURE, "SensorEncodedCapture", &(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 (hcamcorder->dpm_policy) { + if (dpm_restriction_get_camera_state(hcamcorder->dpm_policy, &dpm_camera_state) == DPM_ERROR_NONE) { + _mmcam_dbg_log("DPM camera state %d", dpm_camera_state); + if (dpm_camera_state == DPM_DISALLOWED) { + _mmcam_dbg_err("CAMERA DISALLOWED by DPM"); + ret = MM_ERROR_POLICY_RESTRICTED; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + } else { + _mmcam_dbg_err("get DPM camera state failed, keep going..."); + } + } else { + _mmcam_dbg_warn("NULL dpm_policy"); + } +#ifdef _MMCAMCORDER_MURPHY_SUPPORT + /* prepare resource manager for camera */ + 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; + } + + /* 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, MM_CAMCORDER_RESOURCE_TYPE_VIDEO_OVERLAY); + if(ret != MM_ERROR_NONE) { + _mmcam_dbg_err("could not prepare for video overlay resource"); + ret = MM_ERROR_CAMCORDER_INTERNAL; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + } + + /* acquire resources */ + if (hcamcorder->resource_manager.rset && _mmcamcorder_resource_manager_acquire(&hcamcorder->resource_manager)) { + _mmcam_dbg_err("could not acquire resources"); + _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager); + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ + } + /* create pipeline */ - __ta__(" _mmcamcorder_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->sub_context->error_code != MM_ERROR_NONE) { - ret = hcamcorder->sub_context->error_code; + if (hcamcorder->error_code != MM_ERROR_NONE) { + ret = hcamcorder->error_code; _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret); } @@ -791,27 +1168,72 @@ int _mmcamcorder_realize(MMHandleType handle) return MM_ERROR_NONE; _ERR_CAMCORDER_CMD: - /* set async state and (set async cancel or set state) are pair. */ - _mmcamcorder_set_async_cancel(handle); +#ifdef _MMCAMCORDER_MURPHY_SUPPORT + /* release hw resources */ + 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); + } + ret_resource = _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager); + if (ret_resource != MM_ERROR_NONE) { + _mmcam_dbg_err("failed to unprepare resource manager, ret_resource(0x%x)", ret_resource); + } + } +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: _MMCAMCORDER_UNLOCK_CMD(hcamcorder); - -_ERR_CAMCORDER_CMD_PRECON: - _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)", - hcamcorder->type, state, ret); - /* 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); + 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); + } + } - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL); + 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); + } + } } +#ifdef _MMCAMCORDER_RM_SUPPORT + if (hcamcorder->rm_handle) { + if (hcamcorder->returned_devices.allocated_num > 0) { + int idx = 0; + rm_device_request_s requested; + memset(&requested, 0x0, sizeof(rm_device_request_s)); + requested.request_num = hcamcorder->returned_devices.allocated_num; + for (idx = 0; idx < requested.request_num; idx++) { + requested.device_id[idx] = hcamcorder->returned_devices.device_id[idx]; + } + iret = rm_deallocate_resources(hcamcorder->rm_handle, &requested); + if (iret != RM_OK) + _mmcam_dbg_err("Resource deallocation request failed "); + } + /* unregister RM */ + int ires = rm_unregister(hcamcorder->rm_handle); + if (ires != RM_OK) + _mmcam_dbg_err("rm_unregister() failed"); + hcamcorder->rm_handle = 0; + } +#endif /* _MMCAMCORDER_RM_SUPPORT*/ + +_ERR_CAMCORDER_CMD_PRECON: + _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)", + hcamcorder->type, state, ret); return ret; } @@ -823,8 +1245,6 @@ int _mmcamcorder_unrealize(MMHandleType handle) int state = MM_CAMCORDER_STATE_NONE; int state_FROM = MM_CAMCORDER_STATE_READY; int state_TO = MM_CAMCORDER_STATE_NULL; - int sessionType = MM_SESSION_TYPE_SHARE; - ASM_resource_t mm_resource = ASM_RESOURCE_NONE; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); @@ -849,13 +1269,6 @@ int _mmcamcorder_unrealize(MMHandleType handle) goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - /* set async state */ - ret = _mmcamcorder_set_async_state(handle, state_TO); - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("Can't set async state"); - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; - } - /* Release SubContext */ if (hcamcorder->sub_context) { /* destroy pipeline */ @@ -865,55 +1278,87 @@ int _mmcamcorder_unrealize(MMHandleType handle) hcamcorder->sub_context = NULL; } - /* Deinitialize main context member */ +#ifdef _MMCAMCORDER_MURPHY_SUPPORT + if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) { + /* release resource */ + ret = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager); + if (ret == MM_ERROR_RESOURCE_INVALID_STATE) { + _mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource"); + 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); + } + } +#endif /* _MMCAMCORDER_MURPHY_SUPPORT */ + +#ifdef _MMCAMCORDER_RM_SUPPORT + if (hcamcorder->rm_handle && (hcamcorder->returned_devices.allocated_num > 0)) { + int iret = RM_OK; + int idx = 0; + rm_device_request_s requested; + memset(&requested, 0x0, sizeof(rm_device_request_s)); + requested.request_num = hcamcorder->returned_devices.allocated_num; + for (idx = 0; idx < requested.request_num; idx++) { + requested.device_id[idx] = hcamcorder->returned_devices.device_id[idx]; + } + iret = rm_deallocate_resources(hcamcorder->rm_handle, &requested); + if (iret != RM_OK) + _mmcam_dbg_err("Resource deallocation request failed "); + } +#endif /* _MMCAMCORDER_RM_SUPPORT*/ + /* Deinitialize main context member */ hcamcorder->command = NULL; - /* check who calls unrealize. it's no need to set ASM state if caller is ASM */ - if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_ASM) { - if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) { - _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going..."); - sessionType = MM_SESSION_TYPE_SHARE; - } + _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); - /* Call session is not ended here */ - if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) { - mm_resource = ASM_RESOURCE_NONE; + /* release sound focus or unset sound focus watch callback */ + if (hcamcorder->sound_focus_register) { + int ret_sound = MM_ERROR_NONE; - switch (hcamcorder->type) { - case MM_CAMCORDER_MODE_AUDIO: - mm_resource = ASM_RESOURCE_NONE; - break; - case MM_CAMCORDER_MODE_VIDEO_CAPTURE: - default: - mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER; - break; - } + _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); - /* STOP SHARE session */ - if (!ASM_set_sound_state(hcamcorder->asm_handle_sh, ASM_EVENT_SHARE_MMCAMCORDER, - ASM_STATE_STOP, mm_resource, &ret)) { - _mmcam_dbg_err("SHARE Set state to STOP failed 0x%x", ret); + 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); } - } - _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_NULL); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_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); + _mmcamcorder_set_state(handle, state_TO); + return MM_ERROR_NONE; _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: @@ -948,13 +1393,6 @@ int _mmcamcorder_start(MMHandleType handle) sc = MMF_CAMCORDER_SUBCONTEXT(handle); mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED); - /* check quick-device-close for emergency */ - if (hcamcorder->quick_device_close) { - _mmcam_dbg_err("_mmcamcorder_start can't be called!!!!"); - ret = MM_ERROR_CAMCORDER_DEVICE; - goto _ERR_CAMCORDER_CMD_PRECON; - } - if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) { _mmcam_dbg_err("Another command is running."); ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING; @@ -969,53 +1407,60 @@ int _mmcamcorder_start(MMHandleType handle) } /* initialize error code */ - hcamcorder->sub_context->error_code = MM_ERROR_NONE; + hcamcorder->error_code = MM_ERROR_NONE; - /* set async state */ - ret = _mmcamcorder_set_async_state(handle, state_TO); - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("Can't set async state"); - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + /* 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); } ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_START); if (ret != MM_ERROR_NONE) { - goto _ERR_CAMCORDER_CMD; + /* check internal error of gstreamer */ + if (hcamcorder->error_code != MM_ERROR_NONE) { + ret = hcamcorder->error_code; + _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret); + } + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } _mmcamcorder_set_state(handle, state_TO); - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - _mmcamcorder_set_attribute_to_camsensor(handle); - - /* 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: - /* set async state and (set async cancel or set state) are pair. */ - _mmcamcorder_set_async_cancel(handle); - _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: /* check internal error of gstreamer */ - if (hcamcorder->sub_context->error_code != MM_ERROR_NONE) { - ret = hcamcorder->sub_context->error_code; - hcamcorder->sub_context->error_code = MM_ERROR_NONE; + if (hcamcorder->error_code != MM_ERROR_NONE) { + ret = hcamcorder->error_code; + hcamcorder->error_code = MM_ERROR_NONE; _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret); } @@ -1032,7 +1477,6 @@ int _mmcamcorder_stop(MMHandleType handle) int state = MM_CAMCORDER_STATE_NONE; int state_FROM = MM_CAMCORDER_STATE_PREPARE; int state_TO = MM_CAMCORDER_STATE_READY; - int frame_rate = 0; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); @@ -1057,45 +1501,45 @@ int _mmcamcorder_stop(MMHandleType handle) goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - /* set async state */ - ret = _mmcamcorder_set_async_state(handle, state_TO); - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("Can't set async state"); - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; - } - ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_STOP); if (ret != MM_ERROR_NONE) { - goto _ERR_CAMCORDER_CMD; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - /* KPI : frame rate */ - frame_rate=_mmcamcorder_video_average_framerate(handle); - __ta__(__tafmt__("MM_CAM_006:: Frame per sec : %d", frame_rate), ;); - _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); return MM_ERROR_NONE; -_ERR_CAMCORDER_CMD: - /* set async state and (set async cancel or set state) are pair. */ - _mmcamcorder_set_async_cancel(handle); - _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: _MMCAMCORDER_UNLOCK_CMD(hcamcorder); @@ -1116,7 +1560,6 @@ int _mmcamcorder_capture_start(MMHandleType handle) int state_FROM_1 = MM_CAMCORDER_STATE_RECORDING; int state_FROM_2 = MM_CAMCORDER_STATE_PAUSED; int state_TO = MM_CAMCORDER_STATE_CAPTURING; - char *err_name = NULL; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); @@ -1143,11 +1586,27 @@ int _mmcamcorder_capture_start(MMHandleType handle) goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - /* set async state */ - ret = _mmcamcorder_set_async_state(handle, state_TO); - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("Can't set async state"); - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + /* Handle capture in recording case */ + if (state == state_FROM_1 || state == state_FROM_2) { + if (hcamcorder->capture_in_recording == TRUE) { + _mmcam_dbg_err("Capturing in recording (%d)", state); + ret = MM_ERROR_CAMCORDER_DEVICE_BUSY; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } else { + 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; + } + } } ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_CAPTURE); @@ -1160,16 +1619,19 @@ int _mmcamcorder_capture_start(MMHandleType handle) _mmcamcorder_set_state(handle, state_TO); } - /* Init break continuous shot attr */ - mm_camcorder_set_attributes(handle, &err_name, "capture-break-cont-shot", 0, NULL); - _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) { + _mmcam_dbg_warn("capture-break-cont-shot set 0 failed"); + } + return MM_ERROR_NONE; _ERR_CAMCORDER_CMD: - /* set async state and (set async cancel or set state) are pair. */ - _mmcamcorder_set_async_cancel(handle); + if (hcamcorder->capture_in_recording) { + hcamcorder->capture_in_recording = FALSE; + } _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: _MMCAMCORDER_UNLOCK_CMD(hcamcorder); @@ -1211,30 +1673,17 @@ int _mmcamcorder_capture_stop(MMHandleType handle) goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - /* set async state */ - ret = _mmcamcorder_set_async_state(handle, state_TO); - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("Can't set async state"); - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; - } - ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_START); if (ret != MM_ERROR_NONE) { - goto _ERR_CAMCORDER_CMD; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } _mmcamcorder_set_state(handle, state_TO); _MMCAMCORDER_UNLOCK_CMD(hcamcorder); - MMTA_ACUM_ITEM_END("Real First Capture Start", FALSE); - return MM_ERROR_NONE; -_ERR_CAMCORDER_CMD: - /* set async state and (set async cancel or set state) are pair. */ - _mmcamcorder_set_async_cancel(handle); - _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: _MMCAMCORDER_UNLOCK_CMD(hcamcorder); @@ -1253,7 +1702,7 @@ int _mmcamcorder_record(MMHandleType handle) int state_FROM1 = MM_CAMCORDER_STATE_PREPARE; int state_FROM2 = MM_CAMCORDER_STATE_PAUSED; int state_TO = MM_CAMCORDER_STATE_RECORDING; - int sessionType = MM_SESSION_TYPE_SHARE; + int dpm_mic_state = DPM_ALLOWED; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); @@ -1279,77 +1728,48 @@ int _mmcamcorder_record(MMHandleType handle) } /* initialize error code */ - hcamcorder->sub_context->error_code = MM_ERROR_NONE; - - /* Check and register EXCLUSIVE ASM */ - if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) { - _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going..."); - sessionType = MM_SESSION_TYPE_SHARE; - } - if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) { - int errorcode; - ASM_resource_t mm_resource = ASM_RESOURCE_NONE; - - switch (hcamcorder->type) { - case MM_CAMCORDER_MODE_AUDIO: - mm_resource = ASM_RESOURCE_NONE; - break; - case MM_CAMCORDER_MODE_VIDEO_CAPTURE: - default: - mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER; - break; - } - - if (!ASM_set_sound_state(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER, - ASM_STATE_PLAYING, mm_resource, &errorcode)) { - _mmcam_dbg_err("Set state to playing failed 0x%x", errorcode); - ret = MM_ERROR_POLICY_BLOCKED; - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + hcamcorder->error_code = MM_ERROR_NONE; + + /* check mic policy from DPM */ + if (hcamcorder->dpm_policy) { + if (dpm_restriction_get_microphone_state(hcamcorder->dpm_policy, &dpm_mic_state) == DPM_ERROR_NONE) { + _mmcam_dbg_log("DPM mic state %d", dpm_mic_state); + if (dpm_mic_state == DPM_DISALLOWED) { + _mmcam_dbg_err("MIC DISALLOWED by DPM"); + ret = MM_ERROR_COMMON_INVALID_PERMISSION; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + } else { + _mmcam_dbg_err("get DPM mic state failed, keep going..."); } - } - - /* set async state */ - ret = _mmcamcorder_set_async_state(handle, state_TO); - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("Can't set async state"); - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } else { + _mmcam_dbg_warn("NULL dpm_policy"); } ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_RECORD); if (ret != MM_ERROR_NONE) { - goto _ERR_CAMCORDER_CMD; + /* check internal error of gstreamer */ + if (hcamcorder->error_code != MM_ERROR_NONE) { + ret = hcamcorder->error_code; + _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret); + } + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } _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); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; -_ERR_CAMCORDER_CMD: - /* set async state and (set async cancel or set state) are pair. */ - _mmcamcorder_set_async_cancel(handle); - _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: _MMCAMCORDER_UNLOCK_CMD(hcamcorder); _ERR_CAMCORDER_CMD_PRECON: /* check internal error of gstreamer */ - if (hcamcorder->sub_context->error_code != MM_ERROR_NONE) { - ret = hcamcorder->sub_context->error_code; - hcamcorder->sub_context->error_code = MM_ERROR_NONE; + if (hcamcorder->error_code != MM_ERROR_NONE) { + ret = hcamcorder->error_code; + hcamcorder->error_code = MM_ERROR_NONE; _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret); } @@ -1391,40 +1811,17 @@ int _mmcamcorder_pause(MMHandleType handle) goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - /* set async state */ - ret = _mmcamcorder_set_async_state(handle, state_TO); - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("Can't set async state"); - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; - } - ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PAUSE); if (ret != MM_ERROR_NONE) { - goto _ERR_CAMCORDER_CMD; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } _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); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; -_ERR_CAMCORDER_CMD: - /* set async state and (set async cancel or set state) are pair. */ - _mmcamcorder_set_async_cancel(handle); - _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: _MMCAMCORDER_UNLOCK_CMD(hcamcorder); @@ -1446,7 +1843,7 @@ int _mmcamcorder_commit(MMHandleType handle) int state_TO = MM_CAMCORDER_STATE_PREPARE; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - + _mmcam_dbg_log(""); if (!hcamcorder) { @@ -1468,70 +1865,17 @@ int _mmcamcorder_commit(MMHandleType handle) goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - /* set async state */ - ret = _mmcamcorder_set_async_state(handle, state_TO); + ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_COMMIT); if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("Can't set async state"); goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_COMMIT); - if (ret != MM_ERROR_NONE) { - goto _ERR_CAMCORDER_CMD; - } + _MMCAMCORDER_UNLOCK_CMD(hcamcorder); _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); - } - - /* check who calls unrealize. it's no need to set ASM state if caller is ASM */ - if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_ASM) { - int sessionType = MM_SESSION_TYPE_SHARE; - ASM_resource_t mm_resource = ASM_RESOURCE_NONE; - - if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) { - _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going..."); - sessionType = MM_SESSION_TYPE_SHARE; - } - - /* Call session is not ended here */ - if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) { - switch (hcamcorder->type) { - case MM_CAMCORDER_MODE_AUDIO: - mm_resource = ASM_RESOURCE_NONE; - break; - case MM_CAMCORDER_MODE_VIDEO_CAPTURE: - default: - mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER; - break; - } - - /* STOP EXCLUSIVE session */ - if (!ASM_set_sound_state(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER, - ASM_STATE_STOP, mm_resource, &ret)) { - _mmcam_dbg_err("EXCLUSIVE Set state to STOP failed 0x%x", ret); - } - } - } - - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); - return MM_ERROR_NONE; -_ERR_CAMCORDER_CMD: - /* set async state and (set async cancel or set state) are pair. */ - _mmcamcorder_set_async_cancel(handle); - _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: _MMCAMCORDER_UNLOCK_CMD(hcamcorder); @@ -1551,10 +1895,9 @@ int _mmcamcorder_cancel(MMHandleType handle) int state_FROM1 = MM_CAMCORDER_STATE_RECORDING; int state_FROM2 = MM_CAMCORDER_STATE_PAUSED; int state_TO = MM_CAMCORDER_STATE_PREPARE; - int sessionType = MM_SESSION_TYPE_SHARE; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - + _mmcam_dbg_log(""); if (!hcamcorder) { @@ -1576,67 +1919,17 @@ int _mmcamcorder_cancel(MMHandleType handle) goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - /* set async state */ - ret = _mmcamcorder_set_async_state(handle, state_TO); - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("Can't set async state"); - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; - } - ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_CANCEL); if (ret != MM_ERROR_NONE) { - goto _ERR_CAMCORDER_CMD; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } _mmcamcorder_set_state(handle, state_TO); - /* read session type */ - if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) { - _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going..."); - sessionType = MM_SESSION_TYPE_SHARE; - } - - /* Call session is not ended here */ - if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) { - ASM_resource_t mm_resource = ASM_RESOURCE_NONE; - - switch (hcamcorder->type) { - case MM_CAMCORDER_MODE_AUDIO: - mm_resource = ASM_RESOURCE_NONE; - break; - case MM_CAMCORDER_MODE_VIDEO_CAPTURE: - default: - mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER; - break; - } - - /* STOP EXCLUSIVE session */ - if (!ASM_set_sound_state(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER, - ASM_STATE_STOP, mm_resource, &ret)) { - _mmcam_dbg_err("EXCLUSIVE Set state to STOP failed 0x%x", ret); - } - } - - /* 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); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; -_ERR_CAMCORDER_CMD: - /* set async state and (set async cancel or set state) are pair. */ - _mmcamcorder_set_async_cancel(handle); - _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: _MMCAMCORDER_UNLOCK_CMD(hcamcorder); @@ -1692,7 +1985,7 @@ int _mmcamcorder_set_video_stream_callback(MMHandleType handle, mm_camcorder_vid { mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - _mmcam_dbg_log(""); + /*_mmcam_dbg_log("");*/ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED); @@ -1788,7 +2081,6 @@ int _mmcamcorder_init_focusing(MMHandleType handle) int current_af_range = 0; mmf_camcorder_t *hcamcorder = NULL; _MMCamcorderSubContext *sc = NULL; - mmf_attrs_t *attr = NULL; GstCameraControl *control = NULL; _mmcam_dbg_log(""); @@ -1818,7 +2110,13 @@ int _mmcamcorder_init_focusing(MMHandleType handle) _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; } + 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; + } ret = gst_camera_control_stop_auto_focus(control); if (!ret) { @@ -1828,7 +2126,6 @@ int _mmcamcorder_init_focusing(MMHandleType handle) } /* Initialize lens position */ - attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle); mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FOCUS_MODE, &focus_mode, MMCAM_CAMERA_AF_SCAN_RANGE, &af_range, @@ -1867,12 +2164,18 @@ int _mmcamcorder_adjust_focus(MMHandleType handle, int direction) mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED); mmf_return_val_if_fail(direction, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); - _mmcam_dbg_log(""); + /*_mmcam_dbg_log("");*/ + + if (!_MMCAMCORDER_TRYLOCK_CMD(handle)) { + _mmcam_dbg_err("Another command is running."); + return MM_ERROR_CAMCORDER_CMD_IS_RUNNING; + } state = _mmcamcorder_get_state(handle); if (state == MM_CAMCORDER_STATE_CAPTURING || state < MM_CAMCORDER_STATE_PREPARE) { _mmcam_dbg_err("Not proper state. state[%d]", state); + _MMCAMCORDER_UNLOCK_CMD(handle); return MM_ERROR_CAMCORDER_INVALID_STATE; } @@ -1883,19 +2186,24 @@ int _mmcamcorder_adjust_focus(MMHandleType handle, int direction) if (ret != MM_ERROR_NONE) { _mmcam_dbg_warn("Get focus-mode fail. (%s:%x)", err_attr_name, ret); SAFE_FREE (err_attr_name); + _MMCAMCORDER_UNLOCK_CMD(handle); return ret; } if (focus_mode == MM_CAMCORDER_FOCUS_MODE_MANUAL) { - return _mmcamcorder_adjust_manual_focus(handle, direction); + ret = _mmcamcorder_adjust_manual_focus(handle, direction); } else if (focus_mode == MM_CAMCORDER_FOCUS_MODE_AUTO || focus_mode == MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO || focus_mode == MM_CAMCORDER_FOCUS_MODE_CONTINUOUS) { - return _mmcamcorder_adjust_auto_focus(handle); + ret = _mmcamcorder_adjust_auto_focus(handle); } else { _mmcam_dbg_err("It doesn't adjust focus. Focusing mode(%d)", focus_mode); - return MM_ERROR_CAMCORDER_NOT_SUPPORTED; + ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED; } + + _MMCAMCORDER_UNLOCK_CMD(handle); + + return ret; } int _mmcamcorder_adjust_manual_focus(MMHandleType handle, int direction) @@ -1924,7 +2232,12 @@ int _mmcamcorder_adjust_manual_focus(MMHandleType handle, int direction) _mmcam_dbg_log("Can't cast Video source into camera control."); return MM_ERROR_NONE; } + control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + if (control == NULL) { + _mmcam_dbg_err("cast CAMERA_CONTROL failed"); + return MM_ERROR_CAMCORDER_INTERNAL; + } /* TODO : get max, min level */ if (max_level - min_level + 1 < _MMFCAMCORDER_FOCUS_TOTAL_LEVEL) { @@ -1969,7 +2282,7 @@ int _mmcamcorder_adjust_auto_focus(MMHandleType handle) mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED); - _mmcam_dbg_log(""); + /*_mmcam_dbg_log("");*/ sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder); @@ -1977,10 +2290,16 @@ int _mmcamcorder_adjust_auto_focus(MMHandleType handle) _mmcam_dbg_log("Can't cast Video source into camera control."); return MM_ERROR_NONE; } + control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + if (control) { + /* Start AF */ + ret = gst_camera_control_start_auto_focus(control); + } else { + _mmcam_dbg_err("cast CAMERA_CONTROL failed"); + ret = FALSE; + } - /* Start AF */ - ret = gst_camera_control_start_auto_focus(control); if (ret) { _mmcam_dbg_log("Auto focusing start success."); return MM_ERROR_NONE; @@ -2000,7 +2319,7 @@ int _mmcamcorder_stop_focusing(MMHandleType handle) mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED); - _mmcam_dbg_log(""); + /*_mmcam_dbg_log("");*/ sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder); @@ -2022,9 +2341,14 @@ int _mmcamcorder_stop_focusing(MMHandleType handle) _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; } - control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); - ret = gst_camera_control_stop_auto_focus(control); + control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + if (control) { + ret = gst_camera_control_stop_auto_focus(control); + } else { + _mmcam_dbg_err("cast CAMERA_CONTROL failed"); + ret = FALSE; + } _MMCAMCORDER_UNLOCK_CMD(hcamcorder); @@ -2091,10 +2415,7 @@ __mmcamcorder_gstreamer_init(camera_conf * conf) } /* initializing gstreamer */ - __ta__(" gst_init_check", ret = gst_init_check (argc, &argv, &err); - ); - if (!ret) { _mmcam_dbg_err("Could not initialize GStreamer: %s ", err ? err->message : "unknown error occurred"); @@ -2106,7 +2427,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; } } @@ -2150,7 +2471,7 @@ int _mmcamcorder_get_state(MMHandleType handle) _MMCAMCORDER_LOCK_STATE(handle); state = hcamcorder->state; - _mmcam_dbg_log("state=%d",state); + /*_mmcam_dbg_log("state=%d",state);*/ _MMCAMCORDER_UNLOCK_STATE(handle); @@ -2166,7 +2487,7 @@ void _mmcamcorder_set_state(MMHandleType handle, int state) mmf_return_if_fail(hcamcorder); - _mmcam_dbg_log(""); + /*_mmcam_dbg_log("");*/ _MMCAMCORDER_LOCK_STATE(handle); @@ -2181,7 +2502,15 @@ void _mmcamcorder_set_state(MMHandleType handle, int 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->asm_event_code; + 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: @@ -2193,8 +2522,8 @@ void _mmcamcorder_set_state(MMHandleType handle, int state) msg.param.state.previous = old_state; msg.param.state.current = state; - _mmcam_dbg_log("_mmcamcroder_send_message : msg : %p, id:%x", &msg, msg.id); - _mmcamcroder_send_message(handle, &msg); + /*_mmcam_dbg_log("_mmcamcorder_send_message : msg : %p, id:%x", &msg, msg.id);*/ + _mmcamcorder_send_message(handle, &msg); } _MMCAMCORDER_UNLOCK_STATE(handle); @@ -2216,176 +2545,105 @@ int _mmcamcorder_get_async_state(MMHandleType handle) return state; } -int _mmcamcorder_set_async_state(MMHandleType handle, int target_state) -{ - int error = MM_ERROR_NONE; - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_CONDITION); - - _mmcam_dbg_log(""); +_MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type) +{ + int i; + _MMCamcorderSubContext *sc = NULL; - if (hcamcorder->sync_state_change) { - return error; - } + /*_mmcam_dbg_log("");*/ - _MMCAMCORDER_LOCK_STATE(handle); + /* alloc container */ + sc = (_MMCamcorderSubContext *)malloc(sizeof(_MMCamcorderSubContext)); + mmf_return_val_if_fail(sc != NULL, NULL); - /* check changing state */ - if (hcamcorder->state != hcamcorder->target_state) { - _mmcam_dbg_warn("State is changing now."); - error = MM_ERROR_CAMCORDER_CMD_IS_RUNNING; - goto _SET_ASYNC_END; - } + /* init members */ + memset(sc, 0x00, sizeof(_MMCamcorderSubContext)); - /* check already set */ - if (hcamcorder->state == target_state) { - _mmcam_dbg_log("Target state already set."); - error = MM_ERROR_CAMCORDER_INVALID_STATE; - goto _SET_ASYNC_END; - } + sc->element_num = _MMCAMCORDER_PIPELINE_ELEMENT_NUM; + sc->encode_element_num = _MMCAMCORDER_ENCODE_PIPELINE_ELEMENT_NUM; - hcamcorder->target_state = target_state; + /* alloc info for each mode */ + switch (type) { + case MM_CAMCORDER_MODE_AUDIO: + sc->info_audio = g_malloc0( sizeof(_MMCamcorderAudioInfo)); + if(!sc->info_audio) { + _mmcam_dbg_err("Failed to alloc info structure"); + goto ALLOC_SUBCONTEXT_FAILED; + } + break; + case MM_CAMCORDER_MODE_VIDEO_CAPTURE: + default: + sc->info_image = g_malloc0( sizeof(_MMCamcorderImageInfo)); + if(!sc->info_image) { + _mmcam_dbg_err("Failed to alloc info structure"); + goto ALLOC_SUBCONTEXT_FAILED; + } - _mmcam_dbg_log("Done"); + /* init sound status */ + sc->info_image->sound_status = _SOUND_STATUS_INIT; -_SET_ASYNC_END: - _MMCAMCORDER_UNLOCK_STATE(handle); - return error; -} + sc->info_video = g_malloc0( sizeof(_MMCamcorderVideoInfo)); + if(!sc->info_video) { + _mmcam_dbg_err("Failed to alloc info structure"); + goto ALLOC_SUBCONTEXT_FAILED; + } + g_mutex_init(&sc->info_video->size_check_lock); + break; + } + /* alloc element array */ + sc->element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->element_num); + if(!sc->element) { + _mmcam_dbg_err("Failed to alloc element structure"); + goto ALLOC_SUBCONTEXT_FAILED; + } -gboolean _mmcamcorder_set_async_cancel(MMHandleType handle) -{ - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - - mmf_return_val_if_fail(hcamcorder, FALSE); - - _mmcam_dbg_log(""); + sc->encode_element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->encode_element_num); + if(!sc->encode_element) { + _mmcam_dbg_err("Failed to alloc encode element structure"); + goto ALLOC_SUBCONTEXT_FAILED; + } - if (hcamcorder->sync_state_change) { - return TRUE; + for (i = 0 ; i < sc->element_num ; i++) { + sc->element[i].id = _MMCAMCORDER_NONE; + sc->element[i].gst = NULL; } - _MMCAMCORDER_LOCK_STATE(handle); + for (i = 0 ; i < sc->encode_element_num ; i++) { + sc->encode_element[i].id = _MMCAMCORDER_NONE; + sc->encode_element[i].gst = NULL; + } - if (hcamcorder->target_state != hcamcorder->state) { - hcamcorder->target_state = hcamcorder->state; - _mmcam_dbg_log("Async state change is canceled."); - _MMCAMCORDER_UNLOCK_STATE(handle); - return TRUE; - } else { - _mmcam_dbg_log("Nothing to be cancel or Already processed."); - } - - _MMCAMCORDER_UNLOCK_STATE(handle); - - return FALSE; -} - - -gboolean _mmcamcorder_is_state_changing(MMHandleType handle) -{ - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - - mmf_return_val_if_fail(hcamcorder, FALSE); - - _mmcam_dbg_log("(%d)", (hcamcorder->target_state != hcamcorder->state)); - - if (hcamcorder->sync_state_change) { - return FALSE; - } - - _MMCAMCORDER_LOCK_STATE(handle); - - if (hcamcorder->target_state != hcamcorder->state) { - _MMCAMCORDER_UNLOCK_STATE(handle); - return TRUE; - } - - _MMCAMCORDER_UNLOCK_STATE(handle); - - return FALSE; -} - - -_MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type) -{ - int i; - _MMCamcorderSubContext *sc = NULL; - - _mmcam_dbg_log(""); - - /* alloc container */ - sc = (_MMCamcorderSubContext *)malloc(sizeof(_MMCamcorderSubContext)); - mmf_return_val_if_fail(sc != NULL, NULL); - - /* init members */ - memset(sc, 0x00, sizeof(_MMCamcorderSubContext)); + sc->fourcc = 0x80000000; + sc->cam_stability_count = 0; + sc->drop_vframe = 0; + sc->pass_first_vframe = 0; + sc->is_modified_rate = FALSE; - sc->element_num = _MMCamcorder_PIPELINE_ELEMENT_NUM; + return sc; - /* alloc info for each mode */ - switch (type) { - case MM_CAMCORDER_MODE_AUDIO: - sc->info_audio = malloc( sizeof(_MMCamcorderAudioInfo)); - if(sc->info_audio == NULL) { - _mmcam_dbg_err("Failed to alloc info structure"); - free(sc); - return NULL; - } - memset(sc->info_audio, 0x00, sizeof(_MMCamcorderAudioInfo)); - break; - case MM_CAMCORDER_MODE_VIDEO_CAPTURE: - default: - sc->info_image = malloc( sizeof(_MMCamcorderImageInfo)); - if(sc->info_image == NULL) { - _mmcam_dbg_err("Failed to alloc info structure"); - free(sc); - return NULL; +ALLOC_SUBCONTEXT_FAILED: + if (sc) { + SAFE_G_FREE(sc->info_audio); + SAFE_G_FREE(sc->info_image); + if (sc->info_video) { + g_mutex_clear(&sc->info_video->size_check_lock); } - memset(sc->info_image, 0x00, sizeof(_MMCamcorderImageInfo)); - - /* init sound status */ - sc->info_image->sound_status = _SOUND_STATUS_INIT; - - sc->info_video = malloc( sizeof(_MMCamcorderVideoInfo)); - if(sc->info_video == NULL) { - _mmcam_dbg_err("Failed to alloc info structure"); - free(sc->info_image); - free(sc); - return NULL; + SAFE_G_FREE(sc->info_video); + if (sc->element) { + free(sc->element); + sc->element = NULL; } - memset(sc->info_video, 0x00, sizeof(_MMCamcorderVideoInfo)); - break; - } - - /* alloc element array */ - sc->element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->element_num); - if(!sc->element) { - _mmcam_dbg_err("Failed to alloc element structure"); - if (type == MM_CAMCORDER_MODE_AUDIO) { - free(sc->info_audio); - } else { - free(sc->info_image); - free(sc->info_video); + if (sc->encode_element) { + free(sc->encode_element); + sc->encode_element = NULL; } free(sc); - return NULL; - } - - for (i = 0; i< sc->element_num; i++) { - sc->element[i].id = _MMCAMCORDER_NONE; - sc->element[i].gst = NULL; + sc = NULL; } - memset(sc->format_name, '\0', sizeof(sc->format_name)); - sc->cam_stability_count = 0; - sc->drop_vframe = 0; - sc->pass_first_vframe = 0; - sc->is_modified_rate = FALSE; - - return sc; + return NULL; } @@ -2395,10 +2653,17 @@ void _mmcamcorder_dealloc_subcontext(_MMCamcorderSubContext *sc) if (sc) { if (sc->element) { + _mmcam_dbg_log("release element"); free(sc->element); sc->element = NULL; } + if (sc->encode_element) { + _mmcam_dbg_log("release encode_element"); + free(sc->encode_element); + sc->encode_element = NULL; + } + if (sc->info_image) { _mmcam_dbg_log("release info_image"); free(sc->info_image); @@ -2407,12 +2672,15 @@ void _mmcamcorder_dealloc_subcontext(_MMCamcorderSubContext *sc) if (sc->info_video) { _mmcam_dbg_log("release info_video"); + 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"); + SAFE_G_FREE(sc->info_audio->filename); free(sc->info_audio); sc->info_audio = NULL; } @@ -2429,7 +2697,7 @@ int _mmcamcorder_set_functions(MMHandleType handle, int type) { mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - _mmcam_dbg_log(""); + /*_mmcam_dbg_log("");*/ switch (type) { case MM_CAMCORDER_MODE_AUDIO: @@ -2448,7 +2716,6 @@ int _mmcamcorder_set_functions(MMHandleType handle, int type) gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpointer data) { mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data); - _MMCamcorderMsgItem msg; _MMCamcorderSubContext *sc = NULL; mmf_return_val_if_fail(hcamcorder, FALSE); @@ -2485,17 +2752,24 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi } case GST_MESSAGE_ERROR: { - GError *err; - gchar *debug; - gst_message_parse_error(message, &err, &debug); + GError *err = NULL; + gchar *debug = NULL; - _mmcam_dbg_err ("GSTERR: %s", err->message); - _mmcam_dbg_err ("Error Debug: %s", debug); + gst_message_parse_error(message, &err, &debug); __mmcamcorder_handle_gst_error((MMHandleType)hcamcorder, message, err); - g_error_free (err); - g_free (debug); + if (err) { + _mmcam_dbg_err("GSTERR: %s", err->message); + g_error_free(err); + err = NULL; + } + + if (debug) { + _mmcam_dbg_err("Error Debug: %s", debug); + g_free(debug); + debug = NULL; + } break; } case GST_MESSAGE_WARNING: @@ -2523,7 +2797,7 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi break; case GST_MESSAGE_STATE_CHANGED: { - GValue *vnewstate; + const GValue *vnewstate; GstState newstate; GstElement *pipeline = NULL; @@ -2532,7 +2806,7 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi if (sc->element[_MMCAMCORDER_MAIN_PIPE].gst) { pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst; if (message->src == (GstObject*)pipeline) { - vnewstate = (GValue*)gst_structure_get_value(gst_message_get_structure(message), "new-state"); + 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)); } @@ -2554,47 +2828,181 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi break; case GST_MESSAGE_NEW_CLOCK: { - GstClock *clock; - gst_message_parse_new_clock(message, &clock); - _mmcam_dbg_log("GST_MESSAGE_NEW_CLOCK : %s", (clock ? GST_OBJECT_NAME (clock) : "NULL")); + GstClock *pipe_clock = NULL; + gst_message_parse_new_clock(message, &pipe_clock); + /*_mmcam_dbg_log("GST_MESSAGE_NEW_CLOCK : %s", (clock ? GST_OBJECT_NAME (clock) : "NULL"));*/ break; } case GST_MESSAGE_STRUCTURE_CHANGE: _mmcam_dbg_log("GST_MESSAGE_STRUCTURE_CHANGE"); break; case GST_MESSAGE_STREAM_STATUS: - _mmcam_dbg_log("GST_MESSAGE_STREAM_STATUS"); + /*_mmcam_dbg_log("GST_MESSAGE_STREAM_STATUS");*/ break; case GST_MESSAGE_APPLICATION: _mmcam_dbg_log("GST_MESSAGE_APPLICATION"); break; case GST_MESSAGE_ELEMENT: - _mmcam_dbg_log("GST_MESSAGE_ELEMENT"); + /*_mmcam_dbg_log("GST_MESSAGE_ELEMENT");*/ + break; + case GST_MESSAGE_SEGMENT_START: + _mmcam_dbg_log("GST_MESSAGE_SEGMENT_START"); + break; + case GST_MESSAGE_SEGMENT_DONE: + _mmcam_dbg_log("GST_MESSAGE_SEGMENT_DONE"); + break; + case GST_MESSAGE_DURATION_CHANGED: + _mmcam_dbg_log("GST_MESSAGE_DURATION_CHANGED"); + break; + case GST_MESSAGE_LATENCY: + _mmcam_dbg_log("GST_MESSAGE_LATENCY"); + break; + case GST_MESSAGE_ASYNC_START: + _mmcam_dbg_log("GST_MESSAGE_ASYNC_START"); + break; + case GST_MESSAGE_ASYNC_DONE: + /*_mmcam_dbg_log("GST_MESSAGE_ASYNC_DONE");*/ + break; + case GST_MESSAGE_ANY: + _mmcam_dbg_log("GST_MESSAGE_ANY"); + break; + case GST_MESSAGE_QOS: +// _mmcam_dbg_log("GST_MESSAGE_QOS"); + break; + default: + _mmcam_dbg_log("not handled message type=(%d)", GST_MESSAGE_TYPE(message)); + break; + } + + return TRUE; +} + + +GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data) +{ + GstElement *element = NULL; + GError *err = NULL; + gchar *debug_info = NULL; + + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data); + _MMCamcorderSubContext *sc = NULL; + + mmf_return_val_if_fail(hcamcorder, GST_BUS_PASS); + mmf_return_val_if_fail(message, GST_BUS_PASS); + + sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder); + mmf_return_val_if_fail(sc, GST_BUS_PASS); + + if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) { + /* parse error message */ + gst_message_parse_error(message, &err, &debug_info); + + if (debug_info) { + _mmcam_dbg_err("GST ERROR : %s", debug_info); + g_free(debug_info); + debug_info = NULL; + } + + if (!err) { + _mmcam_dbg_warn("failed to parse error message"); + return GST_BUS_PASS; + } + + /* set videosrc element to compare */ + element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + + /* check domain[RESOURCE] and element[VIDEOSRC] */ + if (err->domain == GST_RESOURCE_ERROR && + GST_ELEMENT_CAST(message->src) == element) { + switch (err->code) { + case GST_RESOURCE_ERROR_BUSY: + _mmcam_dbg_err("Camera device [busy]"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_BUSY; + break; + case GST_RESOURCE_ERROR_OPEN_WRITE: + _mmcam_dbg_err("Camera device [open failed]"); + hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION; + //sc->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN; // SECURITY PART REQUEST PRIVILEGE + break; + case GST_RESOURCE_ERROR_OPEN_READ_WRITE: + _mmcam_dbg_err("Camera device [open failed]"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN; + break; + case GST_RESOURCE_ERROR_OPEN_READ: + _mmcam_dbg_err("Camera device [register trouble]"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE; + break; + case GST_RESOURCE_ERROR_NOT_FOUND: + _mmcam_dbg_err("Camera device [device not found]"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND; + break; + case GST_RESOURCE_ERROR_TOO_LAZY: + _mmcam_dbg_err("Camera device [timeout]"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_TIMEOUT; + break; + case GST_RESOURCE_ERROR_SETTINGS: + _mmcam_dbg_err("Camera device [not supported]"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_NOT_SUPPORTED; + break; + case GST_RESOURCE_ERROR_FAILED: + _mmcam_dbg_err("Camera device [working failed]."); + hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_IO; + break; + default: + _mmcam_dbg_err("Camera device [General(%d)]", err->code); + hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE; + break; + } + + hcamcorder->error_occurs = TRUE; + } - if (gst_structure_has_name(gst_message_get_structure(message), "avsysvideosrc-AF") || - gst_structure_has_name(gst_message_get_structure(message), "camerasrc-AF")) { + g_error_free(err); + + /* store error code and drop this message if cmd is running */ + if (hcamcorder->error_code != MM_ERROR_NONE) { + _MMCamcorderMsgItem msg; + + /* post error to application */ + hcamcorder->error_occurs = TRUE; + msg.id = MM_MESSAGE_CAMCORDER_ERROR; + msg.param.code = hcamcorder->error_code; + _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg); + + goto DROP_MESSAGE; + } + } else if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ELEMENT) { + _MMCamcorderMsgItem msg; + + if (gst_structure_has_name(gst_message_get_structure(message), "avsysvideosrc-AF") || + gst_structure_has_name(gst_message_get_structure(message), "camerasrc-AF")) { int focus_state = 0; - gst_structure_get_int(gst_message_get_structure(message), "focus-state", &focus_state); + gst_structure_get_int(gst_message_get_structure(message), "focus-state", &focus_state); _mmcam_dbg_log("Focus State:%d", focus_state); msg.id = MM_MESSAGE_CAMCORDER_FOCUS_CHANGED; msg.param.code = focus_state; - _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg); - } else if (gst_structure_has_name(gst_message_get_structure(message), "camerasrc-HDR")) { + _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg); + + goto DROP_MESSAGE; + } else if (gst_structure_has_name(gst_message_get_structure(message), "camerasrc-HDR")) { int progress = 0; int status = 0; - gst_structure_get_int(gst_message_get_structure(message), "progress", &progress); - gst_structure_get_int(gst_message_get_structure(message), "status", &status); - _mmcam_dbg_log("HDR progress %d percent, status %d", progress, status); + if (gst_structure_get_int(gst_message_get_structure(message), "progress", &progress)) { + gst_structure_get_int(gst_message_get_structure(message), "status", &status); + _mmcam_dbg_log("HDR progress %d percent, status %d", progress, status); + + msg.id = MM_MESSAGE_CAMCORDER_HDR_PROGRESS; + msg.param.code = progress; + _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg); + } - msg.id = MM_MESSAGE_CAMCORDER_HDR_PROGRESS; - msg.param.code = progress; - _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg); - } else if (gst_structure_has_name(gst_message_get_structure(message), "camerasrc-FD")) { + goto DROP_MESSAGE; + } else if (gst_structure_has_name(gst_message_get_structure(message), "camerasrc-FD")) { int i = 0; - const GValue *g_value = gst_structure_get_value(gst_message_get_structure(message), "face-info");; + const GValue *g_value = gst_structure_get_value(gst_message_get_structure(message), "face-info");; GstCameraControlFaceDetectInfo *fd_info = NULL; MMCamFaceDetectInfo *cam_fd_info = NULL; @@ -2604,24 +3012,21 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi if (fd_info == NULL) { _mmcam_dbg_warn("fd_info is NULL"); - return TRUE; + 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; - - return TRUE; + SAFE_FREE(fd_info); + goto DROP_MESSAGE; } /* set total face count */ 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++) { @@ -2645,8 +3050,7 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi _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; @@ -2659,45 +3063,39 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi msg.param.size = sizeof(MMCamFaceDetectInfo); msg.param.code = 0; - _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg); + _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg); } /* free fd_info allocated by plugin */ free(fd_info); fd_info = NULL; + + goto DROP_MESSAGE; + } else if (gst_structure_has_name(gst_message_get_structure(message), "camerasrc-Capture")) { + int capture_done = FALSE; + + if (gst_structure_get_int(gst_message_get_structure(message), "capture-done", &capture_done)) { + sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder); + if (sc && sc->info_image) { + /* play capture sound */ + _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE01, FALSE); + } + } + + goto DROP_MESSAGE; } - break; - case GST_MESSAGE_SEGMENT_START: - _mmcam_dbg_log("GST_MESSAGE_SEGMENT_START"); - break; - case GST_MESSAGE_SEGMENT_DONE: - _mmcam_dbg_log("GST_MESSAGE_SEGMENT_DONE"); - break; - case GST_MESSAGE_DURATION: - _mmcam_dbg_log("GST_MESSAGE_DURATION"); - break; - case GST_MESSAGE_LATENCY: - _mmcam_dbg_log("GST_MESSAGE_LATENCY"); - break; - case GST_MESSAGE_ASYNC_START: - _mmcam_dbg_log("GST_MESSAGE_ASYNC_START"); - break; - case GST_MESSAGE_ASYNC_DONE: - _mmcam_dbg_log("GST_MESSAGE_ASYNC_DONE"); - break; - case GST_MESSAGE_ANY: - _mmcam_dbg_log("GST_MESSAGE_ANY"); - break; - default: - _mmcam_dbg_log("not handled message type=(%d)", GST_MESSAGE_TYPE(message)); - break; } - return TRUE; + return GST_BUS_PASS; +DROP_MESSAGE: + gst_message_unref(message); + message = NULL; + + return GST_BUS_DROP; } -GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data) +GstBusSyncReply _mmcamcorder_audio_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data) { GstElement *element = NULL; GError *err = NULL; @@ -2716,239 +3114,235 @@ GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage /* parse error message */ gst_message_parse_error(message, &err, &debug_info); - if (!err) { - _mmcam_dbg_warn("failed to parse error message"); - return GST_BUS_PASS; - } - if (debug_info) { _mmcam_dbg_err("GST ERROR : %s", debug_info); g_free(debug_info); debug_info = NULL; } + if (!err) { + _mmcam_dbg_warn("failed to parse error message"); + return GST_BUS_PASS; + } + /* set videosrc element to compare */ - element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst); /* check domain[RESOURCE] and element[VIDEOSRC] */ if (err->domain == GST_RESOURCE_ERROR && GST_ELEMENT_CAST(message->src) == element) { + _MMCamcorderMsgItem msg; + switch (err->code) { - case GST_RESOURCE_ERROR_BUSY: - _mmcam_dbg_err("Camera device [busy]"); - sc->error_code = MM_ERROR_CAMCORDER_DEVICE_BUSY; - break; case GST_RESOURCE_ERROR_OPEN_READ_WRITE: case GST_RESOURCE_ERROR_OPEN_WRITE: - _mmcam_dbg_err("Camera device [open failed]"); - sc->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN; - break; - case GST_RESOURCE_ERROR_OPEN_READ: - _mmcam_dbg_err("Camera device [register trouble]"); - sc->error_code = MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE; - break; - case GST_RESOURCE_ERROR_NOT_FOUND: - _mmcam_dbg_err("Camera device [device not found]"); - sc->error_code = MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND; - break; - case GST_RESOURCE_ERROR_TOO_LAZY: - _mmcam_dbg_err("Camera device [timeout]"); - sc->error_code = MM_ERROR_CAMCORDER_DEVICE_TIMEOUT; - break; - case GST_RESOURCE_ERROR_SETTINGS: - _mmcam_dbg_err("Camera device [not supported]"); - sc->error_code = MM_ERROR_CAMCORDER_NOT_SUPPORTED; - break; - case GST_RESOURCE_ERROR_FAILED: - _mmcam_dbg_err("Camera device [working failed]."); - sc->error_code = MM_ERROR_CAMCORDER_DEVICE_IO; - break; - default: - _mmcam_dbg_err("Camera device [General(%d)]", err->code); - sc->error_code = MM_ERROR_CAMCORDER_DEVICE; - break; - } + _mmcam_dbg_err("audio device [open failed]"); - sc->error_occurs = TRUE; - } + /* post error to application */ + hcamcorder->error_occurs = TRUE; + hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION; - g_error_free(err); + 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); + gst_message_unref(message); + message = NULL; - /* store error code and drop this message if cmd is running */ - if (sc->error_code != MM_ERROR_NONE) { - if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) { - _mmcam_dbg_err("cmd is running and will be returned with this error %x", - sc->error_code); return GST_BUS_DROP; + default: + break; } - - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); } + + g_error_free(err); } return GST_BUS_PASS; } -static int __mmcamcorder_asm_get_event_type(int sessionType) +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) { - switch (sessionType) { - case MM_SESSION_TYPE_SHARE: - return ASM_EVENT_SHARE_MMCAMCORDER; - case MM_SESSION_TYPE_EXCLUSIVE: - return ASM_EVENT_EXCLUSIVE_MMCAMCORDER; - case MM_SESSION_TYPE_NOTIFY: - return ASM_EVENT_NOTIFY; - case MM_SESSION_TYPE_CALL: - return ASM_EVENT_CALL; - case MM_SESSION_TYPE_VIDEOCALL: - return ASM_EVENT_VIDEOCALL; - case MM_SESSION_TYPE_ALARM: - return ASM_EVENT_ALARM; - default: - return ASM_EVENT_SHARE_MMCAMCORDER; - } -} - -ASM_cb_result_t _mmcamcorder_asm_callback_sh(int handle, ASM_event_sources_t event_src, - ASM_sound_commands_t command, - unsigned int sound_status, void* cb_data) -{ - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(cb_data); + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data); int current_state = MM_CAMCORDER_STATE_NONE; - ASM_cb_result_t cb_res = ASM_CB_RES_NONE; - mmf_return_val_if_fail((MMHandleType)hcamcorder, ASM_CB_RES_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, %d)", hcamcorder, command, current_state); + _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; - /* set ASM event code for sending it to application */ - hcamcorder->asm_event_code = event_src; - _mmcam_dbg_log("ASM SHARE callback : event code 0x%x, command 0x%x", event_src, command); + /* 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; + } - switch (command) { - case ASM_COMMAND_STOP: - case ASM_COMMAND_PAUSE: - _mmcam_dbg_log("Got msg from asm to Stop or Pause(%d, %d)", command, current_state); + _mmcam_dbg_log("sound focus watch callback : focus state %d, reason %s", + focus_state, reason_for_change ? reason_for_change : "N/A"); - __mmcamcorder_force_stop(hcamcorder); - cb_res = ASM_CB_RES_STOP; + if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) { + _mmcam_dbg_warn("session flag is UNINTERRUPTIBLE. do nothing."); + return; + } - _mmcam_dbg_log("Finish opeartion. Camera is released.(%d)", cb_res); - break; - case ASM_COMMAND_PLAY: - _mmcam_dbg_log("Got msg from asm to Play(%d, %d)", command, current_state); + _MMCAMCORDER_LOCK_ASM(hcamcorder); - if (current_state >= MM_CAMCORDER_STATE_PREPARE) { - _mmcam_dbg_log("Already start previewing"); - } else { - __mmcamcorder_force_resume(hcamcorder); - } + /* set value to inform a status is changed by asm */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_ASM; - cb_res = ASM_CB_RES_PLAYING; + /* 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; + } - _mmcam_dbg_log("Finish opeartion. Preview is started.(%d)", cb_res); - break; - case ASM_COMMAND_RESUME: - { + if (focus_state == FOCUS_IS_RELEASED) { _MMCamcorderMsgItem msg; - _mmcam_dbg_log("Got msg from asm to Resume(%d, %d)", command, current_state); + _mmcam_dbg_log("other process's FOCUS is acquired"); msg.id = MM_MESSAGE_READY_TO_RESUME; - _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg); - cb_res = ASM_CB_RES_PLAYING; + _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg); - _mmcam_dbg_log("Finish opeartion.(%d)", cb_res); - break; - } - default: /* should not be reached here */ - cb_res = ASM_CB_RES_PLAYING; - _mmcam_dbg_err("Command err."); - break; + _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; - return cb_res; + _MMCAMCORDER_UNLOCK_ASM(hcamcorder); + + return; } -ASM_cb_result_t _mmcamcorder_asm_callback_ex(int handle, ASM_event_sources_t event_src, - ASM_sound_commands_t command, - unsigned int sound_status, void* cb_data) +void _mmcamcorder_dpm_camera_policy_changed_cb(const char *name, const char *value, void *user_data) { - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(cb_data); + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data); int current_state = MM_CAMCORDER_STATE_NONE; - ASM_cb_result_t cb_res = ASM_CB_RES_NONE; - mmf_return_val_if_fail((MMHandleType)hcamcorder, ASM_CB_RES_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_log("ASM EXCLUSIVE callback : event code 0x%x, command 0x%x, current state %d", - event_src, command, current_state); - - /* set value to inform a status is changed by asm */ - hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_ASM; + _mmcam_dbg_warn("camera policy [%s], current state [%d]", value, current_state); - /* set ASM event code for sending it to application */ - hcamcorder->asm_event_code = event_src; + if (!strcmp(value, "disallowed")) { + _MMCAMCORDER_LOCK_ASM(hcamcorder); - switch (command) { - case ASM_COMMAND_STOP: - case ASM_COMMAND_PAUSE: - _mmcam_dbg_log("Got msg from asm to Stop or Pause(%d, %d)", command, current_state); + /* set value to inform a status is changed by DPM */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_DPM; __mmcamcorder_force_stop(hcamcorder); - cb_res = ASM_CB_RES_STOP; - - _mmcam_dbg_log("Finish opeartion. Camera is released.(%d)", cb_res); - break; - case ASM_COMMAND_PLAY: - _mmcam_dbg_log("Got msg from asm to Play(%d, %d)", command, current_state); - - if (current_state >= MM_CAMCORDER_STATE_PREPARE) { - _mmcam_dbg_log("Already start previewing"); - } else { - __mmcamcorder_force_resume(hcamcorder); - } - - cb_res = ASM_CB_RES_PLAYING; - - _mmcam_dbg_log("Finish opeartion. Preview is started.(%d)", cb_res); - break; - case ASM_COMMAND_RESUME: - { - _MMCamcorderMsgItem msg; - _mmcam_dbg_log("Got msg from asm to Resume(%d, %d)", command, current_state); - - msg.id = MM_MESSAGE_READY_TO_RESUME; - _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg); - cb_res = ASM_CB_RES_PLAYING; + /* restore value */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL; - _mmcam_dbg_log("Finish opeartion.(%d)", cb_res); - break; - } - default: /* should not be reached here */ - cb_res = ASM_CB_RES_PLAYING; - _mmcam_dbg_err("Command err."); - break; + _MMCAMCORDER_UNLOCK_ASM(hcamcorder); } - /* restore value */ - hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL; + _mmcam_dbg_warn("done"); - return cb_res; + return; } @@ -2968,27 +3362,21 @@ int _mmcamcorder_create_pipeline(MMHandleType handle, int type) switch (type) { case MM_CAMCORDER_MODE_AUDIO: - __ta__(" _mmcamcorder_create_audio_pipeline", ret = _mmcamcorder_create_audio_pipeline(handle); - ); if (ret != MM_ERROR_NONE) { return ret; } break; case MM_CAMCORDER_MODE_VIDEO_CAPTURE: default: - __ta__(" _mmcamcorder_create_preview_pipeline", ret = _mmcamcorder_create_preview_pipeline(handle); - ); if (ret != MM_ERROR_NONE) { return ret; } /* connect capture signal */ if (!sc->bencbin_capture) { - __ta__(" _mmcamcorder_connect_capture_signal", ret = _mmcamcorder_connect_capture_signal(handle); - ); if (ret != MM_ERROR_NONE) { return ret; } @@ -2998,22 +3386,19 @@ int _mmcamcorder_create_pipeline(MMHandleType handle, int type) pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst; if (type != MM_CAMCORDER_MODE_AUDIO) { - if (hcamcorder->sync_state_change) { - ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY); - } else { - ret = _mmcamcorder_gst_set_state_async(handle, pipeline, GST_STATE_READY); - if (ret == GST_STATE_CHANGE_FAILURE) { - return MM_ERROR_CAMCORDER_GST_STATECHANGE; - } - } + 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)) { _mmcam_dbg_err("Getting device information error!!"); } #endif - _mmcam_dbg_log("ret[%x]", ret); + _mmcam_dbg_log("ret[%x]", ret); if (ret != MM_ERROR_NONE) { _mmcam_dbg_err("error : destroy pipeline"); _mmcamcorder_destroy_pipeline(handle, hcamcorder->type); @@ -3026,8 +3411,10 @@ int _mmcamcorder_create_pipeline(MMHandleType handle, int type) void _mmcamcorder_destroy_pipeline(MMHandleType handle, int type) { mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - _MMCamcorderSubContext *sc = NULL; + _MMCamcorderSubContext *sc = NULL; gint i = 0; + int element_num = 0; + _MMCamcorderGstElement *element = NULL; GstBus *bus = NULL; mmf_return_if_fail(hcamcorder); @@ -3037,14 +3424,18 @@ void _mmcamcorder_destroy_pipeline(MMHandleType handle, int type) _mmcam_dbg_log(""); - bus = gst_pipeline_get_bus(GST_PIPELINE(sc->element[_MMCAMCORDER_MAIN_PIPE].gst)); - /* Inside each pipeline destroy function, Set GST_STATE_NULL to Main pipeline */ switch (type) { case MM_CAMCORDER_MODE_VIDEO_CAPTURE: + element = sc->element; + element_num = sc->element_num; + bus = gst_pipeline_get_bus(GST_PIPELINE(sc->element[_MMCAMCORDER_MAIN_PIPE].gst)); _mmcamcorder_destroy_video_capture_pipeline(handle); break; case MM_CAMCORDER_MODE_AUDIO: + element = sc->encode_element; + element_num = sc->encode_element_num; + bus = gst_pipeline_get_bus(GST_PIPELINE(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst)); _mmcamcorder_destroy_audio_pipeline(handle); break; default: @@ -3055,10 +3446,13 @@ void _mmcamcorder_destroy_pipeline(MMHandleType handle, int type) _mmcam_dbg_log("Pipeline clear!!"); /* Remove pipeline message callback */ - g_source_remove(hcamcorder->pipeline_cb_event_id); + if (hcamcorder->pipeline_cb_event_id > 0) { + g_source_remove(hcamcorder->pipeline_cb_event_id); + hcamcorder->pipeline_cb_event_id = 0; + } /* Remove remained message in bus */ - if (bus != NULL) { + if (bus) { GstMessage *gst_msg = NULL; while ((gst_msg = gst_bus_pop(bus)) != NULL) { _mmcamcorder_pipeline_cb_message(bus, gst_msg, (gpointer)hcamcorder); @@ -3070,23 +3464,25 @@ void _mmcamcorder_destroy_pipeline(MMHandleType handle, int type) } /* checking unreleased element */ - for (i = 0 ; i < _MMCamcorder_PIPELINE_ELEMENT_NUM ; i++ ) { - if (sc->element[i].gst) { - if (GST_IS_ELEMENT(sc->element[i].gst)) { + for (i = 0 ; i < element_num ; i++ ) { + if (element[i].gst) { + if (GST_IS_ELEMENT(element[i].gst)) { _mmcam_dbg_warn("Still alive element - ID[%d], name [%s], ref count[%d], status[%s]", - sc->element[i].id, - GST_OBJECT_NAME(sc->element[i].gst), - GST_OBJECT_REFCOUNT_VALUE(sc->element[i].gst), - gst_element_state_get_name (GST_STATE (sc->element[i].gst))); - g_object_weak_unref(G_OBJECT(sc->element[i].gst), (GWeakNotify)_mmcamcorder_element_release_noti, sc); + element[i].id, + GST_OBJECT_NAME(element[i].gst), + GST_OBJECT_REFCOUNT(element[i].gst), + gst_element_state_get_name(GST_STATE(element[i].gst))); + g_object_weak_unref(G_OBJECT(element[i].gst), (GWeakNotify)_mmcamcorder_element_release_noti, sc); } else { - _mmcam_dbg_warn("The element[%d] is still aliving, check it", sc->element[i].id); + _mmcam_dbg_warn("The element[%d] is still aliving, check it", element[i].id); } - sc->element[i].id = _MMCAMCORDER_NONE; - sc->element[i].gst = NULL; + element[i].id = _MMCAMCORDER_NONE; + element[i].gst = NULL; } } + + return; } @@ -3124,19 +3520,29 @@ static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data) #endif /* _MMCAMCORDER_USE_SET_ATTR_CB */ -int _mmcamcorder_gst_set_state (MMHandleType handle, GstElement *pipeline, GstState target_state) +int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstState target_state) { unsigned int k = 0; + _MMCamcorderSubContext *sc = NULL; GstState pipeline_state = GST_STATE_VOID_PENDING; GstStateChangeReturn setChangeReturn = GST_STATE_CHANGE_FAILURE; GstStateChangeReturn getChangeReturn = GST_STATE_CHANGE_FAILURE; GstClockTime get_timeout = __MMCAMCORDER_SET_GST_STATE_TIMEOUT * GST_SECOND; + GMutex *state_lock = NULL; mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED); + sc = MMF_CAMCORDER_SUBCONTEXT(handle); + mmf_return_val_if_fail(sc && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED); - _mmcam_dbg_log("Set state to %d", target_state); + if (sc->element[_MMCAMCORDER_MAIN_PIPE].gst == pipeline) { + _mmcam_dbg_log("Set state to %d - PREVIEW PIPELINE", target_state); + state_lock = &_MMCAMCORDER_GET_GST_STATE_LOCK(handle); + } else { + _mmcam_dbg_log("Set state to %d - ENDODE PIPELINE", target_state); + state_lock = &_MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle); + } - _MMCAMCORDER_LOCK_GST_STATE(handle); + g_mutex_lock(state_lock); for (k = 0; k < _MMCAMCORDER_STATE_SET_COUNT; k++) { setChangeReturn = gst_element_set_state(pipeline, target_state); @@ -3147,10 +3553,12 @@ int _mmcamcorder_gst_set_state (MMHandleType handle, GstElement *pipeline, GstSt switch (getChangeReturn) { case GST_STATE_CHANGE_NO_PREROLL: _mmcam_dbg_log("status=GST_STATE_CHANGE_NO_PREROLL."); + /* fall through */ case GST_STATE_CHANGE_SUCCESS: /* if we reached the final target state, exit */ if (pipeline_state == target_state) { - _MMCAMCORDER_UNLOCK_GST_STATE(handle); + _mmcam_dbg_log("Set state to %d - DONE", target_state); + g_mutex_unlock(state_lock); return MM_ERROR_NONE; } break; @@ -3158,23 +3566,26 @@ int _mmcamcorder_gst_set_state (MMHandleType handle, GstElement *pipeline, GstSt _mmcam_dbg_log("status=GST_STATE_CHANGE_ASYNC."); break; default: - _MMCAMCORDER_UNLOCK_GST_STATE(handle); + g_mutex_unlock(state_lock); _mmcam_dbg_log("status=GST_STATE_CHANGE_FAILURE."); return MM_ERROR_CAMCORDER_GST_STATECHANGE; } - _MMCAMCORDER_UNLOCK_GST_STATE(handle); + g_mutex_unlock(state_lock); + _mmcam_dbg_err("timeout of gst_element_get_state()!!"); + return MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT; } + usleep(_MMCAMCORDER_STATE_CHECK_INTERVAL); } - _MMCAMCORDER_UNLOCK_GST_STATE(handle); + g_mutex_unlock(state_lock); _mmcam_dbg_err("Failure. gst_element_set_state timeout!!"); - return MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT; + return MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT; } @@ -3188,7 +3599,7 @@ int _mmcamcorder_video_current_framerate(MMHandleType handle) sc = MMF_CAMCORDER_SUBCONTEXT(handle); mmf_return_val_if_fail(sc, -1); - + return sc->kpi.current_fps; } @@ -3222,27 +3633,37 @@ void _mmcamcorder_video_current_framerate_init(MMHandleType handle) return; } -/* Async state change */ -void _mmcamcorder_delete_command_info(__MMCamcorderCmdInfo *cmdinfo) -{ - if (cmdinfo) { - g_free(cmdinfo); - } -} -static void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) +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_log( "Force STOP MMFW Camcorder" ); + _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; @@ -3255,7 +3676,7 @@ static void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) mmf_return_if_fail(sc); mmf_return_if_fail((info = sc->info_image)); - _mmcam_dbg_log("Stop capturing."); + _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, @@ -3279,7 +3700,7 @@ static void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) case MM_CAMCORDER_STATE_RECORDING: case MM_CAMCORDER_STATE_PAUSED: { - _mmcam_dbg_log("Stop recording."); + _mmcam_dbg_warn("Stop recording."); while ((itr_cnt--) && ((result = _mmcamcorder_commit((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) { _mmcam_dbg_warn("Can't commit.(%x)", result); @@ -3288,7 +3709,7 @@ static void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) } case MM_CAMCORDER_STATE_PREPARE: { - _mmcam_dbg_log("Stop preview."); + _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); @@ -3297,7 +3718,7 @@ static void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) } case MM_CAMCORDER_STATE_READY: { - _mmcam_dbg_log("unrealize"); + _mmcam_dbg_warn("unrealize"); if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE) { _mmcam_dbg_warn("Can't unrealize.(%x)", result); @@ -3306,265 +3727,26 @@ static void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder) } case MM_CAMCORDER_STATE_NULL: default: - _mmcam_dbg_log("Already stopped."); - break; - } - - current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); - } - - _mmcam_dbg_log( "Done." ); - - return; -} - - -static void __mmcamcorder_force_resume(mmf_camcorder_t *hcamcorder) -{ - int loop = 0; - int result = MM_ERROR_NONE; - int itr_cnt = 0; - int current_state = MM_CAMCORDER_STATE_NONE; - - mmf_return_if_fail(hcamcorder); - - _mmcam_dbg_log("Force RESUME MMFW Camcorder"); - - current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); - - for (loop = 0 ; current_state < MM_CAMCORDER_STATE_PREPARE && loop < __MMCAMCORDER_CMD_ITERATE_MAX * 3 ; loop++) { - itr_cnt = __MMCAMCORDER_CMD_ITERATE_MAX; - - switch (current_state) { - case MM_CAMCORDER_STATE_NULL: - _mmcam_dbg_log("Realize"); - while ((itr_cnt--) && ((result = _mmcamcorder_realize((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) { - _mmcam_dbg_warn("Can't realize.(%x)", result); - } - break; - case MM_CAMCORDER_STATE_READY: - _mmcam_dbg_log("Start previewing"); - - while ((itr_cnt--) && ((result = _mmcamcorder_start((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) { - _mmcam_dbg_warn("Can't start previewing.(%x)", result); - } - break; - default: - _mmcam_dbg_log("Abnormal state."); + _mmcam_dbg_warn("Already stopped."); break; } current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); } - _mmcam_dbg_log( "Done." ); + _mmcam_dbg_warn( "Done." ); return; } -int _mmcamcorder_create_command_loop(MMHandleType handle) -{ - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - _MMCamcorderCommand *cmd; - - mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED); - - _mmcam_dbg_log(""); - - cmd = (_MMCamcorderCommand *)&(hcamcorder->cmd); - cmd->cmd_queue = g_queue_new(); - mmf_return_val_if_fail(cmd->cmd_queue, MM_ERROR_CAMCORDER_INVALID_CONDITION); - - sem_init(&cmd->sema, 0, 0); - - if (pthread_create(&cmd->pCommandThread, NULL, _mmcamcorder_command_loop_thread, hcamcorder)) { - perror("Make Command Thread Fail"); - return MM_ERROR_COMMON_UNKNOWN; - } - - return MM_ERROR_NONE; -} - - -int _mmcamcorder_destroy_command_loop(MMHandleType handle) -{ - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - _MMCamcorderCommand *cmd; - - mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED); - _mmcam_dbg_log(""); - - cmd = (_MMCamcorderCommand *)&(hcamcorder->cmd); - mmf_return_val_if_fail(cmd->cmd_queue, MM_ERROR_CAMCORDER_INVALID_CONDITION); - - _mmcamcorder_append_simple_command(handle, _MMCAMCORDER_CMD_QUIT); - - sem_post(&cmd->sema); /* why is this needed? */ - - _mmcam_dbg_log("wait for pthread join"); - - pthread_join(cmd->pCommandThread, NULL); - - _mmcam_dbg_log("pthread join!!"); - - sem_destroy(&cmd->sema); - - while (!g_queue_is_empty(cmd->cmd_queue)) { - __MMCamcorderCmdInfo *info = NULL; - info = g_queue_pop_head(cmd->cmd_queue); - _mmcamcorder_delete_command_info(info); - } - g_queue_free(cmd->cmd_queue); - - _mmcam_dbg_log("Command loop clear."); - - return MM_ERROR_NONE; -} - - -int _mmcamcorder_append_command(MMHandleType handle, __MMCamcorderCmdInfo *info) -{ - int value = 0; - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - _MMCamcorderCommand *cmd; - - mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED); - - _mmcam_dbg_log(""); - - cmd = (_MMCamcorderCommand *)&(hcamcorder->cmd); - mmf_return_val_if_fail(cmd->cmd_queue, MM_ERROR_CAMCORDER_INVALID_CONDITION); - - g_queue_push_tail (cmd->cmd_queue, (gpointer)info); - - sem_getvalue(&cmd->sema, &value); - - if (value == 0) { - sem_post(&cmd->sema); - } else { - /* Don't need to post. */ - } - - return MM_ERROR_NONE; -} - - -int _mmcamcorder_append_simple_command(MMHandleType handle, _MMCamcorderCommandType type) -{ - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - __MMCamcorderCmdInfo *info = NULL; - - mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED); - - _mmcam_dbg_log("Command Type=%d", type); - - info = (__MMCamcorderCmdInfo*)malloc(sizeof(__MMCamcorderCmdInfo)); - - info->handle = handle; - info->type = type; - - _mmcamcorder_append_command(handle, info); - - return MM_ERROR_NONE; -} - - -void *_mmcamcorder_command_loop_thread(void *arg) -{ - gboolean bExit_loop = FALSE; - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(arg); - _MMCamcorderCommand *cmd = NULL; - __MMCamcorderCmdInfo *cmdinfo = NULL; - - mmf_return_val_if_fail(hcamcorder, NULL); - - cmd = (_MMCamcorderCommand *)&(hcamcorder->cmd); - mmf_return_val_if_fail(cmd->cmd_queue, NULL); - - _mmcam_dbg_log(""); - - while (!bExit_loop) { - sem_wait(&cmd->sema); - - /* send command */ - while (!g_queue_is_empty (cmd->cmd_queue)) { - int bRet = MM_ERROR_NONE; - - cmdinfo = g_queue_pop_head(cmd->cmd_queue); - if (cmdinfo->handle == (MMHandleType)NULL) { - _mmcam_dbg_log("Handle in cmdinfo is Null."); - bRet = MM_ERROR_CAMCORDER_NOT_INITIALIZED; - } else { - switch (cmdinfo->type) { - case _MMCAMCORDER_CMD_CREATE: - case _MMCAMCORDER_CMD_DESTROY: - case _MMCAMCORDER_CMD_CAPTURESTART: - case _MMCAMCORDER_CMD_CAPTURESTOP: - case _MMCAMCORDER_CMD_RECORD: - case _MMCAMCORDER_CMD_PAUSE: - case _MMCAMCORDER_CMD_COMMIT: - __ta__("_mmcamcorder_commit", - bRet = _mmcamcorder_commit(cmdinfo->handle); - ); - break; - case _MMCAMCORDER_CMD_CANCEL: - //Not used yet. - break; - case _MMCAMCORDER_CMD_REALIZE: - __ta__("_mmcamcorder_realize", - bRet = _mmcamcorder_realize(cmdinfo->handle); - ); - break; - case _MMCAMCORDER_CMD_UNREALIZE: - __ta__("_mmcamcorder_unrealize", - bRet = _mmcamcorder_unrealize(cmdinfo->handle); - ); - break; - case _MMCAMCORDER_CMD_START: - __ta__("_mmcamcorder_start", - bRet = _mmcamcorder_start(cmdinfo->handle); - ); - break; - case _MMCAMCORDER_CMD_STOP: - __ta__("_mmcamcorder_stop", - bRet = _mmcamcorder_stop(cmdinfo->handle); - ); - break; - case _MMCAMCORDER_CMD_QUIT: - _mmcam_dbg_log("Exit command loop!!"); - bExit_loop = TRUE; - break; - default: - _mmcam_dbg_log("Wrong command type!!!"); - break; - } - } - - if (bRet != MM_ERROR_NONE) { - _mmcam_dbg_log("Error on command process!(%x)", bRet); - /* Do something? */ - } - - _mmcamcorder_delete_command_info(cmdinfo); - - if (bExit_loop) { - break; - } - usleep(1); - } - } - - return NULL; -} - 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); return_val_if_fail(error, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); @@ -3617,10 +3799,12 @@ static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage * } #endif /* _MMCAMCORDER_SKIP_GST_FLOW_ERROR */ - /* post error to application */ - sc->error_occurs = TRUE; - msg.id = MM_MESSAGE_CAMCORDER_ERROR; - _mmcamcroder_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; } @@ -3640,7 +3824,7 @@ static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, G mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED); /* Specific plugin - video encoder plugin */ - element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_ENCSINK_VENC].gst); + element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst); if (GST_ELEMENT_CAST(message->src) == element) { if (code == GST_CORE_ERROR_NEGOTIATION) { @@ -3661,7 +3845,7 @@ static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, G case GST_CORE_ERROR_SEEK: case GST_CORE_ERROR_NOT_IMPLEMENTED: case GST_CORE_ERROR_FAILED: - case GST_CORE_ERROR_TOO_LAZY: + case GST_CORE_ERROR_TOO_LAZY: case GST_CORE_ERROR_PAD: case GST_CORE_ERROR_THREAD: case GST_CORE_ERROR_EVENT: @@ -3724,8 +3908,42 @@ 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->element[_MMCAMCORDER_ENCSINK_VENC].gst); + element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst); if (GST_ELEMENT_CAST(message->src) == element) { if (code == GST_RESOURCE_ERROR_FAILED) { _mmcam_dbg_err("Encoder [Resource error]"); @@ -3782,7 +4000,7 @@ static gint __mmcamcorder_gst_handle_stream_error(MMHandleType handle, int code, /* Specific plugin */ /* video encoder */ - element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_ENCSINK_VENC].gst); + element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst); if (GST_ELEMENT_CAST(message->src) == element) { switch (code) { case GST_STREAM_ERROR_WRONG_TYPE: @@ -3915,3 +4133,73 @@ 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; +} +#ifdef _MMCAMCORDER_RM_SUPPORT +rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src, + rm_device_request_s *info, void* cb_data) +{ + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(cb_data); + int current_state = MM_CAMCORDER_STATE_NONE; + rm_cb_result cb_res = RM_CB_RESULT_OK; + + mmf_return_val_if_fail((MMHandleType)hcamcorder, RM_CB_RESULT_OK); + + current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder); + if (current_state <= MM_CAMCORDER_STATE_NONE || + current_state >= MM_CAMCORDER_STATE_NUM) { + _mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state); + } + + _MMCAMCORDER_LOCK_ASM(hcamcorder); + + /* set value to inform a status is changed by RM */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_RM; + + /* set RM event code for sending it to application */ + hcamcorder->interrupt_code = event_src; + + _mmcam_dbg_log("RM conflict callback : event code 0x%x", event_src); + switch (event_src) { + case RM_CALLBACK_TYPE_RESOURCE_CONFLICT: + case RM_CALLBACK_TYPE_RESOURCE_CONFLICT_UD: + __mmcamcorder_force_stop(hcamcorder); + break; + default: + break; + } + + /* restore value */ + hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL; + + _MMCAMCORDER_UNLOCK_ASM(hcamcorder); + + return cb_res; +} +#endif /* _MMCAMCORDER_RM_SUPPORT */ \ No newline at end of file