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
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)
#include <malloc.h>
#include <string.h>
#include <unistd.h>
-#include <pthread.h>
#include <semaphore.h>
#include <mm_types.h>
/**
* 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)
* 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;
/**
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 */
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;
/*=======================================================================================
| INCLUDE FILES |
========================================================================================*/
-#include <pulse/pulseaudio.h>
+
#ifdef __cplusplus
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"
/*=======================================================================================
/**
* 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;
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
/*=======================================================================================
| INCLUDE FILES |
========================================================================================*/
+#include <gio/gio.h>
#include <linux/magic.h>
| 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 {
* 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 |
/* 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.
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
}
* 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;
/*=======================================================================================
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,
},
{
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,
},
{
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);
_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;
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");
_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;
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");
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;
_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");
}
}
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]");
}
}
- 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;
}
| INCLUDE FILES |
| |
========================================================================================== */
-#include <glib.h>
#include <gst/gst.h>
#include <gst/app/gstappsrc.h>
#include <gst/video/videooverlay.h>
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);
_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);
_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));
#include <time.h>
#include <mm_debug.h>
#include <mm_error.h>
-#include <glib.h>
#define MM_EXIFINFO_USE_BINARY_EXIFDATA 1
#define JPEG_MAX_SIZE 20000000
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);
/*---------------------------------------------------------------------------------------
| 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;
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) {
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) {
}
}
-
/* initialize resource manager */
ret = _mmcamcorder_resource_manager_init(&hcamcorder->resource_manager, (void *)hcamcorder);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_log("created handle %p", hcamcorder);
- /* set device type */
- g_mm_camcorder_type = info->videodev_type;
-
*handle = (MMHandleType)hcamcorder;
return MM_ERROR_NONE;
}
/* 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);
}
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));
}
/* 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) {
/* 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 */
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);
/* 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));
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,
_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);
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;
}
}
- /* 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);
/* 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);
}
_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:
_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);
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;
}
_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;
_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;
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);
_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;
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;
}
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;
}
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;
}
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);
}
}
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);
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);
/* 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;
_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()!!");
usleep(_MMCAMCORDER_STATE_CHECK_INTERVAL);
}
- pthread_mutex_unlock(state_lock);
+ g_mutex_unlock(state_lock);
_mmcam_dbg_err("Failure. gst_element_set_state timeout!!");
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;
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;
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;
}
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;
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;
}
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;
}
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;
}
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;
}
}
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");
}
}
}
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;
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;
}
/*---------------------------------------------------------------------------------------
| 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);
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");
_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;
}
_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");
/* 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 {
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 */
/* 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);
}
}
/* 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 */
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...");
}
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);
_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");
| 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;
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;
}
}
-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 {
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;
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) {
}
}
- pthread_mutex_unlock(&(item->lock));
- pthread_mutex_destroy(&(item->lock));
+ g_mutex_unlock(&item->lock);
+ g_mutex_clear(&item->lock);
free(item);
item = NULL;
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);
#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);
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) {
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);
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;
} 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");
}
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;
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;
/* 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;
_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;
}
}
- pthread_mutex_unlock(&(hcamcorder->task_thread_lock));
+ g_mutex_unlock(&hcamcorder->task_thread_lock);
_mmcam_dbg_warn("exit thread");
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);
}
/* 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);
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");
/*_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;
}
_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
}
- pthread_mutex_unlock(&(videoinfo->size_check_lock));
+ g_mutex_unlock(&videoinfo->size_check_lock);
return FALSE;
}
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 (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;
}
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 &&
_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;
}
_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;
}
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 {
projects / platform / core / multimedia / libmm-camcorder.git / commitdiff