#include <sys/time.h>
#include <sys/times.h>
#include <gst/video/cameracontrol.h>
-#include <mm_sound.h>
#include "mm_camcorder_internal.h"
#include "mm_camcorder_stillshot.h"
#include "mm_camcorder_exifinfo.h"
| GLOBAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
#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 |
/* 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_set_data(attr_item, (void *)sink_element, sizeof(*sink_element));
mmf_attribute_commit(attr_item);
/* remove notify callback */
info->next_shot_time = 0;
info->multi_shot_stop = FALSE;
- /* sound init to pause other session */
+ /* sound init */
_mmcamcorder_sound_init(handle);
}
/* 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");
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)
need_change = 1;
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) {
}
cmd_done:
- if (ret != MM_ERROR_NONE)
+ 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;
}
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);
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");
}
/* 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 &&
}
_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)
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)
goto cmd_error;
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);
_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;
/* 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);
+ 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);
+ /* 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)
gst_sample_unref(sample1);
/* 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 */
_mmcam_dbg_log("Done Internal Encode - data %p, length %d", dest.data, dest.length);
}
+ if (pixtype_main < MM_PIXEL_FORMAT_ENCODED) {
+ _mmcam_dbg_log("raw capture, skip EXIF related functions");
+ goto _CAPTURE_CB_EXIF_DONE;
+ }
+
/* create EXIF info */
if (!provide_exif) { /* make new exif */
ret = mm_exif_create_exif_info(&(hcamcorder->exif_info));
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);
+ 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);
+ 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 (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 (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:
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);
- }
+
+ _mmcam_dbg_log("set software_version[%s] ret[0x%x]",
+ hcamcorder->software_version, ret);
} else {
_mmcam_dbg_err("model_name is NULL");
}
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);
- }
+
+ _mmcam_dbg_err("set model name[%s] ret[0x%x]",
+ hcamcorder->model_name, ret);
} else {
_mmcam_dbg_err("model_name is NULL");
}
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) {
+ 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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_LATITUDE_REF);
- }
}
deg = (unsigned int)(latitude);
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) {
+ 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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_LONGITUDE_REF);
- }
}
deg = (unsigned int)(longitude);
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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_PROCESSING_METHOD);
- }
}
}
} else {
__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;
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) {
+ 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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_PIXEL_Y_DIMENSION);
- }
_mmcam_dbg_log("height[%d]", value);
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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_COLOR_SPACE);
- }
}
/*10. EXIF_TAG_COMPONENTS_CONFIGURATION */
_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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_COMPONENTS_CONFIGURATION);
- }
}
/*11. EXIF_TAG_COMPRESSED_BITS_PER_PIXEL */
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_TIME,
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.");
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FNUMBER,
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.");
}
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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_ISO_SPEED_RATINGS);
- }
}
/*18. EXIF_TAG_SHUTTER_SPEED_VALUE*/
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SHUTTER_SPEED_VALUE,
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.");
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_APERTURE_VALUE,
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.");
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_BRIGHTNESS_VALUE,
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.");
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_BIAS_VALUE,
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.");
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_MAX_APERTURE_VALUE,
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");
}
_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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_METERING_MODE);
- }
}
/*25. EXIF_TAG_LIGHT_SOURCE*/
_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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_FLASH);
- }
}
/*27. EXIF_TAG_FOCAL_LENGTH*/
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH,
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.");
}
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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_SENSING_METHOD);
- }
/*29. EXIF_TAG_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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_FILE_SOURCE);
- }
*/
/*30. EXIF_TAG_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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_SCENE_TYPE);
- }
*/
/*31. EXIF_TAG_EXPOSURE_MODE*/
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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_WHITE_BALANCE);
- }
} else {
_mmcam_dbg_warn("failed to get white balance [%x]", ret);
}
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) {
+ 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);
}
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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM);
- }
*/
/*35. EXIF_TAG_SCENE_CAPTURE_TYPE*/
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) {
+ 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);
}
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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GAIN_CONTROL);
- }
*/
_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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_CONTRAST);
- }
} else {
_mmcam_dbg_warn("failed to get range of contrast");
}
_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 {
+ 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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_SATURATION);
- }
} else {
_mmcam_dbg_warn("failed to get range of saturation");
}
_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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_SHARPNESS);
- }
} else {
_mmcam_dbg_warn("failed to get range of sharpness");
}
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) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_SUBJECT_DISTANCE_RANGE);
- }
/* GPS information */
__mmcamcorder_update_exif_gps(handle, ed);
projects / platform / core / multimedia / libmm-camcorder.git / blobdiff