X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_stillshot.c;h=1b718bfc26d977d0cf9671fa9c1afa7d99b8e5fa;hb=aa254c75e23e89333f23a3f97d6e4222eb2e3f9e;hp=d67f67e3f6024dae9434aa228920eef45c819659;hpb=ce9178f9c1138060a1f0deff25db03e2707d1472;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git diff --git a/src/mm_camcorder_stillshot.c b/src/mm_camcorder_stillshot.c index d67f67e..1b718bf 100644 --- a/src/mm_camcorder_stillshot.c +++ b/src/mm_camcorder_stillshot.c @@ -38,11 +38,13 @@ /*--------------------------------------------------------------------------------------- | GLOBAL VARIABLE DEFINITIONS for internal | ---------------------------------------------------------------------------------------*/ -#define EXIF_SET_ERR( return_type,tag_id) \ - _mmcam_dbg_err("error=%x,tag=%x",return_type,tag_id); \ +#define EXIF_SET_ERR(return_type, tag_id) \ +do { \ + _mmcam_dbg_err("error=%x,tag=%x", return_type, tag_id); \ if (return_type == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) { \ goto exit; \ - } + } \ +} while (0) /*--------------------------------------------------------------------------------------- | LOCAL VARIABLE DEFINITIONS for internal | @@ -102,16 +104,15 @@ int _mmcamcorder_create_stillshot_pipeline(MMHandleType handle) _MMCAMCORDER_PIPELINE_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCODE_MAIN_PIPE, "capture_pipeline", err); err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder, MM_CAMCORDER_ENCBIN_PROFILE_IMAGE); - if (err != MM_ERROR_NONE) { + if (err != MM_ERROR_NONE) return err; - } /* add element and encodesink bin to encode main pipeline */ gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst), - sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst, - sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst, - sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, - NULL); + sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst, + sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst, + sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, + NULL); /* Link each element : appsrc - capsfilter - encodesink bin */ srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst, "src"); @@ -124,9 +125,9 @@ int _mmcamcorder_create_stillshot_pipeline(MMHandleType handle) /* connect handoff signal to get capture data */ MMCAMCORDER_SIGNAL_CONNECT(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, - _MMCAMCORDER_HANDLER_STILLSHOT, "handoff", - G_CALLBACK(__mmcamcorder_handoff_callback), - hcamcorder); + _MMCAMCORDER_HANDLER_STILLSHOT, "handoff", + G_CALLBACK(__mmcamcorder_handoff_callback), + hcamcorder); return MM_ERROR_NONE; @@ -150,9 +151,9 @@ int _mmcamcorder_connect_capture_signal(MMHandleType handle) if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) { _mmcam_dbg_warn("connect capture signal to _MMCAMCORDER_VIDEOSRC_SRC"); MMCAMCORDER_SIGNAL_CONNECT(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, - _MMCAMCORDER_HANDLER_STILLSHOT, "still-capture", - G_CALLBACK(__mmcamcorder_image_capture_cb), - hcamcorder); + _MMCAMCORDER_HANDLER_STILLSHOT, "still-capture", + G_CALLBACK(__mmcamcorder_image_capture_cb), + hcamcorder); return MM_ERROR_NONE; } else { @@ -211,6 +212,11 @@ void _mmcamcorder_destroy_video_capture_pipeline(MMHandleType handle) { mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; + int display_reuse_hint = FALSE; + GstElement *sink_element = NULL; + mmf_attrs_t *attrs = NULL; + int attr_index = 0; + mmf_attribute_t *attr_item = NULL; mmf_return_if_fail(hcamcorder); @@ -223,6 +229,52 @@ void _mmcamcorder_destroy_video_capture_pipeline(MMHandleType handle) MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE); MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE); + /* check reuse flag for display element */ + mm_camcorder_get_attributes(handle, NULL, + MMCAM_DISPLAY_REUSE_HINT, &display_reuse_hint, + NULL); + + _mmcam_dbg_log("display reuse hint %d", display_reuse_hint); + + if (!display_reuse_hint) + goto _REUSE_CHECK_DONE; + + sink_element = sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst; + if (!sink_element) { + _mmcam_dbg_warn("sink element is NULL"); + goto _REUSE_CHECK_DONE; + } + + attrs = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle); + if (!attrs) { + _mmcam_dbg_warn("attribute is NULL"); + goto _REUSE_CHECK_DONE; + } + + _mmcam_dbg_log("REF sink element %p and set it to attribute", sink_element); + + /* ref element before remove it from pipeline */ + gst_object_ref(sink_element); + + if (!gst_bin_remove(GST_BIN(sc->element[_MMCAMCORDER_MAIN_PIPE].gst), sink_element)) + _mmcam_dbg_warn("failed to remove sink element from pipeline"); + + /* reset floating reference flag to avoid leak after next use */ + g_object_force_floating(G_OBJECT(sink_element)); + + /* set sink element pointer to attribute */ + mm_attrs_get_index((MMHandleType)attrs, MMCAM_DISPLAY_REUSE_ELEMENT, &attr_index); + attr_item = &attrs->items[attr_index]; + mmf_attribute_set_data(attr_item, (void *)sink_element, sizeof(*sink_element)); + mmf_attribute_commit(attr_item); + + /* remove notify callback */ + g_object_weak_unref(G_OBJECT(sink_element), (GWeakNotify)_mmcamcorder_element_release_noti, sc); + + sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst = NULL; + sc->element[_MMCAMCORDER_VIDEOSINK_SINK].id = _MMCAMCORDER_NONE; + +_REUSE_CHECK_DONE: traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:UNREALIZE:SET_NULL_TO_PIPELINE"); _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_NULL); @@ -284,14 +336,14 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) } _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_CAPTURE, - "UseCaptureMode", - &UseCaptureMode); + CONFIGURE_CATEGORY_MAIN_CAPTURE, + "UseCaptureMode", + &UseCaptureMode); _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, - "VideosrcElement", - &VideosrcElement); + CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, + "VideosrcElement", + &VideosrcElement); _mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name); @@ -302,22 +354,21 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) info->capturing = TRUE; ret = mm_camcorder_get_attributes(handle, &err_name, - MMCAM_IMAGE_ENCODER, &image_encoder, - MMCAM_CAMERA_WIDTH, &width, - MMCAM_CAMERA_HEIGHT, &height, - MMCAM_CAMERA_FPS, &fps, - MMCAM_CAPTURE_FORMAT, &cap_format, - MMCAM_CAPTURE_WIDTH, &info->width, - MMCAM_CAPTURE_HEIGHT, &info->height, - MMCAM_CAPTURE_COUNT, &info->count, - MMCAM_CAPTURE_INTERVAL, &info->interval, - MMCAM_STROBE_MODE, &strobe_mode, - MMCAM_TAG_ORIENTATION, &tag_orientation, - NULL); + MMCAM_IMAGE_ENCODER, &image_encoder, + MMCAM_CAMERA_WIDTH, &width, + MMCAM_CAMERA_HEIGHT, &height, + MMCAM_CAMERA_FPS, &fps, + MMCAM_CAPTURE_FORMAT, &cap_format, + MMCAM_CAPTURE_WIDTH, &info->width, + MMCAM_CAPTURE_HEIGHT, &info->height, + MMCAM_CAPTURE_COUNT, &info->count, + MMCAM_CAPTURE_INTERVAL, &info->interval, + MMCAM_STROBE_MODE, &strobe_mode, + MMCAM_TAG_ORIENTATION, &tag_orientation, + NULL); if (err_name) { _mmcam_dbg_warn("get_attributes err %s, ret 0x%x", err_name, ret); - free(err_name); - err_name = NULL; + SAFE_FREE(err_name); } ret = MM_ERROR_NONE; @@ -335,16 +386,12 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) info->multi_shot_stop = FALSE; /* sound init to pause other session */ -#ifdef _MMCAMCORDER_UPLOAD_SAMPLE - _mmcamcorder_sound_init(handle, _MMCAMCORDER_FILEPATH_CAPTURE2_SND); -#else /* _MMCAMCORDER_UPLOAD_SAMPLE */ _mmcamcorder_sound_init(handle); -#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */ } _mmcam_dbg_log("preview(%dx%d,fmt:%d), capture(%dx%d,fmt:%d), count(%d), hdr mode(%d), interval (%d)", - width, height, info->preview_format, info->width, info->height, cap_format, - info->count, info->hdr_capture_mode, info->interval); + width, height, info->preview_format, info->width, info->height, cap_format, + info->count, info->hdr_capture_mode, info->interval); /* check state */ if (current_state >= MM_CAMCORDER_STATE_RECORDING) { @@ -380,19 +427,18 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) /* Check encoding method */ if (cap_format == MM_PIXEL_FORMAT_ENCODED) { if ((sc->SensorEncodedCapture && info->type == _MMCamcorder_SINGLE_SHOT) || - (sc->SensorEncodedCapture && sc->info_video->support_dual_stream) || - is_modified_size) { + hcamcorder->support_zsl_capture || is_modified_size) { cap_fourcc = _mmcamcorder_get_fourcc(cap_format, image_encoder, hcamcorder->use_zero_copy_format); _mmcam_dbg_log("Sensor JPEG Capture [is_modified_size:%d]", is_modified_size); } else { /* no need to encode internally if ITLV format */ - if (info->preview_format != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) { + if (info->preview_format != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) sc->internal_encode = TRUE; - } + cap_fourcc = _mmcamcorder_get_fourcc(info->preview_format, image_encoder, hcamcorder->use_zero_copy_format); _mmcam_dbg_log("MSL JPEG Capture : capture fourcc %c%c%c%c", - cap_fourcc, cap_fourcc>>8, cap_fourcc>>16, cap_fourcc>>24); + cap_fourcc, cap_fourcc>>8, cap_fourcc>>16, cap_fourcc>>24); } } else { cap_fourcc = _mmcamcorder_get_fourcc(cap_format, MM_IMAGE_CODEC_INVALID, hcamcorder->use_zero_copy_format); @@ -426,13 +472,11 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) } if (UseCaptureMode) { - if (width != MMFCAMCORDER_HIGHQUALITY_WIDTH || height != MMFCAMCORDER_HIGHQUALITY_HEIGHT) { + if (width != MMFCAMCORDER_HIGHQUALITY_WIDTH || height != MMFCAMCORDER_HIGHQUALITY_HEIGHT) need_change = 1; - } } else { - if (width != info->width || height != info->height) { + if (width != info->width || height != info->height) need_change = 1; - } } if (need_change) { @@ -446,6 +490,12 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) /* make pipeline state as READY */ ret = _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY); + /* check decoder recreation */ + if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) { + _mmcam_dbg_err("_mmcamcorder_recreate_decoder_for_encoded_preview failed"); + return MM_ERROR_CAMCORDER_INTERNAL; + } + MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE); MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE); @@ -463,12 +513,11 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) } mm_camcorder_get_attributes(handle, &err_name, - MMCAM_CAMERA_ROTATION, &rotation, - NULL); + MMCAM_CAMERA_ROTATION, &rotation, + NULL); if (err_name) { _mmcam_dbg_warn("get_attributes err %s", err_name); - free(err_name); - err_name = NULL; + SAFE_FREE(err_name); } /* set new caps */ @@ -502,19 +551,18 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) } ret = mm_camcorder_get_attributes(handle, &err_name, - MMCAM_IMAGE_ENCODER_QUALITY, &cap_jpeg_quality, - NULL); + MMCAM_IMAGE_ENCODER_QUALITY, &cap_jpeg_quality, + NULL); if (err_name) { _mmcam_dbg_warn("get_attributes err %s, ret 0x%x", err_name, ret); - free(err_name); - err_name = NULL; + SAFE_FREE(err_name); } /* set JPEG quality */ MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_IENC].gst, "quality", cap_jpeg_quality); /* set handoff signal as TRUE */ - MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,"signal-handoffs", TRUE); + MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "signal-handoffs", TRUE); MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE); /* Prepare for the shutter sound when it's the bencbin mode capture */ @@ -539,7 +587,7 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) if (current_state < MM_CAMCORDER_STATE_RECORDING && hcamcorder->support_zsl_capture == TRUE && !info->hdr_capture_mode) { - _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE); + _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE01, FALSE); } /* set flag */ @@ -550,9 +598,8 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) } cmd_done: - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) info->capturing = FALSE; - } return ret; } @@ -591,9 +638,9 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) info = sc->info_image; _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, - "VideosrcElement", - &VideosrcElement); + CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, + "VideosrcElement", + &VideosrcElement); _mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name); @@ -635,12 +682,12 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) /* This case is starting of preview */ ret = mm_camcorder_get_attributes(handle, &err_name, - MMCAM_CAMERA_FPS_AUTO, &fps_auto, - MMCAM_CAMERA_FOCUS_MODE, &focus_mode, - NULL); + MMCAM_CAMERA_FPS_AUTO, &fps_auto, + MMCAM_CAMERA_FOCUS_MODE, &focus_mode, + NULL); if (ret != MM_ERROR_NONE) { _mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, ret); - SAFE_FREE (err_name); + SAFE_FREE(err_name); } _mmcam_dbg_log("focus mode %d", focus_mode); @@ -651,11 +698,7 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) if (attr) { if (_mmcamcorder_check_supported_attribute(handle, MM_CAM_CAMERA_FOCUS_MODE)) { mmf_attribute_set_modified(&(attr->items[MM_CAM_CAMERA_FOCUS_MODE])); - if (mmf_attrs_commit((MMHandleType)attr) == -1) { - _mmcam_dbg_err("set focus mode error"); - } else { - _mmcam_dbg_log("set focus mode success"); - } + mmf_attrs_commit((MMHandleType)attr); } else { _mmcam_dbg_log("focus mode is not supported"); } @@ -680,13 +723,12 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) /* Set strobe mode - strobe mode can not be set to driver while captuing */ if (attr) { mmf_attribute_set_modified(&(attr->items[MM_CAM_STROBE_MODE])); - if (mmf_attrs_commit((MMHandleType) attr) == -1) { + if (mmf_attrs_commit((MMHandleType) attr) == -1) _mmcam_dbg_warn("Failed to set strobe mode"); - } } while (current_framecount >= sc->kpi.video_framecount && - try_count++ < _MMCAMCORDER_CAPTURE_STOP_CHECK_COUNT) { + try_count++ < _MMCAMCORDER_CAPTURE_STOP_CHECK_COUNT) { usleep(_MMCAMCORDER_CAPTURE_STOP_CHECK_INTERVAL); } } @@ -697,30 +739,41 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) } _mmcam_dbg_log("Wait Frame Done. count before[%d],after[%d], try_count[%d]", - current_framecount, sc->kpi.video_framecount, try_count); + current_framecount, sc->kpi.video_framecount, try_count); } else { ret = _mmcamcorder_remove_stillshot_pipeline(handle); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) goto cmd_error; - } if (info->resolution_change) { MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE); MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE); + ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY); + + /* check decoder recreation */ + if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) { + _mmcam_dbg_err("_mmcamcorder_recreate_decoder_for_encoded_preview failed"); + return MM_ERROR_CAMCORDER_INTERNAL; + } + MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE); MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE); - if (ret != MM_ERROR_NONE) { + + if (ret != MM_ERROR_NONE) goto cmd_error; - } /* check if resolution need to rollback */ mm_camcorder_get_attributes(handle, &err_name, - MMCAM_CAMERA_WIDTH, &width, - MMCAM_CAMERA_HEIGHT, &height, - MMCAM_CAMERA_FPS, &fps, - MMCAM_CAMERA_ROTATION, &rotation, - NULL); + MMCAM_CAMERA_WIDTH, &width, + MMCAM_CAMERA_HEIGHT, &height, + MMCAM_CAMERA_FPS, &fps, + MMCAM_CAMERA_ROTATION, &rotation, + NULL); + if (err_name) { + _mmcam_dbg_warn("get_attributes err %s, ret 0x%x", err_name, ret); + SAFE_FREE(err_name); + } /* set new caps */ ret = _mmcamcorder_set_videosrc_caps(handle, sc->fourcc, width, height, fps, rotation); @@ -731,16 +784,14 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) } ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) goto cmd_error; - } } } /* sound finalize */ - if (info->type == _MMCamcorder_MULTI_SHOT) { + if (info->type == _MMCamcorder_MULTI_SHOT) _mmcamcorder_sound_finalize(handle); - } } else { if (info->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) { MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "bitrate", H264_PREVIEW_BITRATE); @@ -756,22 +807,21 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) traceEnd(TTRACE_TAG_CAMERA); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) goto cmd_error; - } /* get sound status/volume level and register changed_cb */ if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_OFF && info->sound_status == _SOUND_STATUS_INIT) { - _mmcam_dbg_log("get sound status/volume level and register vconf changed_cb"); + _mmcam_dbg_log("register vconf changed_cb and get sound status"); + + /* register changed_cb */ + vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, __sound_status_changed_cb, hcamcorder); /* get sound status */ vconf_get_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &(info->sound_status)); _mmcam_dbg_log("sound status %d", info->sound_status); - - /* register changed_cb */ - vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, __sound_status_changed_cb, hcamcorder); } } @@ -785,6 +835,7 @@ int _mmcamcorder_image_cmd_preview_stop(MMHandleType handle) int ret = MM_ERROR_NONE; int strobe_mode = MM_CAMCORDER_STROBE_MODE_OFF; int set_strobe = 0; + int display_reuse_hint = FALSE; GstCameraControl *control = NULL; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); @@ -801,8 +852,8 @@ int _mmcamcorder_image_cmd_preview_stop(MMHandleType handle) /* check strobe and set OFF if PERMANENT mode */ mm_camcorder_get_attributes(handle, NULL, - MMCAM_STROBE_MODE, &strobe_mode, - NULL); + MMCAM_STROBE_MODE, &strobe_mode, + NULL); if (strobe_mode == MM_CAMCORDER_STROBE_MODE_PERMANENT && GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) { _mmcam_dbg_log("current strobe mode is PERMANENT, set OFF"); @@ -824,13 +875,19 @@ int _mmcamcorder_image_cmd_preview_stop(MMHandleType handle) pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst; - if(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst) { - _mmcam_dbg_log("pipeline is exist so need to remove pipeline and sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst=%p",sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst); + if (sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst) { + _mmcam_dbg_log("pipeline is exist so need to remove pipeline and sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst=%p", + sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst); _mmcamcorder_remove_recorder_pipeline(handle); } - /* Disable skip flush buffer */ - MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "enable-flush-buffer", FALSE); + mm_camcorder_get_attributes(handle, NULL, + MMCAM_DISPLAY_REUSE_HINT, &display_reuse_hint, + NULL); + + _mmcam_dbg_log("display reuse hint %d", display_reuse_hint); + + MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "keep-camera-preview", display_reuse_hint); MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE); MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE); @@ -844,8 +901,8 @@ int _mmcamcorder_image_cmd_preview_stop(MMHandleType handle) MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE); MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE); - /* Enable skip flush buffer */ - MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "enable-flush-buffer", TRUE); + if (display_reuse_hint) + MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "keep-camera-preview", FALSE); /* deregister sound status callback */ if (sc->info_image->sound_status != _SOUND_STATUS_INIT) { @@ -903,7 +960,7 @@ int _mmcamcorder_video_capture_command(MMHandleType handle, int command) } -void __mmcamcorder_init_stillshot_info (MMHandleType handle) +void __mmcamcorder_init_stillshot_info(MMHandleType handle) { mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; @@ -918,7 +975,7 @@ void __mmcamcorder_init_stillshot_info (MMHandleType handle) _mmcam_dbg_log("capture type[%d], capture send count[%d]", info->type, info->capture_send_count); - if (info->type ==_MMCamcorder_SINGLE_SHOT || info->capture_send_count == info->count) { + if (info->type == _MMCamcorder_SINGLE_SHOT || info->capture_send_count == info->count) { info->capture_cur_count = 0; info->capture_send_count = 0; info->multi_shot_stop = TRUE; @@ -947,11 +1004,13 @@ int __mmcamcorder_capture_save_exifinfo(MMHandleType handle, MMCamcorderCaptureD _mmcam_dbg_log(""); if (!original || original->data == NULL || original->length == 0) { - if (!original) { - _mmcam_dbg_log("original is null"); + if (original) { + _mmcam_dbg_err("data=%p, length=%d", + original->data, original->length); } else { - _mmcam_dbg_log("data=%p, length=%d", original->data, original->length); + _mmcam_dbg_err("original is null"); } + return MM_ERROR_CAMCORDER_INVALID_ARGUMENT; } else { /* original is input/output param. save original values to local var. */ @@ -963,17 +1022,17 @@ int __mmcamcorder_capture_save_exifinfo(MMHandleType handle, MMCamcorderCaptureD if (thumbnail) { if (thumbnail->data && thumbnail->length > 0) { _mmcam_dbg_log("thumbnail is added!thumbnail->data=%p thumbnail->width=%d ,thumbnail->height=%d", - thumbnail->data, thumbnail->width, thumbnail->height); + thumbnail->data, thumbnail->width, thumbnail->height); /* add thumbnail exif info */ ret = mm_exif_add_thumbnail_info(hcamcorder->exif_info, - thumbnail->data, - thumbnail->width, - thumbnail->height, - thumbnail->length); + thumbnail->data, + thumbnail->width, + thumbnail->height, + thumbnail->length); } else { _mmcam_dbg_err("Skip adding thumbnail (data=%p, length=%d)", - thumbnail->data, thumbnail->length); + thumbnail->data, thumbnail->length); } } } else { @@ -982,10 +1041,9 @@ int __mmcamcorder_capture_save_exifinfo(MMHandleType handle, MMCamcorderCaptureD if (ret == MM_ERROR_NONE) { /* write jpeg with exif */ - ret = mm_exif_write_exif_jpeg_to_memory(&original->data, &original->length ,hcamcorder->exif_info, data, datalen); - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("mm_exif_write_exif_jpeg_to_memory error! [0x%x]",ret); - } + ret = mm_exif_write_exif_jpeg_to_memory(&original->data, &original->length, hcamcorder->exif_info, data, datalen); + if (ret != MM_ERROR_NONE) + _mmcam_dbg_err("mm_exif_write_exif_jpeg_to_memory error! [0x%x]", ret); } _mmcam_dbg_log("END ret 0x%x", ret); @@ -1025,8 +1083,8 @@ void __mmcamcorder_get_capture_data_from_buffer(MMCamcorderCaptureDataType *capt gst_buffer_unmap(gst_sample_get_buffer(sample), &mapinfo); _mmcam_dbg_warn("buffer data[%p],size[%dx%d],length[%d],format[%d]", - capture_data->data, capture_data->width, capture_data->height, - capture_data->length, capture_data->format); + capture_data->data, capture_data->width, capture_data->height, + capture_data->length, capture_data->format); return; GET_FAILED: @@ -1052,11 +1110,10 @@ int __mmcamcorder_set_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType /* if tag enable and doesn't provide exif, we make it */ _mmcam_dbg_log("Add exif information if existed(thumbnail[%p])", thumbnail); - if (thumbnail && thumbnail->data) { + if (thumbnail && thumbnail->data) return __mmcamcorder_capture_save_exifinfo(handle, dest, thumbnail, provide_exif); - } else { + else return __mmcamcorder_capture_save_exifinfo(handle, dest, NULL, provide_exif); - } } @@ -1144,24 +1201,25 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl _mmcam_dbg_err("START - current state %d", current_state); /* check capture state */ - if (info->type == _MMCamcorder_MULTI_SHOT && info->capture_send_count > 0) { + if (info->type == _MMCamcorder_MULTI_SHOT && info->capture_send_count > 0) mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, "capture-break-cont-shot", &stop_cont_shot, NULL); - } if (!info->capturing || stop_cont_shot) { - _mmcam_dbg_warn("stop command[%d] or not capturing state[%d]. skip this...", - stop_cont_shot, info->capturing); + _mmcam_dbg_warn("stop command[%d] or not capturing state[%d]. skip this...", stop_cont_shot, info->capturing); + + /* set FALSE here for the case that info->capturing is still FALSE + (== capture_send_count is 0 at the time _mmcamcorder_commit_capture_break_cont_shot is called) */ + info->capturing = FALSE; /*free GstBuffer*/ - if (sample1) { + if (sample1) gst_sample_unref(sample1); - } - if (sample2) { + + if (sample2) gst_sample_unref(sample2); - } - if (sample3) { + + if (sample3) gst_sample_unref(sample3); - } return; } @@ -1190,28 +1248,14 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl /* play capture sound here if multi capture or preview format is ITLV(because of AF and flash control in plugin) */ if (info->type == _MMCamcorder_MULTI_SHOT) { - pthread_mutex_lock(&(hcamcorder->task_thread_lock)); + g_mutex_lock(&hcamcorder->task_thread_lock); _mmcam_dbg_log("send signal for sound play"); hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_SOUND_PLAY_START; - pthread_cond_signal(&(hcamcorder->task_thread_cond)); - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); + g_cond_signal(&hcamcorder->task_thread_cond); + g_mutex_unlock(&hcamcorder->task_thread_lock); } else if (!info->played_capture_sound) { - _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE); - } - } else { - /* Handle capture in recording case */ - hcamcorder->capture_in_recording = FALSE; - - pthread_mutex_lock(&(hcamcorder->task_thread_lock)); - - if (hcamcorder->task_thread_state == _MMCAMCORDER_TASK_THREAD_STATE_CHECK_CAPTURE_IN_RECORDING) { - _mmcam_dbg_log("send signal for capture in recording"); - pthread_cond_signal(&(hcamcorder->task_thread_cond)); - } else { - _mmcam_dbg_warn("unexpected task thread state : %d", hcamcorder->task_thread_state); + _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE01, FALSE); } - - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); } /* init capture data */ @@ -1232,25 +1276,25 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl _mmcam_dbg_err("sample1[%p] is NULL or gst_buffer_map failed", sample1); MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INTERNAL); goto error; - }else{ - if ( (mapinfo1.data == NULL) && (mapinfo1.size == 0) ){ + } else { + if ((mapinfo1.data == NULL) && (mapinfo1.size == 0)) { _mmcam_dbg_err("mapinfo1 is wrong (%p, size %d)", mapinfo1.data, mapinfo1.size); MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INTERNAL); gst_buffer_unmap(gst_sample_get_buffer(sample1), &mapinfo1); goto error; - }else + } else { __mmcamcorder_get_capture_data_from_buffer(&dest, pixtype_main, sample1); + } } - if ( !sample2 || !gst_buffer_map(gst_sample_get_buffer(sample2), &mapinfo2, GST_MAP_READ) ) { + if (!sample2 || !gst_buffer_map(gst_sample_get_buffer(sample2), &mapinfo2, GST_MAP_READ)) _mmcam_dbg_log("sample2[%p] is NULL or gst_buffer_map failed. Not Error.", sample2); - } - if ( !sample3 || !gst_buffer_map(gst_sample_get_buffer(sample3), &mapinfo3, GST_MAP_READ)) { + + if (!sample3 || !gst_buffer_map(gst_sample_get_buffer(sample3), &mapinfo3, GST_MAP_READ)) _mmcam_dbg_log("sample3[%p] is NULL or gst_buffer_map failed. Not Error.", sample3); - } /* Screennail image buffer */ - attrs = (mmf_attrs_t*)MMF_CAMCORDER_ATTRS(hcamcorder); + attrs = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(hcamcorder); mm_attrs_get_index((MMHandleType)attrs, MMCAM_CAPTURED_SCREENNAIL, &attr_index); item_screennail = &attrs->items[attr_index]; @@ -1264,7 +1308,7 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl ret = mmf_attribute_set_data(item_screennail, &scrnail, sizeof(scrnail)); _mmcam_dbg_log("Screennail set attribute data %p, size %d, ret %x", &scrnail, sizeof(scrnail), ret); } else { - _mmcam_dbg_log("Sample3 has wrong pointer. Not Error. (sample3=%p)",sample3); + _mmcam_dbg_log("Sample3 has wrong pointer. Not Error. (sample3=%p)", sample3); mmf_attribute_set_data(item_screennail, NULL, 0); } @@ -1279,7 +1323,7 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl /* Thumbnail image buffer */ if (sample2 && mapinfo2.data && (mapinfo2.size != 0)) { - _mmcam_dbg_log("Thumbnail (buffer2=%p)",gst_sample_get_buffer(sample2)); + _mmcam_dbg_log("Thumbnail (buffer2=%p)", gst_sample_get_buffer(sample2)); pixtype_thumb = _mmcamcorder_get_pixel_format(gst_sample_get_caps(sample2)); __mmcamcorder_get_capture_data_from_buffer(&thumb, pixtype_thumb, sample2); } else { @@ -1295,7 +1339,7 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl char height[10]; ExifEntry *entry = NULL; - exif_loader_write (l, dest.data, dest.length); + exif_loader_write(l, dest.data, dest.length); /* Get a pointer to the EXIF data */ ed = exif_loader_get_data(l); @@ -1305,32 +1349,28 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl l = NULL; if (ed) { entry = exif_content_get_entry(ed->ifd[EXIF_IFD_1], EXIF_TAG_IMAGE_WIDTH); - if (entry != NULL) { - exif_entry_get_value(entry,width,10); - } + if (entry != NULL) + exif_entry_get_value(entry, width, 10); + entry = NULL; entry = exif_content_get_entry(ed->ifd[EXIF_IFD_1], EXIF_TAG_IMAGE_LENGTH); - if (entry != NULL) { - exif_entry_get_value(entry,height , 10); - } + if (entry != NULL) + exif_entry_get_value(entry, height, 10); + entry = NULL; /* Make sure the image had a thumbnail before trying to write it */ if (ed->data && ed->size) { thumb.data = malloc(ed->size); - memcpy(thumb.data,ed->data,ed->size); - thumb.length = ed->size; - #if 0 - { - FILE *fp = NULL; - fp = fopen ("/opt/usr/media/thumbnail_test.jpg", "a+"); - fwrite (thumb.data, 1, thumb.length, fp); - fclose (fp); + if (thumb.data) { + memcpy(thumb.data, ed->data, ed->size); + thumb.length = ed->size; + thumb.format = MM_PIXEL_FORMAT_ENCODED; + thumb.width = atoi(width); + thumb.height = atoi(height); + internal_thumb_data = thumb.data; + } else { + _mmcam_dbg_err("failed to alloc thumbnail data"); } - #endif - thumb.format = MM_PIXEL_FORMAT_ENCODED; - thumb.width = atoi(width); - thumb.height = atoi(height); - internal_thumb_data = thumb.data; } exif_data_unref(ed); ed = NULL; @@ -1367,26 +1407,25 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl /* calculate thumbnail size */ thumb_width = THUMBNAIL_WIDTH; thumb_height = (thumb_width * encode_src.height) / encode_src.width; - if (thumb_height % 2 != 0) { + if (thumb_height % 2 != 0) thumb_height += 1; - } _mmcam_dbg_log("need to resize : thumbnail size %dx%d, format %d", - thumb_width, thumb_height, encode_src.format); + thumb_width, thumb_height, encode_src.format); if ((encode_src.format == MM_PIXEL_FORMAT_UYVY || encode_src.format == MM_PIXEL_FORMAT_YUYV) && encode_src.width % thumb_width == 0 && encode_src.height % thumb_height == 0) { if (!_mmcamcorder_downscale_UYVYorYUYV(encode_src.data, encode_src.width, encode_src.height, - &thumb_raw_data, thumb_width, thumb_height)) { + &thumb_raw_data, thumb_width, thumb_height)) { thumb_raw_data = NULL; _mmcam_dbg_warn("_mmcamcorder_downscale_UYVYorYUYV failed. skip thumbnail making..."); } } else { if (!_mmcamcorder_resize_frame(encode_src.data, encode_src.width, encode_src.height, - encode_src.length, encode_src.format, - &thumb_raw_data, &thumb_width, &thumb_height, &thumb_length)) { + encode_src.length, encode_src.format, + &thumb_raw_data, &thumb_width, &thumb_height, &thumb_length)) { thumb_raw_data = NULL; _mmcam_dbg_warn("_mmcamcorder_resize_frame failed. skip thumbnail making..."); } @@ -1403,11 +1442,10 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl if (thumb_raw_data) { ret = _mmcamcorder_encode_jpeg(thumb_raw_data, thumb_width, thumb_height, - encode_src.format, thumb_length, THUMBNAIL_JPEG_QUALITY, - (void **)&internal_thumb_data, &internal_thumb_length); + encode_src.format, thumb_length, THUMBNAIL_JPEG_QUALITY, + (void **)&internal_thumb_data, &internal_thumb_length); if (ret) { - _mmcam_dbg_log("encode THUMBNAIL done - data %p, length %d", - internal_thumb_data, internal_thumb_length); + _mmcam_dbg_log("encode THUMBNAIL done - data %p, length %d", internal_thumb_data, internal_thumb_length); thumb.data = internal_thumb_data; thumb.length = internal_thumb_length; @@ -1428,7 +1466,7 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl _mmcam_dbg_warn("thumb_raw_data is NULL"); } } else { - // no raw data src for thumbnail + /* no raw data src for thumbnail */ _mmcam_dbg_log("no need to encode thumbnail"); } } @@ -1436,13 +1474,13 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl /* Encode JPEG */ if (sc->internal_encode && pixtype_main != MM_PIXEL_FORMAT_ENCODED) { mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, - MMCAM_IMAGE_ENCODER_QUALITY, &capture_quality, - NULL); + MMCAM_IMAGE_ENCODER_QUALITY, &capture_quality, + NULL); _mmcam_dbg_log("Start Internal Encode - capture_quality %d", capture_quality); ret = _mmcamcorder_encode_jpeg(mapinfo1.data, dest.width, dest.height, - pixtype_main, dest.length, capture_quality, - (void **)&internal_main_data, &internal_main_length); + pixtype_main, dest.length, capture_quality, + (void **)&internal_main_data, &internal_main_length); if (!ret) { _mmcam_dbg_err("_mmcamcorder_encode_jpeg failed"); @@ -1460,9 +1498,9 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl } /* create EXIF info */ - if(!provide_exif){ // make new exif + if (!provide_exif) { /* make new exif */ ret = mm_exif_create_exif_info(&(hcamcorder->exif_info)); - } else { // load from jpeg buffer dest.data + } else { /* load from jpeg buffer dest.data */ ret = mm_exif_load_exif_info(&(hcamcorder->exif_info), dest.data, dest.length); if (ret != MM_ERROR_NONE) { _mmcam_dbg_err("Failed to load exif_info [%x], try to create EXIF", ret); @@ -1474,7 +1512,7 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl _mmcam_dbg_err("Failed to create exif_info [%x], but keep going...", ret); } else { /* add basic exif info */ - if(!provide_exif) { + if (!provide_exif) { _mmcam_dbg_log("add basic exif info"); ret = __mmcamcorder_set_exif_basic_info((MMHandleType)hcamcorder, dest.width, dest.height); } else { @@ -1514,11 +1552,11 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, MMCAM_TAG_ENABLE, &tag_enable, NULL); /* Set extra data for JPEG if tag enabled and doesn't provide EXIF */ - if (dest.format == MM_PIXEL_FORMAT_ENCODED){ + if (dest.format == MM_PIXEL_FORMAT_ENCODED) { if (tag_enable) { mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, - MMCAM_IMAGE_ENCODER, &codectype, - NULL); + MMCAM_IMAGE_ENCODER, &codectype, + NULL); _mmcam_dbg_log("codectype %d", codectype); switch (codectype) { @@ -1545,11 +1583,11 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl if (hcamcorder->vcapture_cb) { _mmcam_dbg_log("APPLICATION CALLBACK START"); - if (thumb.data) { + if (thumb.data) ret = hcamcorder->vcapture_cb(&dest, &thumb, hcamcorder->vcapture_cb_param); - } else { + else ret = hcamcorder->vcapture_cb(&dest, NULL, hcamcorder->vcapture_cb_param); - } + _mmcam_dbg_log("APPLICATION CALLBACK END"); } else { _mmcam_dbg_err("Capture callback is NULL."); @@ -1578,9 +1616,8 @@ err_release_exif: } /* Release jpeg data */ - if (pixtype_main == MM_PIXEL_FORMAT_ENCODED) { + if (pixtype_main == MM_PIXEL_FORMAT_ENCODED) __mmcamcorder_release_jpeg_data((MMHandleType)hcamcorder, &dest, tag_enable, provide_exif); - } error: /* Check end condition and set proper value */ @@ -1590,11 +1627,11 @@ error: } /* release internal allocated data */ - if (sc->internal_encode) { + if (sc->internal_encode) compare_data = internal_main_data; - } else { + else compare_data = mapinfo1.data; - } + if (dest.data && compare_data && dest.data != compare_data) { _mmcam_dbg_log("release internal allocated data %p", dest.data); @@ -1638,17 +1675,34 @@ error: if (send_captured_message) { if (info->hdr_capture_mode != MM_CAMCORDER_HDR_ON_AND_ORIGINAL) { /* Send CAPTURED message and count - capture success */ - if (current_state >= MM_CAMCORDER_STATE_RECORDING) { + if (current_state >= MM_CAMCORDER_STATE_RECORDING) MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_VIDEO_SNAPSHOT_CAPTURED, count); - } else { + else MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_CAPTURED, count); - } } else if (info->hdr_capture_mode == MM_CAMCORDER_HDR_ON_AND_ORIGINAL && count == 2) { /* send captured message only once in HDR and Original Capture mode */ MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_CAPTURED, 1); } } + if (current_state >= MM_CAMCORDER_STATE_RECORDING) { + /* Handle capture in recording case */ + hcamcorder->capture_in_recording = FALSE; + + g_mutex_lock(&hcamcorder->task_thread_lock); + + if (hcamcorder->task_thread_state == _MMCAMCORDER_TASK_THREAD_STATE_CHECK_CAPTURE_IN_RECORDING) { + _mmcam_dbg_log("send signal for capture in recording"); + g_cond_signal(&hcamcorder->task_thread_cond); + } else { + _mmcam_dbg_warn("unexpected task thread state : %d", hcamcorder->task_thread_state); + } + + g_mutex_unlock(&hcamcorder->task_thread_lock); + + _MMCAMCORDER_CMD_SIGNAL(hcamcorder); + } + _mmcam_dbg_err("END"); return; @@ -1687,17 +1741,15 @@ static ExifData *__mmcamcorder_update_exif_orientation(MMHandleType handle, Exif int ret = MM_ERROR_NONE; mm_camcorder_get_attributes(handle, NULL, MMCAM_TAG_ORIENTATION, &value, NULL); - _mmcam_dbg_log("get orientation [%d]",value); - if (value == 0) { + _mmcam_dbg_log("get orientation [%d]", value); + if (value == 0) value = MM_EXIF_ORIENTATION; - } exif_set_short((unsigned char *)&eshort, exif_data_get_byte_order(ed), value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_ORIENTATION, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_MAKER_NOTE); - } exit: return ed; @@ -1712,14 +1764,12 @@ static ExifData *__mmcamcorder_update_exif_make(MMHandleType handle, ExifData *e if (make) { _mmcam_dbg_log("maker [%s]", make); ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_MAKE, - EXIF_FORMAT_ASCII, strlen(make)+1, (const char *)make); + EXIF_FORMAT_ASCII, strlen(make)+1, (const char *)make); free(make); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_MAKE); - } } else { - ret = MM_ERROR_CAMCORDER_LOW_MEMORY; - EXIF_SET_ERR(ret, EXIF_TAG_MAKE); + _mmcam_dbg_err("strdup failed [%s]", MM_MAKER_NAME); } exit: @@ -1739,12 +1789,10 @@ static ExifData *__mmcamcorder_update_exif_software(MMHandleType handle, ExifDat if (hcamcorder->software_version) { ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_SOFTWARE, EXIF_FORMAT_ASCII, - strlen(hcamcorder->software_version)+1, (const char *)hcamcorder->software_version); - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("set software_version[%s] failed", hcamcorder->software_version); - } else { - _mmcam_dbg_log("set software_version[%s] done", hcamcorder->software_version); - } + strlen(hcamcorder->software_version)+1, (const char *)hcamcorder->software_version); + + _mmcam_dbg_log("set software_version[%s] ret[0x%x]", + hcamcorder->software_version, ret); } else { _mmcam_dbg_err("model_name is NULL"); } @@ -1765,12 +1813,10 @@ static ExifData *__mmcamcorder_update_exif_model(MMHandleType handle, ExifData * if (hcamcorder->model_name) { ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_MODEL, EXIF_FORMAT_ASCII, - strlen(hcamcorder->model_name)+1, (const char *)hcamcorder->model_name); - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("set model name[%s] failed", hcamcorder->model_name); - } else { - _mmcam_dbg_log("set model name[%s] done", hcamcorder->model_name); - } + strlen(hcamcorder->model_name)+1, (const char *)hcamcorder->model_name); + + _mmcam_dbg_err("set model name[%s] ret[0x%x]", + hcamcorder->model_name, ret); } else { _mmcam_dbg_err("model_name is NULL"); } @@ -1789,20 +1835,19 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed ret = mm_camcorder_get_attributes(handle, NULL, MMCAM_TAG_GPS_ENABLE, &gps_enable, NULL); if (ret == MM_ERROR_NONE && gps_enable) { - ExifByte GpsVersion[4]={2,2,0,0}; + ExifByte GpsVersion[4] = {2, 2, 0, 0}; _mmcam_dbg_log("Tag for GPS is ENABLED."); ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_VERSION_ID, - EXIF_FORMAT_BYTE, 4, (const char *)&GpsVersion); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_BYTE, 4, (const char *)&GpsVersion); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_GPS_VERSION_ID); - } ret = mm_camcorder_get_attributes(handle, &err_name, - MMCAM_TAG_LATITUDE, &latitude, - MMCAM_TAG_LONGITUDE, &longitude, - MMCAM_TAG_ALTITUDE, &altitude, NULL); + MMCAM_TAG_LATITUDE, &latitude, + MMCAM_TAG_LONGITUDE, &longitude, + MMCAM_TAG_ALTITUDE, &altitude, NULL); if (ret != MM_ERROR_NONE) { _mmcam_dbg_err("failed to get gps info [%x][%s]", ret, err_name); SAFE_FREE(err_name); @@ -1819,22 +1864,21 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed if (latitude < 0) { ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE_REF, - EXIF_FORMAT_ASCII, 2, "S"); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_ASCII, 2, "S"); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_GPS_LATITUDE_REF); - } + latitude = -latitude; } else if (latitude > 0) { ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE_REF, - EXIF_FORMAT_ASCII, 2, "N"); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_ASCII, 2, "N"); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_GPS_LATITUDE_REF); - } } deg = (unsigned int)(latitude); - min = (unsigned int)((latitude-deg)*60); - sec = (unsigned int)(((latitude-deg)*3600)-min*60); + min = (unsigned int)((latitude-deg) * 60); + sec = (unsigned int)(((latitude-deg) * 3600) - min * 60); _mmcam_dbg_log("f_latitude deg[%d], min[%d], sec[%d]", deg, min, sec); b = malloc(3 * sizeof(ExifRational)); @@ -1843,16 +1887,15 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed rData.denominator = 1; exif_set_rational(b, exif_data_get_byte_order(ed), rData); rData.numerator = min; - exif_set_rational(b+8, exif_data_get_byte_order(ed), rData); + exif_set_rational(b + 8, exif_data_get_byte_order(ed), rData); rData.numerator = sec; - exif_set_rational(b+16, exif_data_get_byte_order(ed), rData); + exif_set_rational(b + 16, exif_data_get_byte_order(ed), rData); ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE, - EXIF_FORMAT_RATIONAL, 3, (const char *)b); + EXIF_FORMAT_RATIONAL, 3, (const char *)b); free(b); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_GPS_LATITUDE); - } } else { _mmcam_dbg_warn("malloc failed"); } @@ -1868,22 +1911,21 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed if (longitude < 0) { ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE_REF, - EXIF_FORMAT_ASCII, 2, "W"); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_ASCII, 2, "W"); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_GPS_LONGITUDE_REF); - } + longitude = -longitude; } else if (longitude > 0) { ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE_REF, - EXIF_FORMAT_ASCII, 2, "E"); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_ASCII, 2, "E"); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_GPS_LONGITUDE_REF); - } } deg = (unsigned int)(longitude); - min = (unsigned int)((longitude-deg)*60); - sec = (unsigned int)(((longitude-deg)*3600)-min*60); + min = (unsigned int)((longitude-deg) * 60); + sec = (unsigned int)(((longitude-deg) * 3600) - min * 60); _mmcam_dbg_log("longitude deg[%d], min[%d], sec[%d]", deg, min, sec); b = malloc(3 * sizeof(ExifRational)); @@ -1896,11 +1938,10 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed rData.numerator = sec; exif_set_rational(b+16, exif_data_get_byte_order(ed), rData); ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE, - EXIF_FORMAT_RATIONAL, 3, (const char *)b); + EXIF_FORMAT_RATIONAL, 3, (const char *)b); free(b); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_GPS_LONGITUDE); - } } else { _mmcam_dbg_warn("malloc failed"); } @@ -1919,7 +1960,7 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed } ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_ALTITUDE_REF, - EXIF_FORMAT_BYTE, 1, (const char *)&alt_ref); + EXIF_FORMAT_BYTE, 1, (const char *)&alt_ref); if (ret != MM_ERROR_NONE) { _mmcam_dbg_err("error [%x], tag [%x]", ret, EXIF_TAG_GPS_ALTITUDE_REF); if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) { @@ -1933,11 +1974,10 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed rData.denominator = 100; exif_set_rational(b, exif_data_get_byte_order(ed), rData); ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_ALTITUDE, - EXIF_FORMAT_RATIONAL, 1, (const char *)b); + EXIF_FORMAT_RATIONAL, 1, (const char *)b); free(b); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_GPS_ALTITUDE); - } } else { _mmcam_dbg_warn("malloc failed"); } @@ -1974,13 +2014,12 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed exif_set_rational(b + 16, exif_data_get_byte_order(ed), rData); ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_TIME_STAMP, - EXIF_FORMAT_RATIONAL, 3, (const char *)b); + EXIF_FORMAT_RATIONAL, 3, (const char *)b); free(b); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_GPS_TIME_STAMP); - } } else { - _mmcam_dbg_warn( "malloc failed." ); + _mmcam_dbg_warn("malloc failed."); } } } @@ -1996,10 +2035,9 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed /* cause it should include NULL char */ ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_DATE_STAMP, - EXIF_FORMAT_ASCII, date_stamp_len + 1, (const char *)date_stamp); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_ASCII, date_stamp_len + 1, (const char *)date_stamp); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_GPS_DATE_STAMP); - } } } @@ -2013,14 +2051,13 @@ static ExifData *__mmcamcorder_update_exif_gps(MMHandleType handle, ExifData *ed _mmcam_dbg_log("Processing method [%s]", processing_method); ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_PROCESSING_METHOD, - EXIF_FORMAT_UNDEFINED, processing_method_len, (const char *)processing_method); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_UNDEFINED, processing_method_len, (const char *)processing_method); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_GPS_PROCESSING_METHOD); - } } } } else { - _mmcam_dbg_log( "Tag for GPS is DISABLED." ); + _mmcam_dbg_log("Tag for GPS is DISABLED."); } exit: @@ -2039,7 +2076,7 @@ int __mmcamcorder_update_exif_info(MMHandleType handle, void* imagedata, int img mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED); ed = exif_data_new_from_data(imagedata, imgln); - //ed = mm_exif_get_exif_from_info(hcamcorder->exif_info); + /*ed = mm_exif_get_exif_from_info(hcamcorder->exif_info);*/ if (ed == NULL) { _mmcam_dbg_err("get exif data error!!"); @@ -2054,9 +2091,8 @@ int __mmcamcorder_update_exif_info(MMHandleType handle, void* imagedata, int img __mmcamcorder_update_exif_orientation(handle, ed); __mmcamcorder_update_exif_gps(handle, ed); ret = mm_exif_set_exif_to_info(hcamcorder->exif_info, ed); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) _mmcam_dbg_err("mm_exif_set_exif_to_info err!! [%x]", ret); - } exif_data_unref(ed); ed = NULL; @@ -2115,43 +2151,40 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int /*0. EXIF_TAG_EXIF_VERSION */ ExifVersion = MM_EXIF_VERSION; ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXIF_VERSION, - EXIF_FORMAT_UNDEFINED, 4, (const char *)&ExifVersion); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_UNDEFINED, 4, (const char *)&ExifVersion); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_EXIF_VERSION); - } /*1. EXIF_TAG_IMAGE_WIDTH */ /*EXIF_TAG_PIXEL_X_DIMENSION*/ value = image_width; exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_WIDTH, - EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_IMAGE_WIDTH); - } ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_X_DIMENSION, - EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_PIXEL_X_DIMENSION); - } + _mmcam_dbg_log("width[%d]", value); /*2. EXIF_TAG_IMAGE_LENGTH*/ /*EXIF_TAG_PIXEL_Y_DIMENSION*/ value = image_height; - exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order (ed), value); + exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_LENGTH, - EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_IMAGE_LENGTH); - } ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_Y_DIMENSION, - EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_PIXEL_Y_DIMENSION); - } + _mmcam_dbg_log("height[%d]", value); /*4. EXIF_TAG_DATE_TIME */ @@ -2178,30 +2211,30 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int localtime_r(&t, &tm); snprintf((char *)b, 20, "%04i:%02i:%02i %02i:%02i:%02i", - tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, - tm.tm_hour, tm.tm_min, tm.tm_sec); + tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, + tm.tm_hour, tm.tm_min, tm.tm_sec); ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_DATE_TIME, EXIF_FORMAT_ASCII, 20, (const char *)b); if (ret != MM_ERROR_NONE) { - if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) { + if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) free(b); - } + EXIF_SET_ERR(ret, EXIF_TAG_DATE_TIME); } ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_ORIGINAL, EXIF_FORMAT_ASCII, 20, (const char *)b); if (ret != MM_ERROR_NONE) { - if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) { + if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) free(b); - } + EXIF_SET_ERR(ret, EXIF_TAG_DATE_TIME_ORIGINAL); } ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_DIGITIZED, EXIF_FORMAT_ASCII, 20, (const char *)b); if (ret != MM_ERROR_NONE) { - if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) { + if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) free(b); - } + EXIF_SET_ERR(ret, EXIF_TAG_DATE_TIME_DIGITIZED); } @@ -2226,13 +2259,12 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int if (description) { ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_DESCRIPTION, - EXIF_FORMAT_ASCII, strlen(description), (const char *)description); + EXIF_FORMAT_ASCII, strlen(description), (const char *)description); free(description); str_value = NULL; str_val_len = 0; - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_IMAGE_DESCRIPTION); - } } else { _mmcam_dbg_err("strdup failed for [%s]", str_value); } @@ -2248,10 +2280,10 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int char software[50] = {0,}; unsigned int len = 0; - len = snprintf(software, sizeof(software), "%x.%x ", avsys_exif_info.software_used>>8,(avsys_exif_info.software_used & 0xff)); + len = snprintf(software, sizeof(software), "%x.%x ", avsys_exif_info.software_used>>8, (avsys_exif_info.software_used & 0xff)); _mmcam_dbg_log("software [%s], len [%d]", software, len); ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_SOFTWARE, - EXIF_FORMAT_ASCII, len, (const char *)software); + EXIF_FORMAT_ASCII, len, (const char *)software); if (ret != MM_ERROR_NONE) { EXIF_SET_ERR(ret, EXIF_TAG_SOFTWARE); } @@ -2266,13 +2298,12 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int /*FIXME : get user comment from real user */ user_comment = strdup(MM_USER_COMMENT); if (user_comment) { - _mmcam_dbg_log("user_comment=%s",user_comment); + _mmcam_dbg_log("user_comment=%s", user_comment); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_USER_COMMENT, - EXIF_FORMAT_ASCII, strlen(user_comment), (const char *)user_comment); + EXIF_FORMAT_ASCII, strlen(user_comment), (const char *)user_comment); free(user_comment); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_USER_COMMENT); - } } else { ret = MM_ERROR_CAMCORDER_LOW_MEMORY; EXIF_SET_ERR(ret, EXIF_TAG_USER_COMMENT); @@ -2282,21 +2313,19 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int if (control != NULL) { exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.colorspace); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_COLOR_SPACE, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_COLOR_SPACE); - } } /*10. EXIF_TAG_COMPONENTS_CONFIGURATION */ if (control != NULL) { config = avsys_exif_info.component_configuration; - _mmcam_dbg_log("EXIF_TAG_COMPONENTS_CONFIGURATION [%4x] ",config); + _mmcam_dbg_log("EXIF_TAG_COMPONENTS_CONFIGURATION [%4x] ", config); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_COMPONENTS_CONFIGURATION, - EXIF_FORMAT_UNDEFINED, 4, (const char *)&config); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_UNDEFINED, 4, (const char *)&config); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_COMPONENTS_CONFIGURATION); - } } /*11. EXIF_TAG_COMPRESSED_BITS_PER_PIXEL */ @@ -2311,7 +2340,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int ExifRational rData; _mmcam_dbg_log("EXIF_TAG_EXPOSURE_TIME numerator [%d], denominator [%d]", - avsys_exif_info.exposure_time_numerator, avsys_exif_info.exposure_time_denominator); + avsys_exif_info.exposure_time_numerator, avsys_exif_info.exposure_time_denominator); b = malloc(sizeof(ExifRational)); if (b) { @@ -2320,17 +2349,16 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int exif_set_rational(b, exif_data_get_byte_order(ed), rData); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_TIME, - EXIF_FORMAT_RATIONAL, 1, (const char *)b); + EXIF_FORMAT_RATIONAL, 1, (const char *)b); free(b); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_TIME); - } } else { _mmcam_dbg_warn("malloc failed."); } } else { _mmcam_dbg_log("Skip set EXIF_TAG_EXPOSURE_TIME numerator [%d], denominator [%d]", - avsys_exif_info.exposure_time_numerator, avsys_exif_info.exposure_time_denominator); + avsys_exif_info.exposure_time_numerator, avsys_exif_info.exposure_time_denominator); } /*15. EXIF_TAG_FNUMBER */ @@ -2339,7 +2367,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int ExifRational rData; _mmcam_dbg_log("EXIF_TAG_FNUMBER numerator [%d], denominator [%d]", - avsys_exif_info.aperture_f_num_numerator, avsys_exif_info.aperture_f_num_denominator); + avsys_exif_info.aperture_f_num_numerator, avsys_exif_info.aperture_f_num_denominator); b = malloc(sizeof(ExifRational)); if (b) { @@ -2347,17 +2375,16 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int rData.denominator = avsys_exif_info.aperture_f_num_denominator; exif_set_rational(b, exif_data_get_byte_order(ed), rData); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FNUMBER, - EXIF_FORMAT_RATIONAL, 1, (const char *)b); + EXIF_FORMAT_RATIONAL, 1, (const char *)b); free(b); - if(ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_FNUMBER); - } } else { - _mmcam_dbg_warn( "malloc failed." ); + _mmcam_dbg_warn("malloc failed."); } } else { _mmcam_dbg_log("Skip set EXIF_TAG_FNUMBER numerator [%d], denominator [%d]", - avsys_exif_info.aperture_f_num_numerator, avsys_exif_info.aperture_f_num_denominator); + avsys_exif_info.aperture_f_num_numerator, avsys_exif_info.aperture_f_num_denominator); } /*16. EXIF_TAG_EXPOSURE_PROGRAM*/ @@ -2365,20 +2392,18 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int value = MM_EXPOSURE_PROGRAM; exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_PROGRAM, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_PROGRAM); - } /*17. EXIF_TAG_ISO_SPEED_RATINGS*/ if (avsys_exif_info.iso) { _mmcam_dbg_log("EXIF_TAG_ISO_SPEED_RATINGS [%d]", avsys_exif_info.iso); exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.iso); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_ISO_SPEED_RATINGS); - } } /*18. EXIF_TAG_SHUTTER_SPEED_VALUE*/ @@ -2387,7 +2412,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int ExifSRational rsData; _mmcam_dbg_log("EXIF_TAG_SHUTTER_SPEED_VALUE numerator [%d], denominator [%d]", - avsys_exif_info.shutter_speed_numerator, avsys_exif_info.shutter_speed_denominator); + avsys_exif_info.shutter_speed_numerator, avsys_exif_info.shutter_speed_denominator); b = malloc(sizeof(ExifSRational)); if (b) { @@ -2395,17 +2420,16 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int rsData.denominator = avsys_exif_info.shutter_speed_denominator; exif_set_srational(b, exif_data_get_byte_order(ed), rsData); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SHUTTER_SPEED_VALUE, - EXIF_FORMAT_SRATIONAL, 1, (const char *)b); + EXIF_FORMAT_SRATIONAL, 1, (const char *)b); free(b); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_SHUTTER_SPEED_VALUE); - } } else { _mmcam_dbg_warn("malloc failed."); } } else { _mmcam_dbg_log("Skip set EXIF_TAG_SHUTTER_SPEED_VALUE numerator [%d], denominator [%d]", - avsys_exif_info.shutter_speed_numerator, avsys_exif_info.shutter_speed_denominator); + avsys_exif_info.shutter_speed_numerator, avsys_exif_info.shutter_speed_denominator); } /*19. EXIF_TAG_APERTURE_VALUE*/ @@ -2421,11 +2445,10 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int rData.denominator = 1; exif_set_rational(b, exif_data_get_byte_order(ed), rData); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_APERTURE_VALUE, - EXIF_FORMAT_RATIONAL, 1, (const char *)b); + EXIF_FORMAT_RATIONAL, 1, (const char *)b); free(b); - if(ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_APERTURE_VALUE); - } } else { _mmcam_dbg_warn("malloc failed."); } @@ -2439,7 +2462,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int ExifSRational rsData; _mmcam_dbg_log("EXIF_TAG_BRIGHTNESS_VALUE numerator [%d], denominator [%d]", - avsys_exif_info.brigtness_numerator, avsys_exif_info.brightness_denominator); + avsys_exif_info.brigtness_numerator, avsys_exif_info.brightness_denominator); b = malloc(sizeof(ExifSRational)); if (b) { @@ -2447,17 +2470,16 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int rsData.denominator = avsys_exif_info.brightness_denominator; exif_set_srational(b, exif_data_get_byte_order(ed), rsData); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_BRIGHTNESS_VALUE, - EXIF_FORMAT_SRATIONAL, 1, (const char *)b); + EXIF_FORMAT_SRATIONAL, 1, (const char *)b); free(b); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_BRIGHTNESS_VALUE); - } } else { - _mmcam_dbg_warn( "malloc failed." ); + _mmcam_dbg_warn("malloc failed."); } } else { _mmcam_dbg_log("Skip set EXIF_TAG_BRIGHTNESS_VALUE numerator [%d], denominatorr [%d]", - avsys_exif_info.brigtness_numerator, avsys_exif_info.brightness_denominator); + avsys_exif_info.brigtness_numerator, avsys_exif_info.brightness_denominator); } /*21. EXIF_TAG_EXPOSURE_BIAS_VALUE*/ @@ -2468,7 +2490,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int ExifSRational rsData; _mmcam_dbg_log("EXIF_TAG_BRIGHTNESS_VALUE %d, default %d, step denominator %d", - value, hcamcorder->brightness_default, hcamcorder->brightness_step_denominator); + value, hcamcorder->brightness_default, hcamcorder->brightness_step_denominator); b = malloc(sizeof(ExifSRational)); if (b) { @@ -2481,11 +2503,10 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int } exif_set_srational(b, exif_data_get_byte_order(ed), rsData); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_BIAS_VALUE, - EXIF_FORMAT_SRATIONAL, 1, (const char *)b); + EXIF_FORMAT_SRATIONAL, 1, (const char *)b); free(b); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_BIAS_VALUE); - } } else { _mmcam_dbg_warn("malloc failed."); } @@ -2507,11 +2528,10 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int rData.denominator = 1; exif_set_rational(b, exif_data_get_byte_order(ed), rData); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_MAX_APERTURE_VALUE, - EXIF_FORMAT_RATIONAL, 1, b); + EXIF_FORMAT_RATIONAL, 1, b); free(b); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_MAX_APERTURE_VALUE); - } } else { _mmcam_dbg_warn("failed to alloc for MAX aperture value"); } @@ -2523,26 +2543,24 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int /*24. EXIF_TAG_METERING_MODE */ if (control != NULL) { - exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed),avsys_exif_info.metering_mode); + exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.metering_mode); _mmcam_dbg_log("EXIF_TAG_METERING_MODE [%d]", avsys_exif_info.metering_mode); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_METERING_MODE, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_METERING_MODE); - } } /*25. EXIF_TAG_LIGHT_SOURCE*/ /*26. EXIF_TAG_FLASH*/ if (control != NULL) { - exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order (ed),avsys_exif_info.flash); + exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.flash); _mmcam_dbg_log("EXIF_TAG_FLASH [%d]", avsys_exif_info.flash); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FLASH, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_FLASH); - } } /*27. EXIF_TAG_FOCAL_LENGTH*/ @@ -2551,7 +2569,7 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int ExifRational rData; _mmcam_dbg_log("EXIF_TAG_FOCAL_LENGTH numerator [%d], denominator [%d]", - avsys_exif_info.focal_len_numerator, avsys_exif_info.focal_len_denominator); + avsys_exif_info.focal_len_numerator, avsys_exif_info.focal_len_denominator); b = malloc(sizeof(ExifRational)); if (b) { @@ -2559,38 +2577,35 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int rData.denominator = avsys_exif_info.focal_len_denominator; exif_set_rational(b, exif_data_get_byte_order(ed), rData); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH, - EXIF_FORMAT_RATIONAL, 1, (const char *)b); + EXIF_FORMAT_RATIONAL, 1, (const char *)b); free(b); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_FOCAL_LENGTH); - } } else { _mmcam_dbg_warn("malloc failed."); } } else { _mmcam_dbg_log("Skip set EXIF_TAG_FOCAL_LENGTH numerator [%d], denominator [%d]", - avsys_exif_info.focal_len_numerator, avsys_exif_info.focal_len_denominator); + avsys_exif_info.focal_len_numerator, avsys_exif_info.focal_len_denominator); } /*28. EXIF_TAG_SENSING_METHOD*/ /*FIXME*/ value = MM_SENSING_MODE; - exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order (ed),value); + exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SENSING_METHOD, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_SENSING_METHOD); - } /*29. EXIF_TAG_FILE_SOURCE*/ /* value = MM_FILE_SOURCE; exif_set_long(&elong[cntl], exif_data_get_byte_order(ed),value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FILE_SOURCE, - EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_FILE_SOURCE); - } */ /*30. EXIF_TAG_SCENE_TYPE*/ @@ -2598,22 +2613,19 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int value = MM_SCENE_TYPE; exif_set_long(&elong[cntl], exif_data_get_byte_order(ed),value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SCENE_TYPE, - EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_SCENE_TYPE); - } */ /*31. EXIF_TAG_EXPOSURE_MODE*/ /*FIXME*/ value = MM_EXPOSURE_MODE; - exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed),value); + exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_MODE, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_MODE); - } - /*32. EXIF_TAG_WHITE_BALANCE*/ ret = mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_WB, &value, NULL); @@ -2621,18 +2633,16 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int int set_value = 0; _mmcam_dbg_log("WHITE BALANCE [%d]", value); - if (value == MM_CAMCORDER_WHITE_BALANCE_AUTOMATIC) { + if (value == MM_CAMCORDER_WHITE_BALANCE_AUTOMATIC) set_value = 0; - } else { + else set_value = 1; - } exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), set_value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_WHITE_BALANCE, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_WHITE_BALANCE); - } } else { _mmcam_dbg_warn("failed to get white balance [%x]", ret); } @@ -2645,10 +2655,9 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int exif_set_long(&elong[cntl], exif_data_get_byte_order(ed), value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_DIGITAL_ZOOM_RATIO, - EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_DIGITAL_ZOOM_RATIO); - } } else { _mmcam_dbg_warn("failed to get digital zoom [%x]", ret); } @@ -2660,10 +2669,9 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int value = MM_FOCAL_LENGTH_35MMFILM; exif_set_short(&eshort[cnts], exif_data_get_byte_order(ed),value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM); - } */ /*35. EXIF_TAG_SCENE_CAPTURE_TYPE*/ @@ -2674,24 +2682,29 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int if (ret == MM_ERROR_NONE) { _mmcam_dbg_log("Scene mode(program mode) [%d]", value); - if (value == MM_CAMCORDER_SCENE_MODE_NORMAL) { + switch (value) { + case MM_CAMCORDER_SCENE_MODE_NORMAL: scene_capture_type = 0; /* standard */ - } else if (value == MM_CAMCORDER_SCENE_MODE_PORTRAIT) { + break; + case MM_CAMCORDER_SCENE_MODE_PORTRAIT: scene_capture_type = 2; /* portrait */ - } else if (value == MM_CAMCORDER_SCENE_MODE_LANDSCAPE) { + break; + case MM_CAMCORDER_SCENE_MODE_LANDSCAPE: scene_capture_type = 1; /* landscape */ - } else if (value == MM_CAMCORDER_SCENE_MODE_NIGHT_SCENE) { + break; + case MM_CAMCORDER_SCENE_MODE_NIGHT_SCENE: scene_capture_type = 3; /* night scene */ - } else { + break; + default: scene_capture_type = 4; /* Others */ + break; } exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), scene_capture_type); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SCENE_CAPTURE_TYPE, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_SCENE_CAPTURE_TYPE); - } } else { _mmcam_dbg_warn("failed to get scene mode [%x]", ret); } @@ -2703,10 +2716,9 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int value = MM_GAIN_CONTROL; exif_set_long(&elong[cntl], exif_data_get_byte_order(ed), value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_GAIN_CONTROL, - EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_GAIN_CONTROL); - } */ @@ -2716,28 +2728,26 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int int level = 0; _mmcamcorder_conf_get_value_int_range(hcamcorder->conf_ctrl, - CONFIGURE_CATEGORY_CTRL_EFFECT, - "Contrast", - &irange); + CONFIGURE_CATEGORY_CTRL_EFFECT, + "Contrast", + &irange); if (irange != NULL) { mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_CONTRAST, &value, NULL); _mmcam_dbg_log("CONTRAST currentt [%d], default [%d]", value, irange->default_value); - if (value == irange->default_value) { + if (value == irange->default_value) level = MM_VALUE_NORMAL; - } else if (value < irange->default_value) { + else if (value < irange->default_value) level = MM_VALUE_LOW; - } else { + else level = MM_VALUE_HARD; - } exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), level); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_CONTRAST, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_CONTRAST); - } } else { _mmcam_dbg_warn("failed to get range of contrast"); } @@ -2749,28 +2759,26 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int int level = 0; _mmcamcorder_conf_get_value_int_range(hcamcorder->conf_ctrl, - CONFIGURE_CATEGORY_CTRL_EFFECT, - "Saturation", - &irange); + CONFIGURE_CATEGORY_CTRL_EFFECT, + "Saturation", + &irange); if (irange != NULL) { mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SATURATION, &value, NULL); _mmcam_dbg_log("SATURATION current [%d], default [%d]", value, irange->default_value); - if (value == irange->default_value) { + if (value == irange->default_value) level = MM_VALUE_NORMAL; - } else if (value < irange->default_value) { + else if (value < irange->default_value) level = MM_VALUE_LOW; - } else { - level=MM_VALUE_HARD; - } + else + level = MM_VALUE_HARD; exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), level); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SATURATION, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_SATURATION); - } } else { _mmcam_dbg_warn("failed to get range of saturation"); } @@ -2782,28 +2790,26 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int int level = 0; _mmcamcorder_conf_get_value_int_range(hcamcorder->conf_ctrl, - CONFIGURE_CATEGORY_CTRL_EFFECT, - "Sharpness", - &irange); + CONFIGURE_CATEGORY_CTRL_EFFECT, + "Sharpness", + &irange); if (irange != NULL) { mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SHARPNESS, &value, NULL); _mmcam_dbg_log("SHARPNESS current [%d], default [%d]", value, irange->default_value); - if (value == irange->default_value) { + if (value == irange->default_value) level = MM_VALUE_NORMAL; - } else if (value < irange->default_value) { + else if (value < irange->default_value) level = MM_VALUE_LOW; - } else { + else level = MM_VALUE_HARD; - } exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), level); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SHARPNESS, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_SHARPNESS); - } } else { _mmcam_dbg_warn("failed to get range of sharpness"); } @@ -2815,10 +2821,9 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int _mmcam_dbg_log("DISTANCE_RANGE [%d]", value); exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value); ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SUBJECT_DISTANCE_RANGE, - EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); - if (ret != MM_ERROR_NONE) { + EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]); + if (ret != MM_ERROR_NONE) EXIF_SET_ERR(ret, EXIF_TAG_SUBJECT_DISTANCE_RANGE); - } /* GPS information */ __mmcamcorder_update_exif_gps(handle, ed); @@ -2826,16 +2831,14 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int _mmcam_dbg_log(""); ret = mm_exif_set_exif_to_info(hcamcorder->exif_info, ed); - if (ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) _mmcam_dbg_err("mm_exif_set_exif_to_info err!! [%x]", ret); - } exit: _mmcam_dbg_log("finished!! [%x]", ret); - if (ed) { - exif_data_unref (ed); - } + if (ed) + exif_data_unref(ed); return ret; }