#include <mm_session.h>
#include <mm_session_private.h>
+#ifdef _MMCAMCORDER_MURPHY_SUPPORT
#include <murphy/common/glib-glue.h>
+#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
-/*---------------------------------------------------------------------------------------
-| GLOBAL VARIABLE DEFINITIONS for internal |
----------------------------------------------------------------------------------------*/
-struct sigaction mm_camcorder_int_old_action;
-struct sigaction mm_camcorder_abrt_old_action;
-struct sigaction mm_camcorder_segv_old_action;
-struct sigaction mm_camcorder_term_old_action;
-struct sigaction mm_camcorder_sys_old_action;
+#ifdef _MMCAMCORDER_RM_SUPPORT
+#include <aul.h>
+#endif /* _MMCAMCORDER_RM_SUPPORT */
/*---------------------------------------------------------------------------------------
| LOCAL VARIABLE DEFINITIONS for internal |
#define __MMCAMCORDER_SOUND_WAIT_TIMEOUT 3
#define __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN 64
+#define DPM_ALLOWED 1
+#define DPM_DISALLOWED 0
+
+#ifdef _MMCAMCORDER_MURPHY_SUPPORT
+#define __MMCAMCORDER_RESOURCE_WAIT_TIME 5
+#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+
/*---------------------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
static gint __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMessage *message , GError *error);
static gboolean __mmcamcorder_handle_gst_warning(MMHandleType handle, GstMessage *message, GError *error);
+#ifdef _MMCAMCORDER_RM_SUPPORT
+rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src,
+ rm_device_request_s *info, void *cb_data);
+#endif /* _MMCAMCORDER_RM_SUPPORT */
#ifdef _MMCAMCORDER_USE_SET_ATTR_CB
static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data);
#endif /* _MMCAMCORDER_USE_SET_ATTR_CB */
-static void __mm_camcorder_signal_handler(int signo);
-static void _mmcamcorder_constructor() __attribute__((constructor));
-
/*=======================================================================================
| FUNCTION DEFINITIONS |
=======================================================================================*/
| GLOBAL FUNCTION DEFINITIONS: |
---------------------------------------------------------------------------------------*/
-
-static void __mm_camcorder_signal_handler(int signo)
-{
- pid_t my_pid = getpid();
-
- _mmcam_dbg_warn("start - signo [%d], pid [%d]", signo, my_pid);
-
- /* call old signal handler */
- switch (signo) {
- case SIGINT:
- sigaction(SIGINT, &mm_camcorder_int_old_action, NULL);
- raise(signo);
- break;
- case SIGABRT:
- sigaction(SIGABRT, &mm_camcorder_abrt_old_action, NULL);
- raise(signo);
- break;
- case SIGSEGV:
- sigaction(SIGSEGV, &mm_camcorder_segv_old_action, NULL);
- raise(signo);
- break;
- case SIGTERM:
- sigaction(SIGTERM, &mm_camcorder_term_old_action, NULL);
- raise(signo);
- break;
- case SIGSYS:
- sigaction(SIGSYS, &mm_camcorder_sys_old_action, NULL);
- raise(signo);
- break;
- default:
- break;
- }
-
- _mmcam_dbg_warn("done");
-
- return;
-}
-
-
-static void _mmcamcorder_constructor()
-{
- struct sigaction mm_camcorder_action;
- mm_camcorder_action.sa_handler = __mm_camcorder_signal_handler;
- mm_camcorder_action.sa_flags = SA_NOCLDSTOP;
-
- _mmcam_dbg_warn("start");
-
- sigemptyset(&mm_camcorder_action.sa_mask);
-
- sigaction(SIGINT, &mm_camcorder_action, &mm_camcorder_int_old_action);
- sigaction(SIGABRT, &mm_camcorder_action, &mm_camcorder_abrt_old_action);
- sigaction(SIGSEGV, &mm_camcorder_action, &mm_camcorder_segv_old_action);
- sigaction(SIGTERM, &mm_camcorder_action, &mm_camcorder_term_old_action);
- sigaction(SIGSYS, &mm_camcorder_action, &mm_camcorder_sys_old_action);
-
- _mmcam_dbg_warn("done");
-
- return;
-}
-
/* Internal command functions {*/
int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
{
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).vcapture_cb_lock);
g_mutex_init(&(hcamcorder->mtsafe).vstream_cb_lock);
g_mutex_init(&(hcamcorder->mtsafe).astream_cb_lock);
+#ifdef _MMCAMCORDER_MURPHY_SUPPORT
+ g_cond_init(&(hcamcorder->mtsafe).resource_cond);
+ g_mutex_init(&(hcamcorder->mtsafe).resource_lock);
+#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
g_mutex_init(&hcamcorder->restart_preview_lock);
}
/* Get Camera Configure information from Camcorder INI file */
- _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &hcamcorder->conf_main);
-
- if (!(hcamcorder->conf_main)) {
- _mmcam_dbg_err( "Failed to get configure(main) info." );
-
- ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+ ret = _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &hcamcorder->conf_main);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("Failed to get configure(main) info.");
goto _ERR_DEFAULT_VALUE_INIT;
}
goto _ERR_DEFAULT_VALUE_INIT;
}
+ /* get DPM context for camera/microphone restriction */
+ hcamcorder->dpm_context = dpm_context_create();
+ if (hcamcorder->dpm_context) {
+ hcamcorder->dpm_policy = dpm_context_acquire_restriction_policy(hcamcorder->dpm_context);
+ if (hcamcorder->dpm_policy == NULL) {
+ _mmcam_dbg_err("dpm_context_acquire_restriction_policy failed");
+ dpm_context_destroy(hcamcorder->dpm_context);
+ hcamcorder->dpm_context = NULL;
+ }
+ }
+
+ _mmcam_dbg_warn("DPM context %p, policy %p", hcamcorder->dpm_context, hcamcorder->dpm_policy);
+
if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
_mmcam_dbg_log("videodev_type : [%d], ConfCtrlPath : [%s]", info->videodev_type, ConfCtrlFile);
- _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_CTRL, ConfCtrlFile, &hcamcorder->conf_ctrl);
+ ret = _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_CTRL, ConfCtrlFile, &hcamcorder->conf_ctrl);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("Failed to get configure(control) info.");
+ goto _ERR_DEFAULT_VALUE_INIT;
+ }
/*
_mmcamcorder_conf_print_info(&hcamcorder->conf_main);
_mmcamcorder_conf_print_info(&hcamcorder->conf_ctrl);
*/
- if (!(hcamcorder->conf_ctrl)) {
- _mmcam_dbg_err( "Failed to get configure(control) info." );
- ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
- goto _ERR_DEFAULT_VALUE_INIT;
- }
-
ret = _mmcamcorder_init_convert_table((MMHandleType)hcamcorder);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_warn("converting table initialize error!!");
"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,
mm_camcorder_get_fps_list_by_resolution((MMHandleType)hcamcorder, resolution_width, resolution_height, &fps_info);
- _mmcam_dbg_log("UseZeroCopyFormat : %d", hcamcorder->use_zero_copy_format);
- _mmcam_dbg_log("SupportMediaPacketPreviewCb : %d", hcamcorder->support_media_packet_preview_cb);
- _mmcam_dbg_log("res : %d X %d, Default FPS by resolution : %d", resolution_width, resolution_height, fps_info.int_array.def);
+ _mmcam_dbg_log("UseZeroCopyFormat %d, UseVideoconvert %d, SupportMediaPacketPreviewCb %d",
+ hcamcorder->use_zero_copy_format, hcamcorder->use_videoconvert, hcamcorder->support_media_packet_preview_cb);
+ _mmcam_dbg_log("res : %d X %d, Default FPS by resolution : %d",
+ resolution_width, resolution_height, fps_info.int_array.def);
if (camera_facing_direction == 1) {
if (rcmd_dpy_rotation == MM_DISPLAY_ROTATION_270 || rcmd_dpy_rotation == MM_DISPLAY_ROTATION_90) {
} else {
camera_default_flip = MM_FLIP_HORIZONTAL;
}
- _mmcam_dbg_log("camera_default_flip : [%d]",camera_default_flip);
+ _mmcam_dbg_log("camera_default_flip : [%d]", camera_default_flip);
}
mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
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;
}
NULL);
if (err_attr_name) {
_mmcam_dbg_err("Get brightness FAILED.");
- free(err_attr_name);
- err_attr_name = NULL;
+ SAFE_FREE(err_attr_name);
ret = MM_ERROR_CAMCORDER_INTERNAL;
goto _ERR_DEFAULT_VALUE_INIT;
}
_mmcam_dbg_log( "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,
NULL);
if (err_attr_name) {
_mmcam_dbg_err("Set %s FAILED.", err_attr_name);
- free(err_attr_name);
- err_attr_name = NULL;
+ SAFE_FREE(err_attr_name);
ret = MM_ERROR_CAMCORDER_INTERNAL;
goto _ERR_DEFAULT_VALUE_INIT;
}
ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, MM_CAMCONVERT_CATEGORY_AUDIO);
if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_warn("init attribute from configure error : 0x%x", ret);
- ret = MM_ERROR_CAMCORDER_INTERNAL;
+ _mmcam_dbg_err("there is no audio device");
+ ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
goto _ERR_DEFAULT_VALUE_INIT;
}
}
+#ifdef _MMCAMCORDER_MURPHY_SUPPORT
/* initialize resource manager */
ret = _mmcamcorder_resource_manager_init(&hcamcorder->resource_manager, (void *)hcamcorder);
if (ret != MM_ERROR_NONE) {
ret = MM_ERROR_CAMCORDER_INTERNAL;
goto _ERR_DEFAULT_VALUE_INIT;
}
+#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:CREATE:INIT_GSTREAMER");
return MM_ERROR_NONE;
_ERR_DEFAULT_VALUE_INIT:
+#ifdef _MMCAMCORDER_MURPHY_SUPPORT
+ /* de-initialize resource manager */
+ _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager);
+#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+
/* unregister sound focus */
if (hcamcorder->sound_focus_register && hcamcorder->sound_focus_id > 0) {
if (MM_ERROR_NONE != mm_sound_unregister_focus(hcamcorder->sound_focus_id)) {
hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
}
+ /* release DPM related handle */
+ if (hcamcorder->dpm_context) {
+ _mmcam_dbg_log("release DPM context %p, camera changed cb id %d",
+ hcamcorder->dpm_context, hcamcorder->dpm_camera_cb_id);
+
+ /* remove camera policy changed callback */
+ if (hcamcorder->dpm_camera_cb_id > 0) {
+ dpm_context_remove_policy_changed_cb(hcamcorder->dpm_context, hcamcorder->dpm_camera_cb_id);
+ hcamcorder->dpm_camera_cb_id = 0;
+ } else {
+ _mmcam_dbg_warn("invalid dpm camera cb id %d", hcamcorder->dpm_camera_cb_id);
+ }
+
+ if (hcamcorder->dpm_policy) {
+ dpm_context_release_restriction_policy(hcamcorder->dpm_context, hcamcorder->dpm_policy);
+ hcamcorder->dpm_policy = NULL;
+ }
+
+ dpm_context_destroy(hcamcorder->dpm_context);
+ hcamcorder->dpm_context = NULL;
+ }
+
/* Remove attributes */
if (hcamcorder->attributes) {
_mmcamcorder_dealloc_attribute((MMHandleType)hcamcorder, hcamcorder->attributes);
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).vcapture_cb_lock);
g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock);
g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock);
+#ifdef _MMCAMCORDER_MURPHY_SUPPORT
+ g_cond_clear(&(hcamcorder->mtsafe).resource_cond);
+ g_mutex_clear(&(hcamcorder->mtsafe).resource_lock);
+#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
g_mutex_clear(&hcamcorder->snd_info.open_mutex);
g_cond_clear(&hcamcorder->snd_info.open_cond);
g_mutex_clear(&hcamcorder->restart_preview_lock);
if (hcamcorder->conf_ctrl) {
- _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl);
+ _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_ctrl);
}
if (hcamcorder->conf_main) {
- _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_main);
+ _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_main);
}
if (hcamcorder->model_name) {
int ret = MM_ERROR_NONE;
int state = MM_CAMCORDER_STATE_NONE;
int state_FROM = MM_CAMCORDER_STATE_NULL;
+#ifdef _MMCAMCORDER_RM_SUPPORT
+ int iret = RM_OK;
+#endif /* _MMCAMCORDER_RM_SUPPORT */
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
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("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) {
hcamcorder->software_version = NULL;
}
+ /* release DPM related handle */
+ if (hcamcorder->dpm_context) {
+ _mmcam_dbg_log("release DPM context %p, camera changed cb id %d",
+ hcamcorder->dpm_context, hcamcorder->dpm_camera_cb_id);
+
+ /* remove camera policy changed callback */
+ if (hcamcorder->dpm_camera_cb_id > 0) {
+ dpm_context_remove_policy_changed_cb(hcamcorder->dpm_context, hcamcorder->dpm_camera_cb_id);
+ hcamcorder->dpm_camera_cb_id = 0;
+ } else {
+ _mmcam_dbg_warn("invalid dpm camera cb id %d", hcamcorder->dpm_camera_cb_id);
+ }
+
+ if (hcamcorder->dpm_policy) {
+ dpm_context_release_restriction_policy(hcamcorder->dpm_context, hcamcorder->dpm_policy);
+ hcamcorder->dpm_policy = NULL;
+ }
+
+ dpm_context_destroy(hcamcorder->dpm_context);
+ hcamcorder->dpm_context = NULL;
+ }
+
/* join task thread */
_mmcam_dbg_log("task thread join");
g_thread_join(hcamcorder->task_thread);
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).vcapture_cb_lock);
g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock);
g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock);
+#ifdef _MMCAMCORDER_MURPHY_SUPPORT
+ g_cond_clear(&(hcamcorder->mtsafe).resource_cond);
+ g_mutex_clear(&(hcamcorder->mtsafe).resource_lock);
+#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
g_mutex_clear(&hcamcorder->snd_info.open_mutex);
g_cond_clear(&hcamcorder->snd_info.open_cond);
{
int ret = MM_ERROR_NONE;
int ret_sound = MM_ERROR_NONE;
- int ret_resource = MM_ERROR_NONE;
int state = MM_CAMCORDER_STATE_NONE;
int state_FROM = MM_CAMCORDER_STATE_NULL;
int state_TO = MM_CAMCORDER_STATE_READY;
- int display_surface_type = MM_DISPLAY_SURFACE_X;
+ int display_surface_type = MM_DISPLAY_SURFACE_OVERLAY;
int pid_for_sound_focus = 0;
double motion_rate = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
char *videosink_element_type = NULL;
const char *videosink_name = NULL;
char *socket_path = NULL;
int socket_path_len;
+#ifdef _MMCAMCORDER_RM_SUPPORT
+ int iret = RM_OK;
+#endif /* _MMCAMCORDER_RM_SUPPORT */
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_mmcam_dbg_log("Profile mode [%d]", hcamcorder->type);
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_DISPLAY_SURFACE, &display_surface_type,
- MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
- MMCAM_DISPLAY_SOCKET_PATH, &socket_path, &socket_path_len,
- NULL);
+ MMCAM_DISPLAY_SURFACE, &display_surface_type,
+ MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
+ NULL);
/* sound focus */
if (hcamcorder->sound_focus_register) {
_mmcam_dbg_log("no need to register sound focus");
}
+#ifdef _MMCAMCORDER_RM_SUPPORT
+ int preview_format = MM_PIXEL_FORMAT_NV12;
+ int qret = RM_OK;
+ int qret_avail = RM_OK;
+ rm_consumer_info rci;
+ int app_pid = 0;
+ int resource_count = 0;
+
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_PID_FOR_SOUND_FOCUS, &app_pid,
+ NULL);
+ rci.app_pid = app_pid;
+ aul_app_get_appid_bypid(rci.app_pid, rci.app_id, sizeof(rci.app_id));
+
+ /* RM register */
+ if (hcamcorder->rm_handle == 0) {
+ iret = rm_register((rm_resource_cb)_mmcamcorder_rm_callback, (void*)hcamcorder,
+ &(hcamcorder->rm_handle), &rci);
+ if (iret != RM_OK) {
+ _mmcam_dbg_err("rm_register fail");
+ ret = MM_ERROR_POLICY_BLOCKED;
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ }
+ }
+
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_CAMERA_FORMAT, &preview_format,
+ NULL);
+
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO && preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+
+ resource_count = 0;
+ memset(&hcamcorder->request_resources, 0x0, sizeof(rm_category_request_s));
+ memset(&hcamcorder->returned_devices, 0x0, sizeof(rm_device_return_s));
+ hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
+ hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER;
+ _mmcam_dbg_log("request video decoder resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+
+ resource_count++;
+ hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
+ hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER;
+ hcamcorder->request_resources.request_num = resource_count + 1;
+ _mmcam_dbg_log("request scaler resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+
+
+ qret = rm_query(hcamcorder->rm_handle, RM_QUERY_ALLOCATION, &(hcamcorder->request_resources), &qret_avail);
+
+ if (qret != RM_OK || qret_avail != RM_OK) {
+ _mmcam_dbg_log("Resource manager main device request fail");
+
+ resource_count = 0;
+ hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER_SUB;
+ _mmcam_dbg_log("request video decoder resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+
+ resource_count++;
+ hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER_SUB;
+ _mmcam_dbg_log("request scaler resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+ }
+
+ resource_count++;
+ hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
+ hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_CAMERA;
+ hcamcorder->request_resources.request_num = resource_count + 1;
+ _mmcam_dbg_log("request camera resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+
+ iret = rm_allocate_resources(hcamcorder->rm_handle, &(hcamcorder->request_resources), &hcamcorder->returned_devices);
+ if (iret != RM_OK) {
+ _mmcam_dbg_err("Resource allocation request failed");
+ ret = MM_ERROR_POLICY_BLOCKED;
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ }
+ }
+#endif /* _MMCAMCORDER_RM_SUPPORT */
/* alloc sub context */
hcamcorder->sub_context = _mmcamcorder_alloc_subcontext(hcamcorder->type);
_mmcam_dbg_warn("SupportDualStream [%d]", hcamcorder->sub_context->info_video->support_dual_stream);
}
- if (socket_path == NULL) {
- _mmcam_dbg_warn("Socket Path is not properly set, -> to NullSink.");
+ switch (display_surface_type) {
+ case MM_DISPLAY_SURFACE_OVERLAY:
+ videosink_element_type = strdup("VideosinkElementOverlay");
+ break;
+ case MM_DISPLAY_SURFACE_EVAS:
+ videosink_element_type = strdup("VideosinkElementEvas");
+ break;
+ case MM_DISPLAY_SURFACE_GL:
+ videosink_element_type = strdup("VideosinkElementGL");
+ break;
+ case MM_DISPLAY_SURFACE_NULL:
videosink_element_type = strdup("VideosinkElementNull");
- } else {
- switch (display_surface_type) {
- case MM_DISPLAY_SURFACE_X:
- videosink_element_type = strdup("VideosinkElementX");
- break;
- case MM_DISPLAY_SURFACE_EVAS:
- videosink_element_type = strdup("VideosinkElementEvas");
- break;
- case MM_DISPLAY_SURFACE_GL:
- videosink_element_type = strdup("VideosinkElementGL");
- break;
- case MM_DISPLAY_SURFACE_NULL:
+ break;
+ case MM_DISPLAY_SURFACE_REMOTE:
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_DISPLAY_SOCKET_PATH, &socket_path, &socket_path_len,
+ NULL);
+ if (socket_path == NULL) {
+ _mmcam_dbg_warn("REMOTE surface, but socket path is NULL -> to NullSink");
videosink_element_type = strdup("VideosinkElementNull");
- break;
- case MM_DISPLAY_SURFACE_REMOTE:
+ } else
videosink_element_type = strdup("VideosinkElementRemote");
- break;
- default:
- videosink_element_type = strdup("VideosinkElementX");
- break;
- }
+ break;
+ default:
+ videosink_element_type = strdup("VideosinkElementOverlay");
+ break;
}
/* check string of videosink element */
_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;
+#ifdef _MMCAMCORDER_MURPHY_SUPPORT
+ gint64 end_time = 0;
+#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
+
+ /* 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
+ hcamcorder->resource_manager.acquire_count = 0;
+
/* prepare resource manager for camera */
- if((_mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, RESOURCE_TYPE_CAMERA))) {
+ ret = _mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, MM_CAMCORDER_RESOURCE_TYPE_CAMERA);
+ if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("could not prepare for camera resource");
ret = MM_ERROR_CAMCORDER_INTERNAL;
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
/* prepare resource manager for "video_overlay only if display surface is X" */
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_DISPLAY_SURFACE, &display_surface_type,
- NULL);
- if(display_surface_type == MM_DISPLAY_SURFACE_X) {
- if((_mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, RESOURCE_TYPE_VIDEO_OVERLAY))) {
+ MMCAM_DISPLAY_SURFACE, &display_surface_type,
+ NULL);
+
+ if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
+ ret = _mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, MM_CAMCORDER_RESOURCE_TYPE_VIDEO_OVERLAY);
+ if(ret != MM_ERROR_NONE) {
_mmcam_dbg_err("could not prepare for video overlay resource");
ret = MM_ERROR_CAMCORDER_INTERNAL;
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
}
+
/* acquire resources */
- if((hcamcorder->resource_manager.rset && _mmcamcorder_resource_manager_acquire(&hcamcorder->resource_manager))) {
+ _MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
+
+ if (hcamcorder->resource_manager.rset && _mmcamcorder_resource_manager_acquire(&hcamcorder->resource_manager)) {
+ _MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
+
_mmcam_dbg_err("could not acquire resources");
+
_mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager);
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
+
+ if (hcamcorder->resource_manager.acquire_count > 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 */
}
/* create pipeline */
return MM_ERROR_NONE;
_ERR_CAMCORDER_CMD:
+#ifdef _MMCAMCORDER_MURPHY_SUPPORT
/* release hw resources */
if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) {
- ret_resource = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
+ int ret_resource = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
if (ret_resource == MM_ERROR_RESOURCE_INVALID_STATE) {
_mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource");
}
_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);
}
}
}
+#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->sub_context = NULL;
}
+#ifdef _MMCAMCORDER_MURPHY_SUPPORT
if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) {
+ /* release resource */
ret = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
if (ret == MM_ERROR_RESOURCE_INVALID_STATE) {
_mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource");
_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;
int state_FROM1 = MM_CAMCORDER_STATE_PREPARE;
int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
int state_TO = MM_CAMCORDER_STATE_RECORDING;
+ int dpm_mic_state = DPM_ALLOWED;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
/* initialize error code */
hcamcorder->error_code = MM_ERROR_NONE;
+ /* check mic policy from DPM */
+ if (hcamcorder->dpm_policy) {
+ if (dpm_restriction_get_microphone_state(hcamcorder->dpm_policy, &dpm_mic_state) == DPM_ERROR_NONE) {
+ _mmcam_dbg_log("DPM mic state %d", dpm_mic_state);
+ if (dpm_mic_state == DPM_DISALLOWED) {
+ _mmcam_dbg_err("MIC DISALLOWED by DPM");
+ ret = MM_ERROR_COMMON_INVALID_PERMISSION;
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ }
+ } else {
+ _mmcam_dbg_err("get DPM mic state failed, keep going...");
+ }
+ } else {
+ _mmcam_dbg_warn("NULL dpm_policy");
+ }
+
ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_RECORD);
if (ret != MM_ERROR_NONE) {
/* check internal error of gstreamer */
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
+ /* initialize error code */
+ hcamcorder->error_code = MM_ERROR_NONE;
+
ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_COMMIT);
if (ret != MM_ERROR_NONE) {
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
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;
}
msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_RM;
msg.param.state.code = MM_ERROR_NONE;
break;
+ case _MMCAMCORDER_STATE_CHANGE_BY_DPM:
+ msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY;
+ msg.param.state.code = MM_ERROR_NONE;
+ break;
case _MMCAMCORDER_STATE_CHANGE_NORMAL:
default:
msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
/* alloc info for each mode */
switch (type) {
case MM_CAMCORDER_MODE_AUDIO:
- sc->info_audio = malloc( sizeof(_MMCamcorderAudioInfo));
+ sc->info_audio = g_malloc0( sizeof(_MMCamcorderAudioInfo));
if(!sc->info_audio) {
_mmcam_dbg_err("Failed to alloc info structure");
goto ALLOC_SUBCONTEXT_FAILED;
}
- memset(sc->info_audio, 0x00, sizeof(_MMCamcorderAudioInfo));
break;
case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
default:
- sc->info_image = malloc( sizeof(_MMCamcorderImageInfo));
+ sc->info_image = g_malloc0( sizeof(_MMCamcorderImageInfo));
if(!sc->info_image) {
_mmcam_dbg_err("Failed to alloc info structure");
goto ALLOC_SUBCONTEXT_FAILED;
}
- memset(sc->info_image, 0x00, sizeof(_MMCamcorderImageInfo));
/* init sound status */
sc->info_image->sound_status = _SOUND_STATUS_INIT;
- sc->info_video = malloc( sizeof(_MMCamcorderVideoInfo));
+ sc->info_video = g_malloc0( sizeof(_MMCamcorderVideoInfo));
if(!sc->info_video) {
_mmcam_dbg_err("Failed to alloc info structure");
goto ALLOC_SUBCONTEXT_FAILED;
}
- memset(sc->info_video, 0x00, sizeof(_MMCamcorderVideoInfo));
g_mutex_init(&sc->info_video->size_check_lock);
break;
}
ALLOC_SUBCONTEXT_FAILED:
if (sc) {
- if (sc->info_audio) {
- free(sc->info_audio);
- sc->info_audio = NULL;
- }
- if (sc->info_image) {
- free(sc->info_image);
- sc->info_image = NULL;
- }
+ SAFE_G_FREE(sc->info_audio);
+ SAFE_G_FREE(sc->info_image);
if (sc->info_video) {
g_mutex_clear(&sc->info_video->size_check_lock);
- free(sc->info_video);
- sc->info_video = NULL;
}
+ SAFE_G_FREE(sc->info_video);
if (sc->element) {
free(sc->element);
sc->element = NULL;
if (sc->info_video) {
_mmcam_dbg_log("release info_video");
- if (sc->info_video->filename) {
- free(sc->info_video->filename);
- sc->info_video->filename = NULL;
- }
+ SAFE_G_FREE(sc->info_video->filename);
g_mutex_clear(&sc->info_video->size_check_lock);
free(sc->info_video);
sc->info_video = NULL;
if (sc->info_audio) {
_mmcam_dbg_log("release info_audio");
- if (sc->info_audio->filename) {
- free(sc->info_audio->filename);
- sc->info_audio->filename = NULL;
- }
+ SAFE_G_FREE(sc->info_audio->filename);
free(sc->info_audio);
sc->info_audio = NULL;
}
break;
case GST_MESSAGE_EOS:
{
- _mmcam_dbg_log ("Got EOS from element \"%s\".",
- GST_STR_NULL(GST_ELEMENT_NAME(GST_MESSAGE_SRC(message))));
-
- sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
- mmf_return_val_if_fail(sc, TRUE);
-
- if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
- mmf_return_val_if_fail(sc->info_video, TRUE);
- if (sc->info_video->b_commiting) {
- _mmcamcorder_video_handle_eos((MMHandleType)hcamcorder);
- }
- } else {
- mmf_return_val_if_fail(sc->info_audio, TRUE);
- if (sc->info_audio->b_commiting) {
- _mmcamcorder_audio_handle_eos((MMHandleType)hcamcorder);
- }
- }
-
- sc->bget_eos = TRUE;
-
+ _mmcam_dbg_err("Got EOS from element \"%s\"... but should not be reached here!",
+ GST_STR_NULL(GST_ELEMENT_NAME(GST_MESSAGE_SRC(message))));
break;
}
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:
goto DROP_MESSAGE;
}
- cam_fd_info = (MMCamFaceDetectInfo *)malloc(sizeof(MMCamFaceDetectInfo));
+ cam_fd_info = (MMCamFaceDetectInfo *)g_malloc(sizeof(MMCamFaceDetectInfo));
if (cam_fd_info == NULL) {
_mmcam_dbg_warn("cam_fd_info alloc failed");
-
- free(fd_info);
- fd_info = NULL;
-
+ SAFE_FREE(fd_info);
goto DROP_MESSAGE;
}
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++) {
_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;
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) {
+ if (sc->info_image) {
/* play capture sound */
_mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE01, FALSE);
}
}
return GST_BUS_PASS;
+
DROP_MESSAGE:
gst_message_unref(message);
message = NULL;
}
-GstBusSyncReply _mmcamcorder_audio_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data)
+GstBusSyncReply _mmcamcorder_encode_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data)
{
GstElement *element = NULL;
GError *err = NULL;
sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
mmf_return_val_if_fail(sc, GST_BUS_PASS);
- if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) {
+ if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_EOS) {
+ _mmcam_dbg_log("got EOS from pipeline");
+
+ _MMCAMCORDER_LOCK(hcamcorder);
+
+ sc->bget_eos = TRUE;
+ _MMCAMCORDER_SIGNAL(hcamcorder);
+
+ _MMCAMCORDER_UNLOCK(hcamcorder);
+
+ goto DROP_MESSAGE;
+ } else if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) {
+ _MMCamcorderMsgItem msg;
+
/* parse error message */
gst_message_parse_error(message, &err, &debug_info);
/* set videosrc element to compare */
element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst);
- /* check domain[RESOURCE] and element[VIDEOSRC] */
+ /* check domain[RESOURCE] and element[AUDIOSRC] */
if (err->domain == GST_RESOURCE_ERROR &&
GST_ELEMENT_CAST(message->src) == element) {
- _MMCamcorderMsgItem msg;
switch (err->code) {
case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
case GST_RESOURCE_ERROR_OPEN_WRITE:
_mmcam_dbg_err("audio device [open failed]");
- hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
+
/* post error to application */
hcamcorder->error_occurs = TRUE;
+ hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
+
msg.id = MM_MESSAGE_CAMCORDER_ERROR;
msg.param.code = hcamcorder->error_code;
- _mmcam_dbg_err(" error : sc->error_occurs %d", hcamcorder->error_occurs);
- g_error_free(err);
+
_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
- gst_message_unref(message);
- message = NULL;
- return GST_BUS_DROP;
+
+ _mmcam_dbg_err(" error : sc->error_occurs %d", hcamcorder->error_occurs);
+
+ goto DROP_MESSAGE;
+ default:
+ break;
+ }
+ } else {
+ gboolean b_commiting = FALSE;
+
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ mmf_return_val_if_fail(sc->info_video, GST_BUS_PASS);
+ b_commiting = sc->info_video->b_commiting;
+ } else {
+ mmf_return_val_if_fail(sc->info_audio, GST_BUS_PASS);
+ b_commiting = sc->info_audio->b_commiting;
+ }
+
+ _MMCAMCORDER_LOCK(hcamcorder);
+
+ switch (err->code) {
+ case GST_RESOURCE_ERROR_WRITE:
+ _mmcam_dbg_err("File write error");
+ hcamcorder->error_code = MM_ERROR_FILE_WRITE;
+ break;
+ case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
+ _mmcam_dbg_err("No left space");
+ hcamcorder->error_code = MM_MESSAGE_CAMCORDER_NO_FREE_SPACE;
+ break;
+ case GST_RESOURCE_ERROR_OPEN_WRITE:
+ _mmcam_dbg_err("Out of storage");
+ hcamcorder->error_code = MM_ERROR_OUT_OF_STORAGE;
+ break;
+ case GST_RESOURCE_ERROR_SEEK:
+ _mmcam_dbg_err("File read(seek)");
+ hcamcorder->error_code = MM_ERROR_FILE_READ;
+ break;
default:
+ _mmcam_dbg_err("Resource error(%d)", err->code);
+ hcamcorder->error_code = MM_ERROR_CAMCORDER_GST_RESOURCE;
break;
}
+
+ if (b_commiting) {
+ _MMCAMCORDER_SIGNAL(hcamcorder);
+ _MMCAMCORDER_UNLOCK(hcamcorder);
+ } else {
+ _MMCAMCORDER_UNLOCK(hcamcorder);
+
+ msg.id = MM_MESSAGE_CAMCORDER_ERROR;
+ msg.param.code = hcamcorder->error_code;
+
+ _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
+ }
}
- g_error_free(err);
+ goto DROP_MESSAGE;
+ }
+ if (err) {
+ g_error_free(err);
+ err = NULL;
}
return GST_BUS_PASS;
+
+DROP_MESSAGE:
+ if (err) {
+ g_error_free(err);
+ err = NULL;
+ }
+
+ gst_message_unref(message);
+ message = NULL;
+
+ return GST_BUS_DROP;
}
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data);
int current_state = MM_CAMCORDER_STATE_NONE;
- mmf_return_if_fail((MMHandleType)hcamcorder);
+ mmf_return_if_fail(hcamcorder);
current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
if (current_state <= MM_CAMCORDER_STATE_NONE ||
}
+void _mmcamcorder_dpm_camera_policy_changed_cb(const char *name, const char *value, void *user_data)
+{
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data);
+ int current_state = MM_CAMCORDER_STATE_NONE;
+
+ mmf_return_if_fail(hcamcorder);
+ mmf_return_if_fail(value);
+
+ current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
+ if (current_state <= MM_CAMCORDER_STATE_NONE ||
+ current_state >= MM_CAMCORDER_STATE_NUM) {
+ _mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state);
+ return;
+ }
+
+ _mmcam_dbg_warn("camera policy [%s], current state [%d]", value, current_state);
+
+ if (!strcmp(value, "disallowed")) {
+ _MMCAMCORDER_LOCK_ASM(hcamcorder);
+
+ /* set value to inform a status is changed by DPM */
+ hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_DPM;
+
+ __mmcamcorder_force_stop(hcamcorder);
+
+ /* restore value */
+ hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL;
+
+ _MMCAMCORDER_UNLOCK_ASM(hcamcorder);
+ }
+
+ _mmcam_dbg_warn("done");
+
+ return;
+}
+
+
int _mmcamcorder_create_pipeline(MMHandleType handle, int type)
{
int ret = MM_ERROR_NONE;
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) {
{
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);
}
#endif /* _MMCAMCORDER_SKIP_GST_FLOW_ERROR */
- /* post error to application */
- hcamcorder->error_occurs = TRUE;
- msg.id = MM_MESSAGE_CAMCORDER_ERROR;
- _mmcamcorder_send_message(handle, &msg);
+ /* post error to application except RESTRICTED case */
+ if (msg.param.code != MM_ERROR_POLICY_RESTRICTED) {
+ hcamcorder->error_occurs = TRUE;
+ msg.id = MM_MESSAGE_CAMCORDER_ERROR;
+ _mmcamcorder_send_message(handle, &msg);
+ }
return TRUE;
}
}
}
+ /* audiosrc */
+ element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst);
+ if (GST_ELEMENT_CAST(message->src) == element) {
+ if (code == GST_RESOURCE_ERROR_FAILED) {
+ int ret = MM_ERROR_NONE;
+ int current_state = MM_CAMCORDER_STATE_NONE;
+
+ _mmcam_dbg_err("DPM mic DISALLOWED - current state %d", current_state);
+
+ _MMCAMCORDER_LOCK_ASM(hcamcorder);
+
+ current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
+ if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
+ /* set value to inform a status is changed by DPM */
+ hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_DPM;
+
+ ret = _mmcamcorder_commit((MMHandleType)hcamcorder);
+ _mmcam_dbg_log("commit result : 0x%x", ret);
+
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("commit failed, cancel it");
+ ret = _mmcamcorder_cancel((MMHandleType)hcamcorder);
+ }
+ }
+
+ /* restore value */
+ hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL;
+
+ _MMCAMCORDER_UNLOCK_ASM(hcamcorder);
+
+ return MM_ERROR_POLICY_RESTRICTED;
+ }
+ }
+
/* encodebin */
element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst);
if (GST_ELEMENT_CAST(message->src) == element) {
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
projects / platform / core / multimedia / libmm-camcorder.git / blobdiff