From bc1aa0fd5892ccb5f4aeeaa5e92f849d12478e69 Mon Sep 17 00:00:00 2001 From: Jeongmo Yang Date: Tue, 12 Jan 2016 18:45:52 +0900 Subject: [PATCH] [Release version 0.10.29] 1. Replace pthread APIs by glib APIs 2. Remove pulseaudio dependency 3. Replace pulseaudio APIs by dbus APIs for sound play 4. Remove CAMERA_STATE, RECORDER_STATE vconf related code 5. Remove new line in log 6. Correct error check for resource deinit function Change-Id: Ie8c395c2031a44796d27daeb7c2da2651da3c047 Signed-off-by: Jeongmo Yang --- packaging/libmm-camcorder.spec | 4 +- src/include/mm_camcorder_internal.h | 110 +++++---- src/include/mm_camcorder_sound.h | 33 +-- src/include/mm_camcorder_util.h | 38 ++- src/include/mm_camcorder_videorec.h | 48 ++-- src/mm_camcorder_attribute.c | 41 +-- src/mm_camcorder_client.c | 45 ++-- src/mm_camcorder_exifinfo.c | 1 - src/mm_camcorder_gstcommon.c | 6 +- src/mm_camcorder_internal.c | 480 ++++++++++-------------------------- src/mm_camcorder_resource.c | 41 +-- src/mm_camcorder_sound.c | 464 +++++----------------------------- src/mm_camcorder_stillshot.c | 41 ++- src/mm_camcorder_util.c | 290 ++++++++++++++++------ src/mm_camcorder_videorec.c | 34 +-- test/mm_camcorder_testsuite.c | 2 +- 16 files changed, 624 insertions(+), 1054 deletions(-) diff --git a/packaging/libmm-camcorder.spec b/packaging/libmm-camcorder.spec index a64100a..053b754 100644 --- a/packaging/libmm-camcorder.spec +++ b/packaging/libmm-camcorder.spec @@ -2,7 +2,7 @@ Name: libmm-camcorder Summary: Camera and recorder library -Version: 0.10.28 +Version: 0.10.29 Release: 0 Group: Multimedia/Libraries License: Apache-2.0 @@ -24,9 +24,7 @@ BuildRequires: pkgconfig(gstreamer-app-1.0) BuildRequires: pkgconfig(gstreamer-wayland-1.0) BuildRequires: pkgconfig(wayland-client) %endif -BuildRequires: pkgconfig(libpulse) BuildRequires: pkgconfig(vconf) -BuildRequires: gstreamer-devel BuildRequires: pkgconfig(libtbm) BuildRequires: pkgconfig(storage) BuildRequires: pkgconfig(murphy-resource) diff --git a/src/include/mm_camcorder_internal.h b/src/include/mm_camcorder_internal.h index 37f8ff5..d363bdf 100644 --- a/src/include/mm_camcorder_internal.h +++ b/src/include/mm_camcorder_internal.h @@ -28,7 +28,6 @@ #include #include #include -#include #include #include @@ -300,50 +299,50 @@ extern "C" { /** * Functions related with LOCK and WAIT */ -#define _MMCAMCORDER_CAST_MTSAFE(handle) (((mmf_camcorder_t*)handle)->mtsafe) -#define _MMCAMCORDER_LOCK_FUNC(mutex) pthread_mutex_lock(&mutex) -#define _MMCAMCORDER_TRYLOCK_FUNC(mutex) (!pthread_mutex_trylock(&mutex)) -#define _MMCAMCORDER_UNLOCK_FUNC(mutex) pthread_mutex_unlock(&mutex) - -#define _MMCAMCORDER_GET_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).lock) -#define _MMCAMCORDER_LOCK(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_LOCK(handle)) -#define _MMCAMCORDER_TRYLOCK(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_LOCK(handle)) -#define _MMCAMCORDER_UNLOCK(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_LOCK(handle)) - -#define _MMCAMCORDER_GET_COND(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).cond) -#define _MMCAMCORDER_WAIT(handle) pthread_cond_wait(&_MMCAMCORDER_GET_COND(handle), &_MMCAMCORDER_GET_LOCK(handle)) -#define _MMCAMCORDER_TIMED_WAIT(handle, timeout) pthread_cond_timedwait(&_MMCAMCORDER_GET_COND(handle), &_MMCAMCORDER_GET_LOCK(handle), &timeout) -#define _MMCAMCORDER_SIGNAL(handle) pthread_cond_signal(&_MMCAMCORDER_GET_COND(handle)); -#define _MMCAMCORDER_BROADCAST(handle) pthread_cond_broadcast(&_MMCAMCORDER_GET_COND(handle)); +#define _MMCAMCORDER_CAST_MTSAFE(handle) (((mmf_camcorder_t*)handle)->mtsafe) +#define _MMCAMCORDER_LOCK_FUNC(mutex) g_mutex_lock(&mutex) +#define _MMCAMCORDER_TRYLOCK_FUNC(mutex) g_mutex_trylock(&mutex) +#define _MMCAMCORDER_UNLOCK_FUNC(mutex) g_mutex_unlock(&mutex) + +#define _MMCAMCORDER_GET_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).lock) +#define _MMCAMCORDER_LOCK(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_LOCK(handle)) +#define _MMCAMCORDER_TRYLOCK(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_LOCK(handle)) +#define _MMCAMCORDER_UNLOCK(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_LOCK(handle)) + +#define _MMCAMCORDER_GET_COND(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).cond) +#define _MMCAMCORDER_WAIT(handle) g_cond_wait(&_MMCAMCORDER_GET_COND(handle), &_MMCAMCORDER_GET_LOCK(handle)) +#define _MMCAMCORDER_WAIT_UNTIL(handle, timeout) g_cond_wait_until(&_MMCAMCORDER_GET_COND(handle), &_MMCAMCORDER_GET_LOCK(handle), &end_time) +#define _MMCAMCORDER_SIGNAL(handle) g_cond_signal(&_MMCAMCORDER_GET_COND(handle)); +#define _MMCAMCORDER_BROADCAST(handle) g_cond_broadcast(&_MMCAMCORDER_GET_COND(handle)); /* for command */ -#define _MMCAMCORDER_GET_CMD_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).cmd_lock) -#define _MMCAMCORDER_LOCK_CMD(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_CMD_LOCK(handle)) -#define _MMCAMCORDER_TRYLOCK_CMD(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_CMD_LOCK(handle)) -#define _MMCAMCORDER_UNLOCK_CMD(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_CMD_LOCK(handle)) +#define _MMCAMCORDER_GET_CMD_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).cmd_lock) +#define _MMCAMCORDER_LOCK_CMD(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_CMD_LOCK(handle)) +#define _MMCAMCORDER_TRYLOCK_CMD(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_CMD_LOCK(handle)) +#define _MMCAMCORDER_UNLOCK_CMD(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_CMD_LOCK(handle)) /* for ASM */ -#define _MMCAMCORDER_GET_ASM_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).asm_lock) -#define _MMCAMCORDER_LOCK_ASM(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_ASM_LOCK(handle)) -#define _MMCAMCORDER_TRYLOCK_ASM(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_ASM_LOCK(handle)) -#define _MMCAMCORDER_UNLOCK_ASM(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_ASM_LOCK(handle)) +#define _MMCAMCORDER_GET_ASM_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).asm_lock) +#define _MMCAMCORDER_LOCK_ASM(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_ASM_LOCK(handle)) +#define _MMCAMCORDER_TRYLOCK_ASM(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_ASM_LOCK(handle)) +#define _MMCAMCORDER_UNLOCK_ASM(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_ASM_LOCK(handle)) /* for state change */ -#define _MMCAMCORDER_GET_STATE_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).state_lock) -#define _MMCAMCORDER_LOCK_STATE(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_STATE_LOCK(handle)) -#define _MMCAMCORDER_TRYLOCK_STATE(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_STATE_LOCK(handle)) -#define _MMCAMCORDER_UNLOCK_STATE(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_STATE_LOCK(handle)) +#define _MMCAMCORDER_GET_STATE_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).state_lock) +#define _MMCAMCORDER_LOCK_STATE(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_STATE_LOCK(handle)) +#define _MMCAMCORDER_TRYLOCK_STATE(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_STATE_LOCK(handle)) +#define _MMCAMCORDER_UNLOCK_STATE(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_STATE_LOCK(handle)) /* for gstreamer state change */ -#define _MMCAMCORDER_GET_GST_STATE_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).gst_state_lock) -#define _MMCAMCORDER_LOCK_GST_STATE(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_GST_STATE_LOCK(handle)) -#define _MMCAMCORDER_TRYLOCK_GST_STATE(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_GST_STATE_LOCK(handle)) -#define _MMCAMCORDER_UNLOCK_GST_STATE(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_GST_STATE_LOCK(handle)) +#define _MMCAMCORDER_GET_GST_STATE_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).gst_state_lock) +#define _MMCAMCORDER_LOCK_GST_STATE(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_GST_STATE_LOCK(handle)) +#define _MMCAMCORDER_TRYLOCK_GST_STATE(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_GST_STATE_LOCK(handle)) +#define _MMCAMCORDER_UNLOCK_GST_STATE(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_GST_STATE_LOCK(handle)) -#define _MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).gst_encode_state_lock) -#define _MMCAMCORDER_LOCK_GST_ENCODE_STATE(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle)) -#define _MMCAMCORDER_TRYLOCK_GST_ENCODE_STATE(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle)) -#define _MMCAMCORDER_UNLOCK_GST_ENCODE_STATE(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle)) +#define _MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).gst_encode_state_lock) +#define _MMCAMCORDER_LOCK_GST_ENCODE_STATE(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle)) +#define _MMCAMCORDER_TRYLOCK_GST_ENCODE_STATE(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle)) +#define _MMCAMCORDER_UNLOCK_GST_ENCODE_STATE(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle)) /* for setting/calling callback */ #define _MMCAMCORDER_GET_MESSAGE_CALLBACK_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).message_cb_lock) @@ -556,17 +555,17 @@ typedef struct { * MMCamcorder information for Multi-Thread Safe */ typedef struct { - pthread_mutex_t lock; /**< Mutex (for general use) */ - pthread_cond_t cond; /**< Condition (for general use) */ - pthread_mutex_t cmd_lock; /**< Mutex (for command) */ - pthread_mutex_t asm_lock; /**< Mutex (for ASM) */ - pthread_mutex_t state_lock; /**< Mutex (for state change) */ - pthread_mutex_t gst_state_lock; /**< Mutex (for gst pipeline state change) */ - pthread_mutex_t gst_encode_state_lock; /**< Mutex (for gst encode pipeline state change) */ - pthread_mutex_t message_cb_lock; /**< Mutex (for message callback) */ - pthread_mutex_t vcapture_cb_lock; /**< Mutex (for video capture callback) */ - pthread_mutex_t vstream_cb_lock; /**< Mutex (for video stream callback) */ - pthread_mutex_t astream_cb_lock; /**< Mutex (for audio stream callback) */ + GMutex lock; /**< Mutex (for general use) */ + GCond cond; /**< Condition (for general use) */ + GMutex cmd_lock; /**< Mutex (for command) */ + GMutex asm_lock; /**< Mutex (for ASM) */ + GMutex state_lock; /**< Mutex (for state change) */ + GMutex gst_state_lock; /**< Mutex (for gst pipeline state change) */ + GMutex gst_encode_state_lock; /**< Mutex (for gst encode pipeline state change) */ + GMutex message_cb_lock; /**< Mutex (for message callback) */ + GMutex vcapture_cb_lock; /**< Mutex (for video capture callback) */ + GMutex vstream_cb_lock; /**< Mutex (for video stream callback) */ + GMutex astream_cb_lock; /**< Mutex (for audio stream callback) */ } _MMCamcorderMTSafe; /** @@ -659,11 +658,9 @@ typedef struct mmf_camcorder { int conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_NUM]; /** configure info table size - CONTROL category */ _MMCamcorderMTSafe mtsafe; /**< Thread safe */ int state_change_by_system; /**< MSL changes its state by itself because of system */ - pthread_mutex_t sound_lock; /**< Capture sound mutex */ - pthread_cond_t sound_cond; /**< Capture sound cond */ - pthread_mutex_t restart_preview_lock; /**< Capture sound mutex */ + GMutex restart_preview_lock; /**< Capture sound mutex */ int use_zero_copy_format; /**< Whether use zero copy format for camera input */ - int support_media_packet_preview_cb; /**< Whether support zero copy format for camera input */ + int support_media_packet_preview_cb; /**< Whether support zero copy format for camera input */ int shutter_sound_policy; /**< shutter sound policy */ int brightness_default; /**< default value of brightness */ int brightness_step_denominator; /**< denominator of brightness bias step */ @@ -690,14 +687,19 @@ typedef struct mmf_camcorder { int error_code; /**< error code for internal gstreamer error */ /* task thread */ - pthread_t task_thread; /**< thread for task */ - pthread_mutex_t task_thread_lock; /**< mutex for task thread */ - pthread_cond_t task_thread_cond; /**< cond for task thread */ + GThread *task_thread; /**< thread for task */ + GMutex task_thread_lock; /**< mutex for task thread */ + GCond task_thread_cond; /**< cond for task thread */ _MMCamcorderTaskThreadState task_thread_state; /**< state of task thread */ /* resource manager for H/W resources */ MMCamcorderResourceManager resource_manager; + /* gdbus */ + GDBusConnection *gdbus_conn; /**< gdbus connection */ + _MMCamcorderGDbusCbInfo gdbus_info_sound; /**< Informations for the gbus cb of sound play */ + _MMCamcorderGDbusCbInfo gdbus_info_solo_sound; /**< Informations for the gbus cb of solo sound play */ + int reserved[4]; /**< reserved */ } mmf_camcorder_t; diff --git a/src/include/mm_camcorder_sound.h b/src/include/mm_camcorder_sound.h index 72477a9..cdeed58 100644 --- a/src/include/mm_camcorder_sound.h +++ b/src/include/mm_camcorder_sound.h @@ -25,7 +25,7 @@ /*======================================================================================= | INCLUDE FILES | ========================================================================================*/ -#include + #ifdef __cplusplus extern "C" { @@ -39,11 +39,9 @@ extern "C" { /*======================================================================================= | MACRO DEFINITIONS | ========================================================================================*/ -#define _MMCAMCORDER_FILEPATH_CAPTURE_SND "/usr/share/sounds/mm-camcorder/capture_shutter_01.wav" -#define _MMCAMCORDER_FILEPATH_CAPTURE2_SND "/usr/share/sounds/mm-camcorder/capture_shutter_02.wav" -#define _MMCAMCORDER_FILEPATH_REC_START_SND "/usr/share/sounds/mm-camcorder/recording_start_01.wav" -#define _MMCAMCORDER_FILEPATH_REC_STOP_SND "/usr/share/sounds/mm-camcorder/recording_stop_01.wav" -#define _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE "camera-shutter" +#define _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE01 "camera-shutter-01" +#define _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE02 "camera-shutter-02" +#define _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_START "recording-start" #define _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_STOP "recording-stop" /*======================================================================================= @@ -61,23 +59,14 @@ typedef enum { /** * Structure of sound info */ -typedef struct __SOUND_INFO { - /* PCM */ - int volume_type; - unsigned int volume_level; - +typedef struct _SOUND_INFO { /* mutex and cond */ - pthread_mutex_t play_mutex; - pthread_cond_t play_cond; - pthread_mutex_t open_mutex; - pthread_cond_t open_cond; - - /* pulse audio */ - pa_threaded_mainloop *pulse_mainloop; - pa_context *pulse_context; - pa_stream *sample_stream; - pa_sample_spec sample_spec; + GMutex play_mutex; + GCond play_cond; + GMutex open_mutex; + GCond open_cond; + /* state */ _MMCamcorderSoundState state; } SOUND_INFO; @@ -93,7 +82,7 @@ gboolean _mmcamcorder_sound_init(MMHandleType handle); gboolean _mmcamcorder_sound_play(MMHandleType handle, const char *sample_name, gboolean sync_play); gboolean _mmcamcorder_sound_finalize(MMHandleType handle); -void _mmcamcorder_sound_solo_play(MMHandleType handle, const char *filepath, gboolean sync_play); +int _mmcamcorder_sound_solo_play(MMHandleType handle, const char *sample_name, gboolean sync_play); void _mmcamcorder_sound_solo_play_wait(MMHandleType handle); #ifdef __cplusplus diff --git a/src/include/mm_camcorder_util.h b/src/include/mm_camcorder_util.h index fae91e5..bb1bfbc 100644 --- a/src/include/mm_camcorder_util.h +++ b/src/include/mm_camcorder_util.h @@ -25,6 +25,7 @@ /*======================================================================================= | INCLUDE FILES | ========================================================================================*/ +#include #include @@ -168,6 +169,17 @@ do { \ | ENUM DEFINITIONS | ========================================================================================*/ /** + * Structure of GDBus Callback. + */ +typedef struct { + GCond sync_cond; + GMutex sync_mutex; + int param; + int is_playing; + guint subscribe_id; +} _MMCamcorderGDbusCbInfo; + +/** *Type define of util. */ typedef enum { @@ -203,21 +215,23 @@ typedef struct { * Structure of message item */ typedef struct { - MMHandleType handle; /**< handle */ - int id; /**< message id */ - MMMessageParamType param; /**< message parameter */ - pthread_mutex_t lock; /**< mutex for item */ + MMHandleType handle; /**< handle */ + int id; /**< message id */ + MMMessageParamType param; /**< message parameter */ + GMutex lock; /**< mutex for item */ } _MMCamcorderMsgItem; /*======================================================================================= | CONSTANT DEFINITIONS | ========================================================================================*/ +#define G_DBUS_CB_TIMEOUT_MSEC 3000 +#define G_DBUS_REPLY_TIMEOUT (120 * 1000) #define FAT32_FILE_SYSTEM_MAX_SIZE (4294967295UL) /* 4 GigaByte - 1 byte */ #define NANO_SEC_PER_MILI_SEC 1000000 #define _MMCAMCORDER_HANDLER_CATEGORY_ALL \ (_MMCAMCORDER_HANDLER_PREVIEW | _MMCAMCORDER_HANDLER_VIDEOREC |_MMCAMCORDER_HANDLER_STILLSHOT | _MMCAMCORDER_HANDLER_AUDIOREC) -#define G_DBUS_REPLY_TIMEOUT (120 * 1000) + /*======================================================================================= | GLOBAL FUNCTION PROTOTYPES | @@ -246,13 +260,13 @@ unsigned int _mmcamcorder_get_fourcc(int pixtype, int codectype, int use_zero_co /* JPEG encode */ gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsigned int src_height, - int src_format, unsigned int src_length, unsigned int jpeg_quality, - void **result_data, unsigned int *result_length); + int src_format, unsigned int src_length, unsigned int jpeg_quality, + void **result_data, unsigned int *result_length); /* resize */ gboolean _mmcamcorder_resize_frame(unsigned char *src_data, unsigned int src_width, unsigned int src_height, unsigned int src_length, int src_format, - unsigned char **dst_data, unsigned int *dst_width, unsigned int *dst_height, unsigned int *dst_length); + unsigned char **dst_data, unsigned int *dst_width, unsigned int *dst_height, unsigned int *dst_length); gboolean _mmcamcorder_downscale_UYVYorYUYV(unsigned char *src, unsigned int src_width, unsigned int src_height, - unsigned char **dst, unsigned int dst_width, unsigned int dst_height); + unsigned char **dst, unsigned int dst_width, unsigned int dst_height); /* Recording */ /* find top level tag only, do not use this function for finding sub level tags. @@ -277,7 +291,11 @@ int _mmcamcorder_get_file_system_type(const gchar *path, int *file_system_type); void *_mmcamcorder_util_task_thread_func(void *data); /* device */ -int _mmcamcorder_get_device_flash_brightness(int *brightness); +int _mmcamcorder_get_device_flash_brightness(GDBusConnection *conn, int *brightness); + +/* sound play via dbus*/ +int _mmcamcorder_send_sound_play_message(GDBusConnection *conn, _MMCamcorderGDbusCbInfo *gdbus_info, + const char *sample_name, const char *stream_role, const char *volume_gain, int sync_play); #ifdef __cplusplus } diff --git a/src/include/mm_camcorder_videorec.h b/src/include/mm_camcorder_videorec.h index f15a12f..f592e93 100644 --- a/src/include/mm_camcorder_videorec.h +++ b/src/include/mm_camcorder_videorec.h @@ -55,31 +55,31 @@ enum { * MMCamcorder information for video(preview/recording) mode */ typedef struct { - gboolean b_commiting; /**< Is it commiting now? */ - char *filename; /**< recorded filename */ - double record_timestamp_ratio; /**< timestamp ratio of video recording for slow/fast motion recording */ - double record_motion_rate; /**< motion rate of video recording for slow/fast motion recording */ - GstClockTime prev_preview_ts; /**< previous preview frame timestamp */ - GstClockTime base_video_ts; /**< base video frame timestamp */ - guint record_drop_count; /**< drop count of video recording for slow/fast motion recording */ - guint64 video_frame_count; /**< current video frame */ - guint64 audio_frame_count; /**< current audio frame */ - guint64 filesize; /**< current file size */ - guint64 max_size; /**< max recording size */ - guint64 max_time; /**< max recording time */ - int fileformat; /**< recording file format */ - int push_encoding_buffer; /**< ready to record flag */ - int preview_width; /**< preview width */ - int preview_height; /**< preview height */ - int video_width; /**< video width */ - int video_height; /**< video height */ - int fps; /**< fps in videosrc caps */ + gboolean b_commiting; /**< Is it commiting now? */ + char *filename; /**< recorded filename */ + double record_timestamp_ratio; /**< timestamp ratio of video recording for slow/fast motion recording */ + double record_motion_rate; /**< motion rate of video recording for slow/fast motion recording */ + GstClockTime prev_preview_ts; /**< previous preview frame timestamp */ + GstClockTime base_video_ts; /**< base video frame timestamp */ + guint record_drop_count; /**< drop count of video recording for slow/fast motion recording */ + guint64 video_frame_count; /**< current video frame */ + guint64 audio_frame_count; /**< current audio frame */ + guint64 filesize; /**< current file size */ + guint64 max_size; /**< max recording size */ + guint64 max_time; /**< max recording time */ + int fileformat; /**< recording file format */ + int push_encoding_buffer; /**< ready to record flag */ + int preview_width; /**< preview width */ + int preview_height; /**< preview height */ + int video_width; /**< video width */ + int video_height; /**< video height */ + int fps; /**< fps in videosrc caps */ gboolean is_firstframe; - gboolean get_first_I_frame; /**< start flag for H.264 preview recording */ - gboolean support_dual_stream; /**< support dual stream flag */ - gboolean record_dual_stream; /**< record with dual stream flag */ - gboolean restart_preview; /**< flag for whether restart preview or not when start recording */ - pthread_mutex_t size_check_lock;/**< mutex for checking recording size */ + gboolean get_first_I_frame; /**< start flag for H.264 preview recording */ + gboolean support_dual_stream; /**< support dual stream flag */ + gboolean record_dual_stream; /**< record with dual stream flag */ + gboolean restart_preview; /**< flag for whether restart preview or not when start recording */ + GMutex size_check_lock; /**< mutex for checking recording size */ } _MMCamcorderVideoInfo; /*======================================================================================= diff --git a/src/mm_camcorder_attribute.c b/src/mm_camcorder_attribute.c index 2e001ff..c4e312c 100644 --- a/src/mm_camcorder_attribute.c +++ b/src/mm_camcorder_attribute.c @@ -1420,8 +1420,8 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_FLAG_RW, {(void*)MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_BITRATE}, MM_ATTRS_VALID_TYPE_INT_RANGE, - 0, - _MMCAMCORDER_MAX_INT, + {.int_min = 0}, + {.int_max = _MMCAMCORDER_MAX_INT}, _mmcamcorder_commit_encoded_preview_bitrate, }, { @@ -1431,8 +1431,8 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_FLAG_RW, {(void*)MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_GOP_INTERVAL}, MM_ATTRS_VALID_TYPE_INT_RANGE, - 0, - _MMCAMCORDER_MAX_INT, + {.int_min = 0}, + {.int_max = _MMCAMCORDER_MAX_INT}, _mmcamcorder_commit_encoded_preview_gop_interval, }, { @@ -2137,7 +2137,7 @@ bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const m hcamcorder->resolution_changed = FALSE; - if (!pthread_mutex_trylock(&(hcamcorder->restart_preview_lock))) { + if (g_mutex_trylock(&hcamcorder->restart_preview_lock)) { _mmcam_dbg_log("restart preview"); MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE); @@ -2156,7 +2156,7 @@ bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const m _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING); /* unlock */ - pthread_mutex_unlock(&(hcamcorder->restart_preview_lock)); + g_mutex_unlock(&hcamcorder->restart_preview_lock); } else { _mmcam_dbg_err("currently locked for preview restart"); return FALSE; @@ -2225,7 +2225,7 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const hcamcorder->resolution_changed = FALSE; - if (!pthread_mutex_trylock(&(hcamcorder->restart_preview_lock))) { + if (g_mutex_trylock(&hcamcorder->restart_preview_lock)) { _mmcam_dbg_log("restart preview"); _mmcam_dbg_log("set empty buffers"); @@ -2247,7 +2247,7 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING); /* unlock */ - pthread_mutex_unlock(&(hcamcorder->restart_preview_lock)); + g_mutex_unlock(&hcamcorder->restart_preview_lock); } else { _mmcam_dbg_err("currently locked for preview restart"); return FALSE; @@ -3694,7 +3694,6 @@ bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_va mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); int strobe_type, mslVal, newVal, cur_value; int current_state = MM_CAMCORDER_STATE_NONE; - int set_flash_state = -1; if (hcamcorder == NULL) { _mmcam_dbg_err("NULL handle"); @@ -3714,7 +3713,7 @@ bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_va int flash_brightness = 0; /* get current flash brightness */ - if (_mmcamcorder_get_device_flash_brightness(&flash_brightness) != MM_ERROR_NONE) { + if (_mmcamcorder_get_device_flash_brightness(hcamcorder->gdbus_conn, &flash_brightness) != MM_ERROR_NONE) { _mmcam_dbg_err("_mmcamcorder_get_device_flash_brightness failed"); hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION; return FALSE; @@ -3729,14 +3728,7 @@ bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_va _mmcam_dbg_err("other module already turned on flash. avoid to set flash mode here."); return FALSE; } else { - /* flash is OFF state, this case will set flash state key */ - if (mslVal == MM_CAMCORDER_STROBE_MODE_OFF) { - set_flash_state = VCONFKEY_CAMERA_FLASH_STATE_OFF; - } else { - set_flash_state = VCONFKEY_CAMERA_FLASH_STATE_ON; - } - - _mmcam_dbg_log("keep going, and will set flash state key %d", set_flash_state); + _mmcam_dbg_log("keep going"); } } @@ -3744,13 +3736,6 @@ bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_va current_state = _mmcamcorder_get_state(handle); if (current_state < MM_CAMCORDER_STATE_READY) { _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state); - - if (set_flash_state != -1) { - _mmcam_dbg_log("set VCONFKEY_CAMERA_FLASH_STATE : %d", set_flash_state); - vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, set_flash_state); - vconf_set_int(VCONFKEY_CAMERA_PID, (int)getpid()); - } - return TRUE; } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) { _mmcam_dbg_warn("invalid state[capturing]"); @@ -3812,12 +3797,6 @@ bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_va } } - if (bret == TRUE && set_flash_state != -1) { - _mmcam_dbg_log("set VCONFKEY_CAMERA_FLASH_STATE : %d", set_flash_state); - vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, set_flash_state); - vconf_set_int(VCONFKEY_CAMERA_PID, (int)getpid()); - } - return bret; } diff --git a/src/mm_camcorder_client.c b/src/mm_camcorder_client.c index 5c5dd50..e682805 100644 --- a/src/mm_camcorder_client.c +++ b/src/mm_camcorder_client.c @@ -24,7 +24,6 @@ | INCLUDE FILES | | | ========================================================================================== */ -#include #include #include #include @@ -1537,13 +1536,13 @@ int mm_camcorder_client_create(MMHandleType *handle) hcamcorder->target_state = MM_CAMCORDER_STATE_NULL; hcamcorder->capture_in_recording = FALSE; - pthread_mutex_init(&((hcamcorder->mtsafe).lock), NULL); - pthread_cond_init(&((hcamcorder->mtsafe).cond), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).cmd_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).state_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).gst_state_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).message_cb_lock), NULL); - pthread_mutex_init(&(hcamcorder->restart_preview_lock), NULL); + g_mutex_init(&(hcamcorder->mtsafe).lock); + g_cond_init(&(hcamcorder->mtsafe).cond); + g_mutex_init(&(hcamcorder->mtsafe).cmd_lock); + g_mutex_init(&(hcamcorder->mtsafe).state_lock); + g_mutex_init(&(hcamcorder->mtsafe).gst_state_lock); + g_mutex_init(&(hcamcorder->mtsafe).message_cb_lock); + g_mutex_init(&hcamcorder->restart_preview_lock); /* Get Camera Configure information from Camcorder INI file */ _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &hcamcorder->conf_main); @@ -1598,15 +1597,15 @@ _ERR_CAMCORDER_CREATE_CONFIGURE: _ERR_CAMCORDER_RESOURCE_CREATION: _ERR_DEFAULT_VALUE_INIT: /* Release lock, cond */ - pthread_mutex_destroy(&((hcamcorder->mtsafe).lock)); - pthread_cond_destroy(&((hcamcorder->mtsafe).cond)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).cmd_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_encode_state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).message_cb_lock)); + g_mutex_clear(&(hcamcorder->mtsafe).lock); + g_cond_clear(&(hcamcorder->mtsafe).cond); + g_mutex_clear(&(hcamcorder->mtsafe).cmd_lock); + g_mutex_clear(&(hcamcorder->mtsafe).state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).gst_state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).gst_encode_state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).message_cb_lock); - pthread_mutex_destroy(&(hcamcorder->restart_preview_lock)); + g_mutex_clear(&(hcamcorder->restart_preview_lock)); if (hcamcorder->conf_ctrl) { _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl); @@ -1641,13 +1640,13 @@ void mm_camcorder_client_destroy(MMHandleType handle) _mmcam_dbg_log("unlock"); _MMCAMCORDER_UNLOCK_CMD(hcamcorder); - pthread_mutex_destroy(&((hcamcorder->mtsafe).lock)); - pthread_cond_destroy(&((hcamcorder->mtsafe).cond)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).cmd_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).message_cb_lock)); - pthread_mutex_destroy(&(hcamcorder->restart_preview_lock)); + g_mutex_clear(&((hcamcorder->mtsafe).lock)); + g_cond_clear(&((hcamcorder->mtsafe).cond)); + g_mutex_clear(&((hcamcorder->mtsafe).cmd_lock)); + g_mutex_clear(&((hcamcorder->mtsafe).state_lock)); + g_mutex_clear(&((hcamcorder->mtsafe).gst_state_lock)); + g_mutex_clear(&((hcamcorder->mtsafe).message_cb_lock)); + g_mutex_clear(&(hcamcorder->restart_preview_lock)); _mmcamcorder_set_state((MMHandleType)hcamcorder, MM_CAMCORDER_STATE_NONE); /* Release handle */ memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t)); diff --git a/src/mm_camcorder_exifinfo.c b/src/mm_camcorder_exifinfo.c index a2f7e60..a8975b5 100644 --- a/src/mm_camcorder_exifinfo.c +++ b/src/mm_camcorder_exifinfo.c @@ -32,7 +32,6 @@ #include #include #include -#include #define MM_EXIFINFO_USE_BINARY_EXIFDATA 1 #define JPEG_MAX_SIZE 20000000 diff --git a/src/mm_camcorder_gstcommon.c b/src/mm_camcorder_gstcommon.c index 97d2e60..955e7da 100644 --- a/src/mm_camcorder_gstcommon.c +++ b/src/mm_camcorder_gstcommon.c @@ -1734,11 +1734,11 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_push_buffer_to_record(Gst if(sc->info_video->is_firstframe) { /* for image capture with encodebin(ex:emulator) */ if (sc->bencbin_capture && sc->info_image->capturing) { - 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_SOLO_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); } sc->info_video->is_firstframe = FALSE; sc->info_video->base_video_ts = GST_BUFFER_PTS(buffer); diff --git a/src/mm_camcorder_internal.c b/src/mm_camcorder_internal.c index c1847d8..990f8d4 100644 --- a/src/mm_camcorder_internal.c +++ b/src/mm_camcorder_internal.c @@ -47,7 +47,6 @@ /*--------------------------------------------------------------------------------------- | GLOBAL VARIABLE DEFINITIONS for internal | ---------------------------------------------------------------------------------------*/ -int g_mm_camcorder_type = -255; struct sigaction mm_camcorder_int_old_action; struct sigaction mm_camcorder_abrt_old_action; struct sigaction mm_camcorder_segv_old_action; @@ -97,42 +96,8 @@ static void _mmcamcorder_constructor() __attribute__((constructor)); static void __mm_camcorder_signal_handler(int signo) { pid_t my_pid = getpid(); - pid_t vconf_recorder_pid = -1; - pid_t vconf_camera_pid = -1; - int vconf_flash_state = VCONFKEY_CAMERA_FLASH_STATE_OFF; - - _mmcam_dbg_warn("start - signo [%d], pid [%d], device type [%d]", signo, my_pid, g_mm_camcorder_type); - - /* reset vconf key */ - switch (g_mm_camcorder_type) { - case MM_VIDEO_DEVICE_NONE: - vconf_get_int(VCONFKEY_RECORDER_PID, (int *)&vconf_recorder_pid); - if (my_pid == vconf_recorder_pid) { - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL); - vconf_set_int(VCONFKEY_RECORDER_PID, -1); - _mmcam_dbg_warn("set recorder state NULL"); - } else { - _mmcam_dbg_warn("different pid : my[%d] vconf[%d]", my_pid, vconf_recorder_pid); - } - break; - case MM_VIDEO_DEVICE_CAMERA0: - case MM_VIDEO_DEVICE_CAMERA1: - vconf_get_int(VCONFKEY_CAMERA_FLASH_STATE, &vconf_flash_state); - vconf_get_int(VCONFKEY_CAMERA_PID, (int *)&vconf_camera_pid); - if (my_pid == vconf_camera_pid && - vconf_flash_state == VCONFKEY_CAMERA_FLASH_STATE_ON) { - vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, VCONFKEY_CAMERA_FLASH_STATE_OFF); - vconf_set_int(VCONFKEY_CAMERA_PID, -1); - _mmcam_dbg_warn("set camera flash state OFF"); - } - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL); - _mmcam_dbg_warn("set camera state NULL"); - break; - default: - _mmcam_dbg_warn("unknown type [%d]", g_mm_camcorder_type); - break; - } + _mmcam_dbg_warn("start - signo [%d], pid [%d]", signo, my_pid); /* call old signal handler */ switch (signo) { @@ -223,33 +188,39 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) hcamcorder->capture_in_recording = FALSE; hcamcorder->session_type = MM_SESSION_TYPE_MEDIA; - pthread_mutex_init(&((hcamcorder->mtsafe).lock), NULL); - pthread_cond_init(&((hcamcorder->mtsafe).cond), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).cmd_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).asm_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).state_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).gst_state_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).gst_encode_state_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).message_cb_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).vcapture_cb_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).vstream_cb_lock), NULL); - pthread_mutex_init(&((hcamcorder->mtsafe).astream_cb_lock), NULL); - - pthread_mutex_init(&(hcamcorder->sound_lock), NULL); - pthread_cond_init(&(hcamcorder->sound_cond), NULL); - pthread_mutex_init(&(hcamcorder->restart_preview_lock), NULL); + g_mutex_init(&(hcamcorder->mtsafe).lock); + g_cond_init(&(hcamcorder->mtsafe).cond); + g_mutex_init(&(hcamcorder->mtsafe).cmd_lock); + g_mutex_init(&(hcamcorder->mtsafe).asm_lock); + g_mutex_init(&(hcamcorder->mtsafe).state_lock); + g_mutex_init(&(hcamcorder->mtsafe).gst_state_lock); + g_mutex_init(&(hcamcorder->mtsafe).gst_encode_state_lock); + g_mutex_init(&(hcamcorder->mtsafe).message_cb_lock); + g_mutex_init(&(hcamcorder->mtsafe).vcapture_cb_lock); + g_mutex_init(&(hcamcorder->mtsafe).vstream_cb_lock); + g_mutex_init(&(hcamcorder->mtsafe).astream_cb_lock); + + g_mutex_init(&hcamcorder->restart_preview_lock); /* Sound mutex/cond init */ - pthread_mutex_init(&(hcamcorder->snd_info.open_mutex), NULL); - pthread_cond_init(&(hcamcorder->snd_info.open_cond), NULL); + g_mutex_init(&hcamcorder->snd_info.open_mutex); + g_cond_init(&hcamcorder->snd_info.open_cond); + g_mutex_init(&hcamcorder->snd_info.play_mutex); + g_cond_init(&hcamcorder->snd_info.play_cond); /* init for sound thread */ - pthread_mutex_init(&(hcamcorder->task_thread_lock), NULL); - pthread_cond_init(&(hcamcorder->task_thread_cond), NULL); + g_mutex_init(&hcamcorder->task_thread_lock); + g_cond_init(&hcamcorder->task_thread_cond); hcamcorder->task_thread_state = _MMCAMCORDER_SOUND_STATE_NONE; /* create task thread */ - pthread_create(&(hcamcorder->task_thread), NULL, _mmcamcorder_util_task_thread_func, (void *)hcamcorder); + hcamcorder->task_thread = g_thread_try_new("MMCAM_TASK_THREAD", + (GThreadFunc)_mmcamcorder_util_task_thread_func, (gpointer)hcamcorder, NULL); + if (hcamcorder->task_thread == NULL) { + _mmcam_dbg_err("_mmcamcorder_create::failed to create task thread"); + ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION; + goto _ERR_DEFAULT_VALUE_INIT; + } if (info->videodev_type < MM_VIDEO_DEVICE_NONE || info->videodev_type >= MM_VIDEO_DEVICE_NUM) { @@ -502,7 +473,6 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) } } - /* initialize resource manager */ ret = _mmcamcorder_resource_manager_init(&hcamcorder->resource_manager, (void *)hcamcorder); if (ret != MM_ERROR_NONE) { @@ -574,9 +544,6 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info) _mmcam_dbg_log("created handle %p", hcamcorder); - /* set device type */ - g_mm_camcorder_type = info->videodev_type; - *handle = (MMHandleType)hcamcorder; return MM_ERROR_NONE; @@ -601,23 +568,21 @@ _ERR_DEFAULT_VALUE_INIT: } /* Release lock, cond */ - pthread_mutex_destroy(&((hcamcorder->mtsafe).lock)); - pthread_cond_destroy(&((hcamcorder->mtsafe).cond)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).cmd_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).asm_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_encode_state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).message_cb_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).vcapture_cb_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).vstream_cb_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).astream_cb_lock)); - - pthread_mutex_destroy(&(hcamcorder->sound_lock)); - pthread_cond_destroy(&(hcamcorder->sound_cond)); - pthread_mutex_destroy(&(hcamcorder->snd_info.open_mutex)); - pthread_cond_destroy(&(hcamcorder->snd_info.open_cond)); - pthread_mutex_destroy(&(hcamcorder->restart_preview_lock)); + g_mutex_clear(&(hcamcorder->mtsafe).lock); + g_cond_clear(&(hcamcorder->mtsafe).cond); + g_mutex_clear(&(hcamcorder->mtsafe).cmd_lock); + g_mutex_clear(&(hcamcorder->mtsafe).asm_lock); + g_mutex_clear(&(hcamcorder->mtsafe).state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).gst_state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).gst_encode_state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).message_cb_lock); + g_mutex_clear(&(hcamcorder->mtsafe).vcapture_cb_lock); + g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock); + g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock); + + g_mutex_clear(&hcamcorder->snd_info.open_mutex); + g_cond_clear(&hcamcorder->snd_info.open_cond); + g_mutex_clear(&hcamcorder->restart_preview_lock); if (hcamcorder->conf_ctrl) { _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl); @@ -638,15 +603,16 @@ _ERR_DEFAULT_VALUE_INIT: } if (hcamcorder->task_thread) { - pthread_mutex_lock(&(hcamcorder->task_thread_lock)); + g_mutex_lock(&hcamcorder->task_thread_lock); _mmcam_dbg_log("send signal for task thread exit"); hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT; - pthread_cond_signal(&(hcamcorder->task_thread_cond)); - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); - pthread_join(hcamcorder->task_thread, NULL); + g_cond_signal(&hcamcorder->task_thread_cond); + g_mutex_unlock(&hcamcorder->task_thread_lock); + g_thread_join(hcamcorder->task_thread); + hcamcorder->task_thread = NULL; } - pthread_mutex_destroy(&(hcamcorder->task_thread_lock)); - pthread_cond_destroy(&(hcamcorder->task_thread_cond)); + g_mutex_clear(&hcamcorder->task_thread_lock); + g_cond_clear(&hcamcorder->task_thread_cond); /* Release handle */ memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t)); @@ -686,33 +652,14 @@ int _mmcamcorder_destroy(MMHandleType handle) } /* set exit state for sound thread */ - pthread_mutex_lock(&(hcamcorder->task_thread_lock)); + g_mutex_lock(&hcamcorder->task_thread_lock); _mmcam_dbg_log("send signal for task thread exit"); hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT; - pthread_cond_signal(&(hcamcorder->task_thread_cond)); - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); - - pthread_mutex_lock(&(hcamcorder->sound_lock)); - while (hcamcorder->capture_sound_count > 0) { - struct timespec timeout; - struct timeval tv; + g_cond_signal(&hcamcorder->task_thread_cond); + g_mutex_unlock(&hcamcorder->task_thread_lock); - gettimeofday(&tv, NULL); - timeout.tv_sec = tv.tv_sec + __MMCAMCORDER_SOUND_WAIT_TIMEOUT; - timeout.tv_nsec = tv.tv_usec * 1000; - - _mmcam_dbg_warn("capture_sound_count[%d] is not zero. wait signal...", - hcamcorder->capture_sound_count); - - if (!pthread_cond_timedwait(&(hcamcorder->sound_cond), &(hcamcorder->sound_lock), &timeout)) { - _mmcam_dbg_warn("signal received. check again..."); - } else { - hcamcorder->capture_sound_count = 0; - _mmcam_dbg_err("capture sound completion wait time out"); - break; - } - } - pthread_mutex_unlock(&(hcamcorder->sound_lock)); + /* wait for completion of sound play */ + _mmcamcorder_sound_solo_play_wait(handle); /* Release SubContext and pipeline */ if (hcamcorder->sub_context) { @@ -726,8 +673,8 @@ int _mmcamcorder_destroy(MMHandleType handle) /* de-initialize resource manager */ ret = _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager); - if (!ret) { - _mmcam_dbg_err("failed to de-initialize resource manager"); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("failed to de-initialize resource manager 0x%x", ret); } /* Remove idle function which is not called yet */ @@ -737,29 +684,6 @@ int _mmcamcorder_destroy(MMHandleType handle) hcamcorder->setting_event_id = 0; } - /* check current strobe mode */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - pid_t my_pid = getpid(); - int camera_pid = -1; - vconf_get_int(VCONFKEY_CAMERA_PID, &camera_pid); - - if (camera_pid > -1 && my_pid == camera_pid) { - int strobe_mode = MM_CAMCORDER_STROBE_MODE_OFF; - - vconf_set_int(VCONFKEY_CAMERA_PID, -1); - _mmcam_dbg_log("reset camera pid"); - - mm_camcorder_get_attributes(handle, NULL, - MMCAM_STROBE_MODE, &strobe_mode, - NULL); - if (strobe_mode != MM_CAMCORDER_STROBE_MODE_OFF) { - /* set OFF state of vconf key */ - vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, VCONFKEY_CAMERA_FLASH_STATE_OFF); - _mmcam_dbg_log("reset flash state"); - } - } - } - /* Remove attributes */ if (hcamcorder->attributes) { _mmcamcorder_dealloc_attribute(handle, hcamcorder->attributes); @@ -811,30 +735,29 @@ int _mmcamcorder_destroy(MMHandleType handle) /* join task thread */ _mmcam_dbg_log("task thread join"); - pthread_join(hcamcorder->task_thread, NULL); + g_thread_join(hcamcorder->task_thread); + hcamcorder->task_thread = NULL; _MMCAMCORDER_UNLOCK_CMD(hcamcorder); /* Release lock, cond */ - pthread_mutex_destroy(&((hcamcorder->mtsafe).lock)); - pthread_cond_destroy(&((hcamcorder->mtsafe).cond)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).cmd_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).asm_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_encode_state_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).message_cb_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).vcapture_cb_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).vstream_cb_lock)); - pthread_mutex_destroy(&((hcamcorder->mtsafe).astream_cb_lock)); - - pthread_mutex_destroy(&(hcamcorder->sound_lock)); - pthread_cond_destroy(&(hcamcorder->sound_cond)); - pthread_mutex_destroy(&(hcamcorder->snd_info.open_mutex)); - pthread_cond_destroy(&(hcamcorder->snd_info.open_cond)); - pthread_mutex_destroy(&(hcamcorder->restart_preview_lock)); - pthread_mutex_destroy(&(hcamcorder->task_thread_lock)); - pthread_cond_destroy(&(hcamcorder->task_thread_cond)); + g_mutex_clear(&(hcamcorder->mtsafe).lock); + g_cond_clear(&(hcamcorder->mtsafe).cond); + g_mutex_clear(&(hcamcorder->mtsafe).cmd_lock); + g_mutex_clear(&(hcamcorder->mtsafe).asm_lock); + g_mutex_clear(&(hcamcorder->mtsafe).state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).gst_state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).gst_encode_state_lock); + g_mutex_clear(&(hcamcorder->mtsafe).message_cb_lock); + g_mutex_clear(&(hcamcorder->mtsafe).vcapture_cb_lock); + g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock); + g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock); + + g_mutex_clear(&hcamcorder->snd_info.open_mutex); + g_cond_clear(&hcamcorder->snd_info.open_cond); + g_mutex_clear(&hcamcorder->restart_preview_lock); + g_mutex_clear(&hcamcorder->task_thread_lock); + g_cond_clear(&hcamcorder->task_thread_cond); /* Release handle */ memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t)); @@ -908,38 +831,6 @@ int _mmcamcorder_realize(MMHandleType handle) MMCAM_DISPLAY_SOCKET_PATH, &socket_path, &socket_path_len, NULL); - /* set camera/recorder state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - if (vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN)) { - _mmcam_dbg_log("VCONF ERROR %s : cur %d",strerror(errno),errno); - if(errno == EPERM || errno == EACCES) { - ret = MM_ERROR_COMMON_INVALID_PERMISSION; - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; - } - } - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN); - } else { - int vconf_recorder_state = 0; - - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - if (vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED)) { - _mmcam_dbg_log("VCONF ERROR %s : cur %d",strerror(errno),errno); - if (errno == EPERM || errno == EACCES) { - ret = MM_ERROR_COMMON_INVALID_PERMISSION; - goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; - } - } - - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED); - } - /* sound focus */ if (hcamcorder->sound_focus_register) { mm_camcorder_get_attributes(handle, NULL, @@ -1160,26 +1051,6 @@ _ERR_CAMCORDER_CMD: _mmcam_dbg_err("failed to unprepare resource manager, ret_resource(0x%x)", ret_resource); } } - /* rollback camera state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL); - } else { - int vconf_recorder_state = 0; - - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL); - - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_NULL); - } _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: _MMCAMCORDER_UNLOCK_CMD(hcamcorder); @@ -1258,8 +1129,7 @@ int _mmcamcorder_unrealize(MMHandleType handle) if (ret == MM_ERROR_RESOURCE_INVALID_STATE) { _mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource"); ret = MM_ERROR_NONE; - } - else if (ret != MM_ERROR_NONE) { + } else if (ret != MM_ERROR_NONE) { _mmcam_dbg_err("failed to release resource, ret(0x%x)", ret); ret = MM_ERROR_CAMCORDER_INTERNAL; goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; @@ -1312,27 +1182,6 @@ int _mmcamcorder_unrealize(MMHandleType handle) } } - /* set camera state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL); - } else { - int vconf_recorder_state = 0; - - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL); - - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_NULL); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); _mmcamcorder_set_state(handle, state_TO); @@ -1389,6 +1238,19 @@ int _mmcamcorder_start(MMHandleType handle) /* set attributes related sensor */ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { + /* init for gdbus */ + hcamcorder->gdbus_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL); + if (hcamcorder->gdbus_conn == NULL) { + _mmcam_dbg_err("failed to get gdbus"); + ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION; + goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; + } + + g_mutex_init(&hcamcorder->gdbus_info_sound.sync_mutex); + g_cond_init(&hcamcorder->gdbus_info_sound.sync_cond); + g_mutex_init(&hcamcorder->gdbus_info_solo_sound.sync_mutex); + g_cond_init(&hcamcorder->gdbus_info_solo_sound.sync_cond); + _mmcamcorder_set_attribute_to_camsensor(handle); } @@ -1404,24 +1266,21 @@ int _mmcamcorder_start(MMHandleType handle) _mmcamcorder_set_state(handle, state_TO); - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* check camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - - /* set camera state to vconf key */ - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK: + if (hcamcorder->gdbus_conn) { + g_object_unref(hcamcorder->gdbus_conn); + hcamcorder->gdbus_conn = NULL; + + g_mutex_clear(&hcamcorder->gdbus_info_sound.sync_mutex); + g_cond_clear(&hcamcorder->gdbus_info_sound.sync_cond); + g_mutex_clear(&hcamcorder->gdbus_info_solo_sound.sync_mutex); + g_cond_clear(&hcamcorder->gdbus_info_solo_sound.sync_cond); + } + _MMCAMCORDER_UNLOCK_CMD(hcamcorder); _ERR_CAMCORDER_CMD_PRECON: @@ -1477,16 +1336,31 @@ int _mmcamcorder_stop(MMHandleType handle) _mmcamcorder_set_state(handle, state_TO); if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; + g_mutex_lock(&hcamcorder->gdbus_info_sound.sync_mutex); + if (hcamcorder->gdbus_info_sound.subscribe_id > 0) { + _mmcam_dbg_warn("subscribe_id[%u] is remained. remove it.", + hcamcorder->gdbus_info_sound.subscribe_id); + g_dbus_connection_signal_unsubscribe(hcamcorder->gdbus_conn, + hcamcorder->gdbus_info_sound.subscribe_id); + } + g_mutex_unlock(&hcamcorder->gdbus_info_sound.sync_mutex); - /* check camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); + g_mutex_lock(&hcamcorder->gdbus_info_solo_sound.sync_mutex); + if (hcamcorder->gdbus_info_solo_sound.subscribe_id > 0) { + _mmcam_dbg_warn("subscribe_id[%u] is remained. remove it.", + hcamcorder->gdbus_info_solo_sound.subscribe_id); + g_dbus_connection_signal_unsubscribe(hcamcorder->gdbus_conn, + hcamcorder->gdbus_info_solo_sound.subscribe_id); + } + g_mutex_unlock(&hcamcorder->gdbus_info_solo_sound.sync_mutex); - /* set camera state to vconf key */ - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN); + g_object_unref(hcamcorder->gdbus_conn); + hcamcorder->gdbus_conn = NULL; - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN); + g_mutex_clear(&hcamcorder->gdbus_info_sound.sync_mutex); + g_cond_clear(&hcamcorder->gdbus_info_sound.sync_cond); + g_mutex_clear(&hcamcorder->gdbus_info_solo_sound.sync_mutex); + g_cond_clear(&hcamcorder->gdbus_info_solo_sound.sync_cond); } _MMCAMCORDER_UNLOCK_CMD(hcamcorder); @@ -1546,16 +1420,16 @@ int _mmcamcorder_capture_start(MMHandleType handle) ret = MM_ERROR_CAMCORDER_DEVICE_BUSY; goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } else { - pthread_mutex_lock(&(hcamcorder->task_thread_lock)); + g_mutex_lock(&hcamcorder->task_thread_lock); if (hcamcorder->task_thread_state == _MMCAMCORDER_TASK_THREAD_STATE_NONE) { hcamcorder->capture_in_recording = TRUE; 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)); - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); + g_cond_signal(&hcamcorder->task_thread_cond); + g_mutex_unlock(&hcamcorder->task_thread_lock); } else { _mmcam_dbg_err("task thread busy : %d", hcamcorder->task_thread_state); - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); + g_mutex_unlock(&hcamcorder->task_thread_lock); ret = MM_ERROR_CAMCORDER_INVALID_STATE; goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } @@ -1694,27 +1568,6 @@ int _mmcamcorder_record(MMHandleType handle) _mmcamcorder_set_state(handle, state_TO); - /* set camera state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_RECORDING); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING); - } else { - int vconf_recorder_state = 0; - - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_RECORDING); - - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_RECORDING); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; @@ -1775,27 +1628,6 @@ int _mmcamcorder_pause(MMHandleType handle) _mmcamcorder_set_state(handle, state_TO); - /* set camera state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE); - } else { - int vconf_recorder_state = 0; - - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_RECORDING_PAUSE); - - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_RECORDING_PAUSE); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; @@ -1848,27 +1680,6 @@ int _mmcamcorder_commit(MMHandleType handle) goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK; } - /* set camera state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW); - } else { - int vconf_recorder_state = 0; - - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED); - - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); _mmcamcorder_set_state(handle,state_TO); @@ -1925,27 +1736,6 @@ int _mmcamcorder_cancel(MMHandleType handle) _mmcamcorder_set_state(handle, state_TO); - /* set camera state to vconf key */ - if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) { - int vconf_camera_state = 0; - - /* get current camera state of vconf key */ - vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state); - vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW); - - _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d", - vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW); - } else { - int vconf_recorder_state = 0; - - /* get current recorder state of vconf key */ - vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state); - vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED); - - _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d", - vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED); - } - _MMCAMCORDER_UNLOCK_CMD(hcamcorder); return MM_ERROR_NONE; @@ -2606,7 +2396,7 @@ _MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type) goto ALLOC_SUBCONTEXT_FAILED; } memset(sc->info_video, 0x00, sizeof(_MMCamcorderVideoInfo)); - pthread_mutex_init(&(sc->info_video->size_check_lock), NULL); + g_mutex_init(&sc->info_video->size_check_lock); break; } @@ -2652,7 +2442,7 @@ ALLOC_SUBCONTEXT_FAILED: sc->info_image = NULL; } if (sc->info_video) { - pthread_mutex_destroy(&(sc->info_video->size_check_lock)); + g_mutex_clear(&sc->info_video->size_check_lock); free(sc->info_video); sc->info_video = NULL; } @@ -2701,7 +2491,7 @@ void _mmcamcorder_dealloc_subcontext(_MMCamcorderSubContext *sc) free(sc->info_video->filename); sc->info_video->filename = NULL; } - pthread_mutex_destroy(&(sc->info_video->size_check_lock)); + g_mutex_clear(&sc->info_video->size_check_lock); free(sc->info_video); sc->info_video = NULL; } @@ -3106,7 +2896,7 @@ GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder); if (sc && sc->info_image) { /* play 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); } } @@ -3513,7 +3303,7 @@ int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstSta GstStateChangeReturn setChangeReturn = GST_STATE_CHANGE_FAILURE; GstStateChangeReturn getChangeReturn = GST_STATE_CHANGE_FAILURE; GstClockTime get_timeout = __MMCAMCORDER_SET_GST_STATE_TIMEOUT * GST_SECOND; - pthread_mutex_t *state_lock = NULL; + GMutex *state_lock = NULL; mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED); sc = MMF_CAMCORDER_SUBCONTEXT(handle); @@ -3527,7 +3317,7 @@ int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstSta state_lock = &_MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle); } - pthread_mutex_lock(state_lock); + g_mutex_lock(state_lock); for (k = 0; k < _MMCAMCORDER_STATE_SET_COUNT; k++) { setChangeReturn = gst_element_set_state(pipeline, target_state); @@ -3542,7 +3332,7 @@ int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstSta /* if we reached the final target state, exit */ if (pipeline_state == target_state) { _mmcam_dbg_log("Set state to %d - DONE", target_state); - pthread_mutex_unlock(state_lock); + g_mutex_unlock(state_lock); return MM_ERROR_NONE; } break; @@ -3550,12 +3340,12 @@ int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstSta _mmcam_dbg_log("status=GST_STATE_CHANGE_ASYNC."); break; default: - pthread_mutex_unlock(state_lock); + g_mutex_unlock(state_lock); _mmcam_dbg_log("status=GST_STATE_CHANGE_FAILURE."); return MM_ERROR_CAMCORDER_GST_STATECHANGE; } - pthread_mutex_unlock(state_lock); + g_mutex_unlock(state_lock); _mmcam_dbg_err("timeout of gst_element_get_state()!!"); @@ -3565,7 +3355,7 @@ int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstSta usleep(_MMCAMCORDER_STATE_CHECK_INTERVAL); } - pthread_mutex_unlock(state_lock); + g_mutex_unlock(state_lock); _mmcam_dbg_err("Failure. gst_element_set_state timeout!!"); diff --git a/src/mm_camcorder_resource.c b/src/mm_camcorder_resource.c index 54a0b3f..8b363d0 100644 --- a/src/mm_camcorder_resource.c +++ b/src/mm_camcorder_resource.c @@ -86,7 +86,6 @@ static void mrp_state_callback(mrp_res_context_t *context, mrp_res_error_t err, mrp_res_resource_t *resource; mmf_camcorder_t* camcorder = NULL; - if (err != MRP_RES_ERROR_NONE) { _mmcam_dbg_err(" - error message received from Murphy, err(0x%x)", err); return; @@ -133,6 +132,7 @@ static void mrp_state_callback(mrp_res_context_t *context, mrp_res_error_t err, return; } + static void mrp_rset_state_callback(mrp_res_context_t *cx, const mrp_res_resource_set_t *rs, void *user_data) { int i = 0; @@ -213,7 +213,7 @@ static void mrp_resource_release_cb (mrp_res_context_t *cx, const mrp_res_resour static int create_rset(MMCamcorderResourceManager *resource_manager) { if (resource_manager->rset) { - _mmcam_dbg_err(" - resource set was already created\n"); + _mmcam_dbg_err(" - resource set was already created"); return MM_ERROR_RESOURCE_INVALID_STATE; } @@ -222,12 +222,12 @@ static int create_rset(MMCamcorderResourceManager *resource_manager) mrp_rset_state_callback, (void*)resource_manager->user_data); if (resource_manager->rset == NULL) { - _mmcam_dbg_err(" - could not create resource set\n"); + _mmcam_dbg_err(" - could not create resource set"); return MM_ERROR_RESOURCE_INTERNAL; } if (!mrp_res_set_autorelease(TRUE, resource_manager->rset)) { - _mmcam_dbg_warn(" - could not set autorelease flag!\n"); + _mmcam_dbg_warn(" - could not set autorelease flag!"); } return MM_ERROR_NONE; @@ -241,11 +241,11 @@ static int include_resource(MMCamcorderResourceManager *resource_manager, const MRP_RESOURCE_TYPE_MANDATORY, MRP_RESOURCE_TYPE_EXCLUSIVE); if (resource == NULL) { - _mmcam_dbg_err(" - could not include resource[%s]\n", resource_name); + _mmcam_dbg_err(" - could not include resource[%s]", resource_name); return MM_ERROR_RESOURCE_INTERNAL; } - _mmcam_dbg_log(" - include resource[%s]\n", resource_name); + _mmcam_dbg_log(" - include resource[%s]", resource_name); return MM_ERROR_NONE; } @@ -258,11 +258,11 @@ static int set_resource_release_cb(MMCamcorderResourceManager *resource_manager) if (resource_manager->rset) { mrp_ret = mrp_res_set_release_callback(resource_manager->rset, mrp_resource_release_cb, resource_manager->user_data); if (!mrp_ret) { - _mmcam_dbg_err(" - could not set release callback\n"); + _mmcam_dbg_err(" - could not set release callback"); ret = MM_ERROR_RESOURCE_INTERNAL; } } else { - _mmcam_dbg_err(" - resource set is null\n"); + _mmcam_dbg_err(" - resource set is null"); ret = MM_ERROR_RESOURCE_INVALID_STATE; } @@ -277,14 +277,14 @@ int _mmcamcorder_resource_manager_init(MMCamcorderResourceManager *resource_mana if (resource_manager->mloop) { resource_manager->context = mrp_res_create(resource_manager->mloop, mrp_state_callback, user_data); if (resource_manager->context == NULL) { - _mmcam_dbg_err(" - could not get context for resource manager\n"); + _mmcam_dbg_err(" - could not get context for resource manager"); mrp_mainloop_destroy(resource_manager->mloop); resource_manager->mloop = NULL; return MM_ERROR_RESOURCE_INTERNAL; } resource_manager->user_data = user_data; } else { - _mmcam_dbg_err("- could not get mainloop for resource manager\n"); + _mmcam_dbg_err("- could not get mainloop for resource manager"); return MM_ERROR_RESOURCE_INTERNAL; } @@ -321,17 +321,17 @@ int _mmcamcorder_resource_manager_acquire(MMCamcorderResourceManager *resource_m MMCAMCORDER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager); if (resource_manager->rset == NULL) { - _mmcam_dbg_err("- could not acquire resource, resource set is null\n"); + _mmcam_dbg_err("- could not acquire resource, resource set is null"); ret = MM_ERROR_RESOURCE_INVALID_STATE; } else { ret = set_resource_release_cb(resource_manager); if (ret) { - _mmcam_dbg_err("- could not set resource release cb, ret(%d)\n", ret); + _mmcam_dbg_err("- could not set resource release cb, ret(%d)", ret); ret = MM_ERROR_RESOURCE_INTERNAL; } else { ret = mrp_res_acquire_resource_set(resource_manager->rset); if (ret) { - _mmcam_dbg_err("- could not acquire resource, ret(%d)\n", ret); + _mmcam_dbg_err("- could not acquire resource, ret(%d)", ret); ret = MM_ERROR_RESOURCE_INTERNAL; } } @@ -347,17 +347,19 @@ int _mmcamcorder_resource_manager_release(MMCamcorderResourceManager *resource_m MMCAMCORDER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager); if (resource_manager->rset == NULL) { - _mmcam_dbg_err("- could not release resource, resource set is null\n"); + _mmcam_dbg_err("- could not release resource, resource set is null"); ret = MM_ERROR_RESOURCE_INVALID_STATE; } else { if (resource_manager->rset->state != MRP_RES_RESOURCE_ACQUIRED) { - _mmcam_dbg_err("- could not release resource, resource set state is [%s]\n", state_to_str(resource_manager->rset->state)); + _mmcam_dbg_err("- could not release resource, resource set state is [%s]", state_to_str(resource_manager->rset->state)); ret = MM_ERROR_RESOURCE_INVALID_STATE; } else { ret = mrp_res_release_resource_set(resource_manager->rset); if (ret) { - _mmcam_dbg_err("- could not release resource, ret(%d)\n", ret); + _mmcam_dbg_err("- could not release resource, ret(%d)", ret); ret = MM_ERROR_RESOURCE_INTERNAL; + } else { + _mmcam_dbg_log("resource release done"); } } } @@ -372,11 +374,12 @@ int _mmcamcorder_resource_manager_unprepare(MMCamcorderResourceManager *resource MMCAMCORDER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager); if (resource_manager->rset == NULL) { - _mmcam_dbg_err("- could not unprepare for resource_manager, _mmcamcorder_resource_manager_prepare() first\n"); + _mmcam_dbg_err("- could not unprepare for resource_manager, _mmcamcorder_resource_manager_prepare() first"); ret = MM_ERROR_RESOURCE_INVALID_STATE; } else { mrp_res_delete_resource_set(resource_manager->rset); resource_manager->rset = NULL; + _mmcam_dbg_log("delete resource set done"); } return ret; @@ -389,17 +392,21 @@ int _mmcamcorder_resource_manager_deinit(MMCamcorderResourceManager *resource_ma if (resource_manager->rset) { if (resource_manager->rset->state == MRP_RES_RESOURCE_ACQUIRED) { + _mmcam_dbg_warn("resource is still acquired. release..."); if (mrp_res_release_resource_set(resource_manager->rset)) _mmcam_dbg_err("- could not release resource"); } + _mmcam_dbg_log("delete resource set"); mrp_res_delete_resource_set(resource_manager->rset); resource_manager->rset = NULL; } if (resource_manager->context) { + _mmcam_dbg_log("destroy resource context"); mrp_res_destroy(resource_manager->context); resource_manager->context = NULL; } if (resource_manager->mloop) { + _mmcam_dbg_log("destroy resource mainloop"); mrp_mainloop_destroy(resource_manager->mloop); resource_manager->mloop = NULL; } diff --git a/src/mm_camcorder_sound.c b/src/mm_camcorder_sound.c index 7923f0b..4615095 100644 --- a/src/mm_camcorder_sound.c +++ b/src/mm_camcorder_sound.c @@ -34,257 +34,69 @@ /*--------------------------------------------------------------------------------------- | LOCAL VARIABLE DEFINITIONS for internal | ---------------------------------------------------------------------------------------*/ -#define SAMPLE_SOUND_RATE 44100 -#define DEFAULT_ACTIVE_DEVICE 0xffffffff + /*--------------------------------------------------------------------------------------- | LOCAL FUNCTION PROTOTYPES: | ---------------------------------------------------------------------------------------*/ -static void __solo_sound_callback(void *data); - -static void __pulseaudio_play_sample_cb(pa_context *pulse_context, uint32_t stream_index, void *user_data) -{ - SOUND_INFO *info = NULL; - - mmf_return_if_fail(user_data); - - info = (SOUND_INFO *)user_data; - - _mmcam_dbg_log("START - idx : %d", stream_index); - - pa_threaded_mainloop_signal(info->pulse_mainloop, 0); - - _mmcam_dbg_log("DONE"); - - return; -} - -static void __pulseaudio_context_state_cb(pa_context *pulse_context, void *user_data) -{ - int state = 0; - SOUND_INFO *info = NULL; - - mmf_return_if_fail(user_data); - - info = (SOUND_INFO *)user_data; - state = pa_context_get_state(pulse_context); - switch (state) { - case PA_CONTEXT_READY: - _mmcam_dbg_log("pulseaudio context READY"); - if (info->pulse_context == pulse_context) { - /* Signal */ - _mmcam_dbg_log("pulseaudio send signal"); - pa_threaded_mainloop_signal(info->pulse_mainloop, 0); - } - break; - case PA_CONTEXT_TERMINATED: - if (info->pulse_context == pulse_context) { - /* Signal */ - _mmcam_dbg_log("Context terminated : pulseaudio send signal"); - pa_threaded_mainloop_signal(info->pulse_mainloop, 0); - } - break; - case PA_CONTEXT_UNCONNECTED: - case PA_CONTEXT_CONNECTING: - case PA_CONTEXT_AUTHORIZING: - case PA_CONTEXT_SETTING_NAME: - case PA_CONTEXT_FAILED: - default: - _mmcam_dbg_log("pulseaudio context %p, state %d", - pulse_context, state); - break; - } - return; -} gboolean _mmcamcorder_sound_init(MMHandleType handle) { - int ret = 0; int sound_enable = TRUE; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); SOUND_INFO *info = NULL; - pa_mainloop_api *api = NULL; - int error = PA_ERR_INTERNAL; mmf_return_val_if_fail(hcamcorder, FALSE); - /* check sound play enable */ - ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, - "capture-sound-enable", &sound_enable, - NULL); - _mmcam_dbg_log("Capture sound enable %d", sound_enable); - if (!sound_enable) { - _mmcam_dbg_warn("capture sound disabled"); - return FALSE; - } - info = &(hcamcorder->snd_info); - pthread_mutex_lock(&(info->open_mutex)); + g_mutex_lock(&info->open_mutex); + /* check sound state */ if (info->state > _MMCAMCORDER_SOUND_STATE_NONE) { _mmcam_dbg_warn("already initialized [%d]", info->state); - pthread_mutex_unlock(&(info->open_mutex)); + g_mutex_unlock(&info->open_mutex); return TRUE; } - pthread_mutex_init(&(info->play_mutex), NULL); - pthread_cond_init(&(info->play_cond), NULL); - - /** - * Init Pulseaudio thread - */ - /* create pulseaudio mainloop */ - info->pulse_mainloop = pa_threaded_mainloop_new(); - if (info->pulse_mainloop == NULL) { - _mmcam_dbg_err("pa_threaded_mainloop_new failed"); - goto SOUND_INIT_ERROR; - } - - /* start PA mainloop */ - ret = pa_threaded_mainloop_start(info->pulse_mainloop); - if (ret < 0) { - _mmcam_dbg_err("pa_threaded_mainloop_start failed"); - goto SOUND_INIT_ERROR; - } - - /* lock pulseaudio thread */ - pa_threaded_mainloop_lock(info->pulse_mainloop); - - /* get pulseaudio api */ - api = pa_threaded_mainloop_get_api(info->pulse_mainloop); - if (api == NULL) { - _mmcam_dbg_err("pa_threaded_mainloop_get_api failed"); - pa_threaded_mainloop_unlock(info->pulse_mainloop); - goto SOUND_INIT_ERROR; - } - - /* create pulseaudio context */ - info->pulse_context = pa_context_new(api, NULL); - if (info->pulse_context == NULL) { - _mmcam_dbg_err("pa_context_new failed"); - pa_threaded_mainloop_unlock(info->pulse_mainloop); - goto SOUND_INIT_ERROR; - } - - /* set pulseaudio context callback */ - pa_context_set_state_callback(info->pulse_context, __pulseaudio_context_state_cb, info); - - if (pa_context_connect(info->pulse_context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) < 0) { - _mmcam_dbg_err("pa_context_connect error"); - } - - /* wait READY state of pulse context */ - while (TRUE) { - pa_context_state_t state = pa_context_get_state(info->pulse_context); - - _mmcam_dbg_log("pa context state is now %d", state); - - if (!PA_CONTEXT_IS_GOOD (state)) { - _mmcam_dbg_log("connection failed"); - break; - } - - if (state == PA_CONTEXT_READY) { - _mmcam_dbg_log("pa context READY"); - break; - } - - /* Wait until the context is ready */ - _mmcam_dbg_log("waiting.................."); - pa_threaded_mainloop_wait(info->pulse_mainloop); - _mmcam_dbg_log("waiting DONE. check again..."); + /* check sound play enable */ + mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, + "capture-sound-enable", &sound_enable, + NULL); + _mmcam_dbg_log("Capture sound enable %d", sound_enable); + if (!sound_enable) { + _mmcam_dbg_warn("capture sound disabled"); + g_mutex_unlock(&info->open_mutex); + return FALSE; } - /* unlock pulseaudio thread */ - pa_threaded_mainloop_unlock(info->pulse_mainloop); - - if (info->sample_stream) { - pa_stream_connect_playback(info->sample_stream, NULL, NULL, 0, NULL, NULL); - - for (;;) { - pa_stream_state_t state = pa_stream_get_state(info->sample_stream); - - if (state == PA_STREAM_READY) { - _mmcam_dbg_warn("device READY done"); - break; - } - - if (!PA_STREAM_IS_GOOD(state)) { - error = pa_context_errno(info->pulse_context); - _mmcam_dbg_err("pa context state is not good, %d", error); - break; - } - - /* Wait until the stream is ready */ - pa_threaded_mainloop_wait(info->pulse_mainloop); - } + /* check shutter sound policy and status of system */ + if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_OFF && + hcamcorder->sub_context->info_image->sound_status == FALSE) { + _mmcam_dbg_warn("skip sound init : Sound Policy OFF and Silent status"); + g_mutex_unlock(&info->open_mutex); + return FALSE; } - //info->volume_type = PA_TIZEN_AUDIO_VOLUME_TYPE_FIXED; - info->volume_level = 0; - info->state = _MMCAMCORDER_SOUND_STATE_INIT; _mmcam_dbg_log("init DONE"); - pthread_mutex_unlock(&(info->open_mutex)); + g_mutex_unlock(&info->open_mutex); return TRUE; - -SOUND_INIT_ERROR: - /* remove pulse mainloop */ - if (info->pulse_mainloop) { - pa_threaded_mainloop_lock(info->pulse_mainloop); - - /* remove pulse context */ - if (info->pulse_context) { - /* release sample stream */ - if (info->sample_stream) { - pa_stream_disconnect(info->sample_stream); - pa_stream_unref(info->sample_stream); - info->sample_stream = NULL; - } - - /* Make sure we don't get any further callbacks */ - pa_context_set_state_callback(info->pulse_context, NULL, NULL); - - pa_context_disconnect(info->pulse_context); - pa_context_unref(info->pulse_context); - info->pulse_context = NULL; - } - - pa_threaded_mainloop_unlock(info->pulse_mainloop); - - pa_threaded_mainloop_stop(info->pulse_mainloop); - pa_threaded_mainloop_free(info->pulse_mainloop); - info->pulse_mainloop = NULL; - } - - /* remove mutex and cond */ - pthread_mutex_destroy(&(info->play_mutex)); - pthread_cond_destroy(&(info->play_cond)); - - pthread_mutex_unlock(&(info->open_mutex)); - - return FALSE; } gboolean _mmcamcorder_sound_play(MMHandleType handle, const char *sample_name, gboolean sync_play) { int sound_enable = TRUE; -/* - int gain_type = VOLUME_GAIN_SHUTTER1; -*/ + const char *volume_gain = NULL; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); SOUND_INFO *info = NULL; -/* - pa_operation *pulse_op = NULL; -*/ mmf_return_val_if_fail(hcamcorder && sample_name, FALSE); @@ -300,60 +112,26 @@ gboolean _mmcamcorder_sound_play(MMHandleType handle, const char *sample_name, g info = &(hcamcorder->snd_info); - pthread_mutex_lock(&(info->open_mutex)); + g_mutex_lock(&info->open_mutex); if (info->state < _MMCAMCORDER_SOUND_STATE_INIT) { _mmcam_dbg_log("not initialized state:[%d]", info->state); - pthread_mutex_unlock(&(info->open_mutex)); + g_mutex_unlock(&info->open_mutex); return FALSE; } -/* - if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE)) { - gain_type = VOLUME_GAIN_SHUTTER2; + if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE02)) { + volume_gain = "shutter2"; } else if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_STOP)) { - gain_type = VOLUME_GAIN_CAMCORDING; + volume_gain = "camcording"; } -*/ _mmcam_dbg_log("Play start - sample name [%s]", sample_name); - if (sync_play) { - pa_threaded_mainloop_lock(info->pulse_mainloop); -/* - pulse_op = pa_ext_policy_play_sample(info->pulse_context, - sample_name, - info->volume_type, - gain_type, - info->volume_level, - __pulseaudio_play_sample_cb, - info); -*/ - _mmcam_dbg_log("wait for signal"); - pa_threaded_mainloop_wait(info->pulse_mainloop); - _mmcam_dbg_log("received signal"); - - pa_threaded_mainloop_unlock(info->pulse_mainloop); - } else { -/* - pulse_op = pa_ext_policy_play_sample(info->pulse_context, - sample_name, - info->volume_type, - gain_type, - info->volume_level, - NULL, - NULL); -*/ - } + _mmcamcorder_send_sound_play_message(hcamcorder->gdbus_conn, + &hcamcorder->gdbus_info_sound, sample_name, "system", volume_gain, sync_play); -/* - if (pulse_op) { - pa_operation_unref(pulse_op); - pulse_op = NULL; - } -*/ - - pthread_mutex_unlock(&(info->open_mutex)); + g_mutex_unlock(&info->open_mutex); _mmcam_dbg_log("Done"); @@ -372,178 +150,54 @@ gboolean _mmcamcorder_sound_finalize(MMHandleType handle) _mmcam_dbg_err("START"); - pthread_mutex_lock(&(info->open_mutex)); + g_mutex_lock(&info->open_mutex); if (info->state < _MMCAMCORDER_SOUND_STATE_INIT) { _mmcam_dbg_warn("not initialized"); - pthread_mutex_unlock(&(info->open_mutex)); + g_mutex_unlock(&info->open_mutex); return TRUE; } - pa_threaded_mainloop_lock(info->pulse_mainloop); - - if (info->sample_stream) { - pa_stream_disconnect(info->sample_stream); - pa_stream_unref(info->sample_stream); - info->sample_stream = NULL; - } - - /** - * Release pulseaudio thread - */ - _mmcam_dbg_log("release pulseaudio thread"); - - pa_context_disconnect(info->pulse_context); - - /* Make sure we don't get any further callbacks */ - pa_context_set_state_callback(info->pulse_context, NULL, NULL); - - pa_context_unref(info->pulse_context); - info->pulse_context = NULL; - - pa_threaded_mainloop_unlock(info->pulse_mainloop); - - pa_threaded_mainloop_stop(info->pulse_mainloop); - pa_threaded_mainloop_free(info->pulse_mainloop); - info->pulse_mainloop = NULL; - info->state = _MMCAMCORDER_SOUND_STATE_NONE; - /* release mutex and cond */ - _mmcam_dbg_log("release play_mutex/cond"); - pthread_mutex_destroy(&(info->play_mutex)); - pthread_cond_destroy(&(info->play_cond)); - - pthread_mutex_unlock(&(info->open_mutex)); - _mmcam_dbg_err("DONE"); + g_mutex_unlock(&info->open_mutex); + return TRUE; } -void _mmcamcorder_sound_solo_play(MMHandleType handle, const char* filepath, gboolean sync_play) +int _mmcamcorder_sound_solo_play(MMHandleType handle, const char *sample_name, gboolean sync_play) { - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - - int sound_handle = 0; - int ret = MM_ERROR_NONE; int sound_enable = TRUE; - int sound_played = FALSE; - int gain_type = VOLUME_GAIN_SHUTTER1; - - mmf_return_if_fail(filepath && hcamcorder); - _mmcam_dbg_log("START : %s", filepath); - - _mmcamcorder_sound_solo_play_wait(handle); + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - ret = pthread_mutex_trylock(&(hcamcorder->sound_lock)); - if (ret != 0) { - _mmcam_dbg_warn("g_mutex_trylock failed.[%s]", strerror(ret)); - return; - } + mmf_return_val_if_fail(hcamcorder && sample_name, FALSE); - /* check filename to set gain_type */ - if (!strcmp(filepath, _MMCAMCORDER_FILEPATH_CAPTURE_SND) || - !strcmp(filepath, _MMCAMCORDER_FILEPATH_REC_START_SND)) { - if (!strcmp(filepath, _MMCAMCORDER_FILEPATH_REC_START_SND)) { - gain_type = VOLUME_GAIN_CAMCORDING; - } else { - gain_type = VOLUME_GAIN_SHUTTER1; - } - } else if (!strcmp(filepath, _MMCAMCORDER_FILEPATH_CAPTURE2_SND)) { - gain_type = VOLUME_GAIN_SHUTTER2; - } else if (!strcmp(filepath, _MMCAMCORDER_FILEPATH_REC_STOP_SND)) { - gain_type = VOLUME_GAIN_CAMCORDING; - } + _mmcam_dbg_log("START : [%s]", sample_name); - _mmcam_dbg_log("gain type 0x%x", gain_type); + _mmcamcorder_sound_solo_play_wait(handle); - ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, - "capture-sound-enable", &sound_enable, - NULL); + /* check sound play enable */ + mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, + "capture-sound-enable", &sound_enable, + NULL); _mmcam_dbg_log("Capture sound enable %d", sound_enable); - if (!sound_enable) { - /* send capture sound completed message */ - pthread_mutex_unlock(&(hcamcorder->sound_lock)); - return; - } - - - if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON || - hcamcorder->sub_context->info_image->sound_status) { - ret = mm_sound_play_sound(filepath, VOLUME_TYPE_FIXED | gain_type, - (mm_sound_stop_callback_func)__solo_sound_callback, (void*)hcamcorder, &sound_handle); - sound_played = TRUE; - } else { - _mmcam_dbg_warn("skip shutter sound"); - } - - _mmcam_dbg_log("sync_play %d, sound_played %d, ret 0x%x", sync_play, sound_played, ret); - - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err( "Capture sound play FAILED.[%x]", ret ); - } else { - if (sound_played) { - /* increase capture sound count */ - hcamcorder->capture_sound_count++; - } - - /* wait for sound completed signal */ - if (sync_play && sound_played) { - struct timespec timeout; - struct timeval tv; - - gettimeofday( &tv, NULL ); - timeout.tv_sec = tv.tv_sec + 2; - timeout.tv_nsec = tv.tv_usec * 1000; - - _mmcam_dbg_log("Wait for signal"); - - if (!pthread_cond_timedwait(&(hcamcorder->sound_cond), &(hcamcorder->sound_lock), &timeout)) { - _mmcam_dbg_log("signal received."); - } else { - _mmcam_dbg_warn("capture sound play timeout."); - if (sound_handle > 0) { - mm_sound_stop_sound(sound_handle); - } - } - } + _mmcam_dbg_warn("capture sound disabled"); + return FALSE; } - pthread_mutex_unlock(&(hcamcorder->sound_lock)); - - _mmcam_dbg_log("DONE"); - - return; -} - -static void __solo_sound_callback(void *data) -{ - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data); - - mmf_return_if_fail(hcamcorder); - - _mmcam_dbg_log("START"); - - /* decrease capture sound count */ - pthread_mutex_lock(&(hcamcorder->sound_lock)); - if (hcamcorder->capture_sound_count > 0) { - hcamcorder->capture_sound_count--; - } else { - _mmcam_dbg_warn("invalid capture_sound_count %d, reset count", hcamcorder->capture_sound_count); - hcamcorder->capture_sound_count = 0; - } - pthread_mutex_unlock(&(hcamcorder->sound_lock)); + _mmcam_dbg_log("Play start - sample name [%s]", sample_name); - _mmcam_dbg_log("Signal SEND"); - pthread_cond_broadcast(&(hcamcorder->sound_cond)); + _mmcamcorder_send_sound_play_message(hcamcorder->gdbus_conn, + &hcamcorder->gdbus_info_solo_sound, sample_name, "system", "shutter1", sync_play); - _mmcam_dbg_log("DONE"); + _mmcam_dbg_log("Done"); - return; + return TRUE; } @@ -556,26 +210,26 @@ void _mmcamcorder_sound_solo_play_wait(MMHandleType handle) _mmcam_dbg_log("START"); /* check playing sound count */ - pthread_mutex_lock(&(hcamcorder->sound_lock)); - if (hcamcorder->capture_sound_count > 0) { - struct timespec timeout; - struct timeval tv; + g_mutex_lock(&hcamcorder->gdbus_info_solo_sound.sync_mutex); - gettimeofday( &tv, NULL ); - timeout.tv_sec = tv.tv_sec + 2; - timeout.tv_nsec = tv.tv_usec * 1000; + if (hcamcorder->gdbus_info_solo_sound.is_playing) { + gint64 end_time = 0; _mmcam_dbg_log("Wait for signal"); - if (!pthread_cond_timedwait(&(hcamcorder->sound_cond), &(hcamcorder->sound_lock), &timeout)) { + end_time = g_get_monotonic_time() + (2 * G_TIME_SPAN_SECOND); + + if (g_cond_wait_until(&hcamcorder->gdbus_info_solo_sound.sync_cond, + &hcamcorder->gdbus_info_solo_sound.sync_mutex, end_time)) { _mmcam_dbg_log("signal received."); } else { _mmcam_dbg_warn("capture sound play timeout."); } } else { - _mmcam_dbg_warn("no playing sound - count %d", hcamcorder->capture_sound_count); + _mmcam_dbg_warn("no playing sound"); } - pthread_mutex_unlock(&(hcamcorder->sound_lock)); + + g_mutex_unlock(&hcamcorder->gdbus_info_solo_sound.sync_mutex); _mmcam_dbg_log("DONE"); diff --git a/src/mm_camcorder_stillshot.c b/src/mm_camcorder_stillshot.c index da9edc3..caa09d7 100644 --- a/src/mm_camcorder_stillshot.c +++ b/src/mm_camcorder_stillshot.c @@ -376,8 +376,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 { @@ -535,7 +534,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 */ @@ -759,15 +758,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); } } @@ -1186,28 +1185,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 */ @@ -1375,14 +1374,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..."); } @@ -1399,8 +1398,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); @@ -1437,8 +1436,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"); diff --git a/src/mm_camcorder_util.c b/src/mm_camcorder_util.c index 5638dba..0ef310a 100644 --- a/src/mm_camcorder_util.c +++ b/src/mm_camcorder_util.c @@ -97,37 +97,25 @@ static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint widt | GLOBAL FUNCTION DEFINITIONS: | ---------------------------------------------------------------------------*/ -static int __gdbus_method_call_sync(const char* bus_name, const char* object, const char* iface, - const char* method, GVariant* args, GVariant** result, bool is_sync) +static int __gdbus_method_call_sync(GDBusConnection *conn, const char *bus_name, + const char *object, const char *iface, const char *method, + GVariant *args, GVariant **result, bool is_sync) { int ret = MM_ERROR_NONE; - GError *err = NULL; - GVariant* dbus_reply = NULL; - GDBusConnection *conn = NULL; - - if (!object || !iface || !method) { - _mmcam_dbg_err("Invalid Argument"); - if (!object) - _mmcam_dbg_err("object null"); - if (!iface) - _mmcam_dbg_err("iface null"); - if (!method) - _mmcam_dbg_err("method null"); - return MM_ERROR_INVALID_ARGUMENT; - } + GVariant *dbus_reply = NULL; - conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL); - if (conn == NULL) { - _mmcam_dbg_err("get connection failed"); - return MM_ERROR_CAMCORDER_INTERNAL; + if (!conn || !object || !iface || !method) { + _mmcam_dbg_err("Invalid Argument %p %p %p %p", + conn, object, iface, method); + return MM_ERROR_INVALID_ARGUMENT; } - _mmcam_dbg_log("Dbus call with obj : '%s' iface : '%s' method : '%s'", object, iface, method); + _mmcam_dbg_log("Dbus call - obj [%s], iface [%s], method [%s]", object, iface, method); if (is_sync) { - dbus_reply = g_dbus_connection_call_sync(conn, bus_name, object, iface, - method, args, NULL, G_DBUS_CALL_FLAGS_NONE, - G_DBUS_REPLY_TIMEOUT, NULL, &err); + dbus_reply = g_dbus_connection_call_sync(conn, + bus_name, object, iface, method, args, NULL, + G_DBUS_CALL_FLAGS_NONE, G_DBUS_REPLY_TIMEOUT, NULL, NULL); if (dbus_reply) { _mmcam_dbg_log("Method Call '%s.%s' Success", iface, method); *result = dbus_reply; @@ -136,12 +124,112 @@ static int __gdbus_method_call_sync(const char* bus_name, const char* object, co ret = MM_ERROR_CAMCORDER_INTERNAL; } } else { - g_dbus_connection_call(conn, bus_name, object, iface, \ - method, args, \ - NULL, G_DBUS_CALL_FLAGS_NONE, G_DBUS_REPLY_TIMEOUT, \ - NULL, NULL, NULL); + g_dbus_connection_call(conn, bus_name, object, iface, method, args, NULL, + G_DBUS_CALL_FLAGS_NONE, G_DBUS_REPLY_TIMEOUT, NULL, NULL, NULL); } - g_object_unref(conn); + + return ret; +} + +static int __gdbus_subscribe_signal(GDBusConnection *conn, + const char *object_name, const char *iface_name, const char *signal_name, + GDBusSignalCallback signal_cb, guint *subscribe_id, void *userdata) +{ + guint subs_id = 0; + + if (!conn || !object_name || !iface_name || !signal_name || !signal_cb || !subscribe_id) { + _mmcam_dbg_err("Invalid Argument %p %p %p %p %p %p", + conn, object_name, iface_name, signal_name, signal_cb, subscribe_id); + return MM_ERROR_INVALID_ARGUMENT; + } + + _mmcam_dbg_log("subscirbe signal Obj %s, iface_name %s, sig_name %s", + object_name, iface_name, signal_name); + + subs_id = g_dbus_connection_signal_subscribe(conn, + NULL, iface_name, signal_name, object_name, NULL, + G_DBUS_SIGNAL_FLAGS_NONE, signal_cb, userdata, NULL); + if (!subs_id) { + _mmcam_dbg_err("g_dbus_connection_signal_subscribe() failed"); + return MM_ERROR_CAMCORDER_INTERNAL; + } else { + *subscribe_id = subs_id; + _mmcam_dbg_log("subs_id %u", subs_id); + } + + return MM_ERROR_NONE; +} + + +static void __gdbus_stream_eos_cb(GDBusConnection *connection, + const gchar *sender_name, const gchar *object_path, const gchar *interface_name, + const gchar *signal_name, GVariant *param, gpointer user_data) +{ + int played_idx = 0; + _MMCamcorderGDbusCbInfo *gdbus_info = NULL; + + _mmcam_dbg_log("entered"); + + if (!param || !user_data) { + _mmcam_dbg_err("invalid parameter %p %p", param, user_data); + return; + } + + gdbus_info = (_MMCamcorderGDbusCbInfo *)user_data; + + g_variant_get(param, "(i)", &played_idx); + + g_mutex_lock(&gdbus_info->sync_mutex); + + _mmcam_dbg_log("gdbus_info->param %d, played_idx : %d", + gdbus_info->param, played_idx); + + if (gdbus_info->param == played_idx) { + g_dbus_connection_signal_unsubscribe(connection, gdbus_info->subscribe_id); + + gdbus_info->is_playing = FALSE; + gdbus_info->subscribe_id = 0; + gdbus_info->param = 0; + + g_cond_signal(&gdbus_info->sync_cond); + } + + g_mutex_unlock(&gdbus_info->sync_mutex); + + return; +} + +static int __gdbus_wait_for_cb_return(_MMCamcorderGDbusCbInfo *gdbus_info, int time_out) +{ + int ret = MM_ERROR_NONE; + gint64 end_time = 0; + + if (!gdbus_info) { + _mmcam_dbg_err("invalid info"); + return MM_ERROR_CAMCORDER_INVALID_ARGUMENT; + } + + g_mutex_lock(&gdbus_info->sync_mutex); + + _mmcam_dbg_log("entered"); + + if (gdbus_info->is_playing == FALSE) { + _mmcam_dbg_log("callback is already returned"); + g_mutex_unlock(&gdbus_info->sync_mutex); + return MM_ERROR_NONE; + } + + end_time = g_get_monotonic_time()+ (time_out * G_TIME_SPAN_MILLISECOND); + + if (g_cond_wait_until(&gdbus_info->sync_cond, &gdbus_info->sync_mutex, end_time)) { + _mmcam_dbg_log("wait signal received"); + } else { + _mmcam_dbg_err("wait time is expired"); + ret = MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT; + } + + g_mutex_unlock(&gdbus_info->sync_mutex); + return ret; } @@ -679,26 +767,23 @@ int _mmcamcorder_get_file_system_type(const gchar *path, int *file_system_type) } -int _mmcamcorder_get_device_flash_brightness(int *brightness) +int _mmcamcorder_get_device_flash_brightness(GDBusConnection *conn, int *brightness) { int get_value = 0; int ret = MM_ERROR_NONE; - GVariant *params = NULL, *result = NULL; - const char *param_type = "(i)"; - - if ((ret = __gdbus_method_call_sync("org.tizen.system.deviced", - "/Org/Tizen/System/DeviceD/Led", - "org.tizen.system.deviced.Led", - "GetBrightnessForCamera", - params, - &result, - TRUE)) != MM_ERROR_NONE) { + GVariant *params = NULL; + GVariant *result = NULL; + + ret = __gdbus_method_call_sync(conn, "org.tizen.system.deviced", + "/Org/Tizen/System/DeviceD/Led", "org.tizen.system.deviced.Led", + "GetBrightnessForCamera", params, &result, TRUE); + if (ret != MM_ERROR_NONE) { _mmcam_dbg_err("Dbus Call on Client Error"); return ret; } if (result) { - g_variant_get(result, param_type, &get_value); + g_variant_get(result, "(i)", &get_value); *brightness = get_value; _mmcam_dbg_log("flash brightness : %d", *brightness); } else { @@ -709,6 +794,69 @@ int _mmcamcorder_get_device_flash_brightness(int *brightness) return ret; } + +int _mmcamcorder_send_sound_play_message(GDBusConnection *conn, _MMCamcorderGDbusCbInfo *gdbus_info, + const char *sample_name, const char *stream_role, const char *volume_gain, int sync_play) +{ + int get_value = 0; + int ret = MM_ERROR_NONE; + GVariant *params = NULL, *result = NULL; + guint subs_id = 0; + + if (!conn || !gdbus_info) { + _mmcam_dbg_err("Invalid parameter %p %p", conn, gdbus_info); + return MM_ERROR_CAMCORDER_INTERNAL; + } + + params = g_variant_new("(sss)", sample_name, stream_role, volume_gain); + result = g_variant_new("(i)", get_value); + + ret = __gdbus_method_call_sync(conn, "org.pulseaudio.Server", + "/org/pulseaudio/SoundPlayer", "org.pulseaudio.SoundPlayer", + "SamplePlay", params, &result, TRUE); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("Dbus Call on Client Error"); + return ret; + } + + if (result) { + g_variant_get(result, "(i)", &get_value); + _mmcam_dbg_log("played index : %d", get_value); + } else { + _mmcam_dbg_err("replied result is null"); + return MM_ERROR_CAMCORDER_INTERNAL; + } + + g_mutex_lock(&gdbus_info->sync_mutex); + + if (gdbus_info->subscribe_id > 0) { + _mmcam_dbg_warn("subscribe_id[%u] is remained. remove it.", gdbus_info->subscribe_id); + + g_dbus_connection_signal_unsubscribe(conn, gdbus_info->subscribe_id); + + gdbus_info->subscribe_id = 0; + } + + gdbus_info->is_playing = TRUE; + gdbus_info->param = get_value; + + ret = __gdbus_subscribe_signal(conn, + "/org/pulseaudio/SoundPlayer", "org.pulseaudio.SoundPlayer", "EOS", + __gdbus_stream_eos_cb, &subs_id, gdbus_info); + + if (ret == MM_ERROR_NONE) + gdbus_info->subscribe_id = subs_id; + + g_mutex_unlock(&gdbus_info->sync_mutex); + + if (sync_play && ret == MM_ERROR_NONE) { + ret = __gdbus_wait_for_cb_return(gdbus_info, G_DBUS_CB_TIMEOUT_MSEC); + } + + return ret; +} + + int _mmcamcorder_get_file_size(const char *filename, guint64 *size) { struct stat buf; @@ -994,7 +1142,7 @@ gboolean _mmcamcorder_msg_callback(void *data) mmf_camcorder_t *hcamcorder = NULL; mmf_return_val_if_fail(item, FALSE); - pthread_mutex_lock(&(item->lock)); + g_mutex_lock(&item->lock); hcamcorder = MMF_CAMCORDER(item->handle); if (hcamcorder == NULL) { @@ -1052,8 +1200,8 @@ MSG_CALLBACK_DONE: } } - pthread_mutex_unlock(&(item->lock)); - pthread_mutex_destroy(&(item->lock)); + g_mutex_unlock(&item->lock); + g_mutex_clear(&item->lock); free(item); item = NULL; @@ -1109,7 +1257,7 @@ gboolean _mmcamcorder_send_message(MMHandleType handle, _MMCamcorderMsgItem *dat if (item) { memcpy(item, data, sizeof(_MMCamcorderMsgItem)); item->handle = handle; - pthread_mutex_init(&(item->lock), NULL); + g_mutex_init(&item->lock); _MMCAMCORDER_LOCK(handle); hcamcorder->msg_data = g_list_append(hcamcorder->msg_data, item); @@ -1171,10 +1319,7 @@ void _mmcamcorder_remove_message_all(MMHandleType handle) #ifdef _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK _MMCamcorderMsgItem *item = NULL; GList *list = NULL; - struct timespec timeout; - struct timeval tv; - struct timeval tv_to_add; - struct timeval tv_result; + gint64 end_time = 0; #endif /* _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK */ mmf_return_if_fail(hcamcorder); @@ -1185,9 +1330,6 @@ void _mmcamcorder_remove_message_all(MMHandleType handle) if (!hcamcorder->msg_data) { _mmcam_dbg_log("No message data is remained."); } else { - tv_to_add.tv_sec = 0; - tv_to_add.tv_usec = 1000 * 100; /* 100 ms */ - list = hcamcorder->msg_data; while (list) { @@ -1197,7 +1339,7 @@ void _mmcamcorder_remove_message_all(MMHandleType handle) if (!item) { _mmcam_dbg_err("Fail to remove message. The item is NULL"); } else { - if (pthread_mutex_trylock(&(item->lock))) { + if (g_mutex_trylock(&(item->lock))) { ret = g_idle_remove_by_data(item); _mmcam_dbg_log("remove msg item[%p], ret[%d]", item, ret); @@ -1235,10 +1377,10 @@ void _mmcamcorder_remove_message_all(MMHandleType handle) hcamcorder->msg_data = g_list_remove(hcamcorder->msg_data, item); - pthread_mutex_unlock(&(item->lock)); + g_mutex_unlock(&(item->lock)); if (ret == TRUE) { - pthread_mutex_destroy(&(item->lock)); + g_mutex_clear(&item->lock); free(item); item = NULL; @@ -1248,12 +1390,9 @@ void _mmcamcorder_remove_message_all(MMHandleType handle) } else { _mmcam_dbg_warn("item lock failed. it's being called..."); - gettimeofday(&tv, NULL); - timeradd(&tv, &tv_to_add, &tv_result); - timeout.tv_sec = tv_result.tv_sec; - timeout.tv_nsec = tv_result.tv_usec * 1000; + end_time = g_get_monotonic_time() + (100 * G_TIME_SPAN_MILLISECOND); - if (_MMCAMCORDER_TIMED_WAIT(handle, timeout)) { + if (_MMCAMCORDER_WAIT_UNTIL(handle, end_time)) { _mmcam_dbg_warn("signal received"); } else { _mmcam_dbg_warn("timeout"); @@ -1549,7 +1688,7 @@ gboolean _mmcamcorder_link_elements(GList *element_list) } gboolean _mmcamcorder_resize_frame(unsigned char *src_data, unsigned int src_width, unsigned int src_height, unsigned int src_length, int src_format, - unsigned char **dst_data, unsigned int *dst_width, unsigned int *dst_height, unsigned int *dst_length) + unsigned char **dst_data, unsigned int *dst_width, unsigned int *dst_height, unsigned int *dst_length) { int ret = TRUE; int mm_ret = MM_ERROR_NONE; @@ -1622,8 +1761,8 @@ gboolean _mmcamcorder_resize_frame(unsigned char *src_data, unsigned int src_wid gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsigned int src_height, - int src_format, unsigned int src_length, unsigned int jpeg_quality, - void **result_data, unsigned int *result_length) + int src_format, unsigned int src_length, unsigned int jpeg_quality, + void **result_data, unsigned int *result_length) { int ret = 0; gboolean ret_conv = TRUE; @@ -1715,7 +1854,7 @@ gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsign /* make UYVY smaller as multiple size. ex: 640x480 -> 320x240 or 160x120 ... */ gboolean _mmcamcorder_downscale_UYVYorYUYV(unsigned char *src, unsigned int src_width, unsigned int src_height, - unsigned char **dst, unsigned int dst_width, unsigned int dst_height) + unsigned char **dst, unsigned int dst_width, unsigned int dst_height) { unsigned int i = 0; int j = 0; @@ -1827,44 +1966,41 @@ void *_mmcamcorder_util_task_thread_func(void *data) _mmcam_dbg_warn("start thread"); - pthread_mutex_lock(&(hcamcorder->task_thread_lock)); + g_mutex_lock(&hcamcorder->task_thread_lock); while (hcamcorder->task_thread_state != _MMCAMCORDER_TASK_THREAD_STATE_EXIT) { switch (hcamcorder->task_thread_state) { case _MMCAMCORDER_TASK_THREAD_STATE_NONE: _mmcam_dbg_warn("wait for task signal"); - pthread_cond_wait(&(hcamcorder->task_thread_cond), &(hcamcorder->task_thread_lock)); + g_cond_wait(&hcamcorder->task_thread_cond, &hcamcorder->task_thread_lock); _mmcam_dbg_warn("task signal received : state %d", hcamcorder->task_thread_state); break; case _MMCAMCORDER_TASK_THREAD_STATE_SOUND_PLAY_START: - _mmcamcorder_sound_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE, FALSE); + _mmcamcorder_sound_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE02, FALSE); hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE; break; case _MMCAMCORDER_TASK_THREAD_STATE_SOUND_SOLO_PLAY_START: - _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE); + _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE01, FALSE); hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE; break; case _MMCAMCORDER_TASK_THREAD_STATE_ENCODE_PIPE_CREATE: ret = _mmcamcorder_video_prepare_record((MMHandleType)hcamcorder); /* Play record start sound */ - _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_REC_START_SND, FALSE); + _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_START, FALSE); _mmcam_dbg_log("_mmcamcorder_video_prepare_record return 0x%x", ret); hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE; break; case _MMCAMCORDER_TASK_THREAD_STATE_CHECK_CAPTURE_IN_RECORDING: { - struct timespec timeout; - struct timeval tv; - - gettimeofday(&tv, NULL); - timeout.tv_sec = tv.tv_sec + __MMCAMCORDER_CAPTURE_WAIT_TIMEOUT; - timeout.tv_nsec = tv.tv_usec * 1000; + gint64 end_time = 0; _mmcam_dbg_warn("wait for capture data in recording. wait signal..."); - if (!pthread_cond_timedwait(&(hcamcorder->task_thread_cond), &(hcamcorder->task_thread_lock), &timeout)) { + end_time = g_get_monotonic_time() + (5 * G_TIME_SPAN_SECOND); + + if (g_cond_wait_until(&hcamcorder->task_thread_cond, &hcamcorder->task_thread_lock, end_time)) { _mmcam_dbg_warn("signal received"); } else { _MMCamcorderMsgItem message; @@ -1891,7 +2027,7 @@ void *_mmcamcorder_util_task_thread_func(void *data) } } - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); + g_mutex_unlock(&hcamcorder->task_thread_lock); _mmcam_dbg_warn("exit thread"); diff --git a/src/mm_camcorder_videorec.c b/src/mm_camcorder_videorec.c index 69565ab..12656b3 100644 --- a/src/mm_camcorder_videorec.c +++ b/src/mm_camcorder_videorec.c @@ -588,13 +588,13 @@ int _mmcamcorder_video_command(MMHandleType handle, int command) return MM_ERROR_OUT_OF_STORAGE; } - pthread_mutex_lock(&(hcamcorder->task_thread_lock)); + g_mutex_lock(&hcamcorder->task_thread_lock); if (sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst == NULL && hcamcorder->task_thread_state == _MMCAMCORDER_TASK_THREAD_STATE_NONE) { /* Play record start sound */ - _mmcamcorder_sound_solo_play(handle, _MMCAMCORDER_FILEPATH_REC_START_SND, FALSE); + _mmcamcorder_sound_solo_play(handle, _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_START, FALSE); } - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); + g_mutex_unlock(&hcamcorder->task_thread_lock); _mmcam_dbg_warn("video size [%dx%d]", info->video_width, info->video_height); @@ -717,17 +717,17 @@ int _mmcamcorder_video_command(MMHandleType handle, int command) } /* check pre-created encode pipeline */ - pthread_mutex_lock(&(hcamcorder->task_thread_lock)); + g_mutex_lock(&hcamcorder->task_thread_lock); if (sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst == NULL && hcamcorder->task_thread_state == _MMCAMCORDER_TASK_THREAD_STATE_NONE) { /* create encoding pipeline */ ret =_mmcamcorder_video_prepare_record((MMHandleType)hcamcorder); if (ret != MM_ERROR_NONE) { - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); + g_mutex_unlock(&hcamcorder->task_thread_lock); goto _ERR_CAMCORDER_VIDEO_COMMAND; } } - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); + g_mutex_unlock(&hcamcorder->task_thread_lock); /* check recording start sound */ _mmcamcorder_sound_solo_play_wait(handle); @@ -1111,7 +1111,7 @@ int _mmcamcorder_video_handle_eos(MMHandleType handle) if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_ASM) { /* Play record stop sound */ - _mmcamcorder_sound_solo_play(handle, _MMCAMCORDER_FILEPATH_REC_STOP_SND, FALSE); + _mmcamcorder_sound_solo_play(handle, _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_STOP, FALSE); } else { _mmcam_dbg_warn("Play stop sound through pulseaudio"); @@ -1321,18 +1321,18 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_check(GstPad *pad, GstPad /*_mmcam_dbg_err("[%" GST_TIME_FORMAT "]", GST_TIME_ARGS(GST_BUFFER_PTS(buffer)));*/ - pthread_mutex_lock(&(videoinfo->size_check_lock)); + g_mutex_lock(&videoinfo->size_check_lock); if (videoinfo->audio_frame_count == 0) { videoinfo->filesize += buffer_size; videoinfo->audio_frame_count++; - pthread_mutex_unlock(&(videoinfo->size_check_lock)); + g_mutex_unlock(&videoinfo->size_check_lock); return GST_PAD_PROBE_OK; } if (sc->ferror_send || sc->isMaxsizePausing) { _mmcam_dbg_warn("Recording is paused, drop frames"); - pthread_mutex_unlock(&(videoinfo->size_check_lock)); + g_mutex_unlock(&videoinfo->size_check_lock); return GST_PAD_PROBE_DROP; } @@ -1364,7 +1364,7 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_check(GstPad *pad, GstPad _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg); } - pthread_mutex_unlock(&(videoinfo->size_check_lock)); + g_mutex_unlock(&videoinfo->size_check_lock); return FALSE; } @@ -1372,7 +1372,7 @@ static GstPadProbeReturn __mmcamcorder_audio_dataprobe_check(GstPad *pad, GstPad videoinfo->filesize += buffer_size; videoinfo->audio_frame_count++; - pthread_mutex_unlock(&(videoinfo->size_check_lock)); + g_mutex_unlock(&videoinfo->size_check_lock); return GST_PAD_PROBE_OK; } @@ -1417,9 +1417,9 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_record(GstPad *pad, GstPa if (videoinfo->video_frame_count <= (guint64)_MMCAMCORDER_MINIMUM_FRAME) { /* _mmcam_dbg_log("Pass minimum frame: info->video_frame_count: %" G_GUINT64_FORMAT " ", info->video_frame_count); */ - pthread_mutex_lock(&(videoinfo->size_check_lock)); + g_mutex_lock(&videoinfo->size_check_lock); videoinfo->filesize += buffer_size; - pthread_mutex_unlock(&(videoinfo->size_check_lock)); + g_mutex_unlock(&videoinfo->size_check_lock); return GST_PAD_PROBE_OK; } @@ -1493,7 +1493,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_record(GstPad *pad, GstPa break; } - pthread_mutex_lock(&(videoinfo->size_check_lock)); + g_mutex_lock(&videoinfo->size_check_lock); /* check max size of recorded file */ if (videoinfo->max_size > 0 && @@ -1516,7 +1516,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_record(GstPad *pad, GstPa _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg); } - pthread_mutex_unlock(&(videoinfo->size_check_lock)); + g_mutex_unlock(&videoinfo->size_check_lock); return GST_PAD_PROBE_DROP; } @@ -1527,7 +1527,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_record(GstPad *pad, GstPa _mmcam_dbg_log("filesize %lld Byte, ", videoinfo->filesize); */ - pthread_mutex_unlock(&(videoinfo->size_check_lock)); + g_mutex_unlock(&videoinfo->size_check_lock); return GST_PAD_PROBE_OK; } diff --git a/test/mm_camcorder_testsuite.c b/test/mm_camcorder_testsuite.c index 9bdc7df..ce3ddec 100644 --- a/test/mm_camcorder_testsuite.c +++ b/test/mm_camcorder_testsuite.c @@ -631,7 +631,7 @@ camcordertest_video_capture_cb(MMCamcorderCaptureDataType *main, MMCamcorderCapt void *dst = NULL; nret = _mmcamcorder_encode_jpeg(main->data, main->width, main->height, main->format, - main->length, 90, &dst, &dst_size); + main->length, 90, &dst, &dst_size); if (nret) { _file_write(m_filename, dst, dst_size); } else { -- 2.7.4