| INCLUDE FILES |
========================================================================================*/
#include <stdio.h>
+#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <gst/gst.h>
#include <system_info.h>
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
-#include <murphy/common/glib-glue.h>
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
-
#ifdef _MMCAMCORDER_RM_SUPPORT
#include <aul.h>
#endif /* _MMCAMCORDER_RM_SUPPORT */
static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, GstMessage *message);
static gint __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMessage *message , GError *error);
static gboolean __mmcamcorder_handle_gst_warning(MMHandleType handle, GstMessage *message, GError *error);
+static int __mmcamcorder_simulate_asm_conflict_table(int session_type, int pid);
+
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
+static int __mmcamcorder_resource_release_cb(mm_resource_manager_h rm,
+ mm_resource_manager_res_h res, void *user_data);
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
#ifdef _MMCAMCORDER_RM_SUPPORT
rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src,
g_mutex_init(&(hcamcorder->mtsafe).vstream_cb_lock);
g_mutex_init(&(hcamcorder->mtsafe).astream_cb_lock);
g_mutex_init(&(hcamcorder->mtsafe).mstream_cb_lock);
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
- g_cond_init(&(hcamcorder->mtsafe).resource_cond);
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
g_mutex_init(&(hcamcorder->mtsafe).resource_lock);
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
g_mutex_init(&hcamcorder->restart_preview_lock);
_mmcam_dbg_log("DPM camera changed cb id %d", hcamcorder->dpm_camera_cb_id);
}
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
- /* set camcorder handle */
- hcamcorder->resource_manager.id = MM_CAMCORDER_RESOURCE_ID_MAIN;
- hcamcorder->resource_manager.hcamcorder = hcamcorder;
- hcamcorder->resource_manager_sub.id = MM_CAMCORDER_RESOURCE_ID_SUB;
- hcamcorder->resource_manager_sub.hcamcorder = hcamcorder;
-
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
/* initialize resource manager */
- ret = _mmcamcorder_resource_manager_init(&hcamcorder->resource_manager);
- if (ret != MM_ERROR_NONE) {
+ ret = mm_resource_manager_create(MM_RESOURCE_MANAGER_APP_CLASS_MEDIA,
+ __mmcamcorder_resource_release_cb, hcamcorder,
+ &hcamcorder->resource_manager);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
_mmcam_dbg_err("failed to initialize resource manager");
ret = MM_ERROR_CAMCORDER_INTERNAL;
goto _ERR_DEFAULT_VALUE_INIT;
}
-
- ret = _mmcamcorder_resource_manager_init(&hcamcorder->resource_manager_sub);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("failed to initialize resource manager sub");
- ret = MM_ERROR_CAMCORDER_INTERNAL;
- goto _ERR_DEFAULT_VALUE_INIT;
- }
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
} else {
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
/* 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);
- }
+
+ _mmcam_dbg_warn("model name [%s], ret 0x%x",
+ hcamcorder->model_name ? hcamcorder->model_name : "NULL", sys_info_ret);
/* get software version */
sys_info_ret = system_info_get_platform_string("http://tizen.org/system/build.string", &hcamcorder->software_version);
- if (hcamcorder->software_version) {
- _mmcam_dbg_log("software version [%s], sys_info_ret 0x%d", hcamcorder->software_version, sys_info_ret);
- } else {
- _mmcam_dbg_warn("failed get software version, sys_info_ret 0x%x", sys_info_ret);
- }
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
- if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
- ret = _mmcamcorder_resource_wait_for_connection(&hcamcorder->resource_manager);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("failed to connect resource manager");
- goto _ERR_DEFAULT_VALUE_INIT;
- }
-
- ret = _mmcamcorder_resource_wait_for_connection(&hcamcorder->resource_manager_sub);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("failed to connect resource manager");
- goto _ERR_DEFAULT_VALUE_INIT;
- }
- }
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+ _mmcam_dbg_warn("software version [%s], ret 0x%x",
+ hcamcorder->software_version ? hcamcorder->software_version : "NULL", sys_info_ret);
/* Set initial state */
_mmcamcorder_set_state((MMHandleType)hcamcorder, MM_CAMCORDER_STATE_NULL);
return MM_ERROR_NONE;
_ERR_DEFAULT_VALUE_INIT:
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
/* de-initialize resource manager */
- _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager_sub);
- _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager);
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+ if (hcamcorder->resource_manager != NULL)
+ mm_resource_manager_destroy(hcamcorder->resource_manager);
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
/* release DPM related handle */
if (hcamcorder->dpm_handle) {
g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock);
g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock);
g_mutex_clear(&(hcamcorder->mtsafe).mstream_cb_lock);
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
- g_cond_clear(&(hcamcorder->mtsafe).resource_cond);
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
g_mutex_clear(&(hcamcorder->mtsafe).resource_lock);
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
g_mutex_clear(&hcamcorder->snd_info.open_mutex);
g_cond_clear(&hcamcorder->snd_info.open_cond);
hcamcorder->sub_context = NULL;
}
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
/* de-initialize resource manager */
_MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
- ret = _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager);
- if (ret != MM_ERROR_NONE)
- _mmcam_dbg_err("failed to de-initialize resource manager 0x%x", ret);
-
- ret = _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager_sub);
- if (ret != MM_ERROR_NONE)
- _mmcam_dbg_err("failed to de-initialize resource manager sub 0x%x", ret);
+ if (hcamcorder->resource_manager != NULL) {
+ ret = mm_resource_manager_destroy(hcamcorder->resource_manager);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
+ _mmcam_dbg_err("failed to de-initialize resource manager 0x%x", ret);
+ }
_MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
/* Remove idle function which is not called yet */
if (hcamcorder->setting_event_id) {
g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock);
g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock);
g_mutex_clear(&(hcamcorder->mtsafe).mstream_cb_lock);
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
- g_cond_clear(&(hcamcorder->mtsafe).resource_cond);
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
g_mutex_clear(&(hcamcorder->mtsafe).resource_lock);
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
g_mutex_clear(&hcamcorder->snd_info.open_mutex);
g_cond_clear(&hcamcorder->snd_info.open_cond);
int app_pid = 0;
int resource_count = 0;
#endif /* _MMCAMCORDER_RM_SUPPORT */
- char *stream_type = NULL;
- char *ext_info = NULL;
- int option = 0;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
/* 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);
+ }
+
+ ret = __mmcamcorder_simulate_asm_conflict_table(hcamcorder->session_type, pid_for_sound_focus);
+ if (ret != MM_ERROR_NONE)
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+
/* acquire sound focus or set sound focus watch callback */
if (hcamcorder->session_flags & MM_SESSION_OPTION_PAUSE_OTHERS) {
/* acquire sound focus */
/* do nothing */
_mmcam_dbg_log("SESSION_UNINTERRUPTIBLE - do nothing for sound focus");
} else {
- /* check previous acquired focus */
- ret = mm_sound_get_stream_type_of_acquired_focus(FOCUS_FOR_BOTH, &stream_type, &option, &ext_info);
- if (ret == MM_ERROR_NONE && stream_type) {
- if (!strcmp(stream_type, "alarm") ||
- !strcmp(stream_type, "ringtone-voip") ||
- !strcmp(stream_type, "ringtone-call") ||
- !strcmp(stream_type, "voip") ||
- !strcmp(stream_type, "call-voice") ||
- !strcmp(stream_type, "call-video")) {
- _mmcam_dbg_err("Blocked by session policy, stream_type [%s]", stream_type);
- ret = MM_ERROR_POLICY_BLOCKED;
- }
- } else {
- _mmcam_dbg_warn("get stream type failed 0x%x, stream type %s, but ignore it",
- ret, stream_type ? stream_type : "NULL");
- ret = MM_ERROR_NONE;
- }
-
- if (stream_type) {
- free(stream_type);
- stream_type = NULL;
- }
-
- if (ext_info) {
- free(ext_info);
- ext_info = NULL;
- }
-
- if (ret != MM_ERROR_NONE)
- goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
-
/* unset remained watch cb */
if (hcamcorder->sound_focus_watch_id > 0) {
mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id);
}
/* set sound focus watch callback */
- mm_camcorder_get_attributes(handle, NULL,
- MMCAM_PID_FOR_SOUND_FOCUS, &pid_for_sound_focus,
- NULL);
-
- if (pid_for_sound_focus == 0) {
- pid_for_sound_focus = getpid();
- _mmcam_dbg_warn("pid for sound focus is not set, use my pid %d", pid_for_sound_focus);
- }
-
_mmcam_dbg_log("ETC - set sound focus watch callback - pid %d", pid_for_sound_focus);
ret_sound = mm_sound_set_focus_watch_callback_for_session(pid_for_sound_focus,
_mmcam_dbg_warn("NULL dpm_handle");
}
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
- /* check connection */
- ret = _mmcamcorder_resource_check_connection(&hcamcorder->resource_manager);
- if (ret != MM_ERROR_NONE)
- goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
-
- /* create resource set */
- ret = _mmcamcorder_resource_create_resource_set(&hcamcorder->resource_manager);
- if (ret != MM_ERROR_NONE) {
- goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
- }
-
- hcamcorder->resource_manager.acquire_count = 0;
-
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
+ _MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
/* prepare resource manager for camera */
- ret = _mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, MM_CAMCORDER_RESOURCE_TYPE_CAMERA);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("could not prepare for camera resource");
- ret = MM_ERROR_CAMCORDER_INTERNAL;
- goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ if (hcamcorder->camera_resource == NULL) {
+ ret = mm_resource_manager_mark_for_acquire(hcamcorder->resource_manager,
+ MM_RESOURCE_MANAGER_RES_TYPE_CAMERA,
+ MM_RESOURCE_MANAGER_RES_VOLUME_FULL,
+ &hcamcorder->camera_resource);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ _mmcam_dbg_err("could not prepare for camera resource");
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ }
+ } else {
+ _mmcam_dbg_log("camera already acquired");
}
/* prepare resource manager for "video_overlay only if display surface is X" */
if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
- ret = _mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, MM_CAMCORDER_RESOURCE_TYPE_VIDEO_OVERLAY);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("could not prepare for video overlay resource");
- ret = MM_ERROR_CAMCORDER_INTERNAL;
- goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ if (hcamcorder->video_overlay_resource == NULL) {
+ ret = mm_resource_manager_mark_for_acquire(hcamcorder->resource_manager,
+ MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_OVERLAY,
+ MM_RESOURCE_MANAGER_RES_VOLUME_FULL,
+ &hcamcorder->video_overlay_resource);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ _mmcam_dbg_err("could not prepare for overlay resource");
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ }
+ } else {
+ _mmcam_dbg_log("overlay already acquired");
}
}
/* acquire resources */
- _MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
-
- ret = _mmcamcorder_resource_manager_acquire(&hcamcorder->resource_manager);
- if (ret != MM_ERROR_NONE) {
+ ret = mm_resource_manager_commit(hcamcorder->resource_manager);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
_MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
_mmcam_dbg_err("could not acquire resources");
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
-
- if (hcamcorder->resource_manager.acquire_remain > 0) {
- gint64 end_time = 0;
-
- _mmcam_dbg_warn("wait for resource state change");
-
- /* wait for resource state change */
- end_time = g_get_monotonic_time() + (__MMCAMCORDER_RESOURCE_WAIT_TIME * G_TIME_SPAN_SECOND);
-
- if (_MMCAMCORDER_RESOURCE_WAIT_UNTIL(hcamcorder, end_time)) {
- _mmcam_dbg_warn("signal received");
- } else {
- _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
- _mmcam_dbg_err("timeout");
- ret = MM_ERROR_RESOURCE_INTERNAL;
- goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
- }
- } else {
- _mmcam_dbg_log("already all acquired");
- }
-
_MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
#ifdef _MMCAMCORDER_RM_SUPPORT
mm_camcorder_get_attributes(handle, NULL,
return MM_ERROR_NONE;
_ERR_CAMCORDER_CMD:
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
/* release hw resources */
+ _MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) {
- int ret_resource = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
- if (ret_resource == MM_ERROR_RESOURCE_INVALID_STATE) {
- _mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource");
- } else if (ret_resource != MM_ERROR_NONE) {
- _mmcam_dbg_err("failed to release resource, ret_resource(0x%x)", ret_resource);
+ if (hcamcorder->camera_resource != NULL) {
+ mm_resource_manager_mark_for_release(hcamcorder->resource_manager,
+ hcamcorder->camera_resource);
+ hcamcorder->camera_resource = NULL;
+ }
+ if (hcamcorder->video_overlay_resource != NULL) {
+ mm_resource_manager_mark_for_release(hcamcorder->resource_manager,
+ hcamcorder->video_overlay_resource);
+ hcamcorder->video_overlay_resource = NULL;
}
+ mm_resource_manager_commit(hcamcorder->resource_manager);
}
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+ _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
#ifdef _MMCAMCORDER_RM_SUPPORT
if (hcamcorder->rm_handle) {
if (hcamcorder->returned_devices.allocated_num > 0) {
hcamcorder->sub_context = NULL;
}
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
- _mmcam_dbg_warn("lock resource - cb calling %d", hcamcorder->resource_manager.is_release_cb_calling);
-
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
_MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
+ _mmcam_dbg_warn("lock resource - cb calling %d", hcamcorder->is_release_cb_calling);
if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE &&
hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_RM &&
- hcamcorder->resource_manager.is_release_cb_calling == FALSE) {
- gint64 end_time = 0;
+ hcamcorder->is_release_cb_calling == FALSE) {
/* release resource */
- ret = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
- if (ret == MM_ERROR_RESOURCE_INVALID_STATE) {
- _mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource");
- ret = MM_ERROR_NONE;
- } else if (ret != MM_ERROR_NONE) {
+ if (hcamcorder->camera_resource != NULL) {
+ ret = mm_resource_manager_mark_for_release(hcamcorder->resource_manager,
+ hcamcorder->camera_resource);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ _mmcam_dbg_err("could not mark camera resource for release");
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
+ _mmcam_dbg_log("unlock resource");
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ }
+ }
+
+ if (hcamcorder->video_overlay_resource != NULL) {
+ ret = mm_resource_manager_mark_for_release(hcamcorder->resource_manager,
+ hcamcorder->video_overlay_resource);
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ _mmcam_dbg_err("could not mark overlay resource for release");
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
+ _mmcam_dbg_log("unlock resource");
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ }
+ }
+
+ ret = mm_resource_manager_commit(hcamcorder->resource_manager);
+
+ if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
_mmcam_dbg_err("failed to release resource, ret(0x%x)", ret);
ret = MM_ERROR_CAMCORDER_INTERNAL;
_mmcam_dbg_log("unlock resource");
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
- }
-
- if (hcamcorder->resource_manager.acquire_remain < hcamcorder->resource_manager.acquire_count) {
- /* wait for resource release */
- _mmcam_dbg_log("resource is not released all. wait for signal...");
-
- end_time = g_get_monotonic_time() + (__MMCAMCORDER_RESOURCE_WAIT_TIME * G_TIME_SPAN_SECOND);
-
- _MMCAMCORDER_RESOURCE_WAIT_UNTIL(hcamcorder, end_time);
+ } else {
+ if (hcamcorder->camera_resource != NULL)
+ hcamcorder->camera_resource = NULL;
+ if (hcamcorder->video_overlay_resource != NULL)
+ hcamcorder->video_overlay_resource = NULL;
}
}
_MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
_mmcam_dbg_warn("unlock resource");
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
#ifdef _MMCAMCORDER_RM_SUPPORT
if (hcamcorder->rm_handle && (hcamcorder->returned_devices.allocated_num > 0)) {
{
int ret = MM_ERROR_NONE;
int state = MM_CAMCORDER_STATE_NONE;
- int audio_disable = FALSE;
int dpm_mic_state = DPM_ALLOWED;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
if (callback == NULL)
_mmcam_dbg_warn("Video Stream Callback is disabled, because application sets it to NULL");
- if (!_MMCAMCORDER_TRYLOCK_VSTREAM_CALLBACK(hcamcorder)) {
- _mmcam_dbg_warn("Application's video stream callback is running now");
- return MM_ERROR_CAMCORDER_INVALID_CONDITION;
- }
+ _MMCAMCORDER_LOCK_VSTREAM_CALLBACK(hcamcorder);
hcamcorder->vstream_cb = callback;
hcamcorder->vstream_cb_param = user_data;
_MMCamcorderSubContext *sc = NULL;
GstElement *pipeline = NULL;
- _mmcam_dbg_log("handle : %x, type : %d", handle, type);
+ _mmcam_dbg_log("handle : %p, type : %d", handle, type);
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
int result = MM_ERROR_NONE;
int cmd_try_count = 0;
int current_state = MM_CAMCORDER_STATE_NONE;
+ _MMCamcorderMsgItem msg;
mmf_return_if_fail(hcamcorder);
/* set state_change_by_system for state change message */
hcamcorder->state_change_by_system = state_change_by_system;
+ if (current_state >= MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_warn("send state change started message to notify");
+
+ memset(&msg, 0x0, sizeof(_MMCamcorderMsgItem));
+
+ switch (state_change_by_system) {
+ case _MMCAMCORDER_STATE_CHANGE_BY_FOCUS:
+ msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_ASM;
+ break;
+ case _MMCAMCORDER_STATE_CHANGE_BY_RM:
+ msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_RM;
+ break;
+ case _MMCAMCORDER_STATE_CHANGE_BY_DPM:
+ msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_SECURITY;
+ break;
+ default:
+ break;
+ }
+
+ if (msg.id != 0) {
+ msg.param.state.code = hcamcorder->interrupt_code;
+ _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
+ } else {
+ _mmcam_dbg_err("should not be reached here %d", state_change_by_system);
+ }
+ }
+
for (loop = 0 ; current_state > MM_CAMCORDER_STATE_NULL && loop < __MMCAMCORDER_CMD_ITERATE_MAX * 3 ; loop++) {
itr_cnt = __MMCAMCORDER_CMD_ITERATE_MAX;
switch (current_state) {
{
_mmcam_dbg_warn("Stop preview.");
- while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
+ while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE))
_mmcam_dbg_warn("Can't stop preview.(%x)", result);
- }
break;
}
{
_mmcam_dbg_warn("unrealize");
- if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE) {
+ if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE)
_mmcam_dbg_warn("Can't unrealize.(%x)", result);
- }
break;
}
- case MM_CAMCORDER_STATE_NULL:
default:
_mmcam_dbg_warn("Already stopped.");
break;
gchar *msg_src_element = NULL;
_MMCamcorderSubContext *sc = NULL;
- return_val_if_fail(hcamcorder, FALSE);
- return_val_if_fail(error, FALSE);
+ mmf_return_val_if_fail(hcamcorder, FALSE);
+ mmf_return_val_if_fail(error, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc, FALSE);
static gint __mmcamcorder_gst_handle_library_error(MMHandleType handle, int code, GstMessage *message)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
_mmcam_dbg_log("");
gchar *debug = NULL;
GError *err = NULL;
- return_val_if_fail(hcamcorder, FALSE);
- return_val_if_fail(error, FALSE);
+ mmf_return_val_if_fail(hcamcorder, FALSE);
+ mmf_return_val_if_fail(error, FALSE);
_mmcam_dbg_log("");
return MM_ERROR_NONE;
}
+/* Conditions below are from ASM conflict table of Tizen 2.4 */
+static int __mmcamcorder_simulate_asm_conflict_table(int session_type, int pid)
+{
+ int ret = MM_ERROR_NONE;
+ char *stream_type = NULL;
+ char *ext_info = NULL;
+ int option = 0;
+
+ /* check previous acquired focus of other PID */
+ ret = mm_sound_get_stream_type_of_acquired_focus(FOCUS_FOR_BOTH, &stream_type, &option, &ext_info);
+ if (ret == MM_ERROR_NONE && stream_type) {
+ if (ext_info && (pid != atoi(ext_info))) { /* 'ext_info' should contain pid */
+ if ((session_type == MM_SESSION_TYPE_CALL) ||
+ (session_type == MM_SESSION_TYPE_VIDEOCALL) ||
+ (session_type == MM_SESSION_TYPE_VOIP)) {
+ /* case 1. if my session type is call/videocall/voip */
+ if (!strcmp(stream_type, "call-voice") ||
+ !strcmp(stream_type, "call-video") ||
+ !strcmp(stream_type, "ringtone-call")) {
+ _mmcam_dbg_err("Blocked by session policy, stream_type[%s] of acquired focus", stream_type);
+ ret = MM_ERROR_POLICY_BLOCKED;
+ }
+ } else if ((session_type == MM_SESSION_TYPE_MEDIA) ||
+ (session_type == MM_SESSION_TYPE_MEDIA_RECORD)) {
+ /* case 2. if my session type is media */
+ if (!strcmp(stream_type, "alarm") ||
+ !strcmp(stream_type, "ringtone-voip") ||
+ !strcmp(stream_type, "ringtone-call") ||
+ !strcmp(stream_type, "voip") ||
+ !strcmp(stream_type, "call-voice") ||
+ !strcmp(stream_type, "call-video")) {
+ _mmcam_dbg_err("Blocked by session policy, stream_type[%s] of acquired focus", stream_type);
+ ret = MM_ERROR_POLICY_BLOCKED;
+ }
+ }
+ } else {
+ _mmcam_dbg_log("acquired focus is same process with it, skip it");
+ }
+ } else {
+ /* No data case */
+ _mmcam_dbg_warn("get stream type failed 0x%x, stream type %s, but ignore it",
+ ret, stream_type ? stream_type : "NULL");
+ ret = MM_ERROR_NONE;
+ }
+
+ if (stream_type) {
+ free(stream_type);
+ stream_type = NULL;
+ }
+
+ if (ext_info) {
+ free(ext_info);
+ ext_info = NULL;
+ }
+
+ return ret;
+}
+
void _mmcamcorder_emit_signal(MMHandleType handle, const char *object_name,
const char *interface_name, const char *signal_name, int value)
}
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
+static int __mmcamcorder_resource_release_cb(mm_resource_manager_h rm,
+ mm_resource_manager_res_h res, void *user_data)
+{
+ mmf_camcorder_t *hcamcorder = (mmf_camcorder_t *) user_data;
+
+ mmf_return_val_if_fail(hcamcorder, FALSE);
+
+ _mmcam_dbg_warn("enter");
+
+ _MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
+
+ /* set flag for resource release callback */
+ hcamcorder->is_release_cb_calling = TRUE;
+
+ _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
+
+ _MMCAMCORDER_LOCK_ASM(hcamcorder);
+
+ if (res == hcamcorder->video_encoder_resource) {
+ /* Stop video recording */
+ if (_mmcamcorder_commit((MMHandleType)hcamcorder) != MM_ERROR_NONE) {
+ _mmcam_dbg_err("commit failed, cancel it");
+ _mmcamcorder_cancel((MMHandleType)hcamcorder);
+ }
+ } else {
+ /* Stop camera */
+ __mmcamcorder_force_stop(hcamcorder, _MMCAMCORDER_STATE_CHANGE_BY_RM);
+ }
+
+ _MMCAMCORDER_UNLOCK_ASM(hcamcorder);
+
+ _MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
+
+ if (res == hcamcorder->camera_resource)
+ hcamcorder->camera_resource = NULL;
+ else if (res == hcamcorder->video_overlay_resource)
+ hcamcorder->video_overlay_resource = NULL;
+ else if (res == hcamcorder->video_encoder_resource)
+ hcamcorder->video_encoder_resource = NULL;
+
+ /* restore flag for resource release callback */
+ hcamcorder->is_release_cb_calling = FALSE;
+
+ _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
+
+ _mmcam_dbg_warn("leave");
+
+ return FALSE;
+}
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
+
+
#ifdef _MMCAMCORDER_RM_SUPPORT
rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src,
rm_device_request_s *info, void* cb_data)
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);
- }
+
+ _mmcam_dbg_warn("current state %d (handle %p)", current_state, hcamcorder);
_MMCAMCORDER_LOCK_ASM(hcamcorder);
projects / platform / core / multimedia / libmm-camcorder.git / blobdiff