#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 |
#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
_MMCamcorderSubContext *sc = NULL;
int display_reuse_hint = FALSE;
GstElement *sink_element = NULL;
- mmf_attrs_t *attrs = NULL;
+ MMHandleType attrs;
int attr_index = 0;
- mmf_attribute_t *attr_item = NULL;
mmf_return_if_fail(hcamcorder);
goto _REUSE_CHECK_DONE;
}
- attrs = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
+ attrs = MMF_CAMCORDER_ATTRS(handle);
if (!attrs) {
_mmcam_dbg_warn("attribute is NULL");
goto _REUSE_CHECK_DONE;
/* set sink element pointer to attribute */
mm_attrs_get_index((MMHandleType)attrs, MMCAM_DISPLAY_REUSE_ELEMENT, &attr_index);
- attr_item = &attrs->items[attr_index];
- mmf_attribute_set_data(attr_item, (void *)sink_element, sizeof(sink_element));
- mmf_attribute_commit(attr_item);
+ 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);
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;
MMCAM_CAMERA_WIDTH, &width,
MMCAM_CAMERA_HEIGHT, &height,
MMCAM_CAMERA_FPS, &fps,
- MMCAM_CAPTURE_FORMAT, &cap_format,
+ MMCAM_CAPTURE_FORMAT, &info->capture_format,
MMCAM_CAPTURE_WIDTH, &info->width,
MMCAM_CAPTURE_HEIGHT, &info->height,
MMCAM_CAPTURE_COUNT, &info->count,
info->next_shot_time = 0;
info->multi_shot_stop = FALSE;
- /* sound init to pause other session */
+ /* sound init */
_mmcamcorder_sound_init(handle);
}
_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,
+ 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");
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) ||
hcamcorder->support_zsl_capture || is_modified_size) {
- cap_fourcc = _mmcamcorder_get_fourcc(cap_format, image_encoder, hcamcorder->use_zero_copy_format);
+ 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 */
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);
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;
}
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;
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);
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);
}
} 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,
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");
}
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 &&
}
_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_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);
_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;
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;
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);
/* 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);
goto error;
} else {
if ((mapinfo1.data == NULL) && (mapinfo1.size == 0)) {
- _mmcam_dbg_err("mapinfo1 is wrong (%p, size %d)", mapinfo1.data, mapinfo1.size);
+ _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;
_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);
+ 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));
/* 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 (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 */
ret = mm_exif_create_exif_info(&(hcamcorder->exif_info));
}
/* 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);
+ 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);
_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 (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);