/*=======================================================================================
| INCLUDE FILES |
=======================================================================================*/
+#include <stdlib.h>
#include <sys/time.h>
#include <sys/times.h>
#include <gst/video/cameracontrol.h>
/* sound status changed callback */
static void __sound_status_changed_cb(keynode_t* node, void *data);
-static void __volume_level_changed_cb(void* user_data);
/*=======================================================================================
| FUNCTION DEFINITIONS |
return ret;
}
- _mmcamcorder_remove_all_handlers(handle, _MMCAMCORDER_HANDLER_STILLSHOT);
+ _mmcamcorder_remove_all_handlers(handle, _MMCAMCORDER_HANDLER_STILLSHOT | _MMCAMCORDER_HANDLER_VIDEOREC);
GstPad *reqpad = NULL;
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: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 */
}
+
+ return;
}
info = sc->info_image;
+ if (info->capturing) {
+ _mmcam_dbg_err("already capturing");
+ return MM_ERROR_CAMCORDER_DEVICE_BUSY;
+ }
+
_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
CONFIGURE_CATEGORY_MAIN_CAPTURE,
"UseCaptureMode",
_mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
- if (info->capturing) {
- ret = MM_ERROR_CAMCORDER_DEVICE_BUSY;
- goto cmd_error;
- }
-
/* get current state */
mm_camcorder_get_state(handle, ¤t_state);
err_name = NULL;
}
+ ret = MM_ERROR_NONE;
+
/* check capture count */
if (info->count < 1) {
_mmcam_dbg_err("capture count[%d] is invalid", info->count);
ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
- goto cmd_error;
+ goto cmd_done;
} else if (info->count == 1) {
info->type = _MMCamcorder_SINGLE_SHOT;
} else {
info->multi_shot_stop = FALSE;
/* sound init to pause other session */
-#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
- _mmcamcorder_sound_init(handle, _MMCAMCORDER_FILEPATH_CAPTURE2_SND);
-#else /* _MMCAMCORDER_UPLOAD_SAMPLE */
_mmcamcorder_sound_init(handle);
-#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
}
_mmcam_dbg_log("preview(%dx%d,fmt:%d), capture(%dx%d,fmt:%d), count(%d), hdr mode(%d), interval (%d)",
- width, height, info->preview_format,
- info->width, info->height, cap_format,
+ width, height, info->preview_format, info->width, info->height, cap_format,
info->count, info->hdr_capture_mode, info->interval);
/* check state */
info->hdr_capture_mode != MM_CAMCORDER_HDR_OFF) {
_mmcam_dbg_err("does not support multi/HDR capture while recording");
ret = MM_ERROR_CAMCORDER_INVALID_STATE;
- goto cmd_error;
+ goto cmd_done;
}
/* check capture size if ZSL is not supported*/
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
_mmcam_dbg_err("Can't cast Video source into camera control.");
- return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
+ ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
+ goto cmd_done;
}
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
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_error;
+ goto cmd_done;
}
if (UseCaptureMode) {
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("failed to set state PAUSED %x", ret);
- return ret;
+ goto cmd_done;
}
if (UseCaptureMode) {
ret = _mmcamcorder_set_videosrc_caps(handle, sc->fourcc, set_width, set_height, fps, rotation);
if (!ret) {
_mmcam_dbg_err("_mmcamcorder_set_videosrc_caps failed");
- return MM_ERROR_CAMCORDER_INTERNAL;
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ goto cmd_done;
}
info->resolution_change = TRUE;
/* 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) {
- _mmcam_dbg_err("failed to set state PAUSED %x", ret);
- return ret;
+ _mmcam_dbg_err("failed to set state PLAYING %x", ret);
+ goto cmd_done;
}
_mmcam_dbg_log("Change to target resolution(%d, %d)", set_width, set_height);
ret = _mmcamcorder_create_stillshot_pipeline((MMHandleType)hcamcorder);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("failed to create encodesinkbin %x", ret);
- return ret;
+ goto cmd_done;
}
ret = mm_camcorder_get_attributes(handle, &err_name,
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;
ret = _mmcamcorder_gst_set_state(handle, sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst, GST_STATE_PLAYING);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("failed to set state PLAYING %x", ret);
- return ret;
+ goto cmd_done;
}
}
info->played_capture_sound = FALSE;
}
- return ret;
+cmd_done:
+ if (ret != MM_ERROR_NONE) {
+ info->capturing = FALSE;
+ }
-cmd_error:
- info->capturing = FALSE;
return ret;
}
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);
+ traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:START:SET_PLAYING_TO_PIPELINE");
+
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
+
+ traceEnd(TTRACE_TAG_CAMERA);
+
if (ret != MM_ERROR_NONE) {
goto cmd_error;
}
_mmcam_dbg_log("sound status %d", info->sound_status);
- /* get volume level */
- mm_sound_volume_get_value(VOLUME_TYPE_SYSTEM, &info->volume_level);
-
- _mmcam_dbg_log("volume level %d", info->volume_level);
-
/* register changed_cb */
vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, __sound_status_changed_cb, hcamcorder);
- mm_sound_volume_add_callback(VOLUME_TYPE_SYSTEM, __volume_level_changed_cb, hcamcorder);
}
}
/* get camera control */
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (control) {
+ /* convert MSL to sensor value */
+ set_strobe = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_MODE, MM_CAMCORDER_STROBE_MODE_OFF);
- /* convert MSL to sensor value */
- set_strobe = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_MODE, MM_CAMCORDER_STROBE_MODE_OFF);
-
- /* set strobe OFF */
- gst_camera_control_set_strobe(control, GST_CAMERA_CONTROL_STROBE_MODE, set_strobe);
+ /* set strobe OFF */
+ gst_camera_control_set_strobe(control, GST_CAMERA_CONTROL_STROBE_MODE, set_strobe);
- _mmcam_dbg_log("set strobe OFF done - value: %d", set_strobe);
+ _mmcam_dbg_log("set strobe OFF done - value: %d", set_strobe);
+ } else {
+ _mmcam_dbg_warn("cast CAMERA_CONTROL failed");
+ }
}
pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
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);
_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;
}
}
-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);
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",
void __mmcamcorder_get_capture_data_from_buffer(MMCamcorderCaptureDataType *capture_data, int pixtype, GstSample *sample)
{
GstCaps *caps = NULL;
- GstMapInfo mapinfo = GST_MAP_INFO_INIT;
+ GstMapInfo mapinfo;
const GstStructure *structure;
mmf_return_if_fail(capture_data && sample);
goto GET_FAILED;
}
+ memset(&mapinfo, 0x0, sizeof(GstMapInfo));
+
gst_buffer_map(gst_sample_get_buffer(sample), &mapinfo, GST_MAP_READ);
capture_data->data = mapinfo.data;
capture_data->format = pixtype;
}
-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;
/* 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);
+ return __mmcamcorder_capture_save_exifinfo(handle, dest, thumbnail, provide_exif);
} else {
- return __mmcamcorder_capture_save_exifinfo(handle, dest, NULL);
+ 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;
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) {
MMCamcorderCaptureDataType thumb = {0,};
MMCamcorderCaptureDataType scrnail = {0,};
MMCamcorderCaptureDataType encode_src = {0,};
- GstMapInfo mapinfo1 = GST_MAP_INFO_INIT;
- GstMapInfo mapinfo2 = GST_MAP_INFO_INIT;
- GstMapInfo mapinfo3 = GST_MAP_INFO_INIT;
+ GstMapInfo mapinfo1;
+ GstMapInfo mapinfo2;
+ GstMapInfo mapinfo3;
mmf_attrs_t *attrs = NULL;
mmf_attribute_t *item_screennail = NULL;
info = sc->info_image;
+ memset(&mapinfo1, 0x0, sizeof(GstMapInfo));
+ memset(&mapinfo2, 0x0, sizeof(GstMapInfo));
+ memset(&mapinfo3, 0x0, sizeof(GstMapInfo));
+
/* get current state */
current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
} else if (!info->played_capture_sound) {
_mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE);
}
+ } else {
+ /* Handle capture in recording case */
+ hcamcorder->capture_in_recording = FALSE;
+
+ pthread_mutex_lock(&(hcamcorder->task_thread_lock));
+
+ if (hcamcorder->task_thread_state == _MMCAMCORDER_TASK_THREAD_STATE_CHECK_CAPTURE_IN_RECORDING) {
+ _mmcam_dbg_log("send signal for capture in recording");
+ pthread_cond_signal(&(hcamcorder->task_thread_cond));
+ } else {
+ _mmcam_dbg_warn("unexpected task thread state : %d", hcamcorder->task_thread_state);
+ }
+
+ pthread_mutex_unlock(&(hcamcorder->task_thread_lock));
}
/* init capture data */
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, JPEG_ENCODER_SOFTWARE);
+ (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);
ret = _mmcamcorder_encode_jpeg(mapinfo1.data, dest.width, dest.height,
pixtype_main, dest.length, capture_quality,
- (void **)&internal_main_data, &internal_main_length, JPEG_ENCODER_HARDWARE);
+ (void **)&internal_main_data, &internal_main_length);
if (!ret) {
_mmcam_dbg_err("_mmcamcorder_encode_jpeg failed");
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);
+ 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);
/* Release jpeg data */
if (pixtype_main == MM_PIXEL_FORMAT_ENCODED) {
- __mmcamcorder_release_jpeg_data((MMHandleType)hcamcorder, &dest);
+ __mmcamcorder_release_jpeg_data((MMHandleType)hcamcorder, &dest, tag_enable, provide_exif);
}
error:
}
}
- /* Handle capture in recording case */
- if (hcamcorder->capture_in_recording) {
- hcamcorder->capture_in_recording = FALSE;
- }
-
_mmcam_dbg_err("END");
return;
ed = exif_data_new_from_data(imagedata, imgln);
//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;
}
/* 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;
}
#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");
return;
}
-
-
-static void __volume_level_changed_cb(void *data)
-{
- mmf_camcorder_t *hcamcorder = (mmf_camcorder_t *)data;
- _MMCamcorderImageInfo *info = NULL;
-
- mmf_return_if_fail(hcamcorder && hcamcorder->sub_context && hcamcorder->sub_context->info_image);
-
- _mmcam_dbg_log("START");
-
- info = hcamcorder->sub_context->info_image;
-
- mm_sound_volume_get_value(VOLUME_TYPE_SYSTEM, &info->volume_level);
-
- _mmcam_dbg_log("DONE : volume level %d", info->volume_level);
-
- return;
-}