| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------------------*/
/* STATIC INTERNAL FUNCTION */
-static gboolean __mmcamcorder_gstreamer_init(camera_conf * conf);
-
+static gint __mmcamcorder_init_handle(mmf_camcorder_t **hcamcorder, int device_type);
+static void __mmcamcorder_deinit_handle(mmf_camcorder_t *hcamcorder);
+static gint __mmcamcorder_init_configure_video_capture(mmf_camcorder_t *hcamcorder);
+static gint __mmcamcorder_init_configure_audio(mmf_camcorder_t *hcamcorder);
+static void __mmcamcorder_deinit_configure(mmf_camcorder_t *hcamcorder);
+static gboolean __mmcamcorder_init_gstreamer(camera_conf *conf);
+static void __mmcamcorder_get_system_info(mmf_camcorder_t *hcamcorder);
+
+static GstBusSyncReply __mmcamcorder_handle_gst_sync_error(mmf_camcorder_t *hcamcorder, GstMessage *message);
+static GstBusSyncReply __mmcamcorder_gst_handle_sync_audio_error(mmf_camcorder_t *hcamcorder, gint err_code);
+static GstBusSyncReply __mmcamcorder_gst_handle_sync_others_error(mmf_camcorder_t *hcamcorder, gint err_code);
static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage *message, GError *error);
static gint __mmcamcorder_gst_handle_stream_error(MMHandleType handle, int code, GstMessage *message);
static gint __mmcamcorder_gst_handle_resource_error(MMHandleType handle, int code, GstMessage *message);
static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, GstMessage *message);
static gint __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMessage *message , GError *error);
static gboolean __mmcamcorder_handle_gst_warning(MMHandleType handle, GstMessage *message, GError *error);
-
#ifdef _MMCAMCORDER_MM_RM_SUPPORT
static int __mmcamcorder_resource_release_cb(mm_resource_manager_h rm,
- mm_resource_manager_res_h res, void *user_data);
+ mm_resource_manager_res_h res, void *user_data);
#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
-
#ifdef _MMCAMCORDER_RM_SUPPORT
-rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src,
- rm_device_request_s *info, void *cb_data);
+rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src,
+ rm_device_request_s *info, void *cb_data);
#endif /* _MMCAMCORDER_RM_SUPPORT */
#ifdef _MMCAMCORDER_USE_SET_ATTR_CB
static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data);
/*=======================================================================================
| FUNCTION DEFINITIONS |
=======================================================================================*/
-/*---------------------------------------------------------------------------------------
-| GLOBAL FUNCTION DEFINITIONS: |
----------------------------------------------------------------------------------------*/
+static gint __mmcamcorder_init_handle(mmf_camcorder_t **hcamcorder, int device_type)
+{
+ int ret = MM_ERROR_NONE;
+ mmf_camcorder_t *new_handle = NULL;
-/* Internal command functions {*/
-int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
+ if (!hcamcorder) {
+ _mmcam_dbg_err("NULL handle");
+ return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
+ }
+
+ /* Create mmf_camcorder_t handle and initialize every variable */
+ new_handle = (mmf_camcorder_t *)malloc(sizeof(mmf_camcorder_t));
+ if (!new_handle) {
+ _mmcam_dbg_err("new handle allocation failed");
+ return MM_ERROR_CAMCORDER_LOW_MEMORY;
+ }
+
+ memset(new_handle, 0x00, sizeof(mmf_camcorder_t));
+
+ /* set device type */
+ new_handle->device_type = device_type;
+
+ _mmcam_dbg_warn("Device Type : %d", new_handle->device_type);
+
+ new_handle->type = MM_CAMCORDER_MODE_VIDEO_CAPTURE;
+ new_handle->state = MM_CAMCORDER_STATE_NONE;
+ new_handle->old_state = MM_CAMCORDER_STATE_NONE;
+ new_handle->capture_in_recording = FALSE;
+
+ /* init mutex and cond */
+ g_mutex_init(&(new_handle->mtsafe).lock);
+ g_cond_init(&(new_handle->mtsafe).cond);
+ g_mutex_init(&(new_handle->mtsafe).cmd_lock);
+ g_cond_init(&(new_handle->mtsafe).cmd_cond);
+ g_mutex_init(&(new_handle->mtsafe).interrupt_lock);
+ g_mutex_init(&(new_handle->mtsafe).state_lock);
+ g_mutex_init(&(new_handle->mtsafe).gst_state_lock);
+ g_mutex_init(&(new_handle->mtsafe).gst_encode_state_lock);
+ g_mutex_init(&(new_handle->mtsafe).message_cb_lock);
+ g_mutex_init(&(new_handle->mtsafe).vcapture_cb_lock);
+ g_mutex_init(&(new_handle->mtsafe).vstream_cb_lock);
+ g_mutex_init(&(new_handle->mtsafe).astream_cb_lock);
+ g_mutex_init(&(new_handle->mtsafe).mstream_cb_lock);
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
+ g_mutex_init(&(new_handle->mtsafe).resource_lock);
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
+
+ g_mutex_init(&new_handle->restart_preview_lock);
+
+ g_mutex_init(&new_handle->snd_info.open_mutex);
+ g_cond_init(&new_handle->snd_info.open_cond);
+ g_mutex_init(&new_handle->snd_info.play_mutex);
+ g_cond_init(&new_handle->snd_info.play_cond);
+
+ g_mutex_init(&new_handle->task_thread_lock);
+ g_cond_init(&new_handle->task_thread_cond);
+ new_handle->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE;
+
+ if (device_type != MM_VIDEO_DEVICE_NONE) {
+ new_handle->gdbus_info_sound.mm_handle = new_handle;
+ g_mutex_init(&new_handle->gdbus_info_sound.sync_mutex);
+ g_cond_init(&new_handle->gdbus_info_sound.sync_cond);
+
+ new_handle->gdbus_info_solo_sound.mm_handle = new_handle;
+ g_mutex_init(&new_handle->gdbus_info_solo_sound.sync_mutex);
+ g_cond_init(&new_handle->gdbus_info_solo_sound.sync_cond);
+ }
+
+ /* create task thread */
+ new_handle->task_thread = g_thread_try_new("MMCAM_TASK_THREAD",
+ (GThreadFunc)_mmcamcorder_util_task_thread_func, (gpointer)new_handle, NULL);
+ if (new_handle->task_thread == NULL) {
+ _mmcam_dbg_err("_mmcamcorder_create::failed to create task thread");
+ ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
+ goto _INIT_HANDLE_FAILED;
+ }
+
+ /* Get Camera Configure information from Camcorder INI file */
+ ret = _mmcamcorder_conf_get_info((MMHandleType)new_handle, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &new_handle->conf_main);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("Failed to get configure(main) info.");
+ goto _INIT_HANDLE_FAILED;
+ }
+
+ /* allocate attribute */
+ new_handle->attributes = _mmcamcorder_alloc_attribute((MMHandleType)new_handle);
+ if (!new_handle->attributes) {
+ ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
+ goto _INIT_HANDLE_FAILED;
+ }
+
+ *hcamcorder = new_handle;
+
+ _mmcam_dbg_log("new handle %p", new_handle);
+
+ return MM_ERROR_NONE;
+
+_INIT_HANDLE_FAILED:
+ __mmcamcorder_deinit_handle(new_handle);
+ return ret;
+}
+
+
+static void __mmcamcorder_deinit_handle(mmf_camcorder_t *hcamcorder)
+{
+ if (!hcamcorder) {
+ _mmcam_dbg_err("NULL handle");
+ return;
+ }
+
+ /* Remove exif info */
+ if (hcamcorder->exif_info) {
+ mm_exif_destory_exif_info(hcamcorder->exif_info);
+ hcamcorder->exif_info = NULL;
+ }
+
+ /* remove attributes */
+ if (hcamcorder->attributes) {
+ _mmcamcorder_dealloc_attribute((MMHandleType)hcamcorder, hcamcorder->attributes);
+ hcamcorder->attributes = 0;
+ }
+
+ /* Release configure info */
+ __mmcamcorder_deinit_configure(hcamcorder);
+
+ /* remove task thread */
+ if (hcamcorder->task_thread) {
+ g_mutex_lock(&hcamcorder->task_thread_lock);
+ _mmcam_dbg_log("send signal for task thread exit");
+ hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT;
+ g_cond_signal(&hcamcorder->task_thread_cond);
+ g_mutex_unlock(&hcamcorder->task_thread_lock);
+ g_thread_join(hcamcorder->task_thread);
+ hcamcorder->task_thread = NULL;
+ }
+
+ /* Release lock, cond */
+ g_mutex_clear(&(hcamcorder->mtsafe).lock);
+ g_cond_clear(&(hcamcorder->mtsafe).cond);
+ g_mutex_clear(&(hcamcorder->mtsafe).cmd_lock);
+ g_cond_clear(&(hcamcorder->mtsafe).cmd_cond);
+ g_mutex_clear(&(hcamcorder->mtsafe).interrupt_lock);
+ g_mutex_clear(&(hcamcorder->mtsafe).state_lock);
+ g_mutex_clear(&(hcamcorder->mtsafe).gst_state_lock);
+ g_mutex_clear(&(hcamcorder->mtsafe).gst_encode_state_lock);
+ g_mutex_clear(&(hcamcorder->mtsafe).message_cb_lock);
+ g_mutex_clear(&(hcamcorder->mtsafe).vcapture_cb_lock);
+ g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock);
+ g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock);
+ g_mutex_clear(&(hcamcorder->mtsafe).mstream_cb_lock);
+#ifdef _MMCAMCORDER_MM_RM_SUPPORT
+ g_mutex_clear(&(hcamcorder->mtsafe).resource_lock);
+#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
+
+ g_mutex_clear(&hcamcorder->snd_info.open_mutex);
+ g_cond_clear(&hcamcorder->snd_info.open_cond);
+ g_mutex_clear(&hcamcorder->restart_preview_lock);
+
+ if (hcamcorder->device_type != MM_VIDEO_DEVICE_NONE) {
+ g_mutex_clear(&hcamcorder->gdbus_info_sound.sync_mutex);
+ g_cond_clear(&hcamcorder->gdbus_info_sound.sync_cond);
+ g_mutex_clear(&hcamcorder->gdbus_info_solo_sound.sync_mutex);
+ g_cond_clear(&hcamcorder->gdbus_info_solo_sound.sync_cond);
+ }
+
+ g_mutex_clear(&hcamcorder->task_thread_lock);
+ g_cond_clear(&hcamcorder->task_thread_cond);
+
+ if (hcamcorder->model_name)
+ free(hcamcorder->model_name);
+
+ if (hcamcorder->software_version)
+ free(hcamcorder->software_version);
+
+ /* Release handle */
+ memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
+
+ free(hcamcorder);
+
+ return;
+}
+
+
+static void __mmcamcorder_get_system_info(mmf_camcorder_t *hcamcorder)
+{
+ int ret = 0;
+
+ if (!hcamcorder) {
+ _mmcam_dbg_err("NULL handle");
+ return;
+ }
+
+ /* get shutter sound policy */
+ vconf_get_int(VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY, &hcamcorder->shutter_sound_policy);
+ _mmcam_dbg_log("current shutter sound policy : %d", hcamcorder->shutter_sound_policy);
+
+ /* get model name */
+ ret = system_info_get_platform_string("http://tizen.org/system/model_name", &hcamcorder->model_name);
+
+ _mmcam_dbg_warn("model name [%s], ret 0x%x",
+ hcamcorder->model_name ? hcamcorder->model_name : "NULL", ret);
+
+ /* get software version */
+ ret = system_info_get_platform_string("http://tizen.org/system/build.string", &hcamcorder->software_version);
+
+ _mmcam_dbg_warn("software version [%s], ret 0x%x",
+ hcamcorder->software_version ? hcamcorder->software_version : "NULL", ret);
+
+ return;
+}
+
+
+static gint __mmcamcorder_init_configure_video_capture(mmf_camcorder_t *hcamcorder)
{
int ret = MM_ERROR_NONE;
- int sys_info_ret = SYSTEM_INFO_ERROR_NONE;
+ int resolution_width = 0;
+ int resolution_height = 0;
int rcmd_fmt_capture = MM_PIXEL_FORMAT_YUYV;
int rcmd_fmt_recording = MM_PIXEL_FORMAT_NV12;
int rcmd_dpy_rotation = MM_DISPLAY_ROTATION_270;
int camera_default_flip = MM_FLIP_NONE;
int camera_facing_direction = MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR;
char *err_attr_name = NULL;
- mmf_camcorder_t *hcamcorder = NULL;
- type_element *EvasSurfaceElement = NULL;
+ char conf_file_name[__MMCAMCORDER_CONF_FILENAME_LENGTH] = {'\0',};
+ MMCamAttrsInfo fps_info;
- _mmcam_dbg_log("Entered");
+ if (!hcamcorder) {
+ _mmcam_dbg_err("NULL handle");
+ return MM_ERROR_CAMCORDER_NOT_INITIALIZED;
+ }
- mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
- mmf_return_val_if_fail(info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+ snprintf(conf_file_name, sizeof(conf_file_name), "%s%d.ini",
+ CONFIGURE_CTRL_FILE_PREFIX, hcamcorder->device_type);
- /* Create mmf_camcorder_t handle and initialize every variable */
- hcamcorder = (mmf_camcorder_t *)malloc(sizeof(mmf_camcorder_t));
- mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_LOW_MEMORY);
- memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
+ _mmcam_dbg_log("Load control configure file [%d][%s]", hcamcorder->device_type, conf_file_name);
- /* init values */
- hcamcorder->type = 0;
- hcamcorder->state = MM_CAMCORDER_STATE_NONE;
- hcamcorder->sub_context = NULL;
- hcamcorder->old_state = MM_CAMCORDER_STATE_NONE;
- hcamcorder->capture_in_recording = FALSE;
-
- 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).interrupt_lock);
- g_mutex_init(&(hcamcorder->mtsafe).state_lock);
- g_mutex_init(&(hcamcorder->mtsafe).gst_state_lock);
- g_mutex_init(&(hcamcorder->mtsafe).gst_encode_state_lock);
- g_mutex_init(&(hcamcorder->mtsafe).message_cb_lock);
- g_mutex_init(&(hcamcorder->mtsafe).vcapture_cb_lock);
- g_mutex_init(&(hcamcorder->mtsafe).vstream_cb_lock);
- g_mutex_init(&(hcamcorder->mtsafe).astream_cb_lock);
- g_mutex_init(&(hcamcorder->mtsafe).mstream_cb_lock);
-#ifdef _MMCAMCORDER_MM_RM_SUPPORT
- g_mutex_init(&(hcamcorder->mtsafe).resource_lock);
-#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
+ ret = _mmcamcorder_conf_get_info((MMHandleType)hcamcorder,
+ CONFIGURE_TYPE_CTRL, (const char *)conf_file_name, &hcamcorder->conf_ctrl);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("Failed to get configure(control) info.");
+ return ret;
+ }
+/*
+ _mmcamcorder_conf_print_info(&hcamcorder->conf_main);
+ _mmcamcorder_conf_print_info(&hcamcorder->conf_ctrl);
+*/
+ ret = _mmcamcorder_init_convert_table((MMHandleType)hcamcorder);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_warn("converting table initialize error!!");
+ return MM_ERROR_CAMCORDER_INTERNAL;
+ }
- g_mutex_init(&hcamcorder->restart_preview_lock);
+ ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, MM_CAMCONVERT_CATEGORY_ALL);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_warn("attribute initialize from configure error!!");
+ return MM_ERROR_CAMCORDER_INTERNAL;
+ }
- /* Sound mutex/cond init */
- g_mutex_init(&hcamcorder->snd_info.open_mutex);
- g_cond_init(&hcamcorder->snd_info.open_cond);
- g_mutex_init(&hcamcorder->snd_info.play_mutex);
- g_cond_init(&hcamcorder->snd_info.play_cond);
+ /* Get device info, recommend preview fmt and display rotation from INI */
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "RecommendPreviewFormatCapture",
+ &rcmd_fmt_capture);
- /* init for sound thread */
- g_mutex_init(&hcamcorder->task_thread_lock);
- g_cond_init(&hcamcorder->task_thread_cond);
- hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE;
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "RecommendPreviewFormatRecord",
+ &rcmd_fmt_recording);
- if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
- /* init for gdbus */
- hcamcorder->gdbus_info_sound.mm_handle = hcamcorder;
- g_mutex_init(&hcamcorder->gdbus_info_sound.sync_mutex);
- g_cond_init(&hcamcorder->gdbus_info_sound.sync_cond);
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "RecommendDisplayRotation",
+ &rcmd_dpy_rotation);
- hcamcorder->gdbus_info_solo_sound.mm_handle = hcamcorder;
- g_mutex_init(&hcamcorder->gdbus_info_solo_sound.sync_mutex);
- g_cond_init(&hcamcorder->gdbus_info_solo_sound.sync_cond);
- }
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_CAPTURE,
+ "PlayCaptureSound",
+ &play_capture_sound);
- /* 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;
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "DeviceCount",
+ &camera_device_count);
+
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "FacingDirection",
+ &camera_facing_direction);
+
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
+ CONFIGURE_CATEGORY_CTRL_EFFECT,
+ "BrightnessStepDenominator",
+ &hcamcorder->brightness_step_denominator);
+
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
+ CONFIGURE_CATEGORY_CTRL_CAPTURE,
+ "SupportZSL",
+ &hcamcorder->support_zsl_capture);
+
+ _mmcam_dbg_log("Recommend fmt[cap:%d,rec:%d], dpy rot %d, cap snd %d, dev cnt %d, cam facing dir %d, step denom %d, support zsl %d",
+ rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation,
+ play_capture_sound, camera_device_count, camera_facing_direction,
+ hcamcorder->brightness_step_denominator, hcamcorder->support_zsl_capture);
+
+ /* Get UseZeroCopyFormat value from INI */
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "UseZeroCopyFormat",
+ &hcamcorder->use_zero_copy_format);
+
+ /* Get SupportUserBuffer value from INI */
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "SupportUserBuffer",
+ &hcamcorder->support_user_buffer);
+
+ /* Get SupportMediaPacketPreviewCb value from INI */
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "SupportMediaPacketPreviewCb",
+ &hcamcorder->support_media_packet_preview_cb);
+
+ /* Get UseVideoconvert value from INI */
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+ "UseVideoconvert",
+ &hcamcorder->use_videoconvert);
+
+ ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
+ MMCAM_CAMERA_WIDTH, &resolution_width,
+ MMCAM_CAMERA_HEIGHT, &resolution_height,
+ NULL);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("get attribute[resolution] error");
+ return MM_ERROR_CAMCORDER_INTERNAL;
}
- if (info->videodev_type < MM_VIDEO_DEVICE_NONE ||
- info->videodev_type >= MM_VIDEO_DEVICE_NUM) {
- _mmcam_dbg_err("_mmcamcorder_create::video device type is out of range.");
- ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
- goto _ERR_DEFAULT_VALUE_INIT;
+ ret = mm_camcorder_get_fps_list_by_resolution((MMHandleType)hcamcorder, resolution_width, resolution_height, &fps_info);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("get fps list failed with [%dx%d]", resolution_width, resolution_height);
+ return MM_ERROR_CAMCORDER_INTERNAL;
}
- /* set device type */
- hcamcorder->device_type = info->videodev_type;
- _mmcam_dbg_warn("Device Type : %d", hcamcorder->device_type);
+ _mmcam_dbg_log("ZeroCopy %d, UserBuffer %d, Videoconvert %d, MPPreviewCb %d",
+ hcamcorder->use_zero_copy_format, hcamcorder->support_user_buffer,
+ hcamcorder->use_videoconvert, hcamcorder->support_media_packet_preview_cb);
- /* Get Camera Configure information from Camcorder INI file */
- ret = _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &hcamcorder->conf_main);
+ _mmcam_dbg_log("res : %d X %d, Default FPS by resolution : %d",
+ resolution_width, resolution_height, fps_info.int_array.def);
+
+ if (camera_facing_direction == 1) {
+ if (rcmd_dpy_rotation == MM_DISPLAY_ROTATION_270 || rcmd_dpy_rotation == MM_DISPLAY_ROTATION_90)
+ camera_default_flip = MM_FLIP_VERTICAL;
+ else
+ camera_default_flip = MM_FLIP_HORIZONTAL;
+
+ _mmcam_dbg_log("camera_default_flip : [%d]", camera_default_flip);
+ }
+
+ ret = mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
+ MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
+ MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction,
+ MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture,
+ MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording,
+ MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation,
+ MMCAM_SUPPORT_ZSL_CAPTURE, hcamcorder->support_zsl_capture,
+ MMCAM_SUPPORT_ZERO_COPY_FORMAT, hcamcorder->use_zero_copy_format,
+ MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB, hcamcorder->support_media_packet_preview_cb,
+ MMCAM_SUPPORT_USER_BUFFER, hcamcorder->support_user_buffer,
+ MMCAM_CAMERA_FPS, fps_info.int_array.def,
+ MMCAM_DISPLAY_FLIP, camera_default_flip,
+ MMCAM_CAPTURE_SOUND_ENABLE, play_capture_sound,
+ NULL);
if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("Failed to get configure(main) info.");
- goto _ERR_DEFAULT_VALUE_INIT;
+ _mmcam_dbg_err("[0x%x] Set %s FAILED.", ret, err_attr_name ? err_attr_name : "[UNKNOWN]");
+ SAFE_FREE(err_attr_name);
+ return MM_ERROR_CAMCORDER_INTERNAL;
}
- hcamcorder->attributes = _mmcamcorder_alloc_attribute((MMHandleType)hcamcorder, info);
- if (!(hcamcorder->attributes)) {
- _mmcam_dbg_err("_mmcamcorder_create::alloc attribute error.");
+ /* Get default value of brightness */
+ ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
+ MMCAM_FILTER_BRIGHTNESS, &hcamcorder->brightness_default,
+ NULL);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("Get brightness FAILED.");
+ return MM_ERROR_CAMCORDER_INTERNAL;
+ }
- ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
- goto _ERR_DEFAULT_VALUE_INIT;
+ _mmcam_dbg_log("Default brightness : %d", hcamcorder->brightness_default);
+
+ return ret;
+}
+
+
+static gint __mmcamcorder_init_configure_audio(mmf_camcorder_t *hcamcorder)
+{
+ int ret = MM_ERROR_NONE;
+ int camera_device_count = 0;
+
+ if (!hcamcorder) {
+ _mmcam_dbg_err("NULL handle");
+ return MM_ERROR_CAMCORDER_NOT_INITIALIZED;
}
- /* get DPM handle for camera/microphone restriction */
- hcamcorder->dpm_handle = dpm_manager_create();
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "DeviceCount",
+ &camera_device_count);
- _mmcam_dbg_warn("DPM handle %p", hcamcorder->dpm_handle);
+ ret = mm_camcorder_set_attributes((MMHandleType)hcamcorder, NULL,
+ MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
+ NULL);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("Set device count FAILED");
+ return MM_ERROR_CAMCORDER_INTERNAL;
+ }
- if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
- char conf_file_name[__MMCAMCORDER_CONF_FILENAME_LENGTH] = {'\0',};
- int resolution_width = 0;
- int resolution_height = 0;
- MMCamAttrsInfo fps_info;
+ ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, MM_CAMCONVERT_CATEGORY_AUDIO);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("there is no audio device");
+ return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
+ }
- snprintf(conf_file_name, sizeof(conf_file_name), "%s%d.ini",
- CONFIGURE_CTRL_FILE_PREFIX, info->videodev_type);
+ return ret;
+}
- _mmcam_dbg_log("Load control configure file [%d][%s]", info->videodev_type, conf_file_name);
- ret = _mmcamcorder_conf_get_info((MMHandleType)hcamcorder,
- CONFIGURE_TYPE_CTRL, (const char *)conf_file_name, &hcamcorder->conf_ctrl);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("Failed to get configure(control) info.");
- goto _ERR_DEFAULT_VALUE_INIT;
- }
-/*
- _mmcamcorder_conf_print_info(&hcamcorder->conf_main);
- _mmcamcorder_conf_print_info(&hcamcorder->conf_ctrl);
-*/
- ret = _mmcamcorder_init_convert_table((MMHandleType)hcamcorder);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_warn("converting table initialize error!!");
- ret = MM_ERROR_CAMCORDER_INTERNAL;
- goto _ERR_DEFAULT_VALUE_INIT;
- }
+static void __mmcamcorder_deinit_configure(mmf_camcorder_t *hcamcorder)
+{
+ if (!hcamcorder) {
+ _mmcam_dbg_err("NULL handle");
+ return;
+ }
- ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, MM_CAMCONVERT_CATEGORY_ALL);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_warn("attribute initialize from configure error!!");
- ret = MM_ERROR_CAMCORDER_INTERNAL;
- goto _ERR_DEFAULT_VALUE_INIT;
- }
+ if (hcamcorder->conf_ctrl)
+ _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_ctrl);
- /* Get device info, recommend preview fmt and display rotation from INI */
- _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "RecommendPreviewFormatCapture",
- &rcmd_fmt_capture);
-
- _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "RecommendPreviewFormatRecord",
- &rcmd_fmt_recording);
-
- _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "RecommendDisplayRotation",
- &rcmd_dpy_rotation);
-
- _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_CAPTURE,
- "PlayCaptureSound",
- &play_capture_sound);
-
- _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "DeviceCount",
- &camera_device_count);
-
- _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "FacingDirection",
- &camera_facing_direction);
-
- _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_EFFECT,
- "BrightnessStepDenominator",
- &hcamcorder->brightness_step_denominator);
-
- _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAPTURE,
- "SupportZSL",
- &hcamcorder->support_zsl_capture);
-
- _mmcam_dbg_log("Recommend fmt[cap:%d,rec:%d], dpy rot %d, cap snd %d, dev cnt %d, cam facing dir %d, step denom %d, support zsl %d",
- rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation,
- play_capture_sound, camera_device_count, camera_facing_direction,
- hcamcorder->brightness_step_denominator, hcamcorder->support_zsl_capture);
-
- /* Get UseZeroCopyFormat value from INI */
- _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "UseZeroCopyFormat",
- &(hcamcorder->use_zero_copy_format));
-
- /* Get SupportMediaPacketPreviewCb value from INI */
- _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "SupportMediaPacketPreviewCb",
- &(hcamcorder->support_media_packet_preview_cb));
-
- /* Get UseVideoconvert value from INI */
- _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
- "UseVideoconvert",
- &hcamcorder->use_videoconvert);
+ if (hcamcorder->conf_main)
+ _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_main);
- ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
- MMCAM_CAMERA_WIDTH, &resolution_width,
- MMCAM_CAMERA_HEIGHT, &resolution_height,
- NULL);
+ return;
+}
- 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);
+/*---------------------------------------------------------------------------------------
+| GLOBAL FUNCTION DEFINITIONS: |
+---------------------------------------------------------------------------------------*/
+/* Internal command functions {*/
+int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
+{
+ int ret = MM_ERROR_NONE;
+ mmf_camcorder_t *hcamcorder = NULL;
- 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("Entered");
- _mmcam_dbg_log("camera_default_flip : [%d]", camera_default_flip);
- }
+ mmf_return_val_if_fail(handle && info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
- mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
- MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
- MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction,
- MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture,
- MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording,
- MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation,
- MMCAM_SUPPORT_ZSL_CAPTURE, hcamcorder->support_zsl_capture,
- MMCAM_SUPPORT_ZERO_COPY_FORMAT, hcamcorder->use_zero_copy_format,
- MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB, hcamcorder->support_media_packet_preview_cb,
- MMCAM_CAMERA_FPS, fps_info.int_array.def,
- MMCAM_DISPLAY_FLIP, camera_default_flip,
- MMCAM_CAPTURE_SOUND_ENABLE, play_capture_sound,
- NULL);
- if (err_attr_name) {
- _mmcam_dbg_err("Set %s FAILED.", err_attr_name);
- SAFE_FREE(err_attr_name);
- ret = MM_ERROR_CAMCORDER_INTERNAL;
- goto _ERR_DEFAULT_VALUE_INIT;
- }
+ /* check device type */
+ if (info->videodev_type < MM_VIDEO_DEVICE_NONE ||
+ info->videodev_type >= MM_VIDEO_DEVICE_NUM) {
+ _mmcam_dbg_err("video device type[%d] is out of range.", info->videodev_type);
+ return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
+ }
- /* 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;
+ /* init handle */
+ ret = __mmcamcorder_init_handle(&hcamcorder, info->videodev_type);
+ if (ret != MM_ERROR_NONE)
+ return ret;
+
+ /* get DPM handle for camera/microphone restriction */
+ hcamcorder->dpm_handle = dpm_manager_create();
+
+ _mmcam_dbg_warn("DPM handle %p", hcamcorder->dpm_handle);
+
+ if (hcamcorder->device_type != MM_VIDEO_DEVICE_NONE) {
+ ret = __mmcamcorder_init_configure_video_capture(hcamcorder);
+ if (ret != MM_ERROR_NONE) {
goto _ERR_DEFAULT_VALUE_INIT;
}
- _mmcam_dbg_log("Default brightness : %d", hcamcorder->brightness_default);
-
/* add DPM camera policy changed callback */
if (hcamcorder->dpm_handle) {
ret = dpm_add_policy_changed_cb(hcamcorder->dpm_handle, "camera",
}
#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
} 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);
+ ret = __mmcamcorder_init_configure_audio(hcamcorder);
if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("there is no audio device");
- ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
goto _ERR_DEFAULT_VALUE_INIT;
}
}
traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:CREATE:INIT_GSTREAMER");
- ret = __mmcamcorder_gstreamer_init(hcamcorder->conf_main);
+ ret = __mmcamcorder_init_gstreamer(hcamcorder->conf_main);
traceEnd(TTRACE_TAG_CAMERA);
/* Disable attributes in each model */
_mmcamcorder_set_disabled_attributes((MMHandleType)hcamcorder);
- /* Get videosink name for evas surface */
- _mmcamcorder_conf_get_element((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
- "VideosinkElementEvas",
- &EvasSurfaceElement);
- if (EvasSurfaceElement) {
- int attr_index = 0;
- const char *evassink_name = NULL;
- mmf_attribute_t *item_evassink_name = NULL;
- mmf_attrs_t *attrs = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(hcamcorder);
-
- _mmcamcorder_conf_get_value_element_name(EvasSurfaceElement, &evassink_name);
- mm_attrs_get_index((MMHandleType)attrs, MMCAM_DISPLAY_EVAS_SURFACE_SINK, &attr_index);
- item_evassink_name = &attrs->items[attr_index];
- mmf_attribute_set_string(item_evassink_name, evassink_name, strlen(evassink_name));
- mmf_attribute_commit(item_evassink_name);
-
- _mmcam_dbg_log("Evassink name : %s", evassink_name);
- }
-
- /* get shutter sound policy */
- vconf_get_int(VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY, &hcamcorder->shutter_sound_policy);
- _mmcam_dbg_log("current shutter sound policy : %d", hcamcorder->shutter_sound_policy);
-
- /* get model name */
- sys_info_ret = system_info_get_platform_string("http://tizen.org/system/model_name", &hcamcorder->model_name);
-
- _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);
-
- _mmcam_dbg_warn("software version [%s], ret 0x%x",
- hcamcorder->software_version ? hcamcorder->software_version : "NULL", sys_info_ret);
+ /* get system information */
+ __mmcamcorder_get_system_info(hcamcorder);
/* Set initial state */
_mmcamcorder_set_state((MMHandleType)hcamcorder, MM_CAMCORDER_STATE_NULL);
}
dpm_manager_destroy(hcamcorder->dpm_handle);
- hcamcorder->dpm_handle = NULL;
- }
-
- /* Remove attributes */
- if (hcamcorder->attributes) {
- _mmcamcorder_dealloc_attribute((MMHandleType)hcamcorder, hcamcorder->attributes);
- hcamcorder->attributes = 0;
- }
-
- /* Release lock, cond */
- g_mutex_clear(&(hcamcorder->mtsafe).lock);
- g_cond_clear(&(hcamcorder->mtsafe).cond);
- g_mutex_clear(&(hcamcorder->mtsafe).cmd_lock);
- g_cond_clear(&(hcamcorder->mtsafe).cmd_cond);
- g_mutex_clear(&(hcamcorder->mtsafe).interrupt_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).state_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).gst_state_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).gst_encode_state_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).message_cb_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).vcapture_cb_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).mstream_cb_lock);
-#ifdef _MMCAMCORDER_MM_RM_SUPPORT
- g_mutex_clear(&(hcamcorder->mtsafe).resource_lock);
-#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
-
- g_mutex_clear(&hcamcorder->snd_info.open_mutex);
- g_cond_clear(&hcamcorder->snd_info.open_cond);
- g_mutex_clear(&hcamcorder->restart_preview_lock);
-
- if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
- g_mutex_clear(&hcamcorder->gdbus_info_sound.sync_mutex);
- g_cond_clear(&hcamcorder->gdbus_info_sound.sync_cond);
- g_mutex_clear(&hcamcorder->gdbus_info_solo_sound.sync_mutex);
- g_cond_clear(&hcamcorder->gdbus_info_solo_sound.sync_cond);
- }
-
- if (hcamcorder->conf_ctrl)
- _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_ctrl);
-
- if (hcamcorder->conf_main)
- _mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_main);
-
- if (hcamcorder->model_name) {
- free(hcamcorder->model_name);
- hcamcorder->model_name = NULL;
- }
-
- if (hcamcorder->software_version) {
- free(hcamcorder->software_version);
- hcamcorder->software_version = NULL;
+ hcamcorder->dpm_handle = NULL;
}
- if (hcamcorder->task_thread) {
- g_mutex_lock(&hcamcorder->task_thread_lock);
- _mmcam_dbg_log("send signal for task thread exit");
- hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT;
- g_cond_signal(&hcamcorder->task_thread_cond);
- g_mutex_unlock(&hcamcorder->task_thread_lock);
- g_thread_join(hcamcorder->task_thread);
- hcamcorder->task_thread = NULL;
- }
- g_mutex_clear(&hcamcorder->task_thread_lock);
- g_cond_clear(&hcamcorder->task_thread_cond);
+ /* release configure info */
+ __mmcamcorder_deinit_configure(hcamcorder);
- /* Release handle */
- memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
- free(hcamcorder);
+ /* deinitialize handle */
+ __mmcamcorder_deinit_handle(hcamcorder);
return ret;
}
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
- /* set exit state for sound thread */
- g_mutex_lock(&hcamcorder->task_thread_lock);
- _mmcam_dbg_log("send signal for task thread exit");
- hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT;
- g_cond_signal(&hcamcorder->task_thread_cond);
- g_mutex_unlock(&hcamcorder->task_thread_lock);
-
/* remove kept, but not used sink element in attribute */
mm_camcorder_get_attributes(handle, NULL,
MMCAM_DISPLAY_REUSE_ELEMENT, &sink_element, &sink_element_size,
hcamcorder->setting_event_id = 0;
}
- /* Remove attributes */
- if (hcamcorder->attributes) {
- _mmcamcorder_dealloc_attribute(handle, hcamcorder->attributes);
- hcamcorder->attributes = 0;
- }
-
- /* Remove exif info */
- if (hcamcorder->exif_info) {
- mm_exif_destory_exif_info(hcamcorder->exif_info);
- hcamcorder->exif_info = NULL;
- }
-
- /* Release configure info */
- if (hcamcorder->conf_ctrl)
- _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl);
-
- if (hcamcorder->conf_main)
- _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_main);
-
/* Remove messages which are not called yet */
_mmcamcorder_remove_message_all(handle);
}
#endif /* _MMCAMCORDER_RM_SUPPORT */
- /* release model_name */
- if (hcamcorder->model_name) {
- free(hcamcorder->model_name);
- hcamcorder->model_name = NULL;
- }
-
- if (hcamcorder->software_version) {
- free(hcamcorder->software_version);
- hcamcorder->software_version = NULL;
- }
-
/* release DPM handle */
if (hcamcorder->dpm_handle) {
_mmcam_dbg_log("release DPM handle %p, camera changed cb id %d",
hcamcorder->dpm_handle = NULL;
}
- /* join task thread */
- _mmcam_dbg_log("task thread join");
- g_thread_join(hcamcorder->task_thread);
- hcamcorder->task_thread = NULL;
-
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
- /* Release lock, cond */
- g_mutex_clear(&(hcamcorder->mtsafe).lock);
- g_cond_clear(&(hcamcorder->mtsafe).cond);
- g_mutex_clear(&(hcamcorder->mtsafe).cmd_lock);
- g_cond_clear(&(hcamcorder->mtsafe).cmd_cond);
- g_mutex_clear(&(hcamcorder->mtsafe).interrupt_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).state_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).gst_state_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).gst_encode_state_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).message_cb_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).vcapture_cb_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock);
- g_mutex_clear(&(hcamcorder->mtsafe).mstream_cb_lock);
-#ifdef _MMCAMCORDER_MM_RM_SUPPORT
- g_mutex_clear(&(hcamcorder->mtsafe).resource_lock);
-#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
-
- g_mutex_clear(&hcamcorder->snd_info.open_mutex);
- g_cond_clear(&hcamcorder->snd_info.open_cond);
- g_mutex_clear(&hcamcorder->restart_preview_lock);
- g_mutex_clear(&hcamcorder->task_thread_lock);
- g_cond_clear(&hcamcorder->task_thread_cond);
-
- if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
- g_mutex_clear(&hcamcorder->gdbus_info_sound.sync_mutex);
- g_cond_clear(&hcamcorder->gdbus_info_sound.sync_cond);
- g_mutex_clear(&hcamcorder->gdbus_info_solo_sound.sync_mutex);
- g_cond_clear(&hcamcorder->gdbus_info_solo_sound.sync_cond);
- }
-
- /* Release handle */
- memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
- free(hcamcorder);
+ __mmcamcorder_deinit_handle(hcamcorder);
return MM_ERROR_NONE;
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,
+ 1,
&hcamcorder->camera_resource);
if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
_mmcam_dbg_err("could not prepare for camera resource");
#endif /* _MMCAMCORDER_MM_RM_SUPPORT */
#ifdef _MMCAMCORDER_RM_SUPPORT
- mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CLIENT_PID, &app_pid,
- NULL);
- rci.app_pid = app_pid;
- aul_app_get_appid_bypid(rci.app_pid, rci.app_id, sizeof(rci.app_id));
-
- /* RM register */
- if (hcamcorder->rm_handle == 0) {
- iret = rm_register((rm_resource_cb)_mmcamcorder_rm_callback, (void*)hcamcorder, &(hcamcorder->rm_handle), &rci);
- if (iret != RM_OK) {
- _mmcam_dbg_err("rm_register fail");
- ret = MM_ERROR_RESOURCE_INTERNAL;
- goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ if (display_surface_type != MM_DISPLAY_SURFACE_NULL) {
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_CLIENT_PID, &app_pid,
+ NULL);
+ rci.app_pid = app_pid;
+ aul_app_get_appid_bypid(rci.app_pid, rci.app_id, sizeof(rci.app_id));
+
+ /* RM register */
+ if (hcamcorder->rm_handle == 0) {
+ iret = rm_register((rm_resource_cb)_mmcamcorder_rm_callback, (void*)hcamcorder, &(hcamcorder->rm_handle), &rci);
+ if (iret != RM_OK) {
+ _mmcam_dbg_err("rm_register fail");
+ ret = MM_ERROR_RESOURCE_INTERNAL;
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ }
}
- }
- mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_FORMAT, &preview_format,
- NULL);
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_CAMERA_FORMAT, &preview_format,
+ NULL);
- resource_count = 0;
- memset(&hcamcorder->request_resources, 0x0, sizeof(rm_category_request_s));
- memset(&hcamcorder->returned_devices, 0x0, sizeof(rm_device_return_s));
+ resource_count = 0;
+ memset(&hcamcorder->request_resources, 0x0, sizeof(rm_category_request_s));
+ memset(&hcamcorder->returned_devices, 0x0, sizeof(rm_device_return_s));
- if (preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
- hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
- hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER;
+ if (preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+ hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
+ hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER;
- _mmcam_dbg_log("request dec rsc - category 0x%x", RM_CATEGORY_VIDEO_DECODER);
+ _mmcam_dbg_log("request dec rsc - category 0x%x", RM_CATEGORY_VIDEO_DECODER);
- resource_count++;
- }
+ resource_count++;
+ }
- if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
- hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
- hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER;
+ if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
+ hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
+ hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER;
- _mmcam_dbg_log("request scaler rsc - category 0x%x", RM_CATEGORY_SCALER);
+ _mmcam_dbg_log("request scaler rsc - category 0x%x", RM_CATEGORY_SCALER);
- resource_count++;
- }
+ resource_count++;
+ }
- hcamcorder->request_resources.request_num = resource_count;
+ hcamcorder->request_resources.request_num = resource_count;
- if (resource_count > 0) {
- qret = rm_query(hcamcorder->rm_handle, RM_QUERY_ALLOCATION, &(hcamcorder->request_resources), &qret_avail);
- if (qret != RM_OK || qret_avail != 1) {
- _mmcam_dbg_log("rm query failed. retry with sub devices");
+ if (resource_count > 0) {
+ qret = rm_query(hcamcorder->rm_handle, RM_QUERY_ALLOCATION, &(hcamcorder->request_resources), &qret_avail);
+ if (qret != RM_OK || qret_avail != 1) {
+ _mmcam_dbg_log("rm query failed. retry with sub devices");
- resource_count = 0;
+ resource_count = 0;
- if (preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
- hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER_SUB;
- _mmcam_dbg_log("request dec rsc - category 0x%x", RM_CATEGORY_VIDEO_DECODER_SUB);
- resource_count++;
- }
+ if (preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+ hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER_SUB;
+ _mmcam_dbg_log("request dec rsc - category 0x%x", RM_CATEGORY_VIDEO_DECODER_SUB);
+ resource_count++;
+ }
- if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
- hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER_SUB;
- _mmcam_dbg_log("request scaler rsc - category 0x%x", RM_CATEGORY_SCALER_SUB);
- resource_count++;
+ if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
+ hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER_SUB;
+ _mmcam_dbg_log("request scaler rsc - category 0x%x", RM_CATEGORY_SCALER_SUB);
+ resource_count++;
+ }
}
}
- }
- hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
- hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_CAMERA;
+ hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
+ hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_CAMERA;
- hcamcorder->request_resources.request_num = resource_count + 1;
- _mmcam_dbg_log("request camera rsc - category 0x%x", RM_CATEGORY_CAMERA);
+ hcamcorder->request_resources.request_num = resource_count + 1;
+ _mmcam_dbg_log("request camera rsc - category 0x%x", RM_CATEGORY_CAMERA);
- iret = rm_allocate_resources(hcamcorder->rm_handle, &(hcamcorder->request_resources), &hcamcorder->returned_devices);
- if (iret != RM_OK) {
- _mmcam_dbg_err("Resource allocation request failed");
- ret = MM_ERROR_RESOURCE_INTERNAL;
- goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ iret = rm_allocate_resources(hcamcorder->rm_handle, &(hcamcorder->request_resources), &hcamcorder->returned_devices);
+ if (iret != RM_OK) {
+ _mmcam_dbg_err("Resource allocation request failed");
+ ret = MM_ERROR_RESOURCE_INTERNAL;
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ }
}
#endif /* _MMCAMCORDER_RM_SUPPORT */
}
/*-----------------------------------------------
| CAMCORDER INTERNAL LOCAL |
-----------------------------------------------*/
-static gboolean
-__mmcamcorder_gstreamer_init(camera_conf * conf)
+static gboolean __mmcamcorder_init_gstreamer(camera_conf *conf)
{
static const int max_argc = 10;
int i = 0;
}
-GstBusSyncReply _mmcamcorder_encode_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data)
+static GstBusSyncReply __mmcamcorder_gst_handle_sync_audio_error(mmf_camcorder_t *hcamcorder, gint err_code)
{
- GstElement *element = NULL;
- GError *err = NULL;
- gchar *debug_info = NULL;
+ _MMCamcorderMsgItem msg;
- mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
+ if (!hcamcorder) {
+ _mmcam_dbg_err("NULL handle");
+ return GST_BUS_PASS;
+ }
+
+ switch (err_code) {
+ case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
+ case GST_RESOURCE_ERROR_OPEN_WRITE:
+ _mmcam_dbg_err("audio device [open failed]");
+
+ /* post error to application */
+ hcamcorder->error_occurs = TRUE;
+ hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
+
+ msg.id = MM_MESSAGE_CAMCORDER_ERROR;
+ msg.param.code = hcamcorder->error_code;
+
+ _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
+
+ _mmcam_dbg_err("error : sc->error_occurs %d", hcamcorder->error_occurs);
+
+ return GST_BUS_DROP;
+ default:
+ break;
+ }
+
+ return GST_BUS_PASS;
+}
+
+
+static GstBusSyncReply __mmcamcorder_gst_handle_sync_others_error(mmf_camcorder_t *hcamcorder, gint err_code)
+{
+ gboolean b_commiting = FALSE;
+ storage_state_e storage_state = STORAGE_STATE_UNMOUNTABLE;
+ _MMCamcorderMsgItem msg;
_MMCamcorderSubContext *sc = NULL;
- mmf_return_val_if_fail(hcamcorder, GST_BUS_PASS);
- mmf_return_val_if_fail(message, GST_BUS_PASS);
+ if (!hcamcorder) {
+ _mmcam_dbg_err("NULL handle");
+ return GST_BUS_PASS;
+ }
sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
mmf_return_val_if_fail(sc, GST_BUS_PASS);
- if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_EOS) {
- _mmcam_dbg_log("got EOS from pipeline");
+ 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);
+ _MMCAMCORDER_LOCK(hcamcorder);
- sc->bget_eos = TRUE;
- _MMCAMCORDER_SIGNAL(hcamcorder);
+ switch (err_code) {
+ case GST_RESOURCE_ERROR_WRITE:
+ storage_get_state(hcamcorder->storage_info.id, &storage_state);
+ if (storage_state == STORAGE_STATE_REMOVED ||
+ storage_state == STORAGE_STATE_UNMOUNTABLE) {
+ _mmcam_dbg_err("storage was removed! [storage state %d]", storage_state);
+ hcamcorder->error_code = MM_ERROR_OUT_OF_STORAGE;
+ } else {
+ _mmcam_dbg_err("File write error, storage state %d", storage_state);
+ hcamcorder->error_code = MM_ERROR_FILE_WRITE;
+ }
+
+ if (sc->ferror_send == FALSE) {
+ sc->ferror_send = TRUE;
+ } else {
+ _mmcam_dbg_err("error was already sent");
+ _MMCAMCORDER_UNLOCK(hcamcorder);
+ return GST_BUS_DROP;
+ }
+ 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);
- goto DROP_MESSAGE;
- } else if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) {
- _MMCamcorderMsgItem msg;
+ msg.id = MM_MESSAGE_CAMCORDER_ERROR;
+ msg.param.code = hcamcorder->error_code;
- /* parse error message */
- gst_message_parse_error(message, &err, &debug_info);
+ _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
+ }
- if (debug_info) {
- _mmcam_dbg_err("GST ERROR : %s", debug_info);
- g_free(debug_info);
- debug_info = NULL;
- }
+ return GST_BUS_DROP;
+}
- if (!err) {
- _mmcam_dbg_warn("failed to parse error message");
- return GST_BUS_PASS;
- }
- /* set videosrc element to compare */
- element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst);
+static GstBusSyncReply __mmcamcorder_handle_gst_sync_error(mmf_camcorder_t *hcamcorder, GstMessage *message)
+{
+ GError *err = NULL;
+ gchar *debug_info = NULL;
+ GstBusSyncReply ret = GST_BUS_PASS;
+ _MMCamcorderSubContext *sc = NULL;
- /* check domain[RESOURCE] and element[AUDIOSRC] */
- if (err->domain == GST_RESOURCE_ERROR &&
- GST_ELEMENT_CAST(message->src) == element) {
- switch (err->code) {
- case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
- case GST_RESOURCE_ERROR_OPEN_WRITE:
- _mmcam_dbg_err("audio device [open failed]");
+ if (!message || !hcamcorder) {
+ _mmcam_dbg_err("NULL message(%p) or handle(%p)", message, hcamcorder);
+ return GST_BUS_PASS;
+ }
- /* post error to application */
- hcamcorder->error_occurs = TRUE;
- hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
+ sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
+ mmf_return_val_if_fail(sc, GST_BUS_PASS);
- msg.id = MM_MESSAGE_CAMCORDER_ERROR;
- msg.param.code = hcamcorder->error_code;
+ /* parse error message */
+ gst_message_parse_error(message, &err, &debug_info);
- _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
+ if (debug_info) {
+ _mmcam_dbg_err("GST ERROR : %s", debug_info);
+ g_free(debug_info);
+ debug_info = NULL;
+ }
- _mmcam_dbg_err(" error : sc->error_occurs %d", hcamcorder->error_occurs);
+ if (!err) {
+ _mmcam_dbg_warn("failed to parse error message");
+ return GST_BUS_PASS;
+ }
- goto DROP_MESSAGE;
- default:
- break;
- }
- } else {
- gboolean b_commiting = FALSE;
- storage_state_e storage_state = STORAGE_STATE_UNMOUNTABLE;
+ /* check domain[RESOURCE] and element[AUDIOSRC] */
+ if (err->domain == GST_RESOURCE_ERROR &&
+ GST_ELEMENT_CAST(message->src) == GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst))
+ ret = __mmcamcorder_gst_handle_sync_audio_error(hcamcorder, err->code);
+ else
+ ret = __mmcamcorder_gst_handle_sync_others_error(hcamcorder, err->code);
- 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;
- }
+ g_error_free(err);
- _MMCAMCORDER_LOCK(hcamcorder);
+ return ret;
+}
- switch (err->code) {
- case GST_RESOURCE_ERROR_WRITE:
- storage_get_state(hcamcorder->storage_info.id, &storage_state);
- if (storage_state == STORAGE_STATE_REMOVED ||
- storage_state == STORAGE_STATE_UNMOUNTABLE) {
- _mmcam_dbg_err("storage was removed! [storage state %d]", storage_state);
- hcamcorder->error_code = MM_ERROR_OUT_OF_STORAGE;
- } else {
- _mmcam_dbg_err("File write error, storage state %d", storage_state);
- hcamcorder->error_code = MM_ERROR_FILE_WRITE;
- }
- if (sc->ferror_send == FALSE) {
- sc->ferror_send = TRUE;
- } else {
- _mmcam_dbg_err("error was already sent");
- _MMCAMCORDER_UNLOCK(hcamcorder);
- goto DROP_MESSAGE;
- }
- 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;
- }
+GstBusSyncReply _mmcamcorder_encode_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data)
+{
+ GstBusSyncReply ret = GST_BUS_PASS;
+ GstElement *element = NULL;
- if (b_commiting) {
- _MMCAMCORDER_SIGNAL(hcamcorder);
- _MMCAMCORDER_UNLOCK(hcamcorder);
- } else {
- _MMCAMCORDER_UNLOCK(hcamcorder);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
+ _MMCamcorderSubContext *sc = NULL;
- msg.id = MM_MESSAGE_CAMCORDER_ERROR;
- msg.param.code = hcamcorder->error_code;
+ mmf_return_val_if_fail(hcamcorder, GST_BUS_PASS);
+ mmf_return_val_if_fail(message, GST_BUS_PASS);
- _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
- }
+ sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
+ mmf_return_val_if_fail(sc, GST_BUS_PASS);
- goto DROP_MESSAGE;
- }
- }
+ if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_EOS) {
+ _mmcam_dbg_log("got EOS from pipeline");
- if (err) {
- g_error_free(err);
- err = NULL;
- }
+ _MMCAMCORDER_LOCK(hcamcorder);
- return GST_BUS_PASS;
+ sc->bget_eos = TRUE;
+ _MMCAMCORDER_SIGNAL(hcamcorder);
-DROP_MESSAGE:
- if (err) {
- g_error_free(err);
- err = NULL;
+ _MMCAMCORDER_UNLOCK(hcamcorder);
+
+ ret = GST_BUS_DROP;
+ } else if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) {
+ ret = __mmcamcorder_handle_gst_sync_error(hcamcorder, message);
}
- gst_message_unref(message);
- message = NULL;
+ if (ret == GST_BUS_DROP) {
+ gst_message_unref(message);
+ message = NULL;
+ }
- return GST_BUS_DROP;
+ return ret;
}
#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)
+ mm_resource_manager_res_h res, void *user_data)
{
mmf_camcorder_t *hcamcorder = (mmf_camcorder_t *) user_data;
projects / platform / core / multimedia / libmm-camcorder.git / blobdiff