X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_stillshot.c;h=5fc9c957e096994e3d78f962b8c5165579c9762d;hb=refs%2Fchanges%2F99%2F219599%2F4;hp=4f0e08195cbfd9986ada99d29c13fe8172aba35d;hpb=d07badae4689e99903d509ef504c9bbf0ac6d03a;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git diff --git a/src/mm_camcorder_stillshot.c b/src/mm_camcorder_stillshot.c index 4f0e081..5fc9c95 100644 --- a/src/mm_camcorder_stillshot.c +++ b/src/mm_camcorder_stillshot.c @@ -26,7 +26,6 @@ #include #include #include -#include #include "mm_camcorder_internal.h" #include "mm_camcorder_stillshot.h" #include "mm_camcorder_exifinfo.h" @@ -38,11 +37,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 | @@ -52,8 +53,6 @@ #define THUMBNAIL_JPEG_QUALITY 90 #define TRY_LOCK_MAX_COUNT 100 #define TRY_LOCK_TIME 20000 /* ms */ -#define H264_PREVIEW_BITRATE 1024*10 /* kbps */ -#define H264_PREVIEW_NEWGOP_INTERVAL 1000 /* ms */ #define _MMCAMCORDER_MAKE_THUMBNAIL_INTERNAL_ENCODE @@ -102,16 +101,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 +122,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 +148,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 +209,10 @@ 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; + MMHandleType attrs; + int attr_index = 0; mmf_return_if_fail(hcamcorder); @@ -223,12 +225,65 @@ 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_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); + mm_attrs_set_data(attrs, attr_index, (void *)sink_element, sizeof(*sink_element)); + mm_attrs_commit(attrs, attr_index); + + /* 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); + traceEnd(TTRACE_TAG_CAMERA); + _mmcamcorder_remove_all_handlers(handle, _MMCAMCORDER_HANDLER_CATEGORY_ALL); + traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:UNREALIZE:UNREF_PIPELINE"); + gst_object_unref(sc->element[_MMCAMCORDER_MAIN_PIPE].gst); + traceEnd(TTRACE_TAG_CAMERA); + /* NULL initialization will be done in _mmcamcorder_element_release_noti */ } @@ -243,7 +298,6 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) int width = 0; int height = 0; int fps = 0; - int cap_format = MM_PIXEL_FORMAT_NV12; int image_encoder = MM_IMAGE_CODEC_JPEG; int strobe_mode = MM_CAMCORDER_STROBE_MODE_OFF; int is_modified_size = FALSE; @@ -276,14 +330,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); @@ -294,22 +348,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, &info->capture_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; @@ -326,20 +379,22 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) info->next_shot_time = 0; 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 */ + /* sound init */ _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, info->capture_format, + info->count, info->hdr_capture_mode, info->interval); /* check state */ if (current_state >= MM_CAMCORDER_STATE_RECORDING) { + if (sc->bencbin_capture) { + _mmcam_dbg_err("could not capture in this target while recording"); + ret = MM_ERROR_CAMCORDER_INVALID_STATE; + goto cmd_done; + } + if (info->type == _MMCamcorder_MULTI_SHOT || info->hdr_capture_mode != MM_CAMCORDER_HDR_OFF) { _mmcam_dbg_err("does not support multi/HDR capture while recording"); @@ -370,27 +425,26 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) if (!sc->bencbin_capture) { /* Check encoding method */ - if (cap_format == MM_PIXEL_FORMAT_ENCODED) { + if (info->capture_format == MM_PIXEL_FORMAT_ENCODED) { if ((sc->SensorEncodedCapture && info->type == _MMCamcorder_SINGLE_SHOT) || - (sc->SensorEncodedCapture && sc->info_video->support_dual_stream) || - is_modified_size) { - cap_fourcc = _mmcamcorder_get_fourcc(cap_format, image_encoder, hcamcorder->use_zero_copy_format); + hcamcorder->support_zsl_capture || is_modified_size) { + cap_fourcc = _mmcamcorder_get_fourcc(info->capture_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); + cap_fourcc = _mmcamcorder_get_fourcc(info->capture_format, MM_IMAGE_CODEC_INVALID, hcamcorder->use_zero_copy_format); } - _mmcam_dbg_log("capture format (%d)", cap_format); + _mmcam_dbg_log("capture format (%d)", info->capture_format); /* Note: width/height of capture is set in commit function of attribute or in create function of pipeline */ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-fourcc", cap_fourcc); @@ -411,20 +465,12 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) int set_height = 0; int cap_jpeg_quality = 0; - if (current_state >= MM_CAMCORDER_STATE_RECORDING) { - _mmcam_dbg_err("could not capture in this target while recording"); - ret = MM_ERROR_CAMCORDER_INVALID_STATE; - goto cmd_done; - } - 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) { @@ -438,6 +484,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); @@ -455,12 +507,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 */ @@ -473,6 +524,9 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) info->resolution_change = TRUE; + /* set frame stability count for capture */ + _mmcamcorder_video_frame_stabilize(handle, _MMCamcorder_CMD_CAPTURE); + /* make pipeline state as PLAYING */ ret = _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING); if (ret != MM_ERROR_NONE) { @@ -494,21 +548,23 @@ 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 */ + sc->info_video->is_firstframe = TRUE; + /* set push encoding buffer as TRUE */ sc->info_video->push_encoding_buffer = PUSH_ENCODING_BUFFER_INIT; @@ -528,7 +584,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 */ @@ -541,6 +597,27 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle) cmd_done: if (ret != MM_ERROR_NONE) { info->capturing = FALSE; + + /* sound finalize */ + if (info->type == _MMCamcorder_MULTI_SHOT) + _mmcamcorder_sound_finalize(handle); + + /* send signal for task thread : It prevent unnecessary invalid operation error in task thread */ + if (hcamcorder->capture_in_recording) { + 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) { + hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE; + _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); + } } return ret; @@ -554,6 +631,8 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) int height = 0; int fps = 0; int rotation = 0; + int bitrate = 0; + int gop_interval = 0; unsigned int current_framecount = 0; int current_state = MM_CAMCORDER_STATE_NONE; gboolean fps_auto = FALSE; @@ -580,9 +659,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); @@ -594,8 +673,6 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) info->multi_shot_stop = TRUE; info->capturing = FALSE; - _mmcamcorder_vframe_stablize(handle); - current_state = _mmcamcorder_get_state(handle); _mmcam_dbg_log("current state [%d]", current_state); @@ -609,10 +686,11 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) return MM_ERROR_CAMCORDER_NOT_SUPPORTED; } + current_framecount = sc->kpi.video_framecount; + control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); gst_camera_control_set_capture_command(control, GST_CAMERA_CONTROL_CAPTURE_COMMAND_STOP); - current_framecount = sc->kpi.video_framecount; MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "stop-video", FALSE); if (info->type == _MMCamcorder_SINGLE_SHOT) { MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE); @@ -620,16 +698,16 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) } } else { int focus_mode = 0; - mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle); + MMHandleType attrs = MMF_CAMCORDER_ATTRS(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); @@ -637,14 +715,10 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "fps-auto", fps_auto); /* set focus mode */ - if (attr) { + if (attrs) { 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"); - } + mm_attrs_set_modified(attrs, MM_CAM_CAMERA_FOCUS_MODE); + mm_attrs_commit(attrs, MM_CAM_CAMERA_FOCUS_MODE); } else { _mmcam_dbg_log("focus mode is not supported"); } @@ -664,18 +738,17 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) int try_count = 0; if (hcamcorder->support_zsl_capture == FALSE) { - mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle); + MMHandleType attrs = MMF_CAMCORDER_ATTRS(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 (attrs) { + mm_attrs_set_modified(attrs, MM_CAM_STROBE_MODE); + if (mm_attrs_commit(attrs, MM_CAM_STROBE_MODE) == -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); } } @@ -686,30 +759,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); @@ -719,44 +803,59 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle) goto cmd_error; } + /* set frame stability count for preview */ + _mmcamcorder_video_frame_stabilize(handle, _MMCamcorder_CMD_PREVIEW_START); + 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); - MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "newgop-interval", H264_PREVIEW_NEWGOP_INTERVAL); + ret = mm_camcorder_get_attributes(handle, NULL, + MMCAM_ENCODED_PREVIEW_BITRATE, &bitrate, + MMCAM_ENCODED_PREVIEW_GOP_INTERVAL, &gop_interval, + NULL); + if (ret == MM_ERROR_NONE) { + _mmcamcorder_set_encoded_preview_bitrate(handle, bitrate); + _mmcamcorder_set_encoded_preview_gop_interval(handle, gop_interval); + } else { + _mmcam_dbg_err("failed to get encoded preview setting"); + } } 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); + /* set frame stability count for preview */ + _mmcamcorder_video_frame_stabilize(handle, _MMCamcorder_CMD_PREVIEW_START); + + traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:START:SET_PLAYING_TO_PIPELINE"); + ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING); - if (ret != MM_ERROR_NONE) { + traceEnd(TTRACE_TAG_CAMERA); + + 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); } } @@ -770,6 +869,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); @@ -786,8 +886,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"); @@ -809,31 +909,40 @@ 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); + traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:STOP:SET_READY_TO_PIPELINE"); + ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY); + traceEnd(TTRACE_TAG_CAMERA); + 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) { _mmcam_dbg_log("deregister sound status callback"); vconf_ignore_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, __sound_status_changed_cb); - mm_sound_volume_remove_callback(VOLUME_TYPE_SYSTEM); sc->info_image->sound_status = _SOUND_STATUS_INIT; } @@ -885,7 +994,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; @@ -900,7 +1009,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; @@ -914,12 +1023,11 @@ void __mmcamcorder_init_stillshot_info (MMHandleType handle) } -int __mmcamcorder_capture_save_exifinfo(MMHandleType handle, MMCamcorderCaptureDataType *original, MMCamcorderCaptureDataType *thumbnail) +int __mmcamcorder_capture_save_exifinfo(MMHandleType handle, MMCamcorderCaptureDataType *original, MMCamcorderCaptureDataType *thumbnail, int provide_exif) { int ret = MM_ERROR_NONE; unsigned char *data = NULL; unsigned int datalen = 0; - int provide_exif = FALSE; _MMCamcorderSubContext *sc = NULL; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); @@ -930,33 +1038,35 @@ 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. */ data = original->data; datalen = original->length; } - MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "provide-exif", &provide_exif); - if(provide_exif == 0){ + + if (provide_exif == FALSE) { 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 { @@ -965,10 +1075,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); @@ -1008,8 +1117,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: @@ -1021,7 +1130,7 @@ GET_FAILED: } -int __mmcamcorder_set_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType *dest, MMCamcorderCaptureDataType *thumbnail) +int __mmcamcorder_set_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType *dest, MMCamcorderCaptureDataType *thumbnail, int provide_exif) { mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; @@ -1035,19 +1144,15 @@ 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) { - return __mmcamcorder_capture_save_exifinfo(handle, dest, thumbnail); - } else { - return __mmcamcorder_capture_save_exifinfo(handle, dest, NULL); - } + if (thumbnail && thumbnail->data) + return __mmcamcorder_capture_save_exifinfo(handle, dest, thumbnail, provide_exif); + else + return __mmcamcorder_capture_save_exifinfo(handle, dest, NULL, provide_exif); } -void __mmcamcorder_release_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType *dest) +void __mmcamcorder_release_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType *dest, int tag_enable, int provide_exif) { - int tag_enable = 0; - int provide_exif = FALSE; - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; @@ -1057,10 +1162,7 @@ void __mmcamcorder_release_jpeg_data(MMHandleType handle, MMCamcorderCaptureData sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder); mmf_return_if_fail(sc); - _mmcam_dbg_log(""); - - mm_camcorder_get_attributes(handle, NULL, MMCAM_TAG_ENABLE, &tag_enable, NULL); - MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "provide-exif", &provide_exif); + _mmcam_dbg_log("tag : %d, provide exif : %d", tag_enable, provide_exif); /* if dest->data is allocated in MSL, release it */ if (tag_enable && !provide_exif) { @@ -1085,7 +1187,6 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl int pixtype_thumb = MM_PIXEL_FORMAT_INVALID; int pixtype_scrnl = MM_PIXEL_FORMAT_INVALID; int codectype = MM_IMAGE_CODEC_JPEG; - int attr_index = 0; int count = 0; int stop_cont_shot = FALSE; int tag_enable = FALSE; @@ -1112,9 +1213,9 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl GstMapInfo mapinfo2; GstMapInfo mapinfo3; - mmf_attrs_t *attrs = NULL; - mmf_attribute_t *item_screennail = NULL; - mmf_attribute_t *item_exif_raw_data = NULL; + MMHandleType attrs; + int attr_index_for_screennail = 0; + int attr_index_for_exif = 0; mmf_return_if_fail(hcamcorder); @@ -1133,24 +1234,27 @@ 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) { - mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, "capture-break-cont-shot", &stop_cont_shot, NULL); - } + if (info->type == _MMCamcorder_MULTI_SHOT && info->capture_send_count > 0) + mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, + MMCAM_CAPTURE_BREAK_CONTINUOUS_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; } @@ -1179,13 +1283,13 @@ 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); + _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE01, FALSE); } } @@ -1207,44 +1311,43 @@ 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) ){ - _mmcam_dbg_err("mapinfo1 is wrong (%p, size %d)", mapinfo1.data, mapinfo1.size); + } else { + if ((mapinfo1.data == NULL) && (mapinfo1.size == 0)) { + _mmcam_dbg_err("mapinfo1 is wrong (%p, size %zu)", 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); - mm_attrs_get_index((MMHandleType)attrs, MMCAM_CAPTURED_SCREENNAIL, &attr_index); - item_screennail = &attrs->items[attr_index]; + attrs = MMF_CAMCORDER_ATTRS(hcamcorder); + mm_attrs_get_index(attrs, MMCAM_CAPTURED_SCREENNAIL, &attr_index_for_screennail); if (sample3 && mapinfo3.data && mapinfo3.size != 0) { - _mmcam_dbg_log("Screennail (sample3=%p,size=%d)", sample3, mapinfo3.size); + _mmcam_dbg_log("Screennail (sample3=%p,size=%zu)", sample3, mapinfo3.size); pixtype_scrnl = _mmcamcorder_get_pixel_format(gst_sample_get_caps(sample3)); __mmcamcorder_get_capture_data_from_buffer(&scrnail, pixtype_scrnl, sample3); /* Set screennail attribute for application */ - 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); + ret = mm_attrs_set_data(attrs, attr_index_for_screennail, &scrnail, sizeof(scrnail)); + _mmcam_dbg_log("Screennail set attribute data %p, size %zu, ret %x", &scrnail, sizeof(scrnail), ret); } else { - _mmcam_dbg_log("Sample3 has wrong pointer. Not Error. (sample3=%p)",sample3); - mmf_attribute_set_data(item_screennail, NULL, 0); + _mmcam_dbg_log("Sample3 has wrong pointer. Not Error. (sample3=%p)", sample3); + mm_attrs_set_data(attrs, attr_index_for_screennail, NULL, 0); } /* commit screennail data */ - mmf_attribute_commit(item_screennail); + mm_attrs_commit(attrs, attr_index_for_screennail); /* init thumb data */ memset(&encode_src, 0x0, sizeof(MMCamcorderCaptureDataType)); @@ -1254,7 +1357,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 { @@ -1270,7 +1373,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); @@ -1280,32 +1383,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; @@ -1330,9 +1429,9 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl /* encode thumbnail */ if (encode_src.data) { + size_t thumb_length = 0; unsigned int thumb_width = 0; unsigned int thumb_height = 0; - unsigned int thumb_length = 0; unsigned char *thumb_raw_data = NULL; /* encode image */ @@ -1342,26 +1441,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..."); } @@ -1378,11 +1476,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; @@ -1403,7 +1500,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"); } } @@ -1411,13 +1508,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"); @@ -1434,10 +1531,15 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl _mmcam_dbg_log("Done Internal Encode - data %p, length %d", dest.data, dest.length); } + if (info->capture_format != MM_PIXEL_FORMAT_ENCODED) { + _mmcam_dbg_log("not encoded format, skip exif related sequence"); + goto _CAPTURE_CB_EXIF_DONE; + } + /* 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); @@ -1449,7 +1551,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 { @@ -1464,67 +1566,66 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl } /* get attribute item for EXIF data */ - mm_attrs_get_index((MMHandleType)attrs, MMCAM_CAPTURED_EXIF_RAW_DATA, &attr_index); - item_exif_raw_data = &attrs->items[attr_index]; + mm_attrs_get_index((MMHandleType)attrs, MMCAM_CAPTURED_EXIF_RAW_DATA, &attr_index_for_exif); /* set EXIF data to attribute */ if (hcamcorder->exif_info && hcamcorder->exif_info->data) { exif_raw_data = (unsigned char *)malloc(hcamcorder->exif_info->size); if (exif_raw_data) { memcpy(exif_raw_data, hcamcorder->exif_info->data, hcamcorder->exif_info->size); - mmf_attribute_set_data(item_exif_raw_data, exif_raw_data, hcamcorder->exif_info->size); + mm_attrs_set_data(attrs, attr_index_for_exif, exif_raw_data, hcamcorder->exif_info->size); _mmcam_dbg_log("set EXIF raw data %p, size %d", exif_raw_data, hcamcorder->exif_info->size); } else { _mmcam_dbg_warn("failed to alloc for EXIF, size %d", hcamcorder->exif_info->size); } } else { _mmcam_dbg_warn("failed to create EXIF. set EXIF as NULL"); - mmf_attribute_set_data(item_exif_raw_data, NULL, 0); + mm_attrs_set_data(attrs, attr_index_for_exif, NULL, 0); } /* commit EXIF data */ - mmf_attribute_commit(item_exif_raw_data); + mm_attrs_commit(attrs, attr_index_for_exif); /* get tag-enable */ 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 (tag_enable) { - mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, - MMCAM_IMAGE_ENCODER, &codectype, - NULL); - _mmcam_dbg_log("codectype %d", codectype); - - switch (codectype) { - case MM_IMAGE_CODEC_JPEG: - case MM_IMAGE_CODEC_SRW: - case MM_IMAGE_CODEC_JPEG_SRW: - ret = __mmcamcorder_set_jpeg_data((MMHandleType)hcamcorder, &dest, &thumb); - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("Error on setting extra data to jpeg"); - MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, ret); - goto error; - } - break; - default: - _mmcam_dbg_err("The codectype is not supported. (%d)", codectype); - MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INTERNAL); + if (tag_enable) { + mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, + MMCAM_IMAGE_ENCODER, &codectype, + NULL); + _mmcam_dbg_log("codectype %d", codectype); + + switch (codectype) { + case MM_IMAGE_CODEC_JPEG: + case MM_IMAGE_CODEC_SRW: + case MM_IMAGE_CODEC_JPEG_SRW: + ret = __mmcamcorder_set_jpeg_data((MMHandleType)hcamcorder, &dest, &thumb, provide_exif); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("Error on setting extra data to jpeg"); + MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, ret); goto error; } + break; + default: + _mmcam_dbg_err("The codectype is not supported. (%d)", codectype); + MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INTERNAL); + goto error; } } +_CAPTURE_CB_EXIF_DONE: + /* Handle Capture Callback */ _MMCAMCORDER_LOCK_VCAPTURE_CALLBACK(hcamcorder); 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."); @@ -1542,20 +1643,19 @@ err_release_exif: _MMCAMCORDER_UNLOCK_VCAPTURE_CALLBACK(hcamcorder); /* init screennail and EXIF raw data */ - mmf_attribute_set_data(item_screennail, NULL, 0); - mmf_attribute_commit(item_screennail); + mm_attrs_set_data(attrs, attr_index_for_screennail, NULL, 0); + mm_attrs_commit(attrs, attr_index_for_screennail); if (exif_raw_data) { free(exif_raw_data); exif_raw_data = NULL; - mmf_attribute_set_data(item_exif_raw_data, NULL, 0); - mmf_attribute_commit(item_exif_raw_data); + mm_attrs_set_data(attrs, attr_index_for_exif, NULL, 0); + mm_attrs_commit(attrs, attr_index_for_exif); } /* Release jpeg data */ - if (pixtype_main == MM_PIXEL_FORMAT_ENCODED) { - __mmcamcorder_release_jpeg_data((MMHandleType)hcamcorder, &dest); - } + 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 */ @@ -1565,11 +1665,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); @@ -1613,20 +1713,32 @@ 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); } } - /* Handle capture in recording case */ - if (hcamcorder->capture_in_recording) { + 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"); @@ -1667,17 +1779,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; @@ -1692,14 +1802,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: @@ -1719,12 +1827,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"); } @@ -1745,12 +1851,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"); } @@ -1769,20 +1873,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); @@ -1799,22 +1902,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)); @@ -1823,16 +1925,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"); } @@ -1848,22 +1949,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)); @@ -1876,11 +1976,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"); } @@ -1899,7 +1998,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) { @@ -1913,11 +2012,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"); } @@ -1954,13 +2052,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."); } } } @@ -1976,10 +2073,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); - } } } @@ -1993,14 +2089,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: @@ -2019,7 +2114,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!!"); @@ -2034,9 +2129,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; @@ -2083,8 +2177,8 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int /* get ExifData from exif info */ ed = mm_exif_get_exif_from_info(hcamcorder->exif_info); - if (ed == NULL || ed->ifd == NULL) { - _mmcam_dbg_err("get exif data error!!(%p, %p)", ed, (ed ? ed->ifd : NULL)); + if (ed == NULL) { + _mmcam_dbg_err("get exif data error!!"); return MM_ERROR_INVALID_HANDLE; } @@ -2095,43 +2189,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 */ @@ -2158,30 +2249,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); } @@ -2199,16 +2290,21 @@ int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int #endif /*6. EXIF_TAG_IMAGE_DESCRIPTION */ mm_camcorder_get_attributes(handle, NULL, MMCAM_TAG_IMAGE_DESCRIPTION, &str_value, &str_val_len, NULL); - _mmcam_dbg_log("desctiption [%s]", str_value); if (str_value && str_val_len > 0) { char *description = strdup(str_value); - ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_DESCRIPTION, - EXIF_FORMAT_ASCII, strlen(description), (const char *)description); - free(description); - str_value = NULL; - str_val_len = 0; - if (ret != MM_ERROR_NONE) { - EXIF_SET_ERR(ret, EXIF_TAG_IMAGE_DESCRIPTION); + + _mmcam_dbg_log("desctiption [%s]", str_value); + + if (description) { + ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_DESCRIPTION, + EXIF_FORMAT_ASCII, strlen(description), (const char *)description); + free(description); + str_value = NULL; + str_val_len = 0; + if (ret != MM_ERROR_NONE) + EXIF_SET_ERR(ret, EXIF_TAG_IMAGE_DESCRIPTION); + } else { + _mmcam_dbg_err("strdup failed for [%s]", str_value); } } else { _mmcam_dbg_warn("failed to get description"); @@ -2222,10 +2318,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); } @@ -2240,13 +2336,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); @@ -2256,21 +2351,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 */ @@ -2285,7 +2378,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) { @@ -2294,17 +2387,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 */ @@ -2313,7 +2405,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) { @@ -2321,17 +2413,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*/ @@ -2339,20 +2430,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*/ @@ -2361,7 +2450,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) { @@ -2369,17 +2458,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*/ @@ -2395,11 +2483,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."); } @@ -2413,7 +2500,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) { @@ -2421,17 +2508,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*/ @@ -2442,7 +2528,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) { @@ -2455,11 +2541,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."); } @@ -2481,11 +2566,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"); } @@ -2497,26 +2581,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*/ @@ -2525,7 +2607,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) { @@ -2533,38 +2615,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*/ @@ -2572,22 +2651,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); @@ -2595,18 +2671,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); } @@ -2619,10 +2693,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); } @@ -2634,10 +2707,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*/ @@ -2648,24 +2720,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); } @@ -2677,10 +2754,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); - } */ @@ -2690,28 +2766,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"); } @@ -2723,28 +2797,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"); } @@ -2756,28 +2828,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"); } @@ -2789,10 +2859,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); @@ -2800,16 +2869,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; }