[Release version 0.10.48] Change some global function/variable names to avoid invalid...

[platform/core/multimedia/libmm-camcorder.git] / src / mm_camcorder_stillshot.c

diff --git a/src/mm_camcorder_stillshot.c b/src/mm_camcorder_stillshot.c
index d67f67e..fe750c9 100644 (file)
--- a/src/mm_camcorder_stillshot.c
+++ b/src/mm_camcorder_stillshot.c
@@ -316,8 +316,7 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
                                    NULL);
        if (err_name) {
                _mmcam_dbg_warn("get_attributes err %s, ret 0x%x", err_name, ret);
-               free(err_name);
-               err_name = NULL;
+               SAFE_FREE(err_name);
        }
 
        ret = MM_ERROR_NONE;
@@ -335,11 +334,7 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
                info->multi_shot_stop = FALSE;
 
                /* sound init to pause other session */
-#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
-               _mmcamcorder_sound_init(handle, _MMCAMCORDER_FILEPATH_CAPTURE2_SND);
-#else /* _MMCAMCORDER_UPLOAD_SAMPLE */
                _mmcamcorder_sound_init(handle);
-#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
        }
 
        _mmcam_dbg_log("preview(%dx%d,fmt:%d), capture(%dx%d,fmt:%d), count(%d), hdr mode(%d), interval (%d)",
@@ -380,8 +375,7 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
                /* Check encoding method */
                if (cap_format == MM_PIXEL_FORMAT_ENCODED) {
                        if ((sc->SensorEncodedCapture && info->type == _MMCamcorder_SINGLE_SHOT) ||
-                           (sc->SensorEncodedCapture && sc->info_video->support_dual_stream) ||
-                           is_modified_size) {
+                           hcamcorder->support_zsl_capture || is_modified_size) {
                                cap_fourcc = _mmcamcorder_get_fourcc(cap_format, image_encoder, hcamcorder->use_zero_copy_format);
                                _mmcam_dbg_log("Sensor JPEG Capture [is_modified_size:%d]", is_modified_size);
                        } else {
@@ -467,8 +461,7 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
                                                    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 */
@@ -506,8 +499,7 @@ int _mmcamcorder_image_cmd_capture(MMHandleType handle)
                                                  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 */
@@ -539,7 +531,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 */
@@ -721,6 +713,10 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle)
                                                            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);
@@ -763,15 +759,15 @@ int _mmcamcorder_image_cmd_preview_start(MMHandleType handle)
                /* 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);
                }
        }
 
@@ -1190,28 +1186,28 @@ 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);
                }
        } else {
                /* Handle capture in recording case */
                hcamcorder->capture_in_recording = FALSE;
 
-               pthread_mutex_lock(&(hcamcorder->task_thread_lock));
+               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");
-                       pthread_cond_signal(&(hcamcorder->task_thread_cond));
+                       g_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));
+               g_mutex_unlock(&hcamcorder->task_thread_lock);
        }
 
        /* init capture data */
@@ -1319,14 +1315,6 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
                                                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);
-                                               }
-                                               #endif
                                                thumb.format = MM_PIXEL_FORMAT_ENCODED;
                                                thumb.width = atoi(width);
                                                thumb.height = atoi(height);
@@ -1379,14 +1367,14 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
                                     encode_src.width % thumb_width == 0 &&
                                     encode_src.height % thumb_height == 0) {
                                        if (!_mmcamcorder_downscale_UYVYorYUYV(encode_src.data, encode_src.width, encode_src.height,
-                                                                             &thumb_raw_data, thumb_width, thumb_height)) {
+                                               &thumb_raw_data, thumb_width, thumb_height)) {
                                                thumb_raw_data = NULL;
                                                _mmcam_dbg_warn("_mmcamcorder_downscale_UYVYorYUYV failed. skip thumbnail making...");
                                        }
                                } else {
                                        if (!_mmcamcorder_resize_frame(encode_src.data, encode_src.width, encode_src.height,
-                                                                          encode_src.length, encode_src.format,
-                                                                          &thumb_raw_data, &thumb_width, &thumb_height, &thumb_length)) {
+                                               encode_src.length, encode_src.format,
+                                               &thumb_raw_data, &thumb_width, &thumb_height, &thumb_length)) {
                                                thumb_raw_data = NULL;
                                                _mmcam_dbg_warn("_mmcamcorder_resize_frame failed. skip thumbnail making...");
                                        }
@@ -1403,8 +1391,8 @@ 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);
@@ -1441,8 +1429,8 @@ static void __mmcamcorder_image_capture_cb(GstElement *element, GstSample *sampl
                _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");