Name: libmm-camcorder
Summary: Camera and recorder library
-Version: 0.10.63
+Version: 0.10.64
Release: 0
Group: Multimedia/Libraries
License: Apache-2.0
@par
Recording state and paused state exists when the mode of camcorder is
- video-capture or audio-capture mode. In case of image-capture mode, CAPTURING state will
+ video-capture or audio-capture mode. In case of image-capture mode, CAPTURING state will
exsit.
@par
<td><center><b>Attribute</b></center></td>
<td><center><b>Description</b></center></td>
</tr>
- <tr>
+ <tr>
<td>#MMCAM_MODE</td>
<td>Mode of camcorder ( still/video/audio )</td>
</tr>
<td><center><b>Attribute</b></center></td>
<td><center><b>Description</b></center></td>
</tr>
- <tr>
+ <tr>
<td>#MMCAM_AUDIO_ENCODER_BITRATE</td>
<td>Bitrate of Audio Encoder</td>
</tr>
<td><center><b>Attribute</b></center></td>
<td><center><b>Description</b></center></td>
</tr>
- <tr>
+ <tr>
<td>#MMCAM_IMAGE_ENCODER_QUALITY</td>
<td>Encoding quality of Image codec</td>
</tr>
<td><center><b>Attribute</b></center></td>
<td><center><b>Description</b></center></td>
</tr>
- <tr>
+ <tr>
<td>#MMCAM_AUDIO_VOLUME</td>
<td>Input volume of audio source ( double value )</td>
</tr>
/**
* Set fraction value. Definition for fraction setting, such as MMCAM_CAMERA_SHUTTER_SPEED and MMCAM_CAMERA_EXPOSURE_VALUE.
*/
-#define MM_CAMCORDER_SET_FRACTION(numerator,denominator) ((int)((((int)(numerator)) << 16) | (int)(denominator)))
+#define MM_CAMCORDER_SET_FRACTION(numerator, denominator) ((int)((((int)(numerator)) << 16) | (int)(denominator)))
/* Attributes Macros */
/**
/**
* An enumeration of Audio Format.
*/
-typedef enum
-{
+typedef enum {
MM_CAMCORDER_AUDIO_FORMAT_PCM_U8 = 0, /**< unsigned 8bit audio */
MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE = 2, /**< signed 16bit audio. Little endian. */
} MMCamcorderAudioFormat;
* An enumeration for orientation values of tag .
*/
enum MMCamcorderTagOrientation {
- MM_CAMCORDER_TAG_ORT_NONE =0, /**< No Orientation.*/
+ MM_CAMCORDER_TAG_ORT_NONE = 0, /**< No Orientation.*/
MM_CAMCORDER_TAG_ORT_0R_VT_0C_VL, /**< The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side.*/
MM_CAMCORDER_TAG_ORT_0R_VT_0C_VR, /**< The 0th row is at the visual top of the image, and the 0th column is the visual right-hand side.*/
MM_CAMCORDER_TAG_ORT_0R_VB_0C_VR, /**< The 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side.*/
* An enumeration for captured video orientation values of tag .
*/
enum MMCamcorderTagVideoOrientation {
- MM_CAMCORDER_TAG_VIDEO_ORT_NONE =0, /**< No Orientation.*/
+ MM_CAMCORDER_TAG_VIDEO_ORT_NONE = 0, /**< No Orientation.*/
MM_CAMCORDER_TAG_VIDEO_ORT_90, /**< 90 degree */
MM_CAMCORDER_TAG_VIDEO_ORT_180, /**< 180 degree */
MM_CAMCORDER_TAG_VIDEO_ORT_270, /**< 270 degree */
/**
* An enumeration for attribute values types.
*/
-typedef enum{
+typedef enum {
MM_CAM_ATTRS_TYPE_INVALID = -1, /**< Type is invalid */
MM_CAM_ATTRS_TYPE_INT, /**< Integer type attribute */
MM_CAM_ATTRS_TYPE_DOUBLE, /**< Double type attribute */
MM_CAM_ATTRS_TYPE_STRING, /**< UTF-8 String type attribute */
MM_CAM_ATTRS_TYPE_DATA, /**< Pointer type attribute */
-}MMCamAttrsType;
+} MMCamAttrsType;
/**
* This is the finalizing function of mm_camcorder. If this function is not called or fails to call, the handle isn't released fully.
* This function releases attributes, mutexes, sessions, and handle itself. This function also removes all of remaining messages.
* So if your application should wait a certain message of mm_camcorder, please wait to call this function till getting the message.
- *
+ *
*
* @param[in] camcorder A handle of camcorder.
* @return This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
* @pre Previous state of mm-camcorder should be MM_CAMCORDER_STATE_PREPARE
* @post Next state of mm-camcorder will be MM_CAMCORDER_STATE_CAPTURING
* @remarks To call this function, preview should be started successfully.\n
- * This function is a pair of mm_camcorder_capture_stop().
+ * This function is a pair of mm_camcorder_capture_stop().
* So user should call mm_camcorder_capture_stop() after getting captured image.
* @par example
* @code
int err;
err = mm_camcorder_capture_start(hcam);
- if (err < 0)
+ if (err < 0)
{
printf("Fail to call mm_camcorder_capture_start = %x\n", err);
return FALSE;
return TRUE;
}
- * @endcode
+ * @endcode
*/
int mm_camcorder_set_audio_stream_callback(MMHandleType camcorder, mm_camcorder_audio_stream_callback callback, void *user_data);
/**
* Enumerations for camcorder attribute ID.
*/
-typedef enum
-{
+typedef enum {
MM_CAM_MODE, /* 0 */
MM_CAM_AUDIO_DEVICE,
MM_CAM_CAMERA_DEVICE_COUNT,
MM_CAM_DISPLAY_REUSE_HINT,
MM_CAM_DISPLAY_REUSE_ELEMENT,
MM_CAM_ATTRIBUTE_NUM
-}MMCamcorderAttrsID;
+} MMCamcorderAttrsID;
/*=======================================================================================
| TYPE DEFINITIONS |
| GLOBAL FUNCTION PROTOTYPES |
========================================================================================*/
/**
- * Create exif info
+ * Create exif info
* @param[in] info exif info.
* @return return int.
*/
int mm_exif_create_exif_info(mm_exif_info_t **info);
/**
- * Destroy exif info
+ * Destroy exif info
* @param[in] info exif info.
* @return void
*/
* Encodebin profile
*/
typedef enum _MMCamcorderEncodebinProfile {
- MM_CAMCORDER_ENCBIN_PROFILE_VIDEO = 0, /**< Video recording profile */
- MM_CAMCORDER_ENCBIN_PROFILE_AUDIO, /**< Audio recording profile */
- MM_CAMCORDER_ENCBIN_PROFILE_IMAGE, /**< Image capture profile */
- MM_CAMCORDER_ENCBIN_PROFILE_NUM
+ MM_CAMCORDER_ENCBIN_PROFILE_VIDEO = 0, /**< Video recording profile */
+ MM_CAMCORDER_ENCBIN_PROFILE_AUDIO, /**< Audio recording profile */
+ MM_CAMCORDER_ENCBIN_PROFILE_IMAGE, /**< Image capture profile */
+ MM_CAMCORDER_ENCBIN_PROFILE_NUM
} MMCamcorderEncodebinProfile;
/*=======================================================================================
/*=======================================================================================
| MACRO DEFINITIONS |
========================================================================================*/
-#define _mmcam_dbg_verb(fmt, args...) debug_verbose (" "fmt"\n", ##args);
-#define _mmcam_dbg_log(fmt, args...) debug_log (" "fmt"\n", ##args);
-#define _mmcam_dbg_warn(fmt, args...) debug_warning (" "fmt"\n", ##args);
-#define _mmcam_dbg_err(fmt, args...) debug_error (" "fmt"\n", ##args);
-#define _mmcam_dbg_crit(fmt, args...) debug_critical (" "fmt"\n", ##args);
+#define _mmcam_dbg_verb(fmt, args...) debug_verbose(" "fmt"\n", ##args);
+#define _mmcam_dbg_log(fmt, args...) debug_log(" "fmt"\n", ##args);
+#define _mmcam_dbg_warn(fmt, args...) debug_warning(" "fmt"\n", ##args);
+#define _mmcam_dbg_err(fmt, args...) debug_error(" "fmt"\n", ##args);
+#define _mmcam_dbg_crit(fmt, args...) debug_critical(" "fmt"\n", ##args);
/**
* Macro for checking validity and debugging
*/
-#define mmf_return_if_fail( expr ) \
- if( expr ){} \
- else \
- { \
- _mmcam_dbg_err( "failed [%s]", #expr); \
- return; \
- };
+#define mmf_return_if_fail(expr) \
+ if (!(expr)) { \
+ _mmcam_dbg_err("failed [%s]", #expr); \
+ return; \
+ }
/**
* Macro for checking validity and debugging
*/
-#define mmf_return_val_if_fail( expr, val ) \
- if( expr ){} \
- else \
- { \
- _mmcam_dbg_err("failed [%s]", #expr); \
- return( val ); \
- };
+#define mmf_return_val_if_fail(expr, val) \
+ if (!(expr)) { \
+ _mmcam_dbg_err("failed [%s]", #expr); \
+ return (val); \
+ }
+
#ifndef ARRAY_SIZE
/**
#define _MM_GST_ELEMENT_UNLINK gst_element_unlink
#define _MM_GST_PAD_LINK gst_pad_link
-#define _MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, if_fail_goto)\
-{\
- GstPadLinkReturn ret = GST_PAD_LINK_OK;\
- if (srcpad == NULL || sinkpad == NULL) {\
- if (srcpad == NULL) {\
- _mmcam_dbg_err("srcpad is NULL");\
- } else {\
+#define _MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, if_fail_goto) \
+{ \
+ GstPadLinkReturn ret = GST_PAD_LINK_OK; \
+ if (srcpad == NULL || sinkpad == NULL) { \
+ if (srcpad == NULL) { \
+ _mmcam_dbg_err("srcpad is NULL"); \
+ } else { \
gst_object_unref(srcpad);\
- srcpad = NULL;\
- }\
- if (sinkpad == NULL) {\
- _mmcam_dbg_err("sinkpad is NULL");\
- } else {\
- gst_object_unref(sinkpad);\
+ srcpad = NULL; \
+ } \
+ if (sinkpad == NULL) { \
+ _mmcam_dbg_err("sinkpad is NULL"); \
+ } else { \
+ gst_object_unref(sinkpad); \
sinkpad = NULL;\
- }\
- err = MM_ERROR_CAMCORDER_GST_LINK;\
- goto if_fail_goto;\
- }\
- ret = _MM_GST_PAD_LINK(srcpad, sinkpad);\
- if (ret != GST_PAD_LINK_OK) {\
- GstObject *src_parent = gst_pad_get_parent(srcpad);\
- GstObject *sink_parent = gst_pad_get_parent(sinkpad);\
- char *src_name = NULL;\
- char *sink_name = NULL;\
- g_object_get((GObject *)src_parent, "name", &src_name, NULL);\
- g_object_get((GObject *)sink_parent, "name", &sink_name, NULL);\
- _mmcam_dbg_err("src[%s] - sink[%s] link failed", src_name, sink_name);\
- gst_object_unref(src_parent); src_parent = NULL;\
- gst_object_unref(sink_parent); sink_parent = NULL;\
- if (src_name) {\
- free(src_name); src_name = NULL;\
- }\
- if (sink_name) {\
- free(sink_name); sink_name = NULL;\
- }\
- gst_object_unref(srcpad); srcpad = NULL;\
- gst_object_unref(sinkpad); sinkpad = NULL;\
- err = MM_ERROR_CAMCORDER_GST_LINK;\
+ } \
+ err = MM_ERROR_CAMCORDER_GST_LINK; \
+ goto if_fail_goto; \
+ } \
+ ret = _MM_GST_PAD_LINK(srcpad, sinkpad); \
+ if (ret != GST_PAD_LINK_OK) { \
+ GstObject *src_parent = gst_pad_get_parent(srcpad); \
+ GstObject *sink_parent = gst_pad_get_parent(sinkpad); \
+ char *src_name = NULL; \
+ char *sink_name = NULL; \
+ g_object_get((GObject *)src_parent, "name", &src_name, NULL); \
+ g_object_get((GObject *)sink_parent, "name", &sink_name, NULL); \
+ _mmcam_dbg_err("src[%s] - sink[%s] link failed", src_name, sink_name); \
+ gst_object_unref(src_parent); src_parent = NULL; \
+ gst_object_unref(sink_parent); sink_parent = NULL; \
+ if (src_name) { \
+ free(src_name); src_name = NULL; \
+ } \
+ if (sink_name) { \
+ free(sink_name); sink_name = NULL; \
+ } \
+ gst_object_unref(srcpad); srcpad = NULL; \
+ gst_object_unref(sinkpad); sinkpad = NULL; \
+ err = MM_ERROR_CAMCORDER_GST_LINK; \
goto if_fail_goto;\
- }\
- gst_object_unref(srcpad); srcpad = NULL;\
- gst_object_unref(sinkpad); sinkpad = NULL;\
+ } \
+ gst_object_unref(srcpad); srcpad = NULL; \
+ gst_object_unref(sinkpad); sinkpad = NULL; \
}
-#define _MM_GST_PAD_UNLINK_UNREF( srcpad, sinkpad) \
+#define _MM_GST_PAD_UNLINK_UNREF(srcpad, sinkpad) \
if (srcpad && sinkpad) { \
gst_pad_unlink(srcpad, sinkpad); \
} else { \
int device_type; /**< device type */
int state; /**< state of camcorder */
int target_state; /**< Target state that want to set. This is a flag that
- * stands for async state changing. If this value differ from state,
- * it means state is changing now asychronously. */
+ * stands for async state changing. If this value differ from state,
+ * it means state is changing now asychronously. */
/* handles */
MMHandleType attributes; /**< Attribute handle */
/* etc */
mm_cam_attr_construct_info *cam_attrs_const_info; /**< attribute info */
- conf_info_table* conf_main_info_table[CONFIGURE_CATEGORY_MAIN_NUM]; /** configure info table - MAIN category */
- conf_info_table* conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_NUM]; /** configure info table - CONTROL category */
+ conf_info_table *conf_main_info_table[CONFIGURE_CATEGORY_MAIN_NUM]; /** configure info table - MAIN category */
+ conf_info_table *conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_NUM]; /** configure info table - CONTROL category */
int conf_main_category_size[CONFIGURE_CATEGORY_MAIN_NUM]; /** configure info table size - MAIN category */
int conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_NUM]; /** configure info table size - CONTROL category */
_MMCamcorderMTSafe mtsafe; /**< Thread safe */
int _mmcamcorder_cancel(MMHandleType hcamcorder);
/**
- * This function calls after commiting action finished asynchronously.
+ * This function calls after commiting action finished asynchronously.
* In this function, remaining process , such as state change, happens.
*
* @param[in] hcamcorder Specifies the camcorder handle
* @return This function returns zero on success, or negative value with error code.
* @remarks typedef bool (*mm_message_callback) (int msg, mm_messageType *param, void *user_param);@n
* @n
- * typedef union @n
+ * typedef union @n
* { @n
* int code; @n
- * struct @n
+ * struct @n
* { @n
* int total; @n
* int elapsed; @n
* } time; @n
- * struct @n
+ * struct @n
* { @n
* int previous; @n
* int current; @n
/* sound focus related function */
void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder);
void _mmcamcorder_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
- mm_sound_focus_state_e focus_state, const char *reason_for_change,
- const char *additional_info, void *user_data);
+ mm_sound_focus_state_e focus_state, const char *reason_for_change,
+ const char *additional_info, void *user_data);
void _mmcamcorder_sound_focus_watch_cb(mm_sound_focus_type_e focus_type, mm_sound_focus_state_e focus_state,
- const char *reason_for_change, const char *additional_info, void *user_data);
+ const char *reason_for_change, const char *additional_info, void *user_data);
/* device policy manager */
void _mmcamcorder_dpm_camera_policy_changed_cb(const char *name, const char *value, void *user_data);
/*=======================================================================================
| GLOBAL DEFINITIONS AND DECLARATIONS FOR CAMCORDER |
========================================================================================*/
-#define MM_CAMCORDER_ATTR_NONE -1
+#define MM_CAMCORDER_ATTR_NONE -1
/*=======================================================================================
/**
* Default None value for camera sensor enumeration.
*/
-#define _MMCAMCORDER_SENSOR_ENUM_NONE -255
+#define _MMCAMCORDER_SENSOR_ENUM_NONE -255
/* camera information related */
#define CAMINFO_CONVERT_NUM 45
/* Function for capture */
int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int image_height);
-int __mmcamcorder_update_exif_info(MMHandleType handle,void* imagedata, int imgln);
+int __mmcamcorder_update_exif_info(MMHandleType handle, void *imagedata, int imgln);
void __mmcamcorder_init_stillshot_info(MMHandleType handle);
void __mmcamcorder_get_capture_data_from_buffer(MMCamcorderCaptureDataType *capture_data, int pixtype, GstSample *sample);
void __mmcamcorder_release_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType *dest, int tag_enable, int provide_exif);
| MACRO DEFINITIONS |
========================================================================================*/
#ifndef CLEAR
-#define CLEAR(x) memset (&(x), 0, sizeof (x))
+#define CLEAR(x) memset(&(x), 0, sizeof(x))
#endif
#define MMCAMCORDER_ADD_BUFFER_PROBE(x_pad, x_category, x_callback, x_hcamcorder) \
item->category = x_category; \
item->handler_id = gst_pad_add_probe(x_pad, GST_PAD_PROBE_TYPE_BUFFER, x_callback, x_hcamcorder, NULL); \
x_hcamcorder->buffer_probes = g_list_append(x_hcamcorder->buffer_probes, item); \
- _mmcam_dbg_log("Adding buffer probe on [%s:%s] - [ID : %lu], [Category : %x] ", GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); \
+ _mmcam_dbg_log("Adding buffer probe on [%s:%s] - [ID : %lu], [Category : %x] ", \
+ GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); \
} \
} while (0);
else if (x_category == 0 || !(x_category & _MMCAMCORDER_HANDLER_CATEGORY_ALL)) { \
_mmcam_dbg_err("Invalid handler category : %x \n", x_category); \
} else { \
- item->object =G_OBJECT(x_pad); \
+ item->object = G_OBJECT(x_pad); \
item->category = x_category; \
item->handler_id = gst_pad_add_probe(x_pad, GST_PAD_PROBE_TYPE_EVENT_BOTH, x_callback, x_hcamcorder, NULL); \
x_hcamcorder->event_probes = g_list_append(x_hcamcorder->event_probes, item); \
- _mmcam_dbg_log("Adding event probe on [%s:%s] - [ID : %lu], [Category : %x] ", GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); \
+ _mmcam_dbg_log("Adding event probe on [%s:%s] - [ID : %lu], [Category : %x] ", \
+ GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); \
} \
} while (0);
-#define MMCAMCORDER_SIGNAL_CONNECT( x_object, x_category, x_signal, x_callback, x_hcamcorder) \
+#define MMCAMCORDER_SIGNAL_CONNECT(x_object, x_category, x_signal, x_callback, x_hcamcorder) \
do { \
MMCamcorderHandlerItem* item = NULL; \
item = (MMCamcorderHandlerItem *) g_malloc(sizeof(MMCamcorderHandlerItem)); \
if (!item) { \
- _mmcam_dbg_err("Cannot connect signal [%s]\n", x_signal ); \
+ _mmcam_dbg_err("Cannot connect signal [%s]\n", x_signal); \
} else if (x_category == 0 || !(x_category & _MMCAMCORDER_HANDLER_CATEGORY_ALL)) { \
_mmcam_dbg_err("Invalid handler category : %x \n", x_category); \
} else { \
item->object = G_OBJECT(x_object); \
item->category = x_category; \
- item->handler_id = g_signal_connect(G_OBJECT(x_object), x_signal,\
- G_CALLBACK(x_callback), x_hcamcorder ); \
+ item->handler_id = g_signal_connect(G_OBJECT(x_object), x_signal, \
+ G_CALLBACK(x_callback), x_hcamcorder); \
x_hcamcorder->signals = g_list_append(x_hcamcorder->signals, item); \
- _mmcam_dbg_log("Connecting signal on [%s][%p] - [ID : %lu], [Category : %x] ", GST_OBJECT_NAME(item->object), item->object, item->handler_id, item->category); \
+ _mmcam_dbg_log("Connecting signal on [%s][%p] - [ID : %lu], [Category : %x] ", \
+ GST_OBJECT_NAME(item->object), item->object, item->handler_id, item->category); \
} \
} while (0);
#define MMCAMCORDER_G_OBJECT_GET(obj, name, value) \
do { \
if (obj) { \
- if(g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(obj)), name)) { \
+ if (g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(obj)), name)) { \
g_object_get(G_OBJECT(obj), name, value, NULL); \
} else { \
- _mmcam_dbg_warn ("The object doesn't have a property named(%s)", name); \
+ _mmcam_dbg_warn("The object doesn't have a property named(%s)", name); \
} \
} else { \
_mmcam_dbg_err("Null object"); \
} \
-} while(0);
+} while (0);
#define MMCAMCORDER_G_OBJECT_SET(obj, name, value) \
do { \
if (obj) { \
GParamSpec *spec = g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(obj)), name);\
- if(spec) { \
+ if (spec) { \
if (spec->value_type == G_TYPE_INT64) {\
g_object_set(G_OBJECT(obj), name, (gint64)value, NULL); \
} else if (spec->value_type == G_TYPE_UINT64) { \
g_object_set(G_OBJECT(obj), name, value, NULL); \
} \
} else { \
- _mmcam_dbg_warn ("The object doesn't have a property named(%s)", name); \
+ _mmcam_dbg_warn("The object doesn't have a property named(%s)", name); \
} \
} else { \
_mmcam_dbg_err("Null object"); \
} \
-} while(0);
+} while (0);
#define MMCAMCORDER_G_OBJECT_SET_POINTER(obj, name, value) \
do { \
if (obj) { \
GParamSpec *spec = g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(obj)), name);\
- if(spec) { \
+ if (spec) { \
g_object_set(G_OBJECT(obj), name, value, NULL); \
} else { \
- _mmcam_dbg_warn ("The object doesn't have a property named(%s)", name); \
+ _mmcam_dbg_warn("The object doesn't have a property named(%s)", name); \
} \
} else { \
_mmcam_dbg_err("Null object"); \
} \
-} while(0);
+} while (0);
-#define MMCAM_FOURCC(a,b,c,d) (guint32)((a)|(b)<<8|(c)<<16|(d)<<24)
+#define MMCAM_FOURCC(a, b, c, d) (guint32)((a)|(b)<<8|(c)<<16|(d)<<24)
#define MMCAM_FOURCC_ARGS(fourcc) \
- ((gchar)((fourcc)&0xff)), \
- ((gchar)(((fourcc)>>8)&0xff)), \
- ((gchar)(((fourcc)>>16)&0xff)), \
- ((gchar)(((fourcc)>>24)&0xff))
+ ((gchar)((fourcc)&0xff)), \
+ ((gchar)(((fourcc)>>8)&0xff)), \
+ ((gchar)(((fourcc)>>16)&0xff)), \
+ ((gchar)(((fourcc)>>24)&0xff))
#define MMCAM_SEND_MESSAGE(handle, msg_id, msg_code) \
{\
gint32 _mmcamcorder_double_to_fix(gdouble d_number);
gboolean _mmcamcorder_update_size(FILE *f, gint64 prev_pos, gint64 curr_pos);
gboolean _mmcamcorder_write_loci(FILE *f, _MMCamcorderLocationInfo info);
-gboolean _mmcamcorder_write_geodata(FILE *f,_MMCamcorderLocationInfo info);
+gboolean _mmcamcorder_write_geodata(FILE *f, _MMCamcorderLocationInfo info);
gboolean _mmcamcorder_write_udta(FILE *f, int gps_enable, _MMCamcorderLocationInfo info, _MMCamcorderLocationInfo geotag);
guint64 _mmcamcorder_get_container_size(const guchar *size);
guint64 _mmcamcorder_get_container_size64(const guchar *size);
int mm_camcorder_set_video_capture_callback(MMHandleType camcorder, mm_camcorder_video_capture_callback callback, void* user_data)
{
- mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
+ mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
return _mmcamcorder_set_video_capture_callback(camcorder, callback, user_data);
}
va_start(var_args, attribute_name);
ret = _mmcamcorder_get_attributes(camcorder, err_attr_name, attribute_name, var_args);
- va_end (var_args);
+ va_end(var_args);
return ret;
}
return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
- va_start (var_args, attribute_name);
+ va_start(var_args, attribute_name);
ret = _mmcamcorder_set_attributes(camcorder, err_attr_name, attribute_name, var_args);
- va_end (var_args);
+ va_end(var_args);
return ret;
}
}
-int mm_camcorder_start_focusing( MMHandleType camcorder )
+int mm_camcorder_start_focusing(MMHandleType camcorder)
{
int error = MM_ERROR_NONE;
/*-----------------------------------------------------------------------
| LOCAL VARIABLE DEFINITIONS for internal |
-----------------------------------------------------------------------*/
-/* Readonly attributes list.
+/* Readonly attributes list.
* If you want to make some attributes read only, write down here.
* It will make them read only after composing whole attributes.
*/
| GLOBAL FUNCTION DEFINITIONS: |
-----------------------------------------------------------------------*/
MMHandleType
-_mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
+_mmcamcorder_alloc_attribute(MMHandleType handle, MMCamPreset *info)
{
- _mmcam_dbg_log( "" );
+ _mmcam_dbg_log("");
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
MMHandleType attrs = 0;
static int flip_list[] = { MM_FLIP_NONE };
static int rotation_list[] = { MM_VIDEO_INPUT_ROTATION_NONE };
static int visible_values[] = { 0, 1 }; /*0: off, 1:on*/
- static int tag_orientation_values[] =
- {
+ static int tag_orientation_values[] = {
1, /*The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side.*/
2, /*the 0th row is at the visual top of the image, and the 0th column is the visual right-hand side.*/
3, /*the 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side.*/
/* basic attributes' info */
mm_cam_attr_construct_info temp_info[] = {
- //0
+ /* 0 */
{
MM_CAM_MODE, /* ID */
"mode", /* Name */
{ARRAY_SIZE(depth)},
NULL,
},
- //10
+ /* 10 */
{
MM_CAM_AUDIO_CHANNEL,
"audio-channel",
{.int_max = -1},
_mmcamcorder_commit_filter,
},
- //20
+ /* 20 */
{
MM_CAM_FILTER_SHARPNESS,
"filter-sharpness",
{0},
_mmcamcorder_commit_camera_af_scan_range,
},
- //30
+ /* 30 */
{
MM_CAM_CAMERA_EXPOSURE_MODE,
"camera-exposure-mode",
{.int_max = _MMCAMCORDER_MAX_INT},
NULL,
},
- // 40
+ /* 40 */
{
MM_CAM_VIDEO_ENCODER_BITRATE,
"video-encoder-bitrate",
{0},
NULL,
},
- // 50
+ /* 50 */
{
MM_CAM_DISPLAY_SURFACE,
"display-surface",
{.int_max = MM_DISPLAY_ROTATION_270},
_mmcamcorder_commit_display_rotation,
},
- { // 60
+ /* 60 */
+ {
MM_CAM_DISPLAY_VISIBLE,
"display-visible",
MMF_VALUE_TYPE_INT,
{0},
NULL,
},
- //70
+ /* 70 */
{
MM_CAM_TAG_LATITUDE,
"tag-latitude",
{.int_max = -1},
_mmcamcorder_commit_detect,
},
- //80
+ /* 80 */
{
MM_CAM_DETECT_STATUS,
"detect-status",
{.int_max = 1},
NULL,
},
- // 90
+ /* 90 */
{
MM_CAM_TAG_GPS_TIME_STAMP,
"tag-gps-time-stamp",
{0},
_mmcamcorder_commit_display_mode,
},
- //100
+ /* 100 */
{
MM_CAM_AUDIO_DISABLE,
"audio-disable",
{.int_max = MM_CAMCORDER_TAG_VIDEO_ORT_270},
NULL,
},
- //110
+ /* 110 */
{
MM_CAM_CAMERA_PAN_MECHA,
"camera-pan-mecha",
{.int_max = TRUE},
NULL,
},
+ /* 120 */
{
MM_CAM_ENCODED_PREVIEW_BITRATE,
"encoded-preview-bitrate",
{.int_max = _MMCAMCORDER_MAX_INT},
_mmcamcorder_commit_encoded_preview_gop_interval,
},
- //120
{
MM_CAM_RECORDER_TAG_ENABLE,
"recorder-tag-enable",
_mmcam_dbg_log("Create Camcorder Attributes[%p, %d]", attrs_const_info, attr_count);
attrs = mmf_attrs_new_from_data("Camcorder_Attributes",
- attrs_const_info,
- attr_count,
- _mmcamcorder_commit_camcorder_attrs,
- (void *)handle);
+ attrs_const_info,
+ attr_count,
+ _mmcamcorder_commit_camcorder_attrs,
+ (void *)handle);
free(attrs_const_info);
attrs_const_info = NULL;
__mmcamcorder_set_conf_to_valid_info(handle);
- for (idx = 0; idx < attr_count; idx++)
- {
+ for (idx = 0; idx < attr_count; idx++) {
/* _mmcam_dbg_log("Valid type [%s:%d, %d, %d]", cam_attrs_const_info[idx].name, cam_attrs_const_info[idx].validity_type
, cam_attrs_const_info[idx].validity_value1, cam_attrs_const_info[idx].validity_value2);
*/
- mmf_attrs_set_valid_type (attrs, idx, hcamcorder->cam_attrs_const_info[idx].validity_type);
-
- switch (hcamcorder->cam_attrs_const_info[idx].validity_type)
- {
- case MM_ATTRS_VALID_TYPE_INT_ARRAY:
- if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array &&
- hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
- mmf_attrs_set_valid_array(attrs, idx,
- (const int *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array),
- hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
- hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
- }
+ mmf_attrs_set_valid_type(attrs, idx, hcamcorder->cam_attrs_const_info[idx].validity_type);
+
+ switch (hcamcorder->cam_attrs_const_info[idx].validity_type) {
+ case MM_ATTRS_VALID_TYPE_INT_ARRAY:
+ if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array &&
+ hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
+ mmf_attrs_set_valid_array(attrs, idx,
+ (const int *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array),
+ hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
+ hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
+ }
break;
- case MM_ATTRS_VALID_TYPE_INT_RANGE:
- mmf_attrs_set_valid_range(attrs, idx,
- hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_min,
- hcamcorder->cam_attrs_const_info[idx].validity_value_2.int_max,
- hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
+ case MM_ATTRS_VALID_TYPE_INT_RANGE:
+ mmf_attrs_set_valid_range(attrs, idx,
+ hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_min,
+ hcamcorder->cam_attrs_const_info[idx].validity_value_2.int_max,
+ hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
break;
- case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
- if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array &&
- hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
- mmf_attrs_set_valid_double_array(attrs, idx,
- (const double *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array),
- hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
- hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
- }
+ case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
+ if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array &&
+ hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
+ mmf_attrs_set_valid_double_array(attrs, idx,
+ (const double *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array),
+ hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
+ hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
+ }
break;
- case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
- mmf_attrs_set_valid_double_range(attrs, idx,
- hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_min,
- hcamcorder->cam_attrs_const_info[idx].validity_value_2.double_max,
- hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
+ case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
+ mmf_attrs_set_valid_double_range(attrs, idx,
+ hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_min,
+ hcamcorder->cam_attrs_const_info[idx].validity_value_2.double_max,
+ hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
break;
- case MM_ATTRS_VALID_TYPE_NONE:
+ case MM_ATTRS_VALID_TYPE_NONE:
break;
- case MM_ATTRS_VALID_TYPE_INVALID:
- default:
- _mmcam_dbg_err("Valid type error.");
+ case MM_ATTRS_VALID_TYPE_INVALID:
+ default:
+ _mmcam_dbg_err("Valid type error.");
break;
}
}
MMHandleType attrs = 0;
int ret = MM_ERROR_NONE;
- mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
-// mmf_return_val_if_fail( err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
+ mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+ /*mmf_return_val_if_fail(err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);*/
attrs = MMF_CAMCORDER_ATTRS(handle);
- mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
+ mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
ret = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, var_args);
int ret = MM_ERROR_NONE;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
-// mmf_return_val_if_fail( err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
+ mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+ /*mmf_return_val_if_fail(err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);*/
if (!_MMCAMCORDER_TRYLOCK_CMD(handle)) {
_mmcam_dbg_err("Another command is running.");
attrs = MMF_CAMCORDER_ATTRS(handle);
if (attrs) {
- ret = __mmcamcorder_check_valid_pair( handle, err_attr_name, attribute_name, var_args );
+ ret = __mmcamcorder_check_valid_pair(handle, err_attr_name, attribute_name, var_args);
} else {
_mmcam_dbg_err("handle 0x%x, attrs is NULL, attr name [%s]", handle, attribute_name);
ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
MMAttrsInfo attrinfo;
int ret = MM_ERROR_NONE;
- mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
- mmf_return_val_if_fail( attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
- mmf_return_val_if_fail( info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
+ mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+ mmf_return_val_if_fail(attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+ mmf_return_val_if_fail(info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
attrs = MMF_CAMCORDER_ATTRS(handle);
- mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+ mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
ret = mm_attrs_get_info_by_name(attrs, attr_name, (MMAttrsInfo*)&attrinfo);
- if (ret == MM_ERROR_NONE)
- {
+ if (ret == MM_ERROR_NONE) {
memset(info, 0x00, sizeof(MMCamAttrsInfo));
info->type = attrinfo.type;
info->flag = attrinfo.flag;
- info->validity_type= attrinfo.validity_type;
+ info->validity_type = attrinfo.validity_type;
- switch(attrinfo.validity_type)
- {
- case MM_ATTRS_VALID_TYPE_INT_ARRAY:
- info->int_array.array = attrinfo.int_array.array;
- info->int_array.count = attrinfo.int_array.count;
- info->int_array.def = attrinfo.int_array.dval;
+ switch (attrinfo.validity_type) {
+ case MM_ATTRS_VALID_TYPE_INT_ARRAY:
+ info->int_array.array = attrinfo.int_array.array;
+ info->int_array.count = attrinfo.int_array.count;
+ info->int_array.def = attrinfo.int_array.dval;
break;
- case MM_ATTRS_VALID_TYPE_INT_RANGE:
- info->int_range.min = attrinfo.int_range.min;
- info->int_range.max = attrinfo.int_range.max;
- info->int_range.def = attrinfo.int_range.dval;
+ case MM_ATTRS_VALID_TYPE_INT_RANGE:
+ info->int_range.min = attrinfo.int_range.min;
+ info->int_range.max = attrinfo.int_range.max;
+ info->int_range.def = attrinfo.int_range.dval;
break;
- case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
- info->double_array.array = attrinfo.double_array.array;
- info->double_array.count = attrinfo.double_array.count;
- info->double_array.def = attrinfo.double_array.dval;
+ case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
+ info->double_array.array = attrinfo.double_array.array;
+ info->double_array.count = attrinfo.double_array.count;
+ info->double_array.def = attrinfo.double_array.dval;
break;
- case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
- info->double_range.min = attrinfo.double_range.min;
- info->double_range.max = attrinfo.double_range.max;
- info->double_range.def = attrinfo.double_range.dval;
+ case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
+ info->double_range.min = attrinfo.double_range.min;
+ info->double_range.max = attrinfo.double_range.max;
+ info->double_range.def = attrinfo.double_range.dval;
break;
- case MM_ATTRS_VALID_TYPE_NONE:
+ case MM_ATTRS_VALID_TYPE_NONE:
break;
- case MM_ATTRS_VALID_TYPE_INVALID:
- default:
+ case MM_ATTRS_VALID_TYPE_INVALID:
+ default:
break;
}
}
bool
-_mmcamcorder_commit_camcorder_attrs (int attr_idx, const char *attr_name, const mmf_value_t *value, void *commit_param)
+_mmcamcorder_commit_camcorder_attrs(int attr_idx, const char *attr_name, const mmf_value_t *value, void *commit_param)
{
bool bret = FALSE;
mmf_camcorder_t *hcamcorder = NULL;
hcamcorder = MMF_CAMCORDER(commit_param);
- if (hcamcorder->cam_attrs_const_info[attr_idx].attr_commit) {
+ if (hcamcorder->cam_attrs_const_info[attr_idx].attr_commit)
bret = hcamcorder->cam_attrs_const_info[attr_idx].attr_commit((MMHandleType)commit_param, attr_idx, value);
- } else {
+ else
bret = TRUE;
- }
return bret;
}
}
-bool _mmcamcorder_commit_capture_width (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_capture_width(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
MMHandleType attr = 0;
int current_state = MM_CAMCORDER_STATE_NONE;
}
-bool _mmcamcorder_commit_capture_height (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_capture_height(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
int current_state = MM_CAMCORDER_STATE_NONE;
}
-bool _mmcamcorder_commit_capture_break_cont_shot (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_capture_break_cont_shot(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
- int current_state = _mmcamcorder_get_state( handle);
+ int current_state = _mmcamcorder_get_state(handle);
int ivalue = value->value.i_val;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
const char *videosrc_name = NULL;
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "VideosrcElement",
- &VideosrcElement );
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "VideosrcElement",
+ &VideosrcElement);
_mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
_mmcam_dbg_warn("cast CAMERA_CONTROL failed");
}
} else {
- _mmcam_dbg_warn( "Commit Break continuous shot : No effect. value[%d],current state[%d]", ivalue, current_state );
+ _mmcam_dbg_warn("Commit Break continuous shot : No effect. value[%d],current state[%d]", ivalue, current_state);
}
return TRUE;
mm_camcorder_get_attributes(handle, NULL, MMCAM_MODE, &mode, NULL);
_mmcam_dbg_log("current state %d, mode %d, set count %d",
- current_state, mode, value->value.i_val);
+ current_state, mode, value->value.i_val);
if (mode != MM_CAMCORDER_MODE_AUDIO &&
current_state != MM_CAMCORDER_STATE_CAPTURING) {
}
-bool _mmcamcorder_commit_audio_volume (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_audio_volume(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
int current_state = MM_CAMCORDER_STATE_NONE;
_MMCamcorderSubContext *sc = NULL;
bool bret = FALSE;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
- current_state = _mmcamcorder_get_state( handle);
+ current_state = _mmcamcorder_get_state(handle);
- if ((current_state == MM_CAMCORDER_STATE_RECORDING)||(current_state == MM_CAMCORDER_STATE_PAUSED)) {
+ if ((current_state == MM_CAMCORDER_STATE_RECORDING) || (current_state == MM_CAMCORDER_STATE_PAUSED)) {
double mslNewVal = 0;
mslNewVal = value->value.d_val;
}
-bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_fps(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
MMCamAttrsInfo fps_info;
int resolution_width = 0;
_mmcam_dbg_log("FPS(%d)", value->value.i_val);
ret = mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_WIDTH, &resolution_width,
- MMCAM_CAMERA_HEIGHT, &resolution_height,
- NULL);
+ MMCAM_CAMERA_WIDTH, &resolution_width,
+ MMCAM_CAMERA_HEIGHT, &resolution_height,
+ NULL);
- if(ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("FAILED : coult not get resolution values.");
return FALSE;
}
}
for (i = 0 ; i < fps_info.int_array.count ; i++) {
- if(value->value.i_val == fps_info.int_array.array[i]) {
+ if (value->value.i_val == fps_info.int_array.array[i])
return TRUE;
- }
}
_mmcam_dbg_err("FAILED : %d is not supported FPS", value->value.i_val);
/* Verify recording motion rate */
if (value->value.d_val > 0.0) {
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
/* set is_slow flag */
- if (value->value.d_val != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
+ if (value->value.d_val != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE)
sc->is_modified_rate = TRUE;
- } else {
+ else
sc->is_modified_rate = FALSE;
- }
_mmcam_dbg_log("Set slow motion rate %lf", value->value.d_val);
return TRUE;
mmf_return_val_if_fail(hcamcorder, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
attr = MMF_CAMCORDER_ATTRS(handle);
mmf_return_val_if_fail(attr, FALSE);
int codec_type = MM_IMAGE_CODEC_JPEG;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_HEIGHT, &height,
- MMCAM_CAMERA_FORMAT, &preview_format,
- MMCAM_IMAGE_ENCODER, &codec_type,
- NULL);
+ MMCAM_CAMERA_HEIGHT, &height,
+ MMCAM_CAMERA_FORMAT, &preview_format,
+ MMCAM_IMAGE_ENCODER, &codec_type,
+ NULL);
if (current_state == MM_CAMCORDER_STATE_PREPARE) {
if (hcamcorder->resolution_changed == FALSE) {
mmf_return_val_if_fail(hcamcorder, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
attr = MMF_CAMCORDER_ATTRS(hcamcorder);
mmf_return_val_if_fail(attr, FALSE);
int video_stabilization = 0;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_WIDTH, &width,
- MMCAM_CAMERA_FORMAT, &preview_format,
- MMCAM_IMAGE_ENCODER, &codec_type,
- MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization,
- NULL);
+ MMCAM_CAMERA_WIDTH, &width,
+ MMCAM_CAMERA_FORMAT, &preview_format,
+ MMCAM_IMAGE_ENCODER, &codec_type,
+ MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization,
+ NULL);
sc->info_video->preview_width = width;
sc->info_video->preview_height = height;
return FALSE;
} else {
_mmcam_dbg_warn("Video Resolution %d [attr_idx %d] ",
- value->value.i_val, attr_idx);
+ value->value.i_val, attr_idx);
return TRUE;
}
}
-bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_zoom(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
_MMCamcorderSubContext *sc = NULL;
int current_state = MM_CAMCORDER_STATE_NONE;
int zoom_type;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
_mmcam_dbg_log("(%d)", attr_idx);
return FALSE;
}
- if (attr_idx == MM_CAM_CAMERA_OPTICAL_ZOOM) {
+ if (attr_idx == MM_CAM_CAMERA_OPTICAL_ZOOM)
zoom_type = GST_CAMERA_CONTROL_OPTICAL_ZOOM;
- } else {
+ else
zoom_type = GST_CAMERA_CONTROL_DIGITAL_ZOOM;
- }
if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
int ret = FALSE;
return TRUE;
}
- control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
_mmcam_dbg_err("cast CAMERA_CONTROL failed");
return FALSE;
}
-bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_focus_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
MMHandleType attr = 0;
int current_state = MM_CAMCORDER_STATE_NONE;
return TRUE;
}
- control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
_mmcam_dbg_err("cast CAMERA_CONTROL failed");
return FALSE;
}
mslVal = value->value.i_val;
- set_focus_mode = _mmcamcorder_convert_msl_to_sensor( handle, attr_idx, mslVal );
+ set_focus_mode = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal);
mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_SCAN_RANGE, &info);
flags = info.flag;
}
-bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_af_scan_range(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
_MMCamcorderSubContext *sc = NULL;
GstCameraControl *control = NULL;
return TRUE;
}
- control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
_mmcam_dbg_err("cast CAMERA_CONTROL failed");
return FALSE;
}
mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FOCUS_MODE, &msl_mode, NULL);
- converted_mode = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_CAMERA_FOCUS_MODE, msl_mode );
+ converted_mode = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_FOCUS_MODE, msl_mode);
if (gst_camera_control_get_focus(control, &cur_focus_mode, &cur_focus_range)) {
if ((newVal != cur_focus_range) || (converted_mode != cur_focus_mode)) {
if (gst_camera_control_set_focus(control, converted_mode, newVal)) {
- //_mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal);
+ /*_mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal);*/
return TRUE;
} else {
_mmcam_dbg_warn("Failed to set AF mode[%d]", mslVal);
}
} else {
- //_mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal);
+ /*_mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal);*/
return TRUE;
}
} else {
}
-bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_af_touch_area(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
_MMCamcorderSubContext *sc = NULL;
GstCameraControl *control = NULL;
MMCamAttrsInfo info_h;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
_mmcam_dbg_log("(%d)", attr_idx);
}
ret = mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
- NULL);
+ MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
+ NULL);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_warn("Failed to get FOCUS MODE.[%x]", ret);
return FALSE;
if (!((info_y.flag|info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED)) {
set_area.x = value->value.i_val;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
- MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
- MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
- NULL);
+ MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
+ MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
+ MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
+ NULL);
do_set = TRUE;
} else {
_mmcam_dbg_log("Just store AF area[x:%d]", value->value.i_val);
if (!((info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED)) {
set_area.y = value->value.i_val;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
- MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
- MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
- NULL);
+ MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
+ MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
+ MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
+ NULL);
do_set = TRUE;
} else {
- _mmcam_dbg_log( "Just store AF area[y:%d]", value->value.i_val );
+ _mmcam_dbg_log("Just store AF area[y:%d]", value->value.i_val);
return TRUE;
}
break;
if (!(info_h.flag & MM_ATTRS_FLAG_MODIFIED)) {
set_area.width = value->value.i_val;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
- MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
- MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
- NULL);
+ MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
+ MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
+ MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
+ NULL);
do_set = TRUE;
} else {
_mmcam_dbg_log("Just store AF area[width:%d]", value->value.i_val);
case MM_CAM_CAMERA_AF_TOUCH_HEIGHT:
set_area.height = value->value.i_val;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
- MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
- MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
- NULL);
+ MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
+ MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
+ MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
+ NULL);
do_set = TRUE;
break;
default:
return FALSE;
}
- control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
_mmcam_dbg_err("cast CAMERA_CONTROL failed");
return FALSE;
ratio_height = (float)info->video_height / (float)info->preview_height;
_mmcam_dbg_log("original area %d,%d,%dx%d, resolution ratio : width %f, height %f",
- set_area.x, set_area.y, set_area.width, set_area.height, ratio_width, ratio_height);
+ set_area.x, set_area.y, set_area.width, set_area.height, ratio_width, ratio_height);
set_area.x = (int)((float)set_area.x * ratio_width);
set_area.y = (int)((float)set_area.y * ratio_height);
set_area.width = (int)((float)set_area.width * ratio_width);
set_area.height = (int)((float)set_area.height * ratio_height);
- if (set_area.width <= 0) {
+ if (set_area.width <= 0)
set_area.width = 1;
- }
- if (set_area.height <= 0) {
+
+ if (set_area.height <= 0)
set_area.height = 1;
- }
_mmcam_dbg_log("converted area %d,%d,%dx%d",
- set_area.x, set_area.y, set_area.width, set_area.height);
+ set_area.x, set_area.y, set_area.width, set_area.height);
} else {
_mmcam_dbg_warn("invalid preview size %dx%d, skip AF area converting",
- info->preview_width, info->preview_height);
+ info->preview_width, info->preview_height);
}
}
ret = gst_camera_control_get_auto_focus_area(control, &get_area);
if (!ret) {
- _mmcam_dbg_warn( "Failed to get AF area" );
+ _mmcam_dbg_warn("Failed to get AF area");
return FALSE;
}
/* width and height are not supported now */
if (get_area.x == set_area.x && get_area.y == set_area.y) {
_mmcam_dbg_log("No need to set AF area[x,y:%d,%d]",
- get_area.x, get_area.y);
+ get_area.x, get_area.y);
return TRUE;
}
ret = gst_camera_control_set_auto_focus_area(control, set_area);
if (ret) {
_mmcam_dbg_log("Succeed to set AF area[%d,%d,%dx%d]",
- set_area.x, set_area.y, set_area.width, set_area.height);
+ set_area.x, set_area.y, set_area.width, set_area.height);
return TRUE;
} else {
_mmcam_dbg_warn("Failed to set AF area[%d,%d,%dx%d]",
- set_area.x, set_area.y, set_area.width, set_area.height);
+ set_area.x, set_area.y, set_area.width, set_area.height);
}
}
} else {
}
-bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_capture_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
GstCameraControl *control = NULL;
int ivalue = value->value.i_val;
return TRUE;
}
- current_state = _mmcamcorder_get_state( handle);
- if (current_state < MM_CAMCORDER_STATE_READY) {
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_READY)
return TRUE;
- }
if (attr_idx == MM_CAM_CAMERA_F_NUMBER) {
exposure_type = GST_CAMERA_CONTROL_F_NUMBER;
- mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
- mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
+ mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR(ivalue);
+ mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR(ivalue);
} else if (attr_idx == MM_CAM_CAMERA_SHUTTER_SPEED) {
exposure_type = GST_CAMERA_CONTROL_SHUTTER_SPEED;
- mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
- mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
+ mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR(ivalue);
+ mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR(ivalue);
} else if (attr_idx == MM_CAM_CAMERA_ISO) {
exposure_type = GST_CAMERA_CONTROL_ISO;
mslVal1 = ivalue;
check_scene_mode = TRUE;
} else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_VALUE) {
exposure_type = GST_CAMERA_CONTROL_EXPOSURE_VALUE;
- mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
- mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
+ mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR(ivalue);
+ mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR(ivalue);
}
if (check_scene_mode) {
return TRUE;
}
- control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
_mmcam_dbg_err("cast CAMERA_CONTROL failed");
return FALSE;
ret = gst_camera_control_set_exposure(control, exposure_type, newVal1, newVal2);
if (ret) {
- _mmcam_dbg_log("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
+ _mmcam_dbg_log("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2);
return TRUE;
} else {
- _mmcam_dbg_warn("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
+ _mmcam_dbg_warn("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2);
}
} else {
_mmcam_dbg_log("pointer of video src is null");
}
-bool _mmcamcorder_commit_camera_wdr (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_wdr(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
GstCameraControl *control = NULL;
int mslVal = 0;
}
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
/* check current state */
- current_state = _mmcamcorder_get_state( handle);
+ current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
_mmcam_dbg_log("will be applied when preview starts");
return TRUE;
if (gst_camera_control_get_wdr(control, &cur_value)) {
if (newVal != cur_value) {
if (gst_camera_control_set_wdr(control, newVal)) {
- _mmcam_dbg_log( "Success - set wdr[%d]", mslVal );
+ _mmcam_dbg_log("Success - set wdr[%d]", mslVal);
return TRUE;
} else {
_mmcam_dbg_warn("Failed to set WDR. NewVal[%d],CurVal[%d]", newVal, cur_value);
}
} else {
- _mmcam_dbg_log( "No need to set new WDR. Current[%d]", mslVal );
+ _mmcam_dbg_log("No need to set new WDR. Current[%d]", mslVal);
return TRUE;
}
} else {
- _mmcam_dbg_warn( "Failed to get WDR." );
+ _mmcam_dbg_warn("Failed to get WDR.");
}
} else {
_mmcam_dbg_log("pointer of video src is null");
int size = 0;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
/* get string */
filename = mmf_value_get_string(value, &size);
-bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_filter(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
GstColorBalance *balance = NULL;
GstColorBalanceChannel *Colorchannel = NULL;
}
newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslNewVal);
- if (newVal == _MMCAMCORDER_SENSOR_ENUM_NONE) {
+ if (newVal == _MMCAMCORDER_SENSOR_ENUM_NONE)
return FALSE;
- }
/*_mmcam_dbg_log("label(%s): MSL(%d)->Sensor(%d)", control_label, mslNewVal, newVal);*/
for (item = controls ; item && item->data ; item = item->next) {
Colorchannel = item->data;
- //_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label);
+ /*_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label);*/
if (!strcmp(Colorchannel->label, control_label)) {
- gst_color_balance_set_value (balance, Colorchannel, newVal);
+ gst_color_balance_set_value(balance, Colorchannel, newVal);
_mmcam_dbg_log("Set complete - %s[msl:%d,real:%d]", Colorchannel->label, mslNewVal, newVal);
break;
}
}
-bool _mmcamcorder_commit_filter_scene_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_filter_scene_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
GstCameraControl *control = NULL;
int mslVal = value->value.i_val;
- int newVal = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_FILTER_SCENE_MODE, mslVal );
+ int newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_FILTER_SCENE_MODE, mslVal);
_MMCamcorderSubContext *sc = NULL;
int current_state = MM_CAMCORDER_STATE_NONE;
if (mslVal == MM_CAMCORDER_SCENE_MODE_NORMAL) {
unsigned int i = 0;
int attr_idxs[] = {
- MM_CAM_CAMERA_ISO
- , MM_CAM_FILTER_BRIGHTNESS
- , MM_CAM_FILTER_WB
- , MM_CAM_FILTER_SATURATION
- , MM_CAM_FILTER_SHARPNESS
- , MM_CAM_FILTER_COLOR_TONE
- , MM_CAM_CAMERA_EXPOSURE_MODE
+ MM_CAM_CAMERA_ISO,
+ MM_CAM_FILTER_BRIGHTNESS,
+ MM_CAM_FILTER_WB,
+ MM_CAM_FILTER_SATURATION,
+ MM_CAM_FILTER_SHARPNESS,
+ MM_CAM_FILTER_COLOR_TONE,
+ MM_CAM_CAMERA_EXPOSURE_MODE
};
mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
for (i = 0 ; i < ARRAY_SIZE(attr_idxs) ; i++) {
- if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs[i])) {
+ if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs[i]))
mmf_attribute_set_modified(&(attr->items[attr_idxs[i]]));
- }
}
}
return TRUE;
} else {
- _mmcam_dbg_log( "Failed to set program mode[%d].", mslVal );
+ _mmcam_dbg_log("Failed to set program mode[%d].", mslVal);
}
} else {
_mmcam_dbg_warn("pointer of video src is null");
}
-bool _mmcamcorder_commit_filter_flip (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_filter_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
_mmcam_dbg_warn("Filter Flip(%d)", value->value.i_val);
return TRUE;
}
-bool _mmcamcorder_commit_audio_input_route (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_audio_input_route(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
_mmcam_dbg_log("Commit : Do nothing. this attr will be removed soon.");
-
return TRUE;
}
_mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
- if (!strcmp(videosink_name, "xvimagesink") ||
- !strcmp(videosink_name, "ximagesink")) {
+ if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "ximagesink")) {
_mmcam_dbg_log("Commit : Set XID[%x]", *(int*)(p_handle));
gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), *(int*)(p_handle));
- } else if (!strcmp(videosink_name, "evasimagesink") ||
- !strcmp(videosink_name, "evaspixmapsink")) {
+ } else if (!strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "evaspixmapsink")) {
_mmcam_dbg_log("Commit : Set evas object [%p]", p_handle);
MMCAMCORDER_G_OBJECT_SET_POINTER(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "evas-object", p_handle);
} else if (!strcmp(videosink_name, "waylandsink")) {
}
if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink") ||
- !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) {
+ !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "visible", value->value.i_val);
_mmcam_dbg_log("Set visible [%d] done.", value->value.i_val);
return TRUE;
}
-bool _mmcamcorder_commit_display_geometry_method (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_display_geometry_method(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
int method = 0;
int current_state = MM_CAMCORDER_STATE_NONE;
/* check current method */
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_DISPLAY_GEOMETRY_METHOD, &method,
- NULL);
+ MMCAM_DISPLAY_GEOMETRY_METHOD, &method,
+ NULL);
if (method != MM_DISPLAY_METHOD_CUSTOM_ROI) {
_mmcam_dbg_log("current method[%d] is not supported rect", method);
return FALSE;
MMCamAttrsInfo info;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_DISPLAY_RECT_X, &rect_x,
- MMCAM_DISPLAY_RECT_Y, &rect_y,
- MMCAM_DISPLAY_RECT_WIDTH, &rect_width,
- MMCAM_DISPLAY_RECT_HEIGHT, &rect_height,
- NULL);
+ MMCAM_DISPLAY_RECT_X, &rect_x,
+ MMCAM_DISPLAY_RECT_Y, &rect_y,
+ MMCAM_DISPLAY_RECT_WIDTH, &rect_width,
+ MMCAM_DISPLAY_RECT_HEIGHT, &rect_height,
+ NULL);
switch (attr_idx) {
case MM_CAM_DISPLAY_RECT_X:
mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_Y, &info);
}
} else {
g_object_set(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
- "dst-roi-x", rect_x,
- "dst-roi-y", rect_y,
- "dst-roi-w", rect_width,
- "dst-roi-h", rect_height,
- NULL);
+ "dst-roi-x", rect_x,
+ "dst-roi-y", rect_y,
+ "dst-roi-w", rect_width,
+ "dst-roi-h", rect_height,
+ NULL);
}
}
int do_scaling = 0;
const char *videosink_name = NULL;
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER( handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
mmf_return_val_if_fail(handle, FALSE);
}
-bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_strobe(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
bool bret = FALSE;
_MMCamcorderSubContext *sc = NULL;
set_hdr_mode = value->value.i_val;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_HDR_CAPTURE, ¤t_value,
- NULL);
+ MMCAM_CAMERA_HDR_CAPTURE, ¤t_value,
+ NULL);
if (set_hdr_mode == current_value) {
_mmcam_dbg_log("same HDR value : %d, do nothing", set_hdr_mode);
sc->info_image->hdr_capture_mode = set_hdr_mode;
_mmcam_dbg_log("set HDR mode : %d", set_hdr_mode);
- if (current_state == MM_CAMCORDER_STATE_PREPARE) {
+ if (current_state == MM_CAMCORDER_STATE_PREPARE)
_mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
- }
} else {
_mmcam_dbg_err("sc is NULL. can not set HDR capture");
return FALSE;
}
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
/*_mmcam_dbg_log("Commit : detect attribute(%d)", attr_idx);*/
/* state check */
- current_state = _mmcamcorder_get_state( handle);
+ current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
_mmcam_dbg_log("will be applied when preview starts");
return TRUE;
} else {
if (!gst_camera_control_set_detect(control, detect_type, set_value)) {
_mmcam_dbg_warn("Set detect failed. Type[%d],value[%d]",
- detect_type, set_value);
+ detect_type, set_value);
bret = FALSE;
} else {
_mmcam_dbg_log("Set detect success. Type[%d],value[%d]",
- detect_type, set_value);
+ detect_type, set_value);
bret = TRUE;
}
}
bool _mmcamcorder_commit_pid_for_sound_focus(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
int new_pid = 0;
+ int ret = 0;
int current_state = MM_CAMCORDER_STATE_NONE;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
}
/* state check */
- current_state = _mmcamcorder_get_state( handle);
+ current_state = _mmcamcorder_get_state(handle);
if (current_state > MM_CAMCORDER_STATE_NULL) {
_mmcam_dbg_log("invalid state %d", current_state);
return FALSE;
new_pid = value->value.i_val;
_mmcam_dbg_log("Commit : pid %d, current sound_focus_register %d, sound_focus_id %d",
- new_pid, hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
+ new_pid, hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
/* unregister sound focus before set new one */
if (hcamcorder->sound_focus_register && hcamcorder->sound_focus_id > 0) {
return FALSE;
}
- if (MM_ERROR_NONE != mm_sound_register_focus_for_session(hcamcorder->sound_focus_id,
- new_pid,
- "media",
- _mmcamcorder_sound_focus_cb,
- hcamcorder)) {
+ ret = mm_sound_register_focus_for_session(hcamcorder->sound_focus_id,
+ new_pid, "media", _mmcamcorder_sound_focus_cb, hcamcorder);
+ if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("mm_sound_register_focus failed");
hcamcorder->error_code = MM_ERROR_POLICY_BLOCKED;
return FALSE;
}
_mmcam_dbg_log("mm_sound_register_focus done - id %d, session type %d, flags 0x%x",
- hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags);
+ hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags);
} else {
_mmcam_dbg_log("no need to register sound focus");
}
}
-static bool
-__mmcamcorder_attrs_is_supported(MMHandleType handle, int idx)
+static bool __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx)
{
mmf_attrs_t *attr = (mmf_attrs_t*)handle;
int flag;
if (mm_attrs_get_flags(handle, idx, &flag) == MM_ERROR_NONE) {
- if (flag == MM_ATTRS_FLAG_NONE) {
+ if (flag == MM_ATTRS_FLAG_NONE)
return FALSE;
- }
} else {
return FALSE;
}
if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_RANGE) {
int min, max;
mm_attrs_get_valid_range((MMHandleType)attr, idx, &min, &max);
- if (max < min) {
+ if (max < min)
return FALSE;
- }
} else if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_ARRAY) {
int count;
int *array;
mm_attrs_get_valid_array((MMHandleType)attr, idx, &count, &array);
- if (count == 0) {
+ if (count == 0)
return FALSE;
- }
}
return TRUE;
}
-bool
-_mmcamcorder_set_attribute_to_camsensor(MMHandleType handle)
+bool _mmcamcorder_set_attribute_to_camsensor(MMHandleType handle)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
mmf_attrs_t *attr = NULL;
int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
- unsigned int i = 0 ;
+ unsigned int i = 0;
int ret = TRUE;
int attr_idxs_default[] = {
- MM_CAM_CAMERA_DIGITAL_ZOOM
- , MM_CAM_CAMERA_OPTICAL_ZOOM
- , MM_CAM_CAMERA_WDR
- , MM_CAM_FILTER_CONTRAST
- , MM_CAM_FILTER_HUE
- , MM_CAM_STROBE_MODE
- , MM_CAM_DETECT_MODE
+ MM_CAM_CAMERA_DIGITAL_ZOOM,
+ MM_CAM_CAMERA_OPTICAL_ZOOM,
+ MM_CAM_CAMERA_WDR,
+ MM_CAM_FILTER_CONTRAST,
+ MM_CAM_FILTER_HUE,
+ MM_CAM_STROBE_MODE,
+ MM_CAM_DETECT_MODE
};
int attr_idxs_extra[] = {
- MM_CAM_CAMERA_ISO
- , MM_CAM_FILTER_BRIGHTNESS
- , MM_CAM_FILTER_WB
- , MM_CAM_FILTER_SATURATION
- , MM_CAM_FILTER_SHARPNESS
- , MM_CAM_FILTER_COLOR_TONE
- , MM_CAM_CAMERA_EXPOSURE_MODE
+ MM_CAM_CAMERA_ISO,
+ MM_CAM_FILTER_BRIGHTNESS,
+ MM_CAM_FILTER_WB,
+ MM_CAM_FILTER_SATURATION,
+ MM_CAM_FILTER_SHARPNESS,
+ MM_CAM_FILTER_COLOR_TONE,
+ MM_CAM_CAMERA_EXPOSURE_MODE
};
mmf_return_val_if_fail(hcamcorder, FALSE);
_mmcam_dbg_log("attribute count(%d)", attr->count);
for (i = 0 ; i < ARRAY_SIZE(attr_idxs_default) ; i++) {
- if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_default[i])) {
+ if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_default[i]))
mmf_attribute_set_modified(&(attr->items[attr_idxs_default[i]]));
- }
}
/* Set extra if scene mode is NORMAL */
if (scene_mode == MM_CAMCORDER_SCENE_MODE_NORMAL) {
for (i = 0 ; i < ARRAY_SIZE(attr_idxs_extra) ; i++) {
- if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_extra[i])) {
+ if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_extra[i]))
mmf_attribute_set_modified(&(attr->items[attr_idxs_extra[i]]));
- }
}
} else {
/* Set scene mode if scene mode is NOT NORMAL */
- if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, MM_CAM_FILTER_SCENE_MODE)) {
+ if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, MM_CAM_FILTER_SCENE_MODE))
mmf_attribute_set_modified(&(attr->items[MM_CAM_FILTER_SCENE_MODE]));
- }
}
- if (mmf_attrs_commit((MMHandleType)attr) == -1) {
+ if (mmf_attrs_commit((MMHandleType)attr) == -1)
ret = FALSE;
- } else {
+ else
ret = TRUE;
- }
}
_mmcam_dbg_log("Done.");
int _mmcamcorder_lock_readonly_attributes(MMHandleType handle)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
int table_size = 0;
int i = 0;
mmf_attrs_t *attr = NULL;
- int nerror = MM_ERROR_NONE ;
+ int nerror = MM_ERROR_NONE;
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
table_size = ARRAY_SIZE(readonly_attributes);
_mmcam_dbg_log("%d", table_size);
- for (i = 0; i < table_size; i++)
- {
+ for (i = 0; i < table_size; i++) {
int sCategory = readonly_attributes[i];
mmf_attribute_set_readonly(&(attr->items[sCategory]));
int _mmcamcorder_set_disabled_attributes(MMHandleType handle)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
- //int table_size = 0;
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
int i = 0;
mmf_attrs_t *attr = NULL;
type_string_array * disabled_attr = NULL;
/* add gst_param */
_mmcamcorder_conf_get_value_string_array(hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_GENERAL,
- "DisabledAttributes",
- &disabled_attr);
+ CONFIGURE_CATEGORY_MAIN_GENERAL,
+ "DisabledAttributes",
+ &disabled_attr);
if (disabled_attr != NULL && disabled_attr->value) {
cnt_str = disabled_attr->count;
for (i = 0; i < cnt_str; i++) {
int idx = 0;
- _mmcam_dbg_log("[%d]%s", i, disabled_attr->value[i] );
+ _mmcam_dbg_log("[%d]%s", i, disabled_attr->value[i]);
nerror = mm_attrs_get_index((MMHandleType)attr, disabled_attr->value[i], &idx);
- if (nerror == MM_ERROR_NONE) {
+
+ if (nerror == MM_ERROR_NONE)
mmf_attribute_set_disabled(&(attr->items[idx]));
- } else {
- _mmcam_dbg_warn("No ATTR named %s[%d]",disabled_attr->value[i], i);
- }
+ else
+ _mmcam_dbg_warn("No ATTR named %s[%d]", disabled_attr->value[i], i);
}
}
mmf_return_val_if_fail(hcamcorder, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
current_state = _mmcamcorder_get_state(handle);
if (hcamcorder == NULL || attribute_name == NULL) {
_mmcam_dbg_warn("handle[%p] or attribute_name[%p] is NULL.",
- hcamcorder, attribute_name );
+ hcamcorder, attribute_name);
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
- if (err_attr_name) {
+ if (err_attr_name)
*err_attr_name = NULL;
- }
- //_mmcam_dbg_log( "ENTER" );
+ /*_mmcam_dbg_log( "ENTER" );*/
attrs = MMF_CAMCORDER_ATTRS(handle);
/* attribute name check */
if ((ret = mm_attrs_get_index(attrs, name, &idx)) != MM_ERROR_NONE) {
- if (err_attr_name) {
+ if (err_attr_name)
*err_attr_name = strdup(name);
- }
- if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY) { //to avoid confusing
+ if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY)
return MM_ERROR_COMMON_ATTR_NOT_EXIST;
- } else {
+ else
return ret;
- }
}
/* type check */
- if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE) {
+ if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE)
return ret;
- }
switch (attr_type) {
case MM_ATTRS_TYPE_INT:
break;
}
}
- if (matched) {
+ if (matched)
break;
- }
}
- if (matched == FALSE) {
+ if (matched == FALSE)
va_arg((var_args), int);
- }
break;
}
case MM_ATTRS_TYPE_DOUBLE:
case MM_ATTRS_TYPE_INVALID:
default:
_mmcam_dbg_err("Not supported attribute type(%d, name:%s)", attr_type, name);
- if (err_attr_name) {
+ if (err_attr_name)
*err_attr_name = strdup(name);
- }
+
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
check_result = FALSE;
- for( j = 0 ; j < attr_info_0.int_array.count ; j++ ) {
+ for (j = 0 ; j < attr_info_0.int_array.count ; j++) {
if (attr_info_0.int_array.array[j] == check_pair_value[i][0] &&
attr_info_1.int_array.array[j] == check_pair_value[i][1]) {
/*
_mmcam_dbg_log("Valid Pair[%s,%s] existed %dx%d[index:%d]",
- check_pair_name[i][0], check_pair_name[i][1],
- check_pair_value[i][0], check_pair_value[i][1], i);
- */
+ check_pair_name[i][0], check_pair_name[i][1],
+ check_pair_value[i][0], check_pair_value[i][1], i);
+ */
check_result = TRUE;
break;
}
if (check_result == FALSE) {
_mmcam_dbg_err("INVALID pair[%s,%s] %dx%d",
- check_pair_name[i][0], check_pair_name[i][1],
- check_pair_value[i][0], check_pair_value[i][1]);
+ check_pair_name[i][0], check_pair_name[i][1],
+ check_pair_value[i][0], check_pair_value[i][1]);
if (err_attr_name) {
*err_attr_name = err_name;
} else {
int current_height = 0;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_WIDTH, ¤t_width,
- MMCAM_CAMERA_HEIGHT, ¤t_height,
- NULL);
+ MMCAM_CAMERA_WIDTH, ¤t_width,
+ MMCAM_CAMERA_HEIGHT, ¤t_height,
+ NULL);
if (current_width != check_pair_value[i][0] ||
current_height != check_pair_value[i][1]) {
/*
_mmcam_dbg_log("int array count %d", info.int_array.count);
*/
- if (info.int_array.count <= 1) {
+ if (info.int_array.count <= 1)
return FALSE;
- }
break;
case MM_ATTRS_VALID_TYPE_INT_RANGE:
/*
_mmcam_dbg_log("int range min %d, max %d",info.int_range.min, info.int_range.max);
*/
- if (info.int_range.min >= info.int_range.max) {
+ if (info.int_range.min >= info.int_range.max)
return FALSE;
- }
break;
case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
/*
_mmcam_dbg_log("double array count %d", info.double_array.count);
*/
- if (info.double_array.count <= 1) {
+ if (info.double_array.count <= 1)
return FALSE;
- }
break;
case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
/*
_mmcam_dbg_log("double range min %lf, max %lf",info.int_range.min, info.int_range.max);
*/
- if (info.double_range.min >= info.double_range.max) {
+ if (info.double_range.min >= info.double_range.max)
return FALSE;
- }
break;
default:
_mmcam_dbg_warn("invalid type %d", info.validity_type);
static int __mmcamcorder_create_audiop_with_encodebin(MMHandleType handle)
{
int err = MM_ERROR_NONE;
+ int ret = MM_ERROR_NONE;
+
const char *aenc_name = NULL;
const char *mux_name = NULL;
_mmcam_dbg_log("");
mux_elem = _mmcamcorder_get_type_element(handle, MM_CAM_FILE_FORMAT);
- err = _mmcamcorder_conf_get_value_element_name( mux_elem, &mux_name );
+ err = _mmcamcorder_conf_get_value_element_name(mux_elem, &mux_name);
if (!mux_name || !strcmp(mux_name, "wavenc")) {
/* IF MUX in not chosen then record in raw file */
_MMCAMCORDER_PIPELINE_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCODE_MAIN_PIPE, "camcorder_pipeline", err);
err = _mmcamcorder_create_audiosrc_bin(handle);
- if (err != MM_ERROR_NONE) {
+ if (err != MM_ERROR_NONE)
return err;
- }
if (info->bMuxing) {
/* Muxing. can use encodebin. */
err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder, MM_CAMCORDER_ENCBIN_PROFILE_AUDIO);
- if (err != MM_ERROR_NONE) {
+ if (err != MM_ERROR_NONE)
return err;
- }
} else {
/* without muxing. can't use encodebin. */
aenc_elem = _mmcamcorder_get_type_element(handle, MM_CAM_AUDIO_ENCODER);
_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_AQUE, "queue", NULL, element_list, err);
- if (strcmp(aenc_name, "wavenc") != 0) {
+ if (strcmp(aenc_name, "wavenc") != 0)
_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_CONV, "audioconvert", NULL, element_list, err);
- }
_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_AENC, aenc_name, NULL, element_list, err);
if (info->bMuxing) {
/* IF MUX is indicated create MUX */
gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
- sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
- NULL);
+ sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
+ NULL);
- srcpad = gst_element_get_static_pad (sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, "src");
- sinkpad = gst_element_get_static_pad (sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, "audio_sink0");
+ srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, "src");
+ sinkpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, "audio_sink0");
_MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, pipeline_creation_error);
} else {
/* IF MUX in not chosen then record in raw amr file */
if (!strcmp(aenc_name, "wavenc")) {
gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
- sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
- NULL);
-
- if (!_MM_GST_ELEMENT_LINK_MANY(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
- NULL)) {
+ sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
+ NULL);
+
+ ret = _MM_GST_ELEMENT_LINK_MANY(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
+ NULL);
+ if (!ret) {
err = MM_ERROR_CAMCORDER_GST_LINK;
goto pipeline_creation_error;
}
} else {
gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
- sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_CONV].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
- NULL);
-
- if (!_MM_GST_ELEMENT_LINK_MANY(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_CONV].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
- NULL)) {
+ sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_CONV].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
+ NULL);
+
+ ret = _MM_GST_ELEMENT_LINK_MANY(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_CONV].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
+ NULL);
+ if (!ret) {
err = MM_ERROR_CAMCORDER_GST_LINK;
goto pipeline_creation_error;
}
/* set data probe function */
srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, "src");
MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_AUDIOREC,
- __mmcamcorder_audio_dataprobe_voicerecorder, hcamcorder);
+ __mmcamcorder_audio_dataprobe_voicerecorder, hcamcorder);
gst_object_unref(srcpad);
srcpad = NULL;
srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst, "src");
MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_AUDIOREC,
- __mmcamcorder_audio_dataprobe_record, hcamcorder);
+ __mmcamcorder_audio_dataprobe_record, hcamcorder);
gst_object_unref(srcpad);
srcpad = NULL;
int
_mmcamcorder_create_audio_pipeline(MMHandleType handle)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
gst_element_release_request_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, reqpad);
gst_object_unref(reqpad);
- if(GST_IS_ELEMENT(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst) &&
+ if (GST_IS_ELEMENT(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst) &&
GST_OBJECT_REFCOUNT(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst) > 1) {
gst_object_unref(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst);
}
void* _MMCamcorderStartHelperFunc(void *handle)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_mmcamcorder_set_state((MMHandleType)hcamcorder, hcamcorder->target_state);
return NULL;
void* _MMCamcorderStopHelperFunc(void *handle)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_mmcamcorder_set_state((MMHandleType)hcamcorder, hcamcorder->target_state);
return NULL;
int filename_length = 0;
int root_directory_length = 0;
- if(sc->pipeline_time) {
+ if (sc->pipeline_time)
gst_element_set_start_time(pipeline, sc->pipeline_time);
- }
+
sc->pipeline_time = RESET_PAUSE_TIME;
ret = mm_camcorder_get_attributes(handle, &err_attr_name,
- MMCAM_TARGET_MAX_SIZE, &imax_size,
- MMCAM_TARGET_TIME_LIMIT, &imax_time,
- MMCAM_FILE_FORMAT, &(info->fileformat),
- MMCAM_TARGET_FILENAME, &temp_filename, &filename_length,
- MMCAM_ROOT_DIRECTORY, &hcamcorder->root_directory, &root_directory_length,
- NULL);
+ MMCAM_TARGET_MAX_SIZE, &imax_size,
+ MMCAM_TARGET_TIME_LIMIT, &imax_time,
+ MMCAM_FILE_FORMAT, &(info->fileformat),
+ MMCAM_TARGET_FILENAME, &temp_filename, &filename_length,
+ MMCAM_ROOT_DIRECTORY, &hcamcorder->root_directory, &root_directory_length,
+ NULL);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_warn("failed to get attribute. (%s:%x)", err_attr_name, ret);
SAFE_FREE(err_attr_name);
goto _ERR_CAMCORDER_AUDIO_COMMAND;
}
- _mmcam_dbg_log("Record start : set file name using attribute - %s\n ",info->filename);
+ _mmcam_dbg_log("Record start : set file name using attribute - %s\n ", info->filename);
MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", info->filename);
sc->ferror_send = FALSE;
sc->ferror_count = 0;
sc->bget_eos = FALSE;
- info->filesize =0;
+ info->filesize = 0;
/* set max size */
- if (imax_size <= 0) {
+ if (imax_size <= 0)
info->max_size = 0; /* do not check */
- } else {
+ else
info->max_size = ((guint64)imax_size) << 10; /* to byte */
- }
/* set max time */
- if (imax_time <= 0) {
+ if (imax_time <= 0)
info->max_time = 0; /* do not check */
- } else {
+ else
info->max_time = ((guint64)imax_time) * 1000; /* to millisecond */
- }
/* TODO : check free space before recording start */
dir_name = g_path_get_dirname(info->filename);
if (file_system_type == MSDOS_SUPER_MAGIC &&
(info->max_size == 0 || info->max_size > FAT32_FILE_SYSTEM_MAX_SIZE)) {
_mmcam_dbg_warn("FAT32 and too large max[%"G_GUINT64_FORMAT"], set max as %"G_GUINT64_FORMAT,
- info->max_size, FAT32_FILE_SYSTEM_MAX_SIZE);
+ info->max_size, FAT32_FILE_SYSTEM_MAX_SIZE);
info->max_size = FAT32_FILE_SYSTEM_MAX_SIZE;
} else {
_mmcam_dbg_warn("file system 0x%x, max size %"G_GUINT64_FORMAT,
- file_system_type, info->max_size);
+ file_system_type, info->max_size);
}
} else {
_mmcam_dbg_warn("_mmcamcorder_get_file_system_type failed");
if ((err == -1) || free_space <= (_MMCAMCORDER_AUDIO_MINIMUM_SPACE+(5*1024))) {
_mmcam_dbg_err("OUT of STORAGE [err:%d or free space [%" G_GUINT64_FORMAT "] is smaller than [%d]",
- err, free_space, (_MMCAMCORDER_AUDIO_MINIMUM_SPACE+(5*1024)));
+ err, free_space, (_MMCAMCORDER_AUDIO_MINIMUM_SPACE+(5*1024)));
return MM_ERROR_OUT_OF_STORAGE;
}
}
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_AUDIO_COMMAND;
- }
+
break;
case _MMCamcorder_CMD_PAUSE:
break;
} else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
_mmcam_dbg_err("Pause fail, wait 200 ms, but file size is %lld",
- info->filesize);
+ info->filesize);
return MM_ERROR_CAMCORDER_INVALID_CONDITION;
} else {
_mmcam_dbg_warn("Wait for enough audio frame, retry count[%d], file size is %lld",
- count, info->filesize);
+ count, info->filesize);
}
usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
}
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PAUSED);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_AUDIO_COMMAND;
- }
/* FIXME: consider delay. */
pipe_clock = gst_pipeline_get_clock(GST_PIPELINE(pipeline));
}
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_AUDIO_COMMAND;
- }
if (info->bMuxing) {
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
return MM_ERROR_CAMCORDER_INVALID_CONDITION;
} else {
_mmcam_dbg_warn("Waiting for enough audio frame, re-count[%d], file size is %lld",
- count, info->filesize);
+ count, info->filesize);
}
usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
}
/* wait until finishing EOS */
_mmcam_dbg_log("Start to wait EOS");
- if ((ret =_mmcamcorder_get_eos_message(handle)) != MM_ERROR_NONE) {
+ if ((ret = _mmcamcorder_get_eos_message(handle)) != MM_ERROR_NONE) {
info->b_commiting = FALSE;
goto _ERR_CAMCORDER_AUDIO_COMMAND;
}
}
case _MMCamcorder_CMD_PREVIEW_START:
- //MM_CAMCORDER_START_CHANGE_STATE;
+ /*MM_CAMCORDER_START_CHANGE_STATE;*/
break;
case _MMCamcorder_CMD_PREVIEW_STOP:
- //MM_CAMCORDER_STOP_CHANGE_STATE;
- //void
+ /*MM_CAMCORDER_STOP_CHANGE_STATE;*/
+ /*void*/
break;
default:
int _mmcamcorder_audio_handle_eos(MMHandleType handle)
{
int err = MM_ERROR_NONE;
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
_MMCamcorderAudioInfo *info = NULL;
GstElement *pipeline = NULL;
pipeline = sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst;
err = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
- if (err != MM_ERROR_NONE) {
+ if (err != MM_ERROR_NONE)
_mmcam_dbg_warn("Failed:_MMCamcorder_CMD_COMMIT:GST_STATE_READY. err[%x]", err);
- }
/* Send recording report message to application */
msg.id = MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED;
}
/* START TAG HERE */
- // MM_AUDIO_CODEC_AAC + MM_FILE_FORMAT_MP4
- if(info->fileformat == MM_FILE_FORMAT_3GP || info->fileformat == MM_FILE_FORMAT_MP4){
+ /* MM_AUDIO_CODEC_AAC + MM_FILE_FORMAT_MP4 */
+ if (info->fileformat == MM_FILE_FORMAT_3GP || info->fileformat == MM_FILE_FORMAT_MP4)
__mmcamcorder_audio_add_metadata_info_m4a(handle);
- }
/* END TAG HERE */
report->recording_filename = g_strdup(info->filename);
- msg.param.data= report;
+ msg.param.data = report;
_mmcamcorder_send_message(handle, &msg);
if (format == MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE)
depthByte = 2;
- else //MM_CAMCORDER_AUDIO_FORMAT_PCM_U8
+ else /*MM_CAMCORDER_AUDIO_FORMAT_PCM_U8*/
depthByte = 1;
- for( ; i < size ; i += (depthByte<<1) )
- {
- if (depthByte == 1)
- {
+ for ( ; i < size ; i += (depthByte<<1)) {
+ if (depthByte == 1) {
pcm8 = (char *)(raw + i);
- square_sum += (*pcm8)*(*pcm8);
- }
- else //2byte
- {
+ square_sum += (*pcm8) * (*pcm8);
+ } else { /*2byte*/
pcm16 = (short*)(raw + i);
- square_sum += (*pcm16)*(*pcm16);
+ square_sum += (*pcm16) * (*pcm16);
}
count++;
}
if (count > 0) {
- rms = sqrt( (double)square_sum/(double)count );
- if (depthByte == 1) {
- db = 20 * log10( rms/MAX_AMPLITUDE_MEAN_08BIT );
- } else {
- db = 20 * log10( rms/MAX_AMPLITUDE_MEAN_16BIT );
- }
+ rms = sqrt((double)square_sum/(double)count);
+
+ if (depthByte == 1)
+ db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_08BIT);
+ else
+ db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_16BIT);
}
/*
_mmcam_dbg_log("size[%d],depthByte[%d],count[%d],rms[%f],db[%f]",
- size, depthByte, count, rms, db);
+ size, depthByte, count, rms, db);
*/
return db;
/* Set volume to audio input */
err = mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_name,
- MMCAM_AUDIO_VOLUME, &volume,
- MMCAM_AUDIO_FORMAT, &format,
- MMCAM_AUDIO_CHANNEL, &channel,
- NULL);
+ MMCAM_AUDIO_VOLUME, &volume,
+ MMCAM_AUDIO_FORMAT, &format,
+ MMCAM_AUDIO_CHANNEL, &channel,
+ NULL);
+
if (err < 0) {
_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
SAFE_FREE(err_name);
gst_buffer_map(buffer, &mapinfo, GST_MAP_READWRITE);
- if(volume == 0){
+ if (volume == 0)
memset(mapinfo.data, 0, mapinfo.size);
- }
/* Get current volume level of real input stream */
curdcb = __mmcamcorder_get_decibel(mapinfo.data, mapinfo.size, format);
_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
/* CALL audio stream callback */
- if ((hcamcorder->astream_cb) && buffer && mapinfo.data && mapinfo.size > 0)
- {
+ if ((hcamcorder->astream_cb) && buffer && mapinfo.data && mapinfo.size > 0) {
MMCamcorderAudioStreamDataType stream;
- if (_mmcamcorder_get_state((MMHandleType)hcamcorder) < MM_CAMCORDER_STATE_PREPARE)
- {
+ if (_mmcamcorder_get_state((MMHandleType)hcamcorder) < MM_CAMCORDER_STATE_PREPARE) {
_mmcam_dbg_warn("Not ready for stream callback");
gst_buffer_unmap(buffer, &mapinfo);
return GST_PAD_PROBE_OK;
/*
_mmcam_dbg_log("Call audio steramCb, data[%p], format[%d], channel[%d], length[%d], volume_dB[%f]",
- GST_BUFFER_DATA(buffer), format, channel, GST_BUFFER_SIZE(buffer), curdcb);
+ GST_BUFFER_DATA(buffer), format, channel, GST_BUFFER_SIZE(buffer), curdcb);
*/
stream.data = (void *)mapinfo.data;
stream.format = format;
stream.channel = channel;
stream.length = mapinfo.size;
- stream.timestamp = (unsigned int)(GST_BUFFER_PTS(buffer)/1000000); //nano -> msecond
+ stream.timestamp = (unsigned int)(GST_BUFFER_PTS(buffer)/1000000); /* nano -> msecond */
stream.volume_dB = curdcb;
- _MMCAMCORDER_LOCK_ASTREAM_CALLBACK( hcamcorder );
+ _MMCAMCORDER_LOCK_ASTREAM_CALLBACK(hcamcorder);
- if(hcamcorder->astream_cb)
- {
+ if (hcamcorder->astream_cb)
hcamcorder->astream_cb(&stream, hcamcorder->astream_cb_param);
- }
- _MMCAMCORDER_UNLOCK_ASTREAM_CALLBACK( hcamcorder );
+ _MMCAMCORDER_UNLOCK_ASTREAM_CALLBACK(hcamcorder);
}
gst_buffer_unmap(buffer, &mapinfo);
guint64 trailer_size = 0;
char *filename = NULL;
unsigned long long remained_time = 0;
+ int get_trailer_size = 0;
_MMCamcorderSubContext *sc = NULL;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
if (sc->isMaxtimePausing || sc->isMaxsizePausing) {
_mmcam_dbg_warn("isMaxtimePausing[%d],isMaxsizePausing[%d]",
- sc->isMaxtimePausing, sc->isMaxsizePausing);
+ sc->isMaxtimePausing, sc->isMaxsizePausing);
return GST_PAD_PROBE_DROP;
}
buffer_size = gst_buffer_get_size(buffer);
if (audioinfo->filesize == 0) {
- if (audioinfo->fileformat == MM_FILE_FORMAT_WAV) {
+ if (audioinfo->fileformat == MM_FILE_FORMAT_WAV)
audioinfo->filesize += 44; /* wave header size */
- } else if (audioinfo->fileformat == MM_FILE_FORMAT_AMR) {
+ else if (audioinfo->fileformat == MM_FILE_FORMAT_AMR)
audioinfo->filesize += 6; /* amr header size */
- }
audioinfo->filesize += buffer_size;
return GST_PAD_PROBE_OK;
}
/* get trailer size */
- if (audioinfo->fileformat == MM_FILE_FORMAT_3GP ||
- audioinfo->fileformat == MM_FILE_FORMAT_MP4 ||
- audioinfo->fileformat == MM_FILE_FORMAT_AAC) {
+ get_trailer_size = (
+ audioinfo->fileformat == MM_FILE_FORMAT_3GP ||
+ audioinfo->fileformat == MM_FILE_FORMAT_MP4 ||
+ audioinfo->fileformat == MM_FILE_FORMAT_AAC) ? TRUE : FALSE;
+ if (get_trailer_size) {
MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst, "expected-trailer-size", &trailer_size);
/*_mmcam_dbg_log("trailer_size %d", trailer_size);*/
} else {
if (sc->ferror_count == 2 && sc->ferror_send == FALSE) {
sc->ferror_send = TRUE;
msg.id = MM_MESSAGE_CAMCORDER_ERROR;
- if (free_space_ret == -2) {
+ if (free_space_ret == -2)
msg.param.code = MM_ERROR_FILE_NOT_FOUND;
- } else {
+ else
msg.param.code = MM_ERROR_FILE_READ;
- }
+
_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
} else {
sc->ferror_count++;
if (free_space < (guint64)(_MMCAMCORDER_AUDIO_MINIMUM_SPACE + buffer_size + trailer_size)) {
_mmcam_dbg_warn("No more space for recording!!!");
_mmcam_dbg_warn("Free Space : [%" G_GUINT64_FORMAT "], file size : [%" G_GUINT64_FORMAT "]",
- free_space, audioinfo->filesize);
+ free_space, audioinfo->filesize);
if (audioinfo->bMuxing) {
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
audioinfo->max_size < audioinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE) {
_mmcam_dbg_warn("Max size!!! Recording is paused.");
_mmcam_dbg_warn("Max [%" G_GUINT64_FORMAT "], file [%" G_GUINT64_FORMAT "], trailer : [%" G_GUINT64_FORMAT "]", \
- audioinfo->max_size, audioinfo->filesize, trailer_size);
+ audioinfo->max_size, audioinfo->filesize, trailer_size);
/* just same as pause status. After blocking two queue, this function will not call again. */
if (audioinfo->bMuxing) {
/* check recording time limit and send recording status message */
if (audioinfo->max_time > 0 && rec_pipe_time > audioinfo->max_time) {
_mmcam_dbg_warn("Current time : [%" G_GUINT64_FORMAT "], Maximum time : [%" G_GUINT64_FORMAT "]", \
- rec_pipe_time, audioinfo->max_time);
+ rec_pipe_time, audioinfo->max_time);
if (audioinfo->bMuxing) {
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
gint64 current_pos = 0;
gint64 moov_pos = 0;
gint64 udta_pos = 0;
- // supporting audio geo tag for mobile
+ /* supporting audio geo tag for mobile */
int gps_enable = 0;
gdouble longitude = 0;
gdouble latitude = 0;
gdouble altitude = 0;
- _MMCamcorderLocationInfo geo_info = {0,0,0};
- _MMCamcorderLocationInfo loc_info = {0,0,0};
+ _MMCamcorderLocationInfo geo_info = {0, 0, 0};
+ _MMCamcorderLocationInfo loc_info = {0, 0, 0};
char err_msg[128] = {'\0',};
info = sc->info_audio;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_TAG_GPS_ENABLE, &gps_enable,
- NULL);
+ MMCAM_TAG_GPS_ENABLE, &gps_enable,
+ NULL);
if (gps_enable) {
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_TAG_LATITUDE, &latitude,
- MMCAM_TAG_LONGITUDE, &longitude,
- MMCAM_TAG_ALTITUDE, &altitude,
- NULL);
+ MMCAM_TAG_LATITUDE, &latitude,
+ MMCAM_TAG_LONGITUDE, &longitude,
+ MMCAM_TAG_ALTITUDE, &altitude,
+ NULL);
loc_info.longitude = _mmcamcorder_double_to_fix(longitude);
loc_info.latitude = _mmcamcorder_double_to_fix(latitude);
loc_info.altitude = _mmcamcorder_double_to_fix(altitude);
/* find udta container.
if, there are udta container, write loci box after that
else, make udta container and write loci box. */
- if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('u','d','t','a'), TRUE)) {
+ if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('u', 'd', 't', 'a'), TRUE)) {
size_t nread = 0;
_mmcam_dbg_log("find udta container");
/* read size */
- if (fseek(f, -8L, SEEK_CUR) != 0) {
+ if (fseek(f, -8L, SEEK_CUR) != 0)
goto fail;
- }
udta_pos = ftello(f);
- if (udta_pos < 0) {
+ if (udta_pos < 0)
goto ftell_fail;
- }
nread = fread(&buf, sizeof(char), sizeof(buf), f);
udta_size = _mmcamcorder_get_container_size(buf);
/* goto end of udta and write 'smta' box */
- if (fseek(f, (udta_size-4L), SEEK_CUR) != 0) {
+ if (fseek(f, (udta_size-4L), SEEK_CUR) != 0)
goto fail;
- }
if (gps_enable) {
- if (!_mmcamcorder_write_loci(f, loc_info)) {
+ if (!_mmcamcorder_write_loci(f, loc_info))
goto fail;
- }
- if (!_mmcamcorder_write_geodata( f, geo_info )) {
+ if (!_mmcamcorder_write_geodata(f, geo_info))
goto fail;
- }
}
current_pos = ftello(f);
- if (current_pos < 0) {
+ if (current_pos < 0)
goto ftell_fail;
- }
- if (!_mmcamcorder_update_size(f, udta_pos, current_pos)) {
+ if (!_mmcamcorder_update_size(f, udta_pos, current_pos))
goto fail;
- }
} else {
_mmcam_dbg_log("No udta container");
- if (fseek(f, 0, SEEK_END) != 0) {
+ if (fseek(f, 0, SEEK_END) != 0)
goto fail;
- }
- if (!_mmcamcorder_write_udta(f, gps_enable, loc_info, geo_info)) {
+ if (!_mmcamcorder_write_udta(f, gps_enable, loc_info, geo_info))
goto fail;
- }
}
/* find moov container.
update moov container size. */
- if((current_pos = ftello(f))<0)
+ if ((current_pos = ftello(f)) < 0)
goto ftell_fail;
- if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('m','o','o','v'), TRUE)) {
+ if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('m', 'o', 'o', 'v'), TRUE)) {
_mmcam_dbg_log("found moov container");
- if (fseek(f, -8L, SEEK_CUR) !=0) {
+ if (fseek(f, -8L, SEEK_CUR) != 0)
goto fail;
- }
moov_pos = ftello(f);
- if (moov_pos < 0) {
+ if (moov_pos < 0)
goto ftell_fail;
- }
- if (!_mmcamcorder_update_size(f, moov_pos, current_pos)) {
+ if (!_mmcamcorder_update_size(f, moov_pos, current_pos))
goto fail;
- }
-
} else {
_mmcam_dbg_err("No 'moov' container");
};
/* Audiosrc element default value */
- static type_int ___audiosrc_default_channel = { "Channel", 1 };
- static type_int ___audiosrc_default_bitrate = { "BitRate", 8000 };
- static type_int ___audiosrc_default_depth = { "Depth", 16 };
- static type_int ___audiosrc_default_blocksize = { "BlockSize", 1280 };
+ static type_int ___audiosrc_default_channel = {"Channel", 1};
+ static type_int ___audiosrc_default_bitrate = {"BitRate", 8000};
+ static type_int ___audiosrc_default_depth = {"Depth", 16};
+ static type_int ___audiosrc_default_blocksize = {"BlockSize", 1280};
static type_int* __audiosrc_default_int_array[] = {
&___audiosrc_default_channel,
&___audiosrc_default_bitrate,
&___audiosrc_default_depth,
&___audiosrc_default_blocksize,
};
- static type_string ___audiosrc_default_device = { "Device", "default" };
+ static type_string ___audiosrc_default_device = {"Device", "default"};
static type_string* __audiosrc_default_string_array[] = {
&___audiosrc_default_device,
};
"AudiosrcElement",
"audiotestsrc",
__audiosrc_default_int_array,
- sizeof( __audiosrc_default_int_array ) / sizeof( type_int* ),
+ sizeof(__audiosrc_default_int_array) / sizeof(type_int*),
__audiosrc_default_string_array,
- sizeof( __audiosrc_default_string_array ) / sizeof( type_string* ),
+ sizeof(__audiosrc_default_string_array) / sizeof(type_string*),
};
static type_element _audiomodemsrc_element_default = {
"AudiomodemsrcElement",
"audiotestsrc",
__audiosrc_default_int_array,
- sizeof( __audiosrc_default_int_array ) / sizeof( type_int* ),
+ sizeof(__audiosrc_default_int_array) / sizeof(type_int*),
__audiosrc_default_string_array,
- sizeof( __audiosrc_default_string_array ) / sizeof( type_string* ),
+ sizeof(__audiosrc_default_string_array) / sizeof(type_string*),
};
/* Videosink element default value */
- static type_int ___videosink_default_display_id = { "display-id", 3 };
- static type_int ___videosink_default_x = { "x", 0 };
- static type_int ___videosink_default_y = { "y", 0 };
- static type_int ___videosink_default_width = { "width", 800 };
- static type_int ___videosink_default_height = { "height", 480 };
- static type_int ___videosink_default_rotation = { "rotation", 1 };
+ static type_int ___videosink_default_display_id = {"display-id", 3};
+ static type_int ___videosink_default_x = {"x", 0};
+ static type_int ___videosink_default_y = {"y", 0};
+ static type_int ___videosink_default_width = {"width", 800};
+ static type_int ___videosink_default_height = {"height", 480};
+ static type_int ___videosink_default_rotation = {"rotation", 1};
static type_int* __videosink_default_int_array[] = {
&___videosink_default_display_id,
&___videosink_default_x,
&___videosink_default_height,
&___videosink_default_rotation,
};
- static type_string* __videosink_default_string_array[] = { NULL };
+ static type_string* __videosink_default_string_array[] = {NULL};
static type_element _videosink_element_overlay_default = {
"VideosinkElementOverlay",
"waylandsink",
__videosink_default_int_array,
- sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
+ sizeof(__videosink_default_int_array) / sizeof(type_int*),
__videosink_default_string_array,
- sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
+ sizeof(__videosink_default_string_array) / sizeof(type_string*),
};
static type_element _videosink_element_evas_default = {
"VideosinkElementEvas",
"evasimagesink",
__videosink_default_int_array,
- sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
+ sizeof(__videosink_default_int_array) / sizeof(type_int*),
__videosink_default_string_array,
- sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
+ sizeof(__videosink_default_string_array) / sizeof(type_string*),
};
static type_element _videosink_element_gl_default = {
"VideosinkElementGL",
"glimagesink",
__videosink_default_int_array,
- sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
+ sizeof(__videosink_default_int_array) / sizeof(type_int*),
__videosink_default_string_array,
- sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
+ sizeof(__videosink_default_string_array) / sizeof(type_string*),
};
static type_element _videosink_element_remote_default = {
"VideosinkElementRemote",
"shmsink",
__videosink_default_int_array,
- sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
+ sizeof(__videosink_default_int_array) / sizeof(type_int*),
__videosink_default_string_array,
- sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
+ sizeof(__videosink_default_string_array) / sizeof(type_string*),
};
static type_element _videosink_element_null_default = {
"VideosinkElementNull",
"fakesink",
__videosink_default_int_array,
- sizeof( __videosink_default_int_array ) / sizeof( type_int* ),
+ sizeof(__videosink_default_int_array) / sizeof(type_int*),
__videosink_default_string_array,
- sizeof( __videosink_default_string_array ) / sizeof( type_string* ),
+ sizeof(__videosink_default_string_array) / sizeof(type_string*),
};
/* Videoscale element default value */
hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER] = conf_main_image_encoder_table;
hcamcorder->conf_main_info_table[CONFIGURE_CATEGORY_MAIN_MUX] = conf_main_mux_table;
- hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_GENERAL] = sizeof( conf_main_general_table ) / info_table_size;
- hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT] = sizeof( conf_main_video_input_table ) / info_table_size;
- hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT] = sizeof( conf_main_audio_input_table ) / info_table_size;
- hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT] = sizeof( conf_main_video_output_table ) / info_table_size;
- hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_CAPTURE] = sizeof( conf_main_capture_table ) / info_table_size;
- hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_RECORD] = sizeof( conf_main_record_table ) / info_table_size;
- hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER] = sizeof( conf_main_video_encoder_table ) / info_table_size;
- hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER] = sizeof( conf_main_audio_encoder_table ) / info_table_size;
- hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER] = sizeof( conf_main_image_encoder_table ) / info_table_size;
- hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_MUX] = sizeof( conf_main_mux_table ) / info_table_size;
+ hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_GENERAL] = sizeof(conf_main_general_table) / info_table_size;
+ hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT] = sizeof(conf_main_video_input_table) / info_table_size;
+ hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT] = sizeof(conf_main_audio_input_table) / info_table_size;
+ hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT] = sizeof(conf_main_video_output_table) / info_table_size;
+ hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_CAPTURE] = sizeof(conf_main_capture_table) / info_table_size;
+ hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_RECORD] = sizeof(conf_main_record_table) / info_table_size;
+ hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER] = sizeof(conf_main_video_encoder_table) / info_table_size;
+ hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER] = sizeof(conf_main_audio_encoder_table) / info_table_size;
+ hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER] = sizeof(conf_main_image_encoder_table) / info_table_size;
+ hcamcorder->conf_main_category_size[CONFIGURE_CATEGORY_MAIN_MUX] = sizeof(conf_main_mux_table) / info_table_size;
- (*configure_info)->info = (conf_detail**)g_malloc0( sizeof( conf_detail* ) * CONFIGURE_CATEGORY_MAIN_NUM );
+ (*configure_info)->info = (conf_detail**)g_malloc0(sizeof(conf_detail*) * CONFIGURE_CATEGORY_MAIN_NUM);
- for (i = 0 ; i < CONFIGURE_CATEGORY_MAIN_NUM ; i++) {
+ for (i = 0 ; i < CONFIGURE_CATEGORY_MAIN_NUM ; i++)
(*configure_info)->info[i] = NULL;
- }
} else {
hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_CAMERA] = conf_ctrl_camera_table;
hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_STROBE] = conf_ctrl_strobe_table;
hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_CAPTURE] = conf_ctrl_capture_table;
hcamcorder->conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_DETECT] = conf_ctrl_detect_table;
- hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_CAMERA] = sizeof( conf_ctrl_camera_table ) / info_table_size;
- hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_STROBE] = sizeof( conf_ctrl_strobe_table ) / info_table_size;
- hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_EFFECT] = sizeof( conf_ctrl_effect_table ) / info_table_size;
- hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH] = sizeof( conf_ctrl_photograph_table ) / info_table_size;
- hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_CAPTURE] = sizeof( conf_ctrl_capture_table ) / info_table_size;
- hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_DETECT] = sizeof( conf_ctrl_detect_table ) / info_table_size;
+ hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_CAMERA] = sizeof(conf_ctrl_camera_table) / info_table_size;
+ hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_STROBE] = sizeof(conf_ctrl_strobe_table) / info_table_size;
+ hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_EFFECT] = sizeof(conf_ctrl_effect_table) / info_table_size;
+ hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH] = sizeof(conf_ctrl_photograph_table) / info_table_size;
+ hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_CAPTURE] = sizeof(conf_ctrl_capture_table) / info_table_size;
+ hcamcorder->conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_DETECT] = sizeof(conf_ctrl_detect_table) / info_table_size;
- (*configure_info)->info = (conf_detail**)g_malloc0( sizeof( conf_detail* ) * CONFIGURE_CATEGORY_CTRL_NUM );
+ (*configure_info)->info = (conf_detail**)g_malloc0(sizeof(conf_detail*) * CONFIGURE_CATEGORY_CTRL_NUM);
- for (i = 0 ; i < CONFIGURE_CATEGORY_CTRL_NUM ; i++) {
+ for (i = 0 ; i < CONFIGURE_CATEGORY_CTRL_NUM ; i++)
(*configure_info)->info[i] = NULL;
- }
}
_mmcam_dbg_log("Done.");
snprintf(conf_path, sizeof(conf_path), "%s/multimedia/%s", TZ_SYS_ETC, ConfFile);
_mmcam_dbg_log("Try open Configure File[%s]", conf_path);
fd = fopen(conf_path, "r");
- if (fd == NULL) {
+ if (fd == NULL)
_mmcam_dbg_warn("open failed.[%s] errno [%d]", conf_path, errno);
- }
}
if (fd != NULL) {
ret = _mmcamcorder_conf_parse_info(handle, type, fd, configure_info);
fclose(fd);
} else {
- if (errno == ENOENT) {
+ if (errno == ENOENT)
ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
- } else {
+ else
ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
- }
}
_mmcam_dbg_log("Leave...");
char *detail_string = NULL;
char *user_ptr = NULL;
- _mmcam_dbg_log( "" );
+ _mmcam_dbg_log("");
camera_conf* new_conf = (camera_conf *)g_malloc0(sizeof(camera_conf));
if (new_conf == NULL) {
read_main = 0;
count_main_category = 0;
- while( !feof( fd ) )
- {
- if( read_main == 0 )
- {
- length_read = getline( &buffer_string, &BUFFER_LENGTH_STRING, fd );
+ while (!feof(fd)) {
+ if (read_main == 0) {
+ length_read = getline(&buffer_string, &BUFFER_LENGTH_STRING, fd);
/*_mmcam_dbg_log( "Read Line : [%s]", buffer_string );*/
count_token = 0;
- token = strtok_r( buffer_string, delimiters, &user_ptr );
+ token = strtok_r(buffer_string, delimiters, &user_ptr);
- if ((token) && (token[0] == ';') && (length_read > -1))
- {
+ if ((token) && (token[0] == ';') && (length_read > -1)) {
/*_mmcam_dbg_log( "Comment - Nothing to do" );*/
continue;
}
- while( token )
- {
- /*_mmcam_dbg_log( "token : [%s]", token );*/
+ while (token) {
+ /*_mmcam_dbg_log("token : [%s]", token);*/
buffer_token[count_token] = token;
count_token++;
- token = strtok_r( NULL, delimiters, &user_ptr );
+ token = strtok_r(NULL, delimiters, &user_ptr);
}
- if( count_token == 0 )
- {
+ if (count_token == 0)
continue;
- }
}
read_main = 0;
/* Comment */
- if( *buffer_token[0] == ';' )
- {
+ if (*buffer_token[0] == ';') {
/*_mmcam_dbg_log( "Comment - Nothing to do" );*/
}
/* Main Category */
- else if( *buffer_token[0] == '[' )
- {
- category_name = get_new_string( buffer_token[0] );
+ else if (*buffer_token[0] == '[') {
+ category_name = get_new_string(buffer_token[0]);
if (category_name == NULL) {
_mmcam_dbg_err("strdup failed for [%s]", buffer_token[0]);
continue;
count_main_category++;
count_details = 0;
- while( !feof( fd ) )
- {
- length_read = getline( &buffer_string, &BUFFER_LENGTH_STRING, fd );
- /*_mmcam_dbg_log( "Read Detail Line : [%s], read length : [%d]", buffer_string, length_read );*/
+ while (!feof(fd)) {
+ length_read = getline(&buffer_string, &BUFFER_LENGTH_STRING, fd);
+ /*_mmcam_dbg_log("Read Detail Line : [%s], read length : [%d]", buffer_string, length_read);*/
- detail_string = get_new_string( buffer_string );
+ detail_string = get_new_string(buffer_string);
- token = strtok_r( buffer_string, delimiters, &user_ptr );
+ token = strtok_r(buffer_string, delimiters, &user_ptr);
- if( token && token[0] != ';' && length_read > -1 )
- {
- /*_mmcam_dbg_log( "token : [%s]", token );*/
- if( token[0] == '[' )
- {
+ if (token && token[0] != ';' && length_read > -1) {
+ /*_mmcam_dbg_log("token : [%s]", token);*/
+ if (token[0] == '[') {
read_main = 1;
buffer_token[0] = token;
- SAFE_G_FREE( detail_string );
+ SAFE_G_FREE(detail_string);
break;
}
buffer_details[count_details++] = detail_string;
- }
- else
- {
- SAFE_G_FREE( detail_string );
+ } else {
+ SAFE_G_FREE(detail_string);
}
}
- /*_mmcam_dbg_log( "type : %d, category_name : %s, count : [%d]", type, category_name, count_details );*/
+ /*_mmcam_dbg_log("type : %d, category_name : %s, count : [%d]", type, category_name, count_details);*/
- if( count_details == 0 )
- {
- _mmcam_dbg_warn( "category %s has no detail value... skip this category...", category_name );
+ if (count_details == 0) {
+ _mmcam_dbg_warn("category %s has no detail value... skip this category...", category_name);
SAFE_G_FREE(category_name);
continue;
}
category = -1;
/* Details */
- if( type == CONFIGURE_TYPE_MAIN )
- {
- if( !strcmp( "[General]", category_name ) )
- {
+ if (type == CONFIGURE_TYPE_MAIN) {
+ if (!strcmp("[General]", category_name)) {
category = CONFIGURE_CATEGORY_MAIN_GENERAL;
- }
- else if( !strcmp( "[VideoInput]", category_name ) )
- {
+ } else if (!strcmp("[VideoInput]", category_name)) {
category = CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT;
- }
- else if( !strcmp( "[AudioInput]", category_name ) )
- {
+ } else if (!strcmp("[AudioInput]", category_name)) {
category = CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT;
- }
- else if( !strcmp( "[VideoOutput]", category_name ) )
- {
+ } else if (!strcmp("[VideoOutput]", category_name)) {
category = CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT;
- }
- else if( !strcmp( "[Capture]", category_name ) )
- {
+ } else if (!strcmp("[Capture]", category_name)) {
category = CONFIGURE_CATEGORY_MAIN_CAPTURE;
- }
- else if( !strcmp( "[Record]", category_name ) )
- {
+ } else if (!strcmp("[Record]", category_name)) {
category = CONFIGURE_CATEGORY_MAIN_RECORD;
- }
- else if( !strcmp( "[VideoEncoder]", category_name ) )
- {
+ } else if (!strcmp("[VideoEncoder]", category_name)) {
category = CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER;
- }
- else if( !strcmp( "[AudioEncoder]", category_name ) )
- {
+ } else if (!strcmp("[AudioEncoder]", category_name)) {
category = CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER;
- }
- else if( !strcmp( "[ImageEncoder]", category_name ) )
- {
+ } else if (!strcmp("[ImageEncoder]", category_name)) {
category = CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER;
- }
- else if( !strcmp( "[Mux]", category_name ) )
- {
+ } else if (!strcmp("[Mux]", category_name)) {
category = CONFIGURE_CATEGORY_MAIN_MUX;
}
- }
- else
- {
- if( !strcmp( "[Camera]", category_name ) )
- {
+ } else {
+ if (!strcmp("[Camera]", category_name)) {
category = CONFIGURE_CATEGORY_CTRL_CAMERA;
- }
- else if( !strcmp( "[Strobe]", category_name ) )
- {
+ } else if (!strcmp("[Strobe]", category_name)) {
category = CONFIGURE_CATEGORY_CTRL_STROBE;
- }
- else if( !strcmp( "[Effect]", category_name ) )
- {
+ } else if (!strcmp("[Effect]", category_name)) {
category = CONFIGURE_CATEGORY_CTRL_EFFECT;
- }
- else if( !strcmp( "[Photograph]", category_name ) )
- {
+ } else if (!strcmp("[Photograph]", category_name)) {
category = CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH;
- }
- else if( !strcmp( "[Capture]", category_name ) )
- {
+ } else if (!strcmp("[Capture]", category_name)) {
category = CONFIGURE_CATEGORY_CTRL_CAPTURE;
- }
- else if( !strcmp( "[Detect]", category_name ) )
- {
+ } else if (!strcmp("[Detect]", category_name)) {
category = CONFIGURE_CATEGORY_CTRL_DETECT;
}
}
- if( category != -1 )
- {
- _mmcamcorder_conf_add_info( handle, type, &(new_conf->info[category]),
- buffer_details, category, count_details );
- }
- else
- {
- _mmcam_dbg_warn( "No matched category[%s],type[%d]... check it.", category_name, type );
+ if (category != -1) {
+ _mmcamcorder_conf_add_info(handle, type, &(new_conf->info[category]),
+ buffer_details, category, count_details);
+ } else {
+ _mmcam_dbg_warn("No matched category[%s],type[%d]... check it.", category_name, type);
}
- // Free memory
+ /* Free memory */
{
int i;
- for( i = 0 ; i < count_details ; i++ )
- {
- SAFE_G_FREE( buffer_details[i] );
+ for (i = 0 ; i < count_details ; i++) {
+ SAFE_G_FREE(buffer_details[i]);
}
}
}
SAFE_G_FREE(category_name);
}
- //(*configure_info) = new_conf;
+ /* (*configure_info) = new_conf; */
- SAFE_G_FREE( buffer_string );
+ SAFE_G_FREE(buffer_string);
- /*_mmcam_dbg_log( "Done." );*/
+ /*_mmcam_dbg_log("Done.");*/
return MM_ERROR_NONE;
}
mmf_return_if_fail(temp_conf);
- if ((*configure_info)->type == CONFIGURE_TYPE_MAIN) {
+ if ((*configure_info)->type == CONFIGURE_TYPE_MAIN)
category_num = CONFIGURE_CATEGORY_MAIN_NUM;
- } else {
+ else
category_num = CONFIGURE_CATEGORY_CTRL_NUM;
- }
for (i = 0 ; i < category_num ; i++) {
if (temp_conf->info[i]) {
for (j = 0 ; j < temp_conf->info[i]->count ; j++) {
- if (temp_conf->info[i]->detail_info[j] == NULL) {
+ if (temp_conf->info[i]->detail_info[j] == NULL)
continue;
- }
if (_mmcamcorder_conf_get_value_type(handle, temp_conf->type, i, ((type_element*)(temp_conf->info[i]->detail_info[j]))->name, &type)) {
switch (type) {
for (k = 0 ; k < count ; k++) {
SAFE_G_FREE(temp_string_array->value[k]);
}
+
SAFE_G_FREE(temp_string_array->value);
}
SAFE_G_FREE(temp_string_array->default_value);
return FALSE;
}
- /*_mmcam_dbg_log( "Entered..." );*/
+ /*_mmcam_dbg_log("Entered...");*/
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(name, FALSE);
- if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
- {
- _mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
+ if (!_mmcamcorder_conf_get_category_size(handle, type, category, &count_value)) {
+ _mmcam_dbg_warn("No matched category... check it... categoty[%d]", category);
return FALSE;
}
- /*_mmcam_dbg_log( "Number of value : [%d]", count_value );*/
+ /*_mmcam_dbg_log("Number of value : [%d]", count_value);*/
- if( type == CONFIGURE_TYPE_MAIN )
- {
- for( i = 0 ; i < count_value ; i++ )
- {
- if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
- {
+ if (type == CONFIGURE_TYPE_MAIN) {
+ for (i = 0 ; i < count_value ; i++) {
+ if (!strcmp(hcamcorder->conf_main_info_table[category][i].name, name)) {
*value_type = hcamcorder->conf_main_info_table[category][i].value_type;
- /*_mmcam_dbg_log( "Category[%d],Name[%s],Type[%d]", category, name, *value_type );*/
+ /*_mmcam_dbg_log("Category[%d],Name[%s],Type[%d]", category, name, *value_type);*/
return TRUE;
}
}
- }
- else
- {
- for( i = 0 ; i < count_value ; i++ )
- {
- if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
- {
+ } else {
+ for (i = 0 ; i < count_value ; i++) {
+ if (!strcmp(hcamcorder->conf_ctrl_info_table[category][i].name, name)) {
*value_type = hcamcorder->conf_ctrl_info_table[category][i].value_type;
- /*_mmcam_dbg_log( "Category[%d],Name[%s],Type[%d]", category, name, *value_type );*/
+ /*_mmcam_dbg_log("Category[%d],Name[%s],Type[%d]", category, name, *value_type);*/
return TRUE;
}
}
}
-int _mmcamcorder_conf_add_info(MMHandleType handle, int type, conf_detail** info, char** buffer_details, int category, int count_details )
+int _mmcamcorder_conf_add_info(MMHandleType handle, int type, conf_detail** info, char** buffer_details, int category, int count_details)
{
const int BUFFER_NUM_TOKEN = 256;
const char *delimiters_sub = " |\t\n";
const char *delimiters_3rd = "|\n";
- mmf_return_val_if_fail( buffer_details, FALSE );
+ mmf_return_val_if_fail(buffer_details, FALSE);
- (*info) = (conf_detail*)g_malloc0( sizeof(conf_detail) );
+ (*info) = (conf_detail*)g_malloc0(sizeof(conf_detail));
if (*info == NULL) {
_mmcam_dbg_err("allocation failed");
return FALSE;
(*info)->detail_info = (void**)g_malloc0(sizeof(void*) * count_details);
(*info)->count = count_details;
- for ( i = 0 ; i < count_details ; i++ ) {
+ for (i = 0 ; i < count_details ; i++) {
/*_mmcam_dbg_log("Read line\"%s\"", buffer_details[i]);*/
count_token = 0;
- token = strtok_r( buffer_details[i], delimiters, &user_ptr );
+ token = strtok_r(buffer_details[i], delimiters, &user_ptr);
if (token) {
buffer_token[count_token] = token;
count_token++;
} else {
(*info)->detail_info[i] = NULL;
- _mmcam_dbg_warn( "No token... check it.[%s]", buffer_details[i] );
+ _mmcam_dbg_warn("No token... check it.[%s]", buffer_details[i]);
continue;
}
if (!_mmcamcorder_conf_get_value_type(handle, type, category, buffer_token[0], &value_type)) {
(*info)->detail_info[i] = NULL;
- _mmcam_dbg_warn( "Failed to get value type... check it. Category[%d],Name[%s]", category, buffer_token[0] );
+ _mmcam_dbg_warn("Failed to get value type... check it. Category[%d],Name[%s]", category, buffer_token[0]);
continue;
}
if (value_type != CONFIGURE_VALUE_STRING && value_type != CONFIGURE_VALUE_STRING_ARRAY) {
- token = strtok_r( NULL, delimiters, &user_ptr );
+ token = strtok_r(NULL, delimiters, &user_ptr);
while (token) {
buffer_token[count_token] = token;
/*_mmcam_dbg_log("token : [%s]", buffer_token[count_token]);*/
count_token++;
- token = strtok_r( NULL, delimiters, &user_ptr );
+ token = strtok_r(NULL, delimiters, &user_ptr);
}
if (count_token < 2) {
(*info)->detail_info[i] = NULL;
- _mmcam_dbg_warn( "Number of token is too small... check it.[%s]", buffer_details[i] );
+ _mmcam_dbg_warn("Number of token is too small... check it.[%s]", buffer_details[i]);
continue;
}
} else { /* CONFIGURE_VALUE_STRING or CONFIGURE_VALUE_STRING_ARRAY */
/* skip "=" */
- strtok_r( NULL, delimiters_sub, &user_ptr );
+ strtok_r(NULL, delimiters_sub, &user_ptr);
if (value_type == CONFIGURE_VALUE_STRING_ARRAY) {
- token = strtok_r( NULL, delimiters_sub, &user_ptr );
+ token = strtok_r(NULL, delimiters_sub, &user_ptr);
while (token) {
buffer_token[count_token] = token;
/*_mmcam_dbg_log("token : [%s]", buffer_token[count_token]);*/
count_token++;
- token = strtok_r( NULL, delimiters_sub, &user_ptr );
+ token = strtok_r(NULL, delimiters_sub, &user_ptr);
}
} else { /* CONFIGURE_VALUE_STRING */
- token = strtok_r( NULL, delimiters_3rd, &user_ptr );
+ token = strtok_r(NULL, delimiters_3rd, &user_ptr);
if (token) {
- g_strchug( token );
+ g_strchug(token);
buffer_token[count_token] = token;
/*_mmcam_dbg_log("token : [%s]", buffer_token[count_token]);*/
count_token++;
if (count_token < 2) {
(*info)->detail_info[i] = NULL;
- _mmcam_dbg_warn( "No string value... check it.[%s]", buffer_details[i] );
+ _mmcam_dbg_warn("No string value... check it.[%s]", buffer_details[i]);
continue;
}
}
- switch (value_type)
+ switch (value_type) {
+ case CONFIGURE_VALUE_INT:
{
- case CONFIGURE_VALUE_INT:
- {
- type_int2* new_int;
+ type_int2* new_int;
- new_int = (type_int2*)g_malloc0( sizeof(type_int2) );
- if ( new_int == NULL ) {
- _mmcam_dbg_err("allocation failed");
- break;
- }
- new_int->name = get_new_string( buffer_token[0] );
- new_int->value = atoi( buffer_token[1] );
- (*info)->detail_info[i] = (void*)new_int;
- /*_mmcam_dbg_log("INT - name[%s],value[%d]", new_int->name, new_int->value);*/
+ new_int = (type_int2*)g_malloc0(sizeof(type_int2));
+ if (new_int == NULL) {
+ _mmcam_dbg_err("allocation failed");
break;
}
- case CONFIGURE_VALUE_INT_RANGE:
- {
- type_int_range* new_int_range;
+ new_int->name = get_new_string(buffer_token[0]);
+ new_int->value = atoi(buffer_token[1]);
+ (*info)->detail_info[i] = (void*)new_int;
+ /*_mmcam_dbg_log("INT - name[%s],value[%d]", new_int->name, new_int->value);*/
+ break;
+ }
+ case CONFIGURE_VALUE_INT_RANGE:
+ {
+ type_int_range* new_int_range;
- new_int_range = (type_int_range*)g_malloc0( sizeof(type_int_range) );
- if ( new_int_range == NULL ) {
- _mmcam_dbg_err("allocation failed");
- break;
- }
- new_int_range->name = get_new_string( buffer_token[0] );
- new_int_range->min = atoi( buffer_token[1] );
- new_int_range->max = atoi( buffer_token[2] );
- new_int_range->default_value = atoi( buffer_token[3] );
- (*info)->detail_info[i] = (void*)new_int_range;
- /*
- _mmcam_dbg_log("INT RANGE - name[%s],min[%d],max[%d],default[%d]",
- new_int_range->name,
- new_int_range->min,
- new_int_range->max,
- new_int_range->default_value);
- */
+ new_int_range = (type_int_range*)g_malloc0(sizeof(type_int_range));
+ if (new_int_range == NULL) {
+ _mmcam_dbg_err("allocation failed");
break;
}
- case CONFIGURE_VALUE_INT_ARRAY:
- {
- int count_value = count_token - 2;
- type_int_array* new_int_array;
+ new_int_range->name = get_new_string(buffer_token[0]);
+ new_int_range->min = atoi(buffer_token[1]);
+ new_int_range->max = atoi(buffer_token[2]);
+ new_int_range->default_value = atoi(buffer_token[3]);
+ (*info)->detail_info[i] = (void*)new_int_range;
+ /*
+ _mmcam_dbg_log("INT RANGE - name[%s],min[%d],max[%d],default[%d]",
+ new_int_range->name,
+ new_int_range->min,
+ new_int_range->max,
+ new_int_range->default_value);
+ */
+ break;
+ }
+ case CONFIGURE_VALUE_INT_ARRAY:
+ {
+ int count_value = count_token - 2;
+ type_int_array* new_int_array;
- new_int_array = (type_int_array*)g_malloc0( sizeof(type_int_array) );
- if (new_int_array == NULL) {
- _mmcam_dbg_err("allocation failed");
- break;
- }
- new_int_array->name = get_new_string( buffer_token[0] );
- new_int_array->value = (int*)g_malloc0( sizeof(int)*count_value );
- if (new_int_array->value == NULL) {
- SAFE_G_FREE(new_int_array->name);
- SAFE_G_FREE(new_int_array);
- _mmcam_dbg_err("allocation failed");
- break;
- }
- new_int_array->count = count_value;
+ new_int_array = (type_int_array*)g_malloc0(sizeof(type_int_array));
+ if (new_int_array == NULL) {
+ _mmcam_dbg_err("allocation failed");
+ break;
+ }
+ new_int_array->name = get_new_string(buffer_token[0]);
+ new_int_array->value = (int*)g_malloc0(sizeof(int)*count_value);
+ if (new_int_array->value == NULL) {
+ SAFE_G_FREE(new_int_array->name);
+ SAFE_G_FREE(new_int_array);
+ _mmcam_dbg_err("allocation failed");
+ break;
+ }
+ new_int_array->count = count_value;
- /*_mmcam_dbg_log("INT ARRAY - name[%s]", new_int_array->name);*/
- for ( j = 0 ; j < count_value ; j++ ) {
- new_int_array->value[j] = atoi( buffer_token[j+1] );
- /*_mmcam_dbg_log(" index[%d] - value[%d]", j, new_int_array->value[j]);*/
- }
+ /*_mmcam_dbg_log("INT ARRAY - name[%s]", new_int_array->name);*/
+ for (j = 0 ; j < count_value ; j++) {
+ new_int_array->value[j] = atoi(buffer_token[j+1]);
+ /*_mmcam_dbg_log(" index[%d] - value[%d]", j, new_int_array->value[j]);*/
+ }
- new_int_array->default_value = atoi( buffer_token[count_token-1] );
- /*_mmcam_dbg_log(" default value[%d]", new_int_array->default_value);*/
+ new_int_array->default_value = atoi(buffer_token[count_token-1]);
+ /*_mmcam_dbg_log(" default value[%d]", new_int_array->default_value);*/
- (*info)->detail_info[i] = (void*)new_int_array;
+ (*info)->detail_info[i] = (void*)new_int_array;
+ break;
+ }
+ case CONFIGURE_VALUE_INT_PAIR_ARRAY:
+ {
+ int count_value = (count_token - 3) >> 1;
+ type_int_pair_array* new_int_pair_array;
+
+ new_int_pair_array = (type_int_pair_array*)g_malloc0(sizeof(type_int_pair_array));
+ if (new_int_pair_array == NULL) {
+ _mmcam_dbg_err("allocation failed");
break;
}
- case CONFIGURE_VALUE_INT_PAIR_ARRAY:
- {
- int count_value = ( count_token - 3 ) >> 1;
- type_int_pair_array* new_int_pair_array;
-
- new_int_pair_array = (type_int_pair_array*)g_malloc0( sizeof(type_int_pair_array) );
- if ( new_int_pair_array == NULL ) {
- _mmcam_dbg_err("allocation failed");
- break;
- }
- new_int_pair_array->name = get_new_string( buffer_token[0] );
- new_int_pair_array->value[0] = (int*)g_malloc0( sizeof(int)*(count_value) );
- if ( new_int_pair_array->value[0] == NULL ) {
- SAFE_G_FREE(new_int_pair_array->name);
- SAFE_G_FREE(new_int_pair_array);
- _mmcam_dbg_err("allocation failed");
- break;
- }
- new_int_pair_array->value[1] = (int*)g_malloc0( sizeof(int)*(count_value) );
- if ( new_int_pair_array->value[1] == NULL ) {
- SAFE_G_FREE(new_int_pair_array->value[0]);
- SAFE_G_FREE(new_int_pair_array->name);
- SAFE_G_FREE(new_int_pair_array);
- _mmcam_dbg_err("allocation failed");
- break;
- }
- new_int_pair_array->count = count_value;
-
- /*_mmcam_dbg_log("INT PAIR ARRAY - name[%s],count[%d]", new_int_pair_array->name, count_value);*/
- for ( j = 0 ; j < count_value ; j++ ) {
- new_int_pair_array->value[0][j] = atoi( buffer_token[(j<<1)+1] );
- new_int_pair_array->value[1][j] = atoi( buffer_token[(j<<1)+2] );
- /*
- _mmcam_dbg_log(" index[%d] - value[%d,%d]", j,
- new_int_pair_array->value[0][j],
- new_int_pair_array->value[1][j]);
- */
- }
+ new_int_pair_array->name = get_new_string(buffer_token[0]);
+ new_int_pair_array->value[0] = (int*)g_malloc0(sizeof(int)*(count_value));
+ if (new_int_pair_array->value[0] == NULL) {
+ SAFE_G_FREE(new_int_pair_array->name);
+ SAFE_G_FREE(new_int_pair_array);
+ _mmcam_dbg_err("allocation failed");
+ break;
+ }
+ new_int_pair_array->value[1] = (int*)g_malloc0(sizeof(int)*(count_value));
+ if (new_int_pair_array->value[1] == NULL) {
+ SAFE_G_FREE(new_int_pair_array->value[0]);
+ SAFE_G_FREE(new_int_pair_array->name);
+ SAFE_G_FREE(new_int_pair_array);
+ _mmcam_dbg_err("allocation failed");
+ break;
+ }
+ new_int_pair_array->count = count_value;
- new_int_pair_array->default_value[0] = atoi( buffer_token[count_token-2] );
- new_int_pair_array->default_value[1] = atoi( buffer_token[count_token-1] );
+ /*_mmcam_dbg_log("INT PAIR ARRAY - name[%s],count[%d]", new_int_pair_array->name, count_value);*/
+ for (j = 0 ; j < count_value ; j++) {
+ new_int_pair_array->value[0][j] = atoi(buffer_token[(j<<1)+1]);
+ new_int_pair_array->value[1][j] = atoi(buffer_token[(j<<1)+2]);
/*
- _mmcam_dbg_log(" default value[%d,%d]",
- new_int_pair_array->default_value[0],
- new_int_pair_array->default_value[1]);
+ _mmcam_dbg_log(" index[%d] - value[%d,%d]", j,
+ new_int_pair_array->value[0][j],
+ new_int_pair_array->value[1][j]);
*/
- (*info)->detail_info[i] = (void*)new_int_pair_array;
- break;
}
- case CONFIGURE_VALUE_STRING:
- {
- type_string2* new_string;
- new_string = (type_string2*)g_malloc0( sizeof(type_string2) );
- if (new_string == NULL) {
- _mmcam_dbg_err("allocation failed");
- break;
- }
- new_string->name = get_new_string( buffer_token[0] );
- new_string->value = get_new_string( buffer_token[1] );
- (*info)->detail_info[i] = (void*)new_string;
+ new_int_pair_array->default_value[0] = atoi(buffer_token[count_token-2]);
+ new_int_pair_array->default_value[1] = atoi(buffer_token[count_token-1]);
+ /*
+ _mmcam_dbg_log(" default value[%d,%d]",
+ new_int_pair_array->default_value[0],
+ new_int_pair_array->default_value[1]);
+ */
+ (*info)->detail_info[i] = (void*)new_int_pair_array;
+ break;
+ }
+ case CONFIGURE_VALUE_STRING:
+ {
+ type_string2* new_string;
- /*_mmcam_dbg_log("STRING - name[%s],value[%s]", new_string->name, new_string->value);*/
+ new_string = (type_string2*)g_malloc0(sizeof(type_string2));
+ if (new_string == NULL) {
+ _mmcam_dbg_err("allocation failed");
break;
}
- case CONFIGURE_VALUE_STRING_ARRAY:
- {
- int count_value = count_token - 2;
- type_string_array* new_string_array;
+ new_string->name = get_new_string(buffer_token[0]);
+ new_string->value = get_new_string(buffer_token[1]);
+ (*info)->detail_info[i] = (void*)new_string;
- new_string_array = (type_string_array*)g_malloc0( sizeof(type_string_array) );
- if ( new_string_array == NULL ) {
- break;
- }
- new_string_array->name = get_new_string( buffer_token[0] );
- new_string_array->count = count_value;
- new_string_array->value = (char**)g_malloc0( sizeof(char*)*count_value );
- if ( new_string_array->value == NULL ) {
- SAFE_G_FREE(new_string_array->name);
- SAFE_G_FREE(new_string_array);
- _mmcam_dbg_err("allocation failed");
- break;
- }
- /*_mmcam_dbg_log("STRING ARRAY - name[%s]", new_string_array->name);*/
- for ( j = 0 ; j < count_value ; j++ ) {
- new_string_array->value[j] = get_new_string( buffer_token[j+1] );
- /*_mmcam_dbg_log(" index[%d] - value[%s]", j, new_string_array->value[j]);*/
- }
+ /*_mmcam_dbg_log("STRING - name[%s],value[%s]", new_string->name, new_string->value);*/
+ break;
+ }
+ case CONFIGURE_VALUE_STRING_ARRAY:
+ {
+ int count_value = count_token - 2;
+ type_string_array* new_string_array;
- new_string_array->default_value = get_new_string( buffer_token[count_token-1] );
- /*_mmcam_dbg_log(" default value[%s]", new_string_array->default_value);*/
- (*info)->detail_info[i] = (void*)new_string_array;
+ new_string_array = (type_string_array*)g_malloc0(sizeof(type_string_array));
+ if (new_string_array == NULL)
+ break;
+
+ new_string_array->name = get_new_string(buffer_token[0]);
+ new_string_array->count = count_value;
+ new_string_array->value = (char**)g_malloc0(sizeof(char*)*count_value);
+ if (new_string_array->value == NULL) {
+ SAFE_G_FREE(new_string_array->name);
+ SAFE_G_FREE(new_string_array);
+ _mmcam_dbg_err("allocation failed");
break;
}
- case CONFIGURE_VALUE_ELEMENT:
- {
- type_element2* new_element;
+ /*_mmcam_dbg_log("STRING ARRAY - name[%s]", new_string_array->name);*/
+ for (j = 0 ; j < count_value ; j++) {
+ new_string_array->value[j] = get_new_string(buffer_token[j+1]);
+ /*_mmcam_dbg_log(" index[%d] - value[%s]", j, new_string_array->value[j]);*/
+ }
- new_element = (type_element2*)g_malloc0( sizeof(type_element2) );
- if ( new_element == NULL ) {
- _mmcam_dbg_err("allocation failed");
- break;
- }
- new_element->name = get_new_string( buffer_token[0] );
- new_element->element_name = get_new_string( buffer_token[1] );
- new_element->count_int = atoi( buffer_token[2] );
- new_element->value_int = NULL;
- new_element->count_string = atoi( buffer_token[3] );
- new_element->value_string = NULL;
- /*
- _mmcam_dbg_log("Element - name[%s],element_name[%s],count_int[%d],count_string[%d]",
- new_element->name, new_element->element_name, new_element->count_int, new_element->count_string);
- */
+ new_string_array->default_value = get_new_string(buffer_token[count_token-1]);
+ /*_mmcam_dbg_log(" default value[%s]", new_string_array->default_value);*/
+ (*info)->detail_info[i] = (void*)new_string_array;
+ break;
+ }
+ case CONFIGURE_VALUE_ELEMENT:
+ {
+ type_element2* new_element;
- /* add int values */
- if ( new_element->count_int > 0 && new_element->count_int <= 30 ) {
- new_element->value_int = (type_int2**)g_malloc0( sizeof(type_int2*)*(new_element->count_int) );
- if ( new_element->value_int) {
- for ( j = 0 ; j < new_element->count_int ; j++ ) {
- new_element->value_int[j] = (type_int2*)g_malloc0( sizeof(type_int2) );
- if ( new_element->value_int[j] ) {
- new_element->value_int[j]->name = get_new_string( buffer_token[4+(j<<1)] );
- new_element->value_int[j]->value = atoi( buffer_token[5+(j<<1)] );
- } else {
- _mmcam_dbg_err("allocation failed");
- }
- /*
- _mmcam_dbg_log(" Element INT[%d] - name[%s],value[%d]",
- j, new_element->value_int[j]->name, new_element->value_int[j]->value);
- */
+ new_element = (type_element2*)g_malloc0(sizeof(type_element2));
+ if (new_element == NULL) {
+ _mmcam_dbg_err("allocation failed");
+ break;
+ }
+ new_element->name = get_new_string(buffer_token[0]);
+ new_element->element_name = get_new_string(buffer_token[1]);
+ new_element->count_int = atoi(buffer_token[2]);
+ new_element->value_int = NULL;
+ new_element->count_string = atoi(buffer_token[3]);
+ new_element->value_string = NULL;
+ /*
+ _mmcam_dbg_log("Element - name[%s],element_name[%s],count_int[%d],count_string[%d]",
+ new_element->name, new_element->element_name, new_element->count_int, new_element->count_string);
+ */
+
+ /* add int values */
+ if (new_element->count_int > 0 && new_element->count_int <= 30) {
+ new_element->value_int = (type_int2**)g_malloc0(sizeof(type_int2*)*(new_element->count_int));
+ if (new_element->value_int) {
+ for (j = 0 ; j < new_element->count_int ; j++) {
+ new_element->value_int[j] = (type_int2*)g_malloc0(sizeof(type_int2));
+ if (new_element->value_int[j]) {
+ new_element->value_int[j]->name = get_new_string(buffer_token[4+(j<<1)]);
+ new_element->value_int[j]->value = atoi(buffer_token[5+(j<<1)]);
+ } else {
+ _mmcam_dbg_err("allocation failed");
}
- } else {
- _mmcam_dbg_err("allocation failed");
+ /*
+ _mmcam_dbg_log(" Element INT[%d] - name[%s],value[%d]",
+ j, new_element->value_int[j]->name, new_element->value_int[j]->value);
+ */
}
} else {
- /*_mmcam_dbg_err("invalid count - %d", new_element->count_int);*/
- new_element->value_int = NULL;
+ _mmcam_dbg_err("allocation failed");
}
+ } else {
+ /*_mmcam_dbg_err("invalid count - %d", new_element->count_int);*/
+ new_element->value_int = NULL;
+ }
- /* add string values */
- if ( new_element->count_string > 0 && new_element->count_string <= 30 &&
- new_element->count_int >= 0 && new_element->count_int <= 30 ) {
- new_element->value_string = (type_string2**)g_malloc0( sizeof(type_string2*)*(new_element->count_string) );
- if (new_element->value_string) {
- for ( ; j < new_element->count_string + new_element->count_int ; j++ ) {
- new_element->value_string[j-new_element->count_int] = (type_string2*)g_malloc0( sizeof(type_string2) );
- if(new_element->value_string[j-new_element->count_int]) {
- new_element->value_string[j-new_element->count_int]->name = get_new_string( buffer_token[4+(j<<1)] );
- new_element->value_string[j-new_element->count_int]->value = get_new_string( buffer_token[5+(j<<1)] );
- /*
- _mmcam_dbg_log(" Element STRING[%d] - name[%s],value[%s]",
- j-new_element->count_int, new_element->value_string[j-new_element->count_int]->name, new_element->value_string[j-new_element->count_int]->value);
- */
- } else {
- _mmcam_dbg_err("allocation failed");
- }
+ /* add string values */
+ if (new_element->count_string > 0 && new_element->count_string <= 30 &&
+ new_element->count_int >= 0 && new_element->count_int <= 30) {
+ new_element->value_string = (type_string2**)g_malloc0(sizeof(type_string2*)*(new_element->count_string));
+ if (new_element->value_string) {
+ for ( ; j < new_element->count_string + new_element->count_int ; j++) {
+ new_element->value_string[j-new_element->count_int] = (type_string2*)g_malloc0(sizeof(type_string2));
+ if (new_element->value_string[j-new_element->count_int]) {
+ new_element->value_string[j-new_element->count_int]->name = get_new_string(buffer_token[4+(j<<1)]);
+ new_element->value_string[j-new_element->count_int]->value = get_new_string(buffer_token[5+(j<<1)]);
+ /*
+ _mmcam_dbg_log(" Element STRING[%d] - name[%s],value[%s]",
+ j-new_element->count_int, new_element->value_string[j-new_element->count_int]->name, new_element->value_string[j-new_element->count_int]->value);
+ */
+ } else {
+ _mmcam_dbg_err("allocation failed");
}
- } else {
- _mmcam_dbg_err("malloc failed : %d", sizeof(type_string2*)*(new_element->count_string));
}
} else {
- /*_mmcam_dbg_err("invalid count - %d", new_element->count_string);*/
- new_element->value_string = NULL;
+ _mmcam_dbg_err("malloc failed : %d", sizeof(type_string2*)*(new_element->count_string));
}
-
- (*info)->detail_info[i] = (void*)new_element;
- break;
+ } else {
+ /*_mmcam_dbg_err("invalid count - %d", new_element->count_string);*/
+ new_element->value_string = NULL;
}
- default:
- break;
+
+ (*info)->detail_info[i] = (void*)new_element;
+ break;
+ }
+ default:
+ break;
}
}
int i, count;
conf_detail* info;
- //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
+ /* _mmcam_dbg_log("Entered... category[%d],name[%s]", category, name); */
- mmf_return_val_if_fail( configure_info, FALSE );
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(configure_info, FALSE);
+ mmf_return_val_if_fail(name, FALSE);
- if( configure_info->info[category] )
- {
+ if (configure_info->info[category]) {
count = configure_info->info[category]->count;
info = configure_info->info[category];
- for( i = 0 ; i < count ; i++ )
- {
- if( info->detail_info[i] == NULL )
- {
+ for (i = 0 ; i < count ; i++) {
+ if (info->detail_info[i] == NULL)
continue;
- }
- if( !strcmp( ((type_int*)(info->detail_info[i]))->name , name ) )
- {
+ if (!strcmp(((type_int*)(info->detail_info[i]))->name , name)) {
*value = ((type_int*)(info->detail_info[i]))->value;
- //_mmcam_dbg_log( "Get[%s] int[%d]", name, *value );
+ /* _mmcam_dbg_log("Get[%s] int[%d]", name, *value); */
return TRUE;
}
}
}
- if( _mmcamcorder_conf_get_default_value_int( handle, configure_info->type, category, name, value ) )
- {
- //_mmcam_dbg_log( "Get[%s] int[%d]", name, *value );
+ if (_mmcamcorder_conf_get_default_value_int(handle, configure_info->type, category, name, value)) {
+ /* _mmcam_dbg_log("Get[%s] int[%d]", name, *value); */
return TRUE;
}
- _mmcam_dbg_warn( "Faild to get int... check it...Category[%d],Name[%s]", category, name );
+ _mmcam_dbg_warn("Faild to get int... check it...Category[%d],Name[%s]", category, name);
return FALSE;
}
int
-_mmcamcorder_conf_get_value_int_range( camera_conf* configure_info, int category, const char* name, type_int_range** value )
+_mmcamcorder_conf_get_value_int_range(camera_conf* configure_info, int category, const char* name, type_int_range** value)
{
int i, count;
conf_detail* info;
- //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
+ /* _mmcam_dbg_log("Entered... category[%d],name[%s]", category, name); */
- mmf_return_val_if_fail( configure_info, FALSE );
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(configure_info, FALSE);
+ mmf_return_val_if_fail(name, FALSE);
- if( configure_info->info[category] )
- {
+ if (configure_info->info[category]) {
count = configure_info->info[category]->count;
info = configure_info->info[category];
- for( i = 0 ; i < count ; i++ )
- {
- if( info->detail_info[i] == NULL )
- {
+ for (i = 0 ; i < count ; i++) {
+ if (info->detail_info[i] == NULL)
continue;
- }
- if( !strcmp( ((type_int_range*)(info->detail_info[i]))->name , name ) )
- {
+ if (!strcmp(((type_int_range*)(info->detail_info[i]))->name , name)) {
*value = (type_int_range*)(info->detail_info[i]);
/*
- _mmcam_dbg_log( "Get[%s] int range - min[%d],max[%d],default[%d]",
- name, (*value)->min, (*value)->max, (*value)->default_value );
+ _mmcam_dbg_log("Get[%s] int range - min[%d],max[%d],default[%d]",
+ name, (*value)->min, (*value)->max, (*value)->default_value);
*/
return TRUE;
}
}
int
-_mmcamcorder_conf_get_value_int_array( camera_conf* configure_info, int category, const char* name, type_int_array** value )
+_mmcamcorder_conf_get_value_int_array(camera_conf* configure_info, int category, const char* name, type_int_array** value)
{
int i, count;
conf_detail* info;
- /*_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );*/
+ /*_mmcam_dbg_log("Entered... category[%d],name[%s]", category, name);*/
- mmf_return_val_if_fail( configure_info, FALSE );
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(configure_info, FALSE);
+ mmf_return_val_if_fail(name, FALSE);
- if( configure_info->info[category] )
- {
+ if (configure_info->info[category]) {
count = configure_info->info[category]->count;
info = configure_info->info[category];
- for( i = 0 ; i < count ; i++ )
- {
- if( info->detail_info[i] == NULL )
- {
+ for (i = 0 ; i < count ; i++) {
+ if (info->detail_info[i] == NULL)
continue;
- }
- if( !strcmp( ((type_int_array*)(info->detail_info[i]))->name , name ) )
- {
+ if (!strcmp(((type_int_array*)(info->detail_info[i]))->name , name)) {
*value = (type_int_array*)(info->detail_info[i]);
/*
- _mmcam_dbg_log( "Get[%s] int array - [%x],count[%d],default[%d]",
- name, (*value)->value, (*value)->count, (*value)->default_value );
+ _mmcam_dbg_log("Get[%s] int array - [%x],count[%d],default[%d]",
+ name, (*value)->value, (*value)->count, (*value)->default_value);
*/
return TRUE;
}
}
int
-_mmcamcorder_conf_get_value_int_pair_array( camera_conf* configure_info, int category, const char* name, type_int_pair_array** value )
+_mmcamcorder_conf_get_value_int_pair_array(camera_conf* configure_info, int category, const char* name, type_int_pair_array** value)
{
int i, count;
conf_detail* info;
- //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
+ /* _mmcam_dbg_log("Entered... category[%d],name[%s]", category, name); */
- mmf_return_val_if_fail( configure_info, FALSE );
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(configure_info, FALSE);
+ mmf_return_val_if_fail(name, FALSE);
- if( configure_info->info[category] )
- {
+ if (configure_info->info[category]) {
count = configure_info->info[category]->count;
info = configure_info->info[category];
- for( i = 0 ; i < count ; i++ )
- {
- if( info->detail_info[i] == NULL )
- {
+ for (i = 0 ; i < count ; i++) {
+ if (info->detail_info[i] == NULL)
continue;
- }
- if( !strcmp( ((type_int_pair_array*)(info->detail_info[i]))->name , name ) )
- {
+ if (!strcmp(((type_int_pair_array*)(info->detail_info[i]))->name , name)) {
*value = (type_int_pair_array*)(info->detail_info[i]);
/*
- _mmcam_dbg_log( "Get[%s] int pair array - [%x][%x],count[%d],default[%d][%d]",
- name, (*value)->value[0], (*value)->value[1], (*value)->count,
- (*value)->default_value[0], (*value)->default_value[1] );
+ _mmcam_dbg_log("Get[%s] int pair array - [%x][%x],count[%d],default[%d][%d]",
+ name, (*value)->value[0], (*value)->value[1], (*value)->count,
+ (*value)->default_value[0], (*value)->default_value[1]);
*/
return TRUE;
}
*value = NULL;
- _mmcam_dbg_warn( "Faild to get int pair array... check it...Category[%d],Name[%s]", category, name );
+ _mmcam_dbg_warn("Faild to get int pair array... check it...Category[%d],Name[%s]", category, name);
return FALSE;
}
int i, count;
conf_detail* info;
- //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
+ /* _mmcam_dbg_log("Entered... category[%d],name[%s]", category, name); */
- mmf_return_val_if_fail( configure_info, FALSE );
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(configure_info, FALSE);
+ mmf_return_val_if_fail(name, FALSE);
- if( configure_info->info[category] )
- {
+ if (configure_info->info[category]) {
count = configure_info->info[category]->count;
info = configure_info->info[category];
- for( i = 0 ; i < count ; i++ )
- {
- if( info->detail_info[i] == NULL )
- {
+ for (i = 0 ; i < count ; i++) {
+ if (info->detail_info[i] == NULL)
continue;
- }
- if( !strcmp( ((type_string*)(info->detail_info[i]))->name , name ) )
- {
+ if (!strcmp(((type_string*)(info->detail_info[i]))->name , name)) {
*value = ((type_string*)(info->detail_info[i]))->value;
- //_mmcam_dbg_log( "Get[%s] string[%s]", name, *value );
+ /* _mmcam_dbg_log( "Get[%s] string[%s]", name, *value ); */
return TRUE;
}
}
}
- if( _mmcamcorder_conf_get_default_value_string(handle, configure_info->type, category, name, value ) )
- {
- //_mmcam_dbg_log( "Get[%s]string[%s]", name, *value );
+ if (_mmcamcorder_conf_get_default_value_string(handle, configure_info->type, category, name, value)) {
+ /* _mmcam_dbg_log("Get[%s]string[%s]", name, *value); */
return TRUE;
}
- _mmcam_dbg_warn( "Faild to get string... check it...Category[%d],Name[%s]", category, name );
+ _mmcam_dbg_warn("Faild to get string... check it...Category[%d],Name[%s]", category, name);
return FALSE;
}
int
-_mmcamcorder_conf_get_value_string_array( camera_conf* configure_info, int category, const char* name, type_string_array** value )
+_mmcamcorder_conf_get_value_string_array(camera_conf* configure_info, int category, const char* name, type_string_array** value)
{
int i, count;
conf_detail* info;
- //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
+ /* _mmcam_dbg_log("Entered... category[%d],name[%s]", category, name); */
- mmf_return_val_if_fail( configure_info, FALSE );
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(configure_info, FALSE);
+ mmf_return_val_if_fail(name, FALSE);
- if( configure_info->info[category] )
- {
+ if (configure_info->info[category]) {
count = configure_info->info[category]->count;
info = configure_info->info[category];
- for( i = 0 ; i < count ; i++ )
- {
- if( info->detail_info[i] == NULL )
- {
+ for (i = 0 ; i < count ; i++) {
+ if (info->detail_info[i] == NULL)
continue;
- }
- if( !strcmp( ((type_string_array*)(info->detail_info[i]))->name , name ) )
- {
+ if (!strcmp(((type_string_array*)(info->detail_info[i]))->name , name)) {
*value = (type_string_array*)(info->detail_info[i]);
/*
- _mmcam_dbg_log( "Get[%s] string array - [%x],count[%d],default[%s]",
- name, (*value)->value, (*value)->count, (*value)->default_value );
+ _mmcam_dbg_log("Get[%s] string array - [%x],count[%d],default[%s]",
+ name, (*value)->value, (*value)->count, (*value)->default_value);
*/
return TRUE;
}
*value = NULL;
- /*_mmcam_dbg_warn( "Faild to get string array... check it...Category[%d],Name[%s]", category, name );*/
+ /*_mmcam_dbg_warn("Faild to get string array... check it...Category[%d],Name[%s]", category, name);*/
return FALSE;
}
int i, count;
conf_detail* info;
- //_mmcam_dbg_log( "Entered... category[%d],name[%s]", category, name );
+ /* _mmcam_dbg_log("Entered... category[%d], ame[%s]", category, name); */
- mmf_return_val_if_fail( configure_info, FALSE );
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(configure_info, FALSE);
+ mmf_return_val_if_fail(name, FALSE);
- if( configure_info->info[category] )
- {
+ if (configure_info->info[category]) {
count = configure_info->info[category]->count;
info = configure_info->info[category];
- for( i = 0 ; i < count ; i++ )
- {
- if( info->detail_info[i] == NULL )
- {
+ for (i = 0 ; i < count ; i++) {
+ if (info->detail_info[i] == NULL)
continue;
- }
- if( !strcmp( ((type_element*)(info->detail_info[i]))->name , name ) )
- {
+ if (!strcmp(((type_element*)(info->detail_info[i]))->name , name)) {
*element = (type_element*)(info->detail_info[i]);
- //_mmcam_dbg_log( "Get[%s] element[%x]", name, *element );
+ /* _mmcam_dbg_log("Get[%s] element[%x]", name, *element); */
return TRUE;
}
}
}
- if( _mmcamcorder_conf_get_default_element(handle, configure_info->type, category, name, element ) )
- {
- //_mmcam_dbg_log( "Get[%s] element[%x]", name, *element );
+ if (_mmcamcorder_conf_get_default_element(handle, configure_info->type, category, name, element)) {
+ /* _mmcam_dbg_log("Get[%s] element[%x]", name, *element); */
return TRUE;
}
- _mmcam_dbg_warn( "Faild to get element name... check it...Category[%d],Name[%s]", category, name );
+ _mmcam_dbg_warn("Faild to get element name... check it...Category[%d],Name[%s]", category, name);
return FALSE;
}
int
-_mmcamcorder_conf_get_value_element_name( type_element* element, const char** value )
+_mmcamcorder_conf_get_value_element_name(type_element* element, const char** value)
{
- //_mmcam_dbg_log( "Entered..." );
+ /* _mmcam_dbg_log("Entered..."); */
- mmf_return_val_if_fail( element, FALSE );
+ mmf_return_val_if_fail(element, FALSE);
*value = element->element_name;
- //_mmcam_dbg_log( "Get element name : [%s]", *value );
+ /* _mmcam_dbg_log("Get element name : [%s]", *value); */
return TRUE;
}
int
-_mmcamcorder_conf_get_value_element_int( type_element* element, const char* name, int* value )
+_mmcamcorder_conf_get_value_element_int(type_element* element, const char* name, int* value)
{
int i;
- //_mmcam_dbg_log( "Entered..." );
+ /* _mmcam_dbg_log( "Entered..." ); */
- mmf_return_val_if_fail( element, FALSE );
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(element, FALSE);
+ mmf_return_val_if_fail(name, FALSE);
- for( i = 0 ; i < element->count_int ; i++ )
- {
- if( !strcmp( element->value_int[i]->name , name ) )
- {
+ for (i = 0 ; i < element->count_int ; i++) {
+ if (!strcmp(element->value_int[i]->name, name)) {
*value = element->value_int[i]->value;
- //_mmcam_dbg_log( "Get[%s] element int[%d]", name, *value );
+ /* _mmcam_dbg_log("Get[%s] element int[%d]", name, *value); */
return TRUE;
}
}
- _mmcam_dbg_warn( "Faild to get int in element... ElementName[%p],Name[%s],Count[%d]",
- element->name, name, element->count_int );
+ _mmcam_dbg_warn("Faild to get int in element... ElementName[%p],Name[%s],Count[%d]",
+ element->name, name, element->count_int);
return FALSE;
}
int
-_mmcamcorder_conf_get_value_element_string( type_element* element, const char* name, const char** value )
+_mmcamcorder_conf_get_value_element_string(type_element* element, const char* name, const char** value)
{
int i;
- //_mmcam_dbg_log( "Entered..." );
+ /* _mmcam_dbg_log("Entered..."); */
- mmf_return_val_if_fail( element, FALSE );
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(element, FALSE);
+ mmf_return_val_if_fail(name, FALSE);
- for( i = 0 ; i < element->count_string ; i++ )
- {
- if( !strcmp( element->value_string[i]->name , name ) )
- {
+ for (i = 0 ; i < element->count_string ; i++) {
+ if (!strcmp(element->value_string[i]->name, name)) {
*value = element->value_string[i]->value;
- //_mmcam_dbg_log( "Get[%s] element string[%s]", name, *value );
+ /*_mmcam_dbg_log("Get[%s] element string[%s]", name, *value);*/
return TRUE;
}
}
- _mmcam_dbg_warn( "Faild to get int in element... ElementName[%p],Name[%s],Count[%d]",
- element->name, name, element->count_string );
+ _mmcam_dbg_warn("Faild to get int in element... ElementName[%p],Name[%s],Count[%d]",
+ element->name, name, element->count_string);
return FALSE;
}
int
-_mmcamcorder_conf_set_value_element_property( GstElement* gst, type_element* element )
+_mmcamcorder_conf_set_value_element_property(GstElement* gst, type_element* element)
{
int i;
- //_mmcam_dbg_log( "Entered..." );
+ /* _mmcam_dbg_log("Entered..."); */
- mmf_return_val_if_fail( gst, FALSE );
- mmf_return_val_if_fail( element, FALSE );
+ mmf_return_val_if_fail(gst, FALSE);
+ mmf_return_val_if_fail(element, FALSE);
- if( element->count_int == 0 )
- {
+ if (element->count_int == 0) {
/*_mmcam_dbg_log( "There is no integer property to set in INI file[%s].", element->name );*/
- }
- else
- {
- if( element->value_int == NULL )
- {
- _mmcam_dbg_warn( "count_int[%d] is NOT zero, but value_int is NULL", element->count_int );
+ } else {
+ if (element->value_int == NULL) {
+ _mmcam_dbg_warn("count_int[%d] is NOT zero, but value_int is NULL", element->count_int);
return FALSE;
}
- for( i = 0 ; i < element->count_int ; i++ )
- {
- MMCAMCORDER_G_OBJECT_SET( gst, element->value_int[i]->name, element->value_int[i]->value );
+ for (i = 0 ; i < element->count_int ; i++) {
+ MMCAMCORDER_G_OBJECT_SET(gst, element->value_int[i]->name, element->value_int[i]->value);
/*
- _mmcam_dbg_log( "Element[%s] Set[%s] -> integer[%d]",
+ _mmcam_dbg_log("Element[%s] Set[%s] -> integer[%d]",
element->element_name,
element->value_int[i]->name,
- element->value_int[i]->value );
- */
+ element->value_int[i]->value);
+ */
}
}
- if( element->count_string == 0 )
- {
- _mmcam_dbg_log( "There is no string property to set in INI file[%s].", element->name );
- }
- else
- {
- if( element->value_string == NULL )
- {
- _mmcam_dbg_warn( "count_string[%d] is NOT zero, but value_string is NULL", element->count_string );
+ if (element->count_string == 0) {
+ _mmcam_dbg_log("There is no string property to set in INI file[%s].", element->name);
+ } else {
+ if (element->value_string == NULL) {
+ _mmcam_dbg_warn("count_string[%d] is NOT zero, but value_string is NULL", element->count_string);
return FALSE;
}
- for( i = 0 ; i < element->count_string ; i++ )
- {
- MMCAMCORDER_G_OBJECT_SET_POINTER( gst, element->value_string[i]->name, element->value_string[i]->value );
+ for (i = 0 ; i < element->count_string ; i++) {
+ MMCAMCORDER_G_OBJECT_SET_POINTER(gst, element->value_string[i]->name, element->value_string[i]->value);
- _mmcam_dbg_log( "Element[%s] Set[%s] -> string[%s]",
+ _mmcam_dbg_log("Element[%s] Set[%s] -> string[%s]",
element->element_name,
element->value_string[i]->name,
- element->value_string[i]->value );
+ element->value_string[i]->value);
}
}
- //_mmcam_dbg_log( "Done." );
+ /* _mmcam_dbg_log( "Done." ); */
return TRUE;
}
int
-_mmcamcorder_conf_get_default_value_int(MMHandleType handle, int type, int category, const char* name, int* value )
+_mmcamcorder_conf_get_default_value_int(MMHandleType handle, int type, int category, const char* name, int* value)
{
int i = 0;
int count_value = 0;
return FALSE;
}
- //_mmcam_dbg_log( "Entered..." );
+ /* _mmcam_dbg_log("Entered..."); */
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(name, FALSE);
- if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
- {
- _mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
+ if (!_mmcamcorder_conf_get_category_size(handle, type, category, &count_value)) {
+ _mmcam_dbg_warn("No matched category... check it... categoty[%d]", category);
return FALSE;
}
- if( type == CONFIGURE_TYPE_MAIN )
- {
- for( i = 0 ; i < count_value ; i++ )
- {
- if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
- {
+ if (type == CONFIGURE_TYPE_MAIN) {
+ for (i = 0 ; i < count_value ; i++) {
+ if (!strcmp(hcamcorder->conf_main_info_table[category][i].name, name)) {
*value = hcamcorder->conf_main_info_table[category][i].value_int;
return TRUE;
}
}
- }
- else
- {
- for( i = 0 ; i < count_value ; i++ )
- {
- if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
- {
+ } else {
+ for (i = 0 ; i < count_value ; i++) {
+ if (!strcmp(hcamcorder->conf_ctrl_info_table[category][i].name, name)) {
*value = hcamcorder->conf_ctrl_info_table[category][i].value_int;
return TRUE;
}
}
}
- _mmcam_dbg_warn( "Failed to get default int... check it... Type[%d],Category[%d],Name[%s]", type, category, name );
+ _mmcam_dbg_warn("Failed to get default int... check it... Type[%d],Category[%d],Name[%s]", type, category, name);
return FALSE;
}
return FALSE;
}
- //_mmcam_dbg_log( "Entered..." );
+ /* _mmcam_dbg_log("Entered..."); */
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(name, FALSE);
- if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
- {
- _mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
+ if (!_mmcamcorder_conf_get_category_size(handle, type, category, &count_value)) {
+ _mmcam_dbg_warn("No matched category... check it... categoty[%d]", category);
return FALSE;
}
- if( type == CONFIGURE_TYPE_MAIN )
- {
- for( i = 0 ; i < count_value ; i++ )
- {
- if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
- {
+ if (type == CONFIGURE_TYPE_MAIN) {
+ for (i = 0 ; i < count_value ; i++) {
+ if (!strcmp(hcamcorder->conf_main_info_table[category][i].name, name)) {
*value = hcamcorder->conf_main_info_table[category][i].value_string;
- _mmcam_dbg_log( "Get[%s] default string[%s]", name, *value );
+ _mmcam_dbg_log("Get[%s] default string[%s]", name, *value);
return TRUE;
}
}
- }
- else
- {
- for( i = 0 ; i < count_value ; i++ )
- {
- if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
- {
+ } else {
+ for (i = 0 ; i < count_value ; i++) {
+ if (!strcmp(hcamcorder->conf_ctrl_info_table[category][i].name, name)) {
*value = hcamcorder->conf_ctrl_info_table[category][i].value_string;
- _mmcam_dbg_log( "Get[%s] default string[%s]", name, *value );
+ _mmcam_dbg_log("Get[%s] default string[%s]", name, *value);
return TRUE;
}
}
}
- _mmcam_dbg_warn( "Failed to get default string... check it... Type[%d],Category[%d],Name[%s]", type, category, name );
+ _mmcam_dbg_warn("Failed to get default string... check it... Type[%d],Category[%d],Name[%s]", type, category, name);
return FALSE;
}
return FALSE;
}
- //_mmcam_dbg_log( "Entered..." );
+ /* _mmcam_dbg_log("Entered..."); */
- mmf_return_val_if_fail( name, FALSE );
+ mmf_return_val_if_fail(name, FALSE);
- if( !_mmcamcorder_conf_get_category_size( handle, type, category, &count_value ) )
- {
- _mmcam_dbg_warn( "No matched category... check it... categoty[%d]", category );
+ if (!_mmcamcorder_conf_get_category_size(handle, type, category, &count_value)) {
+ _mmcam_dbg_warn("No matched category... check it... categoty[%d]", category);
return FALSE;
}
- if( type == CONFIGURE_TYPE_MAIN )
- {
- for( i = 0 ; i < count_value ; i++ )
- {
- if( !strcmp( hcamcorder->conf_main_info_table[category][i].name, name ) )
- {
+ if (type == CONFIGURE_TYPE_MAIN) {
+ for (i = 0 ; i < count_value ; i++) {
+ if (!strcmp(hcamcorder->conf_main_info_table[category][i].name, name)) {
*element = hcamcorder->conf_main_info_table[category][i].value_element;
- _mmcam_dbg_log( "Get[%s] element[%p]", name, *element );
+ _mmcam_dbg_log("Get[%s] element[%p]", name, *element);
return TRUE;
}
}
- }
- else
- {
- for( i = 0 ; i < count_value ; i++ )
- {
- if( !strcmp( hcamcorder->conf_ctrl_info_table[category][i].name, name ) )
- {
+ } else {
+ for (i = 0 ; i < count_value ; i++) {
+ if (!strcmp(hcamcorder->conf_ctrl_info_table[category][i].name, name)) {
*element = hcamcorder->conf_ctrl_info_table[category][i].value_element;
- _mmcam_dbg_log( "Get[%s] element[%p]", name, *element );
+ _mmcam_dbg_log("Get[%s] element[%p]", name, *element);
return TRUE;
}
}
}
- _mmcam_dbg_warn( "Failed to get default element... check it... Type[%d],Category[%d],Name[%s]", type, category, name );
+ _mmcam_dbg_warn("Failed to get default element... check it... Type[%d],Category[%d],Name[%s]", type, category, name);
return FALSE;
}
return FALSE;
}
-// mmf_return_val_if_fail( conf_main_category_size, FALSE );
-// mmf_return_val_if_fail( conf_ctrl_category_size, FALSE );
+ /*
+ mmf_return_val_if_fail(conf_main_category_size, FALSE);
+ mmf_return_val_if_fail(conf_ctrl_category_size, FALSE);
+ */
- if( type == CONFIGURE_TYPE_MAIN )
- {
- mmf_return_val_if_fail( category < CONFIGURE_CATEGORY_MAIN_NUM, FALSE );
+ if (type == CONFIGURE_TYPE_MAIN) {
+ mmf_return_val_if_fail(category < CONFIGURE_CATEGORY_MAIN_NUM, FALSE);
*size = (int)hcamcorder->conf_main_category_size[category];
- }
- else
- {
- mmf_return_val_if_fail( category < CONFIGURE_CATEGORY_CTRL_NUM, FALSE );
+ } else {
+ mmf_return_val_if_fail(category < CONFIGURE_CATEGORY_CTRL_NUM, FALSE);
*size = (int)hcamcorder->conf_ctrl_category_size[category];
}
}
void
-_mmcamcorder_conf_print_info(MMHandleType handle, camera_conf** configure_info )
+_mmcamcorder_conf_print_info(MMHandleType handle, camera_conf** configure_info)
{
int i, j, k, type, category_type;
type_string *temp_string;
type_element *temp_element;
- g_print( "[ConfigureInfoPrint] : Entered.\n" );
+ g_print("[ConfigureInfoPrint] : Entered.\n");
- mmf_return_if_fail( *configure_info );
+ mmf_return_if_fail(*configure_info);
- if( (*configure_info)->type == CONFIGURE_TYPE_MAIN )
- {
+ if ((*configure_info)->type == CONFIGURE_TYPE_MAIN)
category_type = CONFIGURE_CATEGORY_MAIN_NUM;
- }
else
- {
category_type = CONFIGURE_CATEGORY_CTRL_NUM;
- }
- for( i = 0 ; i < category_type ; i++ )
- {
- if( (*configure_info)->info[i] )
- {
- g_print( "[ConfigureInfo] : Category [%d]\n", i );
- for( j = 0 ; j < (*configure_info)->info[i]->count ; j++ )
- {
- if( _mmcamcorder_conf_get_value_type(handle, (*configure_info)->type, i, ((type_int*)((*configure_info)->info[i]->detail_info[j]))->name, &type ) )
- {
- switch( type )
- {
- case CONFIGURE_VALUE_INT:
- temp_int = (type_int*)((*configure_info)->info[i]->detail_info[j]);
- g_print( "[ConfigureInfo] : INT - Name[%s],Value [%d]\n", temp_int->name, temp_int->value );
- break;
- case CONFIGURE_VALUE_INT_RANGE:
- temp_int_range = (type_int_range*)((*configure_info)->info[i]->detail_info[j]);
- g_print( "[ConfigureInfo] : INT_RANGE - Name[%s],Value [%d]~[%d], default [%d]\n",
- temp_int_range->name, temp_int_range->min, temp_int_range->max, temp_int_range->default_value );
- break;
- case CONFIGURE_VALUE_INT_ARRAY:
- temp_int_array = (type_int_array*)((*configure_info)->info[i]->detail_info[j]);
- g_print( "[ConfigureInfo] : INT_ARRAY - Name[%s], default [%d]\n - ",
- temp_int_array->name, temp_int_array->default_value );
- for( k = 0 ; k < temp_int_array->count ; k++ )
- {
- g_print( "[%d] ", temp_int_array->value[k] );
- }
- g_print( "\n" );
- break;
- case CONFIGURE_VALUE_INT_PAIR_ARRAY:
- temp_int_pair_array = (type_int_pair_array*)((*configure_info)->info[i]->detail_info[j]);
- g_print( "[ConfigureInfo] : INT_PAIR_ARRAY - Name[%s], default [%d][%d]\n - ",
- temp_int_pair_array->name, temp_int_pair_array->default_value[0], temp_int_pair_array->default_value[0] );
- for( k = 0 ; k < temp_int_pair_array->count ; k++ )
- {
- g_print( "[%d,%d] ", temp_int_pair_array->value[0][k], temp_int_pair_array->value[1][k] );
- }
- g_print( "\n" );
- break;
- case CONFIGURE_VALUE_STRING:
- temp_string = (type_string*)((*configure_info)->info[i]->detail_info[j]);
- g_print( "[ConfigureInfo] : STRING - Name[%s],Value[%s]\n", temp_string->name, temp_string->value );
- break;
- case CONFIGURE_VALUE_ELEMENT:
- temp_element = (type_element*)((*configure_info)->info[i]->detail_info[j]);
- g_print( "[ConfigureInfo] : Element - Name[%s],Element_Name[%s]\n", temp_element->name, temp_element->element_name );
- for( k = 0 ; k < temp_element->count_int ; k++ )
- {
- g_print( " - INT[%d] Name[%s],Value[%d]\n", k, temp_element->value_int[k]->name, temp_element->value_int[k]->value );
- }
- for( k = 0 ; k < temp_element->count_string ; k++ )
- {
- g_print( " - STRING[%d] Name[%s],Value[%s]\n", k, temp_element->value_string[k]->name, temp_element->value_string[k]->value );
- }
- break;
- default:
- g_print( "[ConfigureInfo] : Not matched value type... So can not print data... check it... Name[%s],type[%d]\n", ((type_int*)((*configure_info)->info[i]->detail_info[j]))->name, type );
- break;
+ for (i = 0 ; i < category_type ; i++) {
+
+ if ((*configure_info)->info[i]) {
+ g_print("[ConfigureInfo] : Category [%d]\n", i);
+
+ for (j = 0 ; j < (*configure_info)->info[i]->count ; j++) {
+
+ if (_mmcamcorder_conf_get_value_type(handle, (*configure_info)->type, i, ((type_int*)((*configure_info)->info[i]->detail_info[j]))->name, &type)) {
+ switch (type) {
+ case CONFIGURE_VALUE_INT:
+ temp_int = (type_int*)((*configure_info)->info[i]->detail_info[j]);
+ g_print("[ConfigureInfo] : INT - Name[%s],Value [%d]\n", temp_int->name, temp_int->value);
+ break;
+ case CONFIGURE_VALUE_INT_RANGE:
+ temp_int_range = (type_int_range*)((*configure_info)->info[i]->detail_info[j]);
+ g_print("[ConfigureInfo] : INT_RANGE - Name[%s],Value [%d]~[%d], default [%d]\n",
+ temp_int_range->name, temp_int_range->min, temp_int_range->max, temp_int_range->default_value);
+ break;
+ case CONFIGURE_VALUE_INT_ARRAY:
+ temp_int_array = (type_int_array*)((*configure_info)->info[i]->detail_info[j]);
+ g_print("[ConfigureInfo] : INT_ARRAY - Name[%s], default [%d]\n - ",
+ temp_int_array->name, temp_int_array->default_value);
+
+ for (k = 0 ; k < temp_int_array->count ; k++)
+ g_print("[%d] ", temp_int_array->value[k]);
+
+ g_print("\n");
+ break;
+ case CONFIGURE_VALUE_INT_PAIR_ARRAY:
+ temp_int_pair_array = (type_int_pair_array*)((*configure_info)->info[i]->detail_info[j]);
+ g_print("[ConfigureInfo] : INT_PAIR_ARRAY - Name[%s], default [%d][%d]\n - ",
+ temp_int_pair_array->name, temp_int_pair_array->default_value[0], temp_int_pair_array->default_value[0]);
+
+ for (k = 0 ; k < temp_int_pair_array->count ; k++)
+ g_print("[%d,%d] ", temp_int_pair_array->value[0][k], temp_int_pair_array->value[1][k]);
+
+ g_print("\n");
+ break;
+ case CONFIGURE_VALUE_STRING:
+ temp_string = (type_string*)((*configure_info)->info[i]->detail_info[j]);
+ g_print("[ConfigureInfo] : STRING - Name[%s],Value[%s]\n", temp_string->name, temp_string->value);
+ break;
+ case CONFIGURE_VALUE_ELEMENT:
+ temp_element = (type_element*)((*configure_info)->info[i]->detail_info[j]);
+ g_print("[ConfigureInfo] : Element - Name[%s],Element_Name[%s]\n", temp_element->name, temp_element->element_name);
+
+ for (k = 0 ; k < temp_element->count_int ; k++)
+ g_print(" - INT[%d] Name[%s],Value[%d]\n", k, temp_element->value_int[k]->name, temp_element->value_int[k]->value);
+
+ for (k = 0 ; k < temp_element->count_string ; k++)
+ g_print(" - STRING[%d] Name[%s],Value[%s]\n", k, temp_element->value_string[k]->name, temp_element->value_string[k]->value);
+
+ break;
+ default:
+ g_print("[ConfigureInfo] : Not matched value type... So can not print data... check it... Name[%s],type[%d]\n", ((type_int*)((*configure_info)->info[i]->detail_info[j]))->name, type);
+ break;
}
- }
- else
- {
- g_print( "[ConfigureInfo] : Failed to get value type." );
+ } else {
+ g_print("[ConfigureInfo] : Failed to get value type.");
}
}
}
}
- g_print( "[ConfigureInfoPrint] : Done.\n" );
+ g_print("[ConfigureInfoPrint] : Done.\n");
}
type_element *telement = NULL;
const char *codec_type_str = NULL;
int codec_type = MM_AUDIO_CODEC_INVALID;
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
mmf_return_val_if_fail(hcamcorder, NULL);
/* Check element availability */
mm_camcorder_get_attributes(handle, NULL, MMCAM_AUDIO_ENCODER, &codec_type, NULL);
- switch( codec_type )
- {
- case MM_AUDIO_CODEC_AMR:
- codec_type_str = "AMR";
- break;
- case MM_AUDIO_CODEC_G723_1:
- codec_type_str = "G723_1";
- break;
- case MM_AUDIO_CODEC_MP3:
- codec_type_str = "MP3";
- break;
- case MM_AUDIO_CODEC_AAC:
- codec_type_str = "AAC";
- break;
- case MM_AUDIO_CODEC_MMF:
- codec_type_str = "MMF";
- break;
- case MM_AUDIO_CODEC_ADPCM:
- codec_type_str = "ADPCM";
- break;
- case MM_AUDIO_CODEC_WAVE:
- codec_type_str = "WAVE";
- break;
- case MM_AUDIO_CODEC_MIDI:
- codec_type_str = "MIDI";
- break;
- case MM_AUDIO_CODEC_IMELODY:
- codec_type_str = "IMELODY";
- break;
- case MM_AUDIO_CODEC_VORBIS:
- codec_type_str = "VORBIS";
- break;
- default:
- _mmcam_dbg_err( "Not supported audio codec[%d]", codec_type );
- return NULL;
+ switch (codec_type) {
+ case MM_AUDIO_CODEC_AMR:
+ codec_type_str = "AMR";
+ break;
+ case MM_AUDIO_CODEC_G723_1:
+ codec_type_str = "G723_1";
+ break;
+ case MM_AUDIO_CODEC_MP3:
+ codec_type_str = "MP3";
+ break;
+ case MM_AUDIO_CODEC_AAC:
+ codec_type_str = "AAC";
+ break;
+ case MM_AUDIO_CODEC_MMF:
+ codec_type_str = "MMF";
+ break;
+ case MM_AUDIO_CODEC_ADPCM:
+ codec_type_str = "ADPCM";
+ break;
+ case MM_AUDIO_CODEC_WAVE:
+ codec_type_str = "WAVE";
+ break;
+ case MM_AUDIO_CODEC_MIDI:
+ codec_type_str = "MIDI";
+ break;
+ case MM_AUDIO_CODEC_IMELODY:
+ codec_type_str = "IMELODY";
+ break;
+ case MM_AUDIO_CODEC_VORBIS:
+ codec_type_str = "VORBIS";
+ break;
+ default:
+ _mmcam_dbg_err("Not supported audio codec[%d]", codec_type);
+ return NULL;
}
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER,
- codec_type_str,
- &telement);
+ CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER,
+ codec_type_str,
+ &telement);
return telement;
}
type_element *telement = NULL;
const char *codec_type_str = NULL;
int codec_type = MM_VIDEO_CODEC_INVALID;
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
mmf_return_val_if_fail(hcamcorder, NULL);
/* Check element availability */
mm_camcorder_get_attributes(handle, NULL, MMCAM_VIDEO_ENCODER, &codec_type, NULL);
- switch( codec_type )
- {
- case MM_VIDEO_CODEC_H263:
- codec_type_str = "H263";
- break;
- case MM_VIDEO_CODEC_H264:
- codec_type_str = "H264";
- break;
- case MM_VIDEO_CODEC_H26L:
- codec_type_str = "H26L";
- break;
- case MM_VIDEO_CODEC_MPEG4:
- codec_type_str = "MPEG4";
- break;
- case MM_VIDEO_CODEC_MPEG1:
- codec_type_str = "MPEG1";
- break;
- case MM_VIDEO_CODEC_THEORA:
- codec_type_str = "THEORA";
- break;
- default:
- _mmcam_dbg_err( "Not supported video codec[%d]", codec_type );
- return NULL;
+ switch (codec_type) {
+ case MM_VIDEO_CODEC_H263:
+ codec_type_str = "H263";
+ break;
+ case MM_VIDEO_CODEC_H264:
+ codec_type_str = "H264";
+ break;
+ case MM_VIDEO_CODEC_H26L:
+ codec_type_str = "H26L";
+ break;
+ case MM_VIDEO_CODEC_MPEG4:
+ codec_type_str = "MPEG4";
+ break;
+ case MM_VIDEO_CODEC_MPEG1:
+ codec_type_str = "MPEG1";
+ break;
+ case MM_VIDEO_CODEC_THEORA:
+ codec_type_str = "THEORA";
+ break;
+ default:
+ _mmcam_dbg_err("Not supported video codec[%d]", codec_type);
+ return NULL;
}
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER,
- codec_type_str,
- &telement);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER,
+ codec_type_str,
+ &telement);
return telement;
}
type_element *telement = NULL;
const char *codec_type_str = NULL;
int codec_type = MM_IMAGE_CODEC_INVALID;
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
mmf_return_val_if_fail(hcamcorder, NULL);
/* Check element availability */
mm_camcorder_get_attributes(handle, NULL, MMCAM_IMAGE_ENCODER, &codec_type, NULL);
- switch( codec_type )
- {
- case MM_IMAGE_CODEC_JPEG:
- codec_type_str = "JPEG";
- break;
- case MM_IMAGE_CODEC_SRW:
- codec_type_str = "SRW";
- break;
- case MM_IMAGE_CODEC_JPEG_SRW:
- codec_type_str = "JPEG_SRW";
- break;
- case MM_IMAGE_CODEC_PNG:
- codec_type_str = "PNG";
- break;
- case MM_IMAGE_CODEC_BMP:
- codec_type_str = "BMP";
- break;
- case MM_IMAGE_CODEC_WBMP:
- codec_type_str = "WBMP";
- break;
- case MM_IMAGE_CODEC_TIFF:
- codec_type_str = "TIFF";
- break;
- case MM_IMAGE_CODEC_PCX:
- codec_type_str = "PCX";
- break;
- case MM_IMAGE_CODEC_GIF:
- codec_type_str = "GIF";
- break;
- case MM_IMAGE_CODEC_ICO:
- codec_type_str = "ICO";
- break;
- case MM_IMAGE_CODEC_RAS:
- codec_type_str = "RAS";
- break;
- case MM_IMAGE_CODEC_TGA:
- codec_type_str = "TGA";
- break;
- case MM_IMAGE_CODEC_XBM:
- codec_type_str = "XBM";
- break;
- case MM_IMAGE_CODEC_XPM:
- codec_type_str = "XPM";
- break;
- default:
- _mmcam_dbg_err( "Not supported image codec[%d]", codec_type );
- return NULL;
+ switch (codec_type) {
+ case MM_IMAGE_CODEC_JPEG:
+ codec_type_str = "JPEG";
+ break;
+ case MM_IMAGE_CODEC_SRW:
+ codec_type_str = "SRW";
+ break;
+ case MM_IMAGE_CODEC_JPEG_SRW:
+ codec_type_str = "JPEG_SRW";
+ break;
+ case MM_IMAGE_CODEC_PNG:
+ codec_type_str = "PNG";
+ break;
+ case MM_IMAGE_CODEC_BMP:
+ codec_type_str = "BMP";
+ break;
+ case MM_IMAGE_CODEC_WBMP:
+ codec_type_str = "WBMP";
+ break;
+ case MM_IMAGE_CODEC_TIFF:
+ codec_type_str = "TIFF";
+ break;
+ case MM_IMAGE_CODEC_PCX:
+ codec_type_str = "PCX";
+ break;
+ case MM_IMAGE_CODEC_GIF:
+ codec_type_str = "GIF";
+ break;
+ case MM_IMAGE_CODEC_ICO:
+ codec_type_str = "ICO";
+ break;
+ case MM_IMAGE_CODEC_RAS:
+ codec_type_str = "RAS";
+ break;
+ case MM_IMAGE_CODEC_TGA:
+ codec_type_str = "TGA";
+ break;
+ case MM_IMAGE_CODEC_XBM:
+ codec_type_str = "XBM";
+ break;
+ case MM_IMAGE_CODEC_XPM:
+ codec_type_str = "XPM";
+ break;
+ default:
+ _mmcam_dbg_err("Not supported image codec[%d]", codec_type);
+ return NULL;
}
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER,
- codec_type_str,
- &telement);
+ CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER,
+ codec_type_str,
+ &telement);
return telement;
}
type_element *telement = NULL;
const char *mux_type_str = NULL;
int file_type = MM_FILE_FORMAT_INVALID;
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
mmf_return_val_if_fail(hcamcorder, NULL);
/* Check element availability */
mm_camcorder_get_attributes(handle, NULL, MMCAM_FILE_FORMAT, &file_type, NULL);
- switch( file_type )
- {
- case MM_FILE_FORMAT_3GP:
- mux_type_str = "3GP";
- break;
- case MM_FILE_FORMAT_AMR:
- mux_type_str = "AMR";
- break;
- case MM_FILE_FORMAT_MP4:
- mux_type_str = "MP4";
- break;
- case MM_FILE_FORMAT_AAC:
- mux_type_str = "AAC";
- break;
- case MM_FILE_FORMAT_MP3:
- mux_type_str = "MP3";
- break;
- case MM_FILE_FORMAT_OGG:
- mux_type_str = "OGG";
- break;
- case MM_FILE_FORMAT_WAV:
- mux_type_str = "WAV";
- break;
- case MM_FILE_FORMAT_AVI:
- mux_type_str = "AVI";
- break;
- case MM_FILE_FORMAT_WMA:
- mux_type_str = "WMA";
- break;
- case MM_FILE_FORMAT_WMV:
- mux_type_str = "WMV";
- break;
- case MM_FILE_FORMAT_MID:
- mux_type_str = "MID";
- break;
- case MM_FILE_FORMAT_MMF:
- mux_type_str = "MMF";
- break;
- case MM_FILE_FORMAT_MATROSKA:
- mux_type_str = "MATROSKA";
- break;
- case MM_FILE_FORMAT_M2TS:
- mux_type_str = "M2TS";
- break;
- default:
- _mmcam_dbg_err( "Not supported file format[%d]", file_type );
- return NULL;
+ switch (file_type) {
+ case MM_FILE_FORMAT_3GP:
+ mux_type_str = "3GP";
+ break;
+ case MM_FILE_FORMAT_AMR:
+ mux_type_str = "AMR";
+ break;
+ case MM_FILE_FORMAT_MP4:
+ mux_type_str = "MP4";
+ break;
+ case MM_FILE_FORMAT_AAC:
+ mux_type_str = "AAC";
+ break;
+ case MM_FILE_FORMAT_MP3:
+ mux_type_str = "MP3";
+ break;
+ case MM_FILE_FORMAT_OGG:
+ mux_type_str = "OGG";
+ break;
+ case MM_FILE_FORMAT_WAV:
+ mux_type_str = "WAV";
+ break;
+ case MM_FILE_FORMAT_AVI:
+ mux_type_str = "AVI";
+ break;
+ case MM_FILE_FORMAT_WMA:
+ mux_type_str = "WMA";
+ break;
+ case MM_FILE_FORMAT_WMV:
+ mux_type_str = "WMV";
+ break;
+ case MM_FILE_FORMAT_MID:
+ mux_type_str = "MID";
+ break;
+ case MM_FILE_FORMAT_MMF:
+ mux_type_str = "MMF";
+ break;
+ case MM_FILE_FORMAT_MATROSKA:
+ mux_type_str = "MATROSKA";
+ break;
+ case MM_FILE_FORMAT_M2TS:
+ mux_type_str = "M2TS";
+ break;
+ default:
+ _mmcam_dbg_err("Not supported file format[%d]", file_type);
+ return NULL;
}
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_MUX,
- mux_type_str,
- &telement);
+ CONFIGURE_CATEGORY_MAIN_MUX,
+ mux_type_str,
+ &telement);
return telement;
}
_mmcam_dbg_log("type:%d", type);
- switch(type)
- {
- case MM_CAM_AUDIO_ENCODER:
- telement = __mmcamcorder_get_audio_codec_element(handle);
- break;
- case MM_CAM_VIDEO_ENCODER:
- telement = __mmcamcorder_get_video_codec_element(handle);
- break;
- case MM_CAM_IMAGE_ENCODER:
- telement = __mmcamcorder_get_image_codec_element(handle);
- break;
- case MM_CAM_FILE_FORMAT:
- telement = __mmcamcorder_get_file_format_element(handle);
- break;
- default :
- _mmcam_dbg_log("Can't get element type form this profile.(%d)", type);
+ switch (type) {
+ case MM_CAM_AUDIO_ENCODER:
+ telement = __mmcamcorder_get_audio_codec_element(handle);
+ break;
+ case MM_CAM_VIDEO_ENCODER:
+ telement = __mmcamcorder_get_video_codec_element(handle);
+ break;
+ case MM_CAM_IMAGE_ENCODER:
+ telement = __mmcamcorder_get_image_codec_element(handle);
+ break;
+ case MM_CAM_FILE_FORMAT:
+ telement = __mmcamcorder_get_file_format_element(handle);
+ break;
+ default:
+ _mmcam_dbg_log("Can't get element type form this profile.(%d)", type);
}
return telement;
mux_index = MM_FILE_FORMAT_MATROSKA;
} else if (!strcmp(name, "M2TS")) {
mux_index = MM_FILE_FORMAT_M2TS;
-
}
/*_mmcam_dbg_log("mux index %d", mux_index);*/
mmf_return_val_if_fail(name, -1);
- switch(conf_category)
- {
- case CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER:
- fmt = _mmcamcorder_get_audio_codec_format(handle, name);
- break;
- case CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER:
- fmt = _mmcamcorder_get_video_codec_format(handle, name);
- break;
- case CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER:
- fmt = _mmcamcorder_get_image_codec_format(handle, name);
- break;
- case CONFIGURE_CATEGORY_MAIN_MUX:
- fmt = _mmcamcorder_get_mux_format(handle, name);
- break;
- default :
- _mmcam_dbg_log("Can't get format from this category.(%d)", conf_category);
+ switch (conf_category) {
+ case CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER:
+ fmt = _mmcamcorder_get_audio_codec_format(handle, name);
+ break;
+ case CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER:
+ fmt = _mmcamcorder_get_video_codec_format(handle, name);
+ break;
+ case CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER:
+ fmt = _mmcamcorder_get_image_codec_format(handle, name);
+ break;
+ case CONFIGURE_CATEGORY_MAIN_MUX:
+ fmt = _mmcamcorder_get_mux_format(handle, name);
+ break;
+ default:
+ _mmcam_dbg_log("Can't get format from this category.(%d)", conf_category);
}
return fmt;
int
_mmcamcorder_get_available_format(MMHandleType handle, int conf_category, int ** format)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
camera_conf* configure_info = NULL;
int *arr = NULL;
int total_count = 0;
/*_mmcam_dbg_log("count[%d], info[%p]", count, info);*/
- if (count <= 0 || !info) {
+ if (count <= 0 || !info)
return total_count;
- }
arr = (int*) g_malloc0(count * sizeof(int));
if (arr == NULL) {
}
for (i = 0 ; i < count ; i++) {
- if (info->detail_info[i] == NULL) {
+ if (info->detail_info[i] == NULL)
continue;
- }
name = ((type_element*)(info->detail_info[i]))->name;
fmt = _mmcamcorder_get_format(handle, conf_category, name);
- if (fmt >= 0) {
+ if (fmt >= 0)
arr[total_count++] = fmt;
- }
/*_mmcam_dbg_log("name:%s, fmt:%d", name, fmt);*/
}
*/
#include <string.h>
#define _EXIF_BIN_SIZE_ ((unsigned int)174)
-unsigned char g_exif_bin [_EXIF_BIN_SIZE_] = {
- 0x45 , 0x78 , 0x69 , 0x66 , 0x00 , 0x00 , 0x49 , 0x49 , 0x2a , 0x00 , 0x08 , 0x00 , 0x00 , 0x00 , 0x05 , 0x00
- , 0x1a , 0x01 , 0x05 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x4a , 0x00 , 0x00 , 0x00 , 0x1b , 0x01 , 0x05 , 0x00
- , 0x01 , 0x00 , 0x00 , 0x00 , 0x52 , 0x00 , 0x00 , 0x00 , 0x28 , 0x01 , 0x03 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00
- , 0x02 , 0x00 , 0x00 , 0x00 , 0x13 , 0x02 , 0x03 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00
- , 0x69 , 0x87 , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x5a , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
- , 0x48 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x48 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00
- , 0x06 , 0x00 , 0x00 , 0x90 , 0x07 , 0x00 , 0x04 , 0x00 , 0x00 , 0x00 , 0x30 , 0x32 , 0x31 , 0x30 , 0x01 , 0x91
- , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0xa0 , 0x07 , 0x00 , 0x04 , 0x00
- , 0x00 , 0x00 , 0x30 , 0x31 , 0x30 , 0x30 , 0x01 , 0xa0 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
- , 0x00 , 0x00 , 0x02 , 0xa0 , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x03 , 0xa0
- , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
+unsigned char g_exif_bin[_EXIF_BIN_SIZE_] = {
+ 0x45 , 0x78 , 0x69 , 0x66 , 0x00 , 0x00 , 0x49 , 0x49 , 0x2a , 0x00 , 0x08 , 0x00 , 0x00 , 0x00 , 0x05 , 0x00 ,
+ 0x1a , 0x01 , 0x05 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x4a , 0x00 , 0x00 , 0x00 , 0x1b , 0x01 , 0x05 , 0x00 ,
+ 0x01 , 0x00 , 0x00 , 0x00 , 0x52 , 0x00 , 0x00 , 0x00 , 0x28 , 0x01 , 0x03 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 ,
+ 0x02 , 0x00 , 0x00 , 0x00 , 0x13 , 0x02 , 0x03 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 ,
+ 0x69 , 0x87 , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x5a , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 ,
+ 0x48 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x48 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 ,
+ 0x06 , 0x00 , 0x00 , 0x90 , 0x07 , 0x00 , 0x04 , 0x00 , 0x00 , 0x00 , 0x30 , 0x32 , 0x31 , 0x30 , 0x01 , 0x91 ,
+ 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0xa0 , 0x07 , 0x00 , 0x04 , 0x00 ,
+ 0x00 , 0x00 , 0x30 , 0x31 , 0x30 , 0x30 , 0x01 , 0xa0 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 ,
+ 0x00 , 0x00 , 0x02 , 0xa0 , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x03 , 0xa0 ,
+ 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
};
#endif
/**
* Structure for exif entry.
*/
-typedef struct _mm_exif_entry_t
-{
+typedef struct _mm_exif_entry_t {
ExifTag tag; /**< exif tag*/
ExifFormat format; /**< exif format*/
unsigned long components; /**< number of components*/
* local functions.
*/
static void
-_exif_set_uint16 (int is_motorola, void * out, unsigned short in)
+_exif_set_uint16(int is_motorola, void * out, unsigned short in)
{
if (is_motorola) {
((unsigned char *)out)[0] = in & 0x00ff;
#ifdef _MMCAMCORDER_EXIF_GET_JPEG_MARKER_OFFSET
static unsigned long
-_exif_get_jpeg_marker_offset (void *jpeg, int jpeg_size, unsigned short marker)
+_exif_get_jpeg_marker_offset(void *jpeg, int jpeg_size, unsigned short marker)
{
- unsigned char *p = NULL;
- unsigned char *src = jpeg;
- int src_sz = jpeg_size;
- unsigned char m[2];
- unsigned long ret;
+ unsigned char *p = NULL;
+ unsigned char *src = jpeg;
+ int src_sz = jpeg_size;
+ unsigned char m[2];
+ unsigned long ret;
int i;
m[0] = marker >> 8;
_mmcam_dbg_log("marker: 0x%02X 0x%02X", m[0], m[1]);
- if (*src == 0xff && *(src + 1) == 0xd8)
- {
+ if (*src == 0xff && *(src + 1) == 0xd8) {
p = src + 2; /* SOI(start of image) */
- }
- else
- {
+ } else {
_mmcam_dbg_log("invalid JPEG file.");
return 0UL;
}
- for (i = 0; i < src_sz - (1 + 2); i++, p++)
- {
- if (*p == 0xff)
- {
+ for (i = 0; i < src_sz - (1 + 2); i++, p++) {
+ if (*p == 0xff) {
/*marker is 0xFFxx*/
- if (*(p + 1) == m[1])
- {
+ if (*(p + 1) == m[1]) {
ret = p - src;
- _mmcam_dbg_log("marker offset: %lu %p %p.",ret, (p+1), src);
+ _mmcam_dbg_log("marker offset: %lu %p %p.", ret, (p+1), src);
return ret;
}
}
ExifData*
-mm_exif_get_exif_data_from_data (mm_exif_info_t *info)
+mm_exif_get_exif_data_from_data(mm_exif_info_t *info)
{
- ExifData *ed = NULL;
+ ExifData *ed = NULL;
ed = exif_data_new_from_data(info->data, info->size);
- if( ed == NULL )
- {
+ if (ed == NULL)
_mmcam_dbg_log("Null exif data. (ed:%p)", ed);
- }
return ed;
}
ExifData*
-mm_exif_get_exif_from_info (mm_exif_info_t *info)
+mm_exif_get_exif_from_info(mm_exif_info_t *info)
{
- ExifData *ed = NULL;
- ExifLoader *loader = NULL;
+ ExifData *ed = NULL;
+ ExifLoader *loader = NULL;
- unsigned char size[2];
- unsigned int i;
+ unsigned char size[2];
+ unsigned int i;
/*get ExifData from info*/
- loader = exif_loader_new ();
+ loader = exif_loader_new();
size[0] = (unsigned char) (info->size);
size[1] = (unsigned char) (info->size >> 8);
- exif_loader_write (loader, size, 2);
+ exif_loader_write(loader, size, 2);
- for (i = 0; i < info->size && exif_loader_write (loader, info->data + i, 1); i++);
+ for (i = 0; i < info->size && exif_loader_write(loader, info->data + i, 1); i++);
- ed = exif_loader_get_data (loader);
- exif_loader_unref (loader);
+ ed = exif_loader_get_data(loader);
+ exif_loader_unref(loader);
return ed;
}
int
-mm_exif_set_exif_to_info (mm_exif_info_t *info, ExifData *exif)
+mm_exif_set_exif_to_info(mm_exif_info_t *info, ExifData *exif)
{
- unsigned char *eb = NULL;
- unsigned int ebs;
+ unsigned char *eb = NULL;
+ unsigned int ebs;
- if (!exif)
- {
+ if (!exif) {
_mmcam_dbg_log("exif Null");
return MM_ERROR_CAMCORDER_NOT_INITIALIZED;
}
_mmcam_dbg_log("exif(ifd :%p)", exif->ifd);
- if(info->data)
- {
- free (info->data);
+ if (info->data) {
+ free(info->data);
info->data = NULL;
info->size = 0;
}
- exif_data_save_data (exif, &eb, &ebs);
- if(eb==NULL)
- {
+ exif_data_save_data(exif, &eb, &ebs);
+ if (eb == NULL) {
_mmcam_dbg_log("MM_ERROR_CAMCORDER_LOW_MEMORY");
return MM_ERROR_CAMCORDER_LOW_MEMORY;
}
int
-mm_exif_set_add_entry (ExifData *exif, ExifIfd ifd, ExifTag tag,ExifFormat format,unsigned long components, const char* data)
+mm_exif_set_add_entry(ExifData *exif, ExifIfd ifd, ExifTag tag, ExifFormat format, unsigned long components, const char* data)
{
ExifData *ed = (ExifData *)exif;
ExifEntry *e = NULL;
if (exif == NULL || format <= 0 || components <= 0 || data == NULL) {
_mmcam_dbg_err("invalid argument exif=%p format=%d, components=%lu data=%p!",
- exif,format,components,data);
+ exif, format, components, data);
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
return MM_ERROR_CAMCORDER_LOW_MEMORY;
}
- if (format == EXIF_FORMAT_ASCII) {
+ if (format == EXIF_FORMAT_ASCII)
memset(e->data, '\0', exif_format_get_size(format) * e->components);
- }
}
e->size = exif_format_get_size(format) * e->components;
- memcpy(e->data,data,e->size);
+ memcpy(e->data, data, e->size);
exif_content_add_entry(ed->ifd[ifd], e);
exif_entry_unref(e);
int
-mm_exif_create_exif_info (mm_exif_info_t **info)
+mm_exif_create_exif_info(mm_exif_info_t **info)
{
mm_exif_info_t *x = NULL;
#if (MM_EXIFINFO_USE_BINARY_EXIFDATA == 0)
}
void
-mm_exif_destory_exif_info (mm_exif_info_t *info)
+mm_exif_destory_exif_info(mm_exif_info_t *info)
{
- //_mmcam_dbg_log( "");
+ /* _mmcam_dbg_log( ""); */
#if MM_EXIFINFO_USE_BINARY_EXIFDATA
if (info) {
if (info->data)
- free (info->data);
- free (info);
+ free(info->data);
+ free(info);
}
#else
if (info) {
if (info->data)
- exif_mem_free (info->data);
- free (info);
+ exif_mem_free(info->data);
+ free(info);
}
#endif
}
int
-mm_exif_add_thumbnail_info (mm_exif_info_t *info, void *thumbnail, int width, int height, int len)
+mm_exif_add_thumbnail_info(mm_exif_info_t *info, void *thumbnail, int width, int height, int len)
{
ExifData *ed = NULL;
static ExifLong elong[10];
_mmcam_dbg_log("Thumbnail size:%d, width:%d, height:%d", len, width, height);
- if( len > JPEG_THUMBNAIL_MAX_SIZE )
- {
+ if (len > JPEG_THUMBNAIL_MAX_SIZE) {
_mmcam_dbg_err("Thumbnail size[%d] over!!! Skip inserting thumbnail...", len);
return MM_ERROR_NONE;
}
if (p_compressed != NULL) {
exif_set_short(p_compressed, exif_data_get_byte_order(ed), 6);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_1, EXIF_TAG_COMPRESSION, EXIF_FORMAT_SHORT, 1, (const char *)p_compressed);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto exit;
- }
} else {
ret = MM_ERROR_CAMCORDER_LOW_MEMORY;
goto exit;
}
/* set thumbnail size */
- exif_set_long ((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), width);
+ exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), width);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_1, EXIF_TAG_IMAGE_WIDTH, EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto exit;
- }
- exif_set_long ((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), height);
+
+ exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), height);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_1, EXIF_TAG_IMAGE_LENGTH, EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto exit;
- }
- ret = mm_exif_set_exif_to_info (info, ed);
- if (ret != MM_ERROR_NONE) {
+ ret = mm_exif_set_exif_to_info(info, ed);
+ if (ret != MM_ERROR_NONE)
goto exit;
- }
ed->data = NULL;
ed->size = 0;
- exif_data_unref (ed);
+ exif_data_unref(ed);
-exit :
- if(p_compressed != NULL)
+exit:
+ if (p_compressed != NULL)
free(p_compressed);
+
return ret;
}
int
-mm_exif_write_exif_jpeg_to_file (char *filename, mm_exif_info_t *info, void *jpeg, int jpeg_len)
+mm_exif_write_exif_jpeg_to_file(char *filename, mm_exif_info_t *info, void *jpeg, int jpeg_len)
{
FILE *fp = NULL;
unsigned short head[2] = {0,};
ebs = info->size;
/*create file*/
- fp = fopen (filename, "wb");
+ fp = fopen(filename, "wb");
if (!fp) {
- _mmcam_dbg_err( "fopen() failed [%s].", filename);
+ _mmcam_dbg_err("fopen() failed [%s].", filename);
return MM_ERROR_IMAGE_FILEOPEN;
}
/*set SOI, APP1*/
- _exif_set_uint16 (0, &head[0], 0xffd8);
- _exif_set_uint16 (0, &head[1], 0xffe1);
+ _exif_set_uint16(0, &head[0], 0xffd8);
+ _exif_set_uint16(0, &head[1], 0xffe1);
/*set header length*/
- _exif_set_uint16 (0, &head_len, (unsigned short)(ebs + 2));
+ _exif_set_uint16(0, &head_len, (unsigned short)(ebs + 2));
- if(head[0]==0 || head[1]==0 || head_len==0)
- {
+ if (head[0] == 0 || head[1] == 0 || head_len == 0) {
_mmcam_dbg_err("setting error");
- fclose (fp);
+ fclose(fp);
return -1;
}
- fwrite (&head[0], 1, EXIF_MARKER_SOI_LENGTH, fp); /*SOI marker*/
- fwrite (&head[1], 1, EXIF_MARKER_APP1_LENGTH, fp); /*APP1 marker*/
- fwrite (&head_len, 1, EXIF_APP1_LENGTH, fp); /*length of APP1*/
- fwrite (eb, 1, ebs, fp); /*EXIF*/
- fwrite (jpeg + JPEG_DATA_OFFSET, 1, jpeg_len - JPEG_DATA_OFFSET, fp); /*IMAGE*/
+ fwrite(&head[0], 1, EXIF_MARKER_SOI_LENGTH, fp); /*SOI marker*/
+ fwrite(&head[1], 1, EXIF_MARKER_APP1_LENGTH, fp); /*APP1 marker*/
+ fwrite(&head_len, 1, EXIF_APP1_LENGTH, fp); /*length of APP1*/
+ fwrite(eb, 1, ebs, fp); /*EXIF*/
+ fwrite(jpeg + JPEG_DATA_OFFSET, 1, jpeg_len - JPEG_DATA_OFFSET, fp); /*IMAGE*/
- fclose (fp);
+ fclose(fp);
return MM_ERROR_NONE;
}
int
-mm_exif_write_exif_jpeg_to_memory (void **mem, unsigned int *length, mm_exif_info_t *info, void *jpeg, unsigned int jpeg_len)
+mm_exif_write_exif_jpeg_to_memory(void **mem, unsigned int *length, mm_exif_info_t *info, void *jpeg, unsigned int jpeg_len)
{
unsigned short head[2] = {0,};
unsigned short head_len = 0;
_mmcam_dbg_log("");
- if(info==NULL || jpeg==NULL)
- {
- _mmcam_dbg_err( "MM_ERROR_CAMCORDER_INVALID_ARGUMENT info=%p, jpeg=%p",info,jpeg);
+ if (info == NULL || jpeg == NULL) {
+ _mmcam_dbg_err("MM_ERROR_CAMCORDER_INVALID_ARGUMENT info=%p, jpeg=%p", info, jpeg);
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
- if(jpeg_len>JPEG_MAX_SIZE)
- {
- _mmcam_dbg_err( "jpeg_len is worng jpeg_len=%d",jpeg_len);
+ if (jpeg_len > JPEG_MAX_SIZE) {
+ _mmcam_dbg_err("jpeg_len is worng jpeg_len=%d", jpeg_len);
return MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG;
}
/*SOI + APP1 + length of APP1 + length of EXIF + IMAGE*/
m_len = EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH + ebs + (jpeg_len - jpeg_offset);
/*alloc output image*/
- m = malloc (m_len);
+ m = malloc(m_len);
if (!m) {
- _mmcam_dbg_err( "malloc() failed.");
+ _mmcam_dbg_err("malloc() failed.");
return MM_ERROR_CAMCORDER_LOW_MEMORY;
}
/*set SOI, APP1*/
- _exif_set_uint16 (0, &head[0], 0xffd8);
- _exif_set_uint16 (0, &head[1], 0xffe1);
+ _exif_set_uint16(0, &head[0], 0xffd8);
+ _exif_set_uint16(0, &head[1], 0xffe1);
/*set header length*/
- _exif_set_uint16 (0, &head_len, (unsigned short)(ebs + 2));
+ _exif_set_uint16(0, &head_len, (unsigned short)(ebs + 2));
if (head[0] == 0 || head[1] == 0 || head_len == 0) {
_mmcam_dbg_err("setting error");
free(m);
/* Complete JPEG+EXIF */
/*SOI marker*/
memcpy(m, &head[0], EXIF_MARKER_SOI_LENGTH);
+
/*APP1 marker*/
- memcpy(m + EXIF_MARKER_SOI_LENGTH,
- &head[1], EXIF_MARKER_APP1_LENGTH);
+ memcpy(m + EXIF_MARKER_SOI_LENGTH, &head[1], EXIF_MARKER_APP1_LENGTH);
+
/*length of APP1*/
- memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH,
- &head_len, EXIF_APP1_LENGTH);
+ memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH, &head_len, EXIF_APP1_LENGTH);
+
/*EXIF*/
- memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH,
- eb, ebs);
+ memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH, eb, ebs);
+
/*IMAGE*/
memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH + ebs,
- jpeg + jpeg_offset, jpeg_len - jpeg_offset);
+ jpeg + jpeg_offset, jpeg_len - jpeg_offset);
_mmcam_dbg_log("JPEG+EXIF Copy DONE(original:%d, offset:%d, copied:%d)",
- jpeg_len, jpeg_offset, jpeg_len - jpeg_offset);
+ jpeg_len, jpeg_offset, jpeg_len - jpeg_offset);
/*set ouput param*/
- *mem = m;
+ *mem = m;
*length = m_len;
return MM_ERROR_NONE;
const unsigned char *b = NULL;
unsigned int s = 0;
mm_exif_info_t *x = NULL;
- // TODO : get exif and re-set exif
+
+ /* TODO : get exif and re-set exif */
+
loader = exif_loader_new();
if (loader) {
- exif_loader_write (loader, jpeg_data, jpeg_length);
- exif_loader_get_buf (loader, &b, &s);
+ exif_loader_write(loader, jpeg_data, jpeg_length);
+ exif_loader_get_buf(loader, &b, &s);
if (s > 0) {
x = malloc(sizeof(mm_exif_info_t));
if (x) {
_mmcam_dbg_err("mm_exif_info_t malloc failed");
free(x);
exif_loader_unref(loader);
+
return MM_ERROR_CAMCORDER_LOW_MEMORY;
}
} else {
_mmcam_dbg_err("exif_loader_new failed");
}
- if (x) {
+ if (x)
return MM_ERROR_NONE;
- } else {
+ else
return MM_ERROR_CAMCORDER_INTERNAL;
- }
}
| GLOBAL VARIABLE DEFINITIONS for internal |
-----------------------------------------------------------------------*/
/* Table for compatibility between audio codec and file format */
-gboolean audiocodec_fileformat_compatibility_table[MM_AUDIO_CODEC_NUM][MM_FILE_FORMAT_NUM] =
-{ /* 3GP ASF AVI MATROSKA MP4 OGG NUT QT REAL AMR AAC MP3 AIFF AU WAV MID MMF DIVX FLV VOB IMELODY WMA WMV JPG FLAC M2TS*/
+gboolean audiocodec_fileformat_compatibility_table[MM_AUDIO_CODEC_NUM][MM_FILE_FORMAT_NUM] = {
+ /* 3GP ASF AVI MATROSKA MP4 OGG NUT QT REAL AMR AAC MP3 AIFF AU WAV MID MMF DIVX FLV VOB IMELODY WMA WMV JPG FLAC M2TS*/
/*AMR*/ { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
/*G723.1*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
/*MP3*/ { 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1},
};
/* Table for compatibility between video codec and file format */
-gboolean videocodec_fileformat_compatibility_table[MM_VIDEO_CODEC_NUM][MM_FILE_FORMAT_NUM] =
-{ /* 3GP ASF AVI MATROSKA MP4 OGG NUT QT REAL AMR AAC MP3 AIFF AU WAV MID MMF DIVX FLV VOB IMELODY WMA WMV JPG FLAC M2TS*/
+gboolean videocodec_fileformat_compatibility_table[MM_VIDEO_CODEC_NUM][MM_FILE_FORMAT_NUM] = {
+ /* 3GP ASF AVI MATROSKA MP4 OGG NUT QT REAL AMR AAC MP3 AIFF AU WAV MID MMF DIVX FLV VOB IMELODY WMA WMV JPG FLAC M2TS*/
/*NONE*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
/*H263*/ { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
/*H264*/ { 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
/* Check existence */
for (i = _MMCAMCORDER_VIDEOSRC_SRC ; i <= _MMCAMCORDER_VIDEOSINK_SINK ; i++) {
if (sc->element[i].gst) {
- if (((GObject *)sc->element[i].gst)->ref_count > 0) {
+ if (((GObject *)sc->element[i].gst)->ref_count > 0)
gst_object_unref(sc->element[i].gst);
- }
+
_mmcam_dbg_log("element[index:%d] is Already existed.", i);
}
}
/* Get video device index info */
_mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "InputIndex",
- &input_index);
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "InputIndex",
+ &input_index);
if (input_index == NULL) {
_mmcam_dbg_err("Failed to get input_index");
return MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
}
err = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_CAMERA_WIDTH, &camera_width,
- MMCAM_CAMERA_HEIGHT, &camera_height,
- MMCAM_CAMERA_FORMAT, &sc->info_image->preview_format,
- MMCAM_CAMERA_FPS, &fps,
- MMCAM_CAMERA_ROTATION, &camera_rotate,
- MMCAM_CAMERA_FLIP, &camera_flip,
- MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization,
- MMCAM_CAMERA_ANTI_HANDSHAKE, &anti_shake,
- MMCAM_CAPTURE_WIDTH, &capture_width,
- MMCAM_CAPTURE_HEIGHT, &capture_height,
- MMCAM_CAMERA_HDR_CAPTURE, &sc->info_image->hdr_capture_mode,
- MMCAM_IMAGE_ENCODER, &codectype,
- MMCAM_IMAGE_ENCODER_QUALITY, &capture_jpg_quality,
- MMCAM_DISPLAY_SOCKET_PATH, &socket_path, &socket_path_len,
- MMCAM_DISPLAY_SURFACE, &display_surface_type,
- NULL);
+ MMCAM_CAMERA_WIDTH, &camera_width,
+ MMCAM_CAMERA_HEIGHT, &camera_height,
+ MMCAM_CAMERA_FORMAT, &sc->info_image->preview_format,
+ MMCAM_CAMERA_FPS, &fps,
+ MMCAM_CAMERA_ROTATION, &camera_rotate,
+ MMCAM_CAMERA_FLIP, &camera_flip,
+ MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization,
+ MMCAM_CAMERA_ANTI_HANDSHAKE, &anti_shake,
+ MMCAM_CAPTURE_WIDTH, &capture_width,
+ MMCAM_CAPTURE_HEIGHT, &capture_height,
+ MMCAM_CAMERA_HDR_CAPTURE, &sc->info_image->hdr_capture_mode,
+ MMCAM_IMAGE_ENCODER, &codectype,
+ MMCAM_IMAGE_ENCODER_QUALITY, &capture_jpg_quality,
+ MMCAM_DISPLAY_SOCKET_PATH, &socket_path, &socket_path_len,
+ MMCAM_DISPLAY_SURFACE, &display_surface_type,
+ NULL);
if (err != MM_ERROR_NONE) {
_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
SAFE_FREE(err_name);
/* Get videosrc element and its name from configure */
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "VideosrcElement",
- &VideosrcElement);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "VideosrcElement",
+ &VideosrcElement);
_mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
/**
/* set anti handshake mode */
_mmcamcorder_set_videosrc_anti_shake(handle, anti_shake);
- if (sc->is_modified_rate) {
+ if (sc->is_modified_rate)
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", fps);
- }
/* Set basic infomation of videosrc element */
_mmcamcorder_conf_set_value_element_property(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, VideosrcElement);
/* link elements */
if (!_mmcamcorder_link_elements(element_list)) {
- _mmcam_dbg_err( "element link error." );
+ _mmcam_dbg_err("element link error.");
err = MM_ERROR_CAMCORDER_GST_LINK;
goto pipeline_creation_error;
}
_mmcam_dbg_log("");
err = _mmcamcorder_check_audiocodec_fileformat_compatibility(handle);
- if (err != MM_ERROR_NONE) {
+ if (err != MM_ERROR_NONE)
return err;
- }
err = mm_camcorder_get_attributes(handle, &err_name,
MMCAM_AUDIO_DEVICE, &a_dev,
/* Check existence */
if (sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst) {
- if (((GObject *)sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst)->ref_count > 0) {
+ if (((GObject *)sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst)->ref_count > 0)
gst_object_unref(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst);
- }
+
_mmcam_dbg_log("_MMCAMCORDER_AUDIOSRC_BIN is Already existed. Unref once...");
}
}
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT,
- cat_name,
- &AudiosrcElement);
+ CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT,
+ cat_name,
+ &AudiosrcElement);
_mmcamcorder_conf_get_value_element_name(AudiosrcElement, &audiosrc_name);
free(cat_name);
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_QUE].gst, "max-size-bytes", 0);
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_QUE].gst, "max-size-time", 0);
- if (a_enc != MM_AUDIO_CODEC_VORBIS) {
+ if (a_enc != MM_AUDIO_CODEC_VORBIS)
_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_AUDIOSRC_VOL, "volume", "audiosrc_volume", element_list, err);
- }
/* Set basic infomation */
if (a_enc != MM_AUDIO_CODEC_VORBIS) {
}
caps = gst_caps_new_simple("audio/x-raw",
- "rate", G_TYPE_INT, rate,
- "channels", G_TYPE_INT, channel,
- "format", G_TYPE_STRING, format_name,
- NULL);
+ "rate", G_TYPE_INT, rate,
+ "channels", G_TYPE_INT, channel,
+ "format", G_TYPE_STRING, format_name,
+ NULL);
_mmcam_dbg_log("caps [x-raw, rate:%d, channel:%d, depth:%d], volume %lf",
- rate, channel, depth, volume);
+ rate, channel, depth, volume);
} else {
/* what are the audio encoder which should get audio/x-raw-float? */
caps = gst_caps_new_simple("audio/x-raw",
- "rate", G_TYPE_INT, rate,
- "channels", G_TYPE_INT, channel,
- "format", G_TYPE_STRING, GST_AUDIO_NE(F32),
- NULL);
+ "rate", G_TYPE_INT, rate,
+ "channels", G_TYPE_INT, channel,
+ "format", G_TYPE_STRING, GST_AUDIO_NE(F32),
+ NULL);
_mmcam_dbg_log("caps [x-raw (F32), rate:%d, channel:%d, endianness:%d, width:32]",
- rate, channel, BYTE_ORDER);
+ rate, channel, BYTE_ORDER);
}
if (caps) {
/* Check existence */
if (sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst) {
- if (((GObject *)sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst)->ref_count > 0) {
+ if (((GObject *)sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst)->ref_count > 0)
gst_object_unref(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst);
- }
+
_mmcam_dbg_log("_MMCAMCORDER_ENCSINK_BIN is Already existed.");
}
if (profile == MM_CAMCORDER_ENCBIN_PROFILE_VIDEO) {
gst_caps_set_simple(video_caps,
- "width", G_TYPE_INT, sc->info_video->video_width,
- "height", G_TYPE_INT, sc->info_video->video_height,
- NULL);
+ "width", G_TYPE_INT, sc->info_video->video_width,
+ "height", G_TYPE_INT, sc->info_video->video_height,
+ NULL);
}
caps_str = gst_caps_to_string(video_caps);
/* connect signal for ready to push buffer */
MMCAMCORDER_SIGNAL_CONNECT(sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst,
- _MMCAMCORDER_HANDLER_VIDEOREC,
- "need-data",
- _mmcamcorder_ready_to_encode_callback,
- hcamcorder);
+ _MMCAMCORDER_HANDLER_VIDEOREC,
+ "need-data",
+ _mmcamcorder_ready_to_encode_callback,
+ hcamcorder);
}
_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_ENCBIN, "encodebin", "encodesink_encbin", element_list, err);
/* check element availability */
err = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_AUDIO_ENCODER, &audio_enc,
- MMCAM_AUDIO_CHANNEL, &channel,
- MMCAM_VIDEO_ENCODER_BITRATE, &v_bitrate,
- MMCAM_AUDIO_ENCODER_BITRATE, &a_bitrate,
- NULL);
+ MMCAM_AUDIO_ENCODER, &audio_enc,
+ MMCAM_AUDIO_CHANNEL, &channel,
+ MMCAM_VIDEO_ENCODER_BITRATE, &v_bitrate,
+ MMCAM_AUDIO_ENCODER_BITRATE, &a_bitrate,
+ NULL);
if (err != MM_ERROR_NONE) {
if (err_name) {
_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main, CONFIGURE_CATEGORY_MAIN_RECORD, str_acs, &auto_color_space);
_mmcam_dbg_log("Profile:%d, AutoAudioConvert:%d, AutoAudioResample:%d, AutoColorSpace:%d",
- encodebin_profile, auto_audio_convert, auto_audio_resample, auto_color_space);
+ encodebin_profile, auto_audio_convert, auto_audio_resample, auto_color_space);
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "profile", encodebin_profile);
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "auto-audio-convert", auto_audio_convert);
goto pipeline_creation_error;
}
- if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+ if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264)
gst_element_venc_name = "capsfilter";
- } else {
+ else
_mmcamcorder_conf_get_value_element_name(VideoencElement, &gst_element_venc_name);
- }
if (gst_element_venc_name) {
_mmcam_dbg_log("video encoder name [%s]", gst_element_venc_name);
/* fourcc type was removed in GST 1.0 */
if (hcamcorder->use_zero_copy_format) {
- if(strstr(gst_element_venc_name, "omx")) {
- video_caps = gst_caps_new_simple("video/x-raw",
- "format", G_TYPE_STRING, "SN12",
- NULL);
+ if (strstr(gst_element_venc_name, "omx")) {
+ video_caps = gst_caps_new_simple("video/x-raw", "format", G_TYPE_STRING, "SN12", NULL);
if (video_caps) {
MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "vcaps", video_caps);
_mmcam_dbg_warn("failed to create caps");
}
} else {
- _mmcam_dbg_log("current video codec is not openmax but [%s]",gst_element_venc_name);
+ _mmcam_dbg_log("current video codec is not openmax but [%s]", gst_element_venc_name);
}
}
}
_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_RECORD,
- "UseVideoEncoderQueue",
- &use_venc_queue);
- if (use_venc_queue) {
+ CONFIGURE_CATEGORY_MAIN_RECORD,
+ "UseVideoEncoderQueue",
+ &use_venc_queue);
+ if (use_venc_queue)
_MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_VENC_QUE, "use-venc-queue", err);
- }
}
if (sc->audio_disable == FALSE &&
profile != MM_CAMCORDER_ENCBIN_PROFILE_IMAGE) {
- int use_aenc_queue =0;
+ int use_aenc_queue = 0;
AudioencElement = _mmcamcorder_get_type_element(handle, MM_CAM_AUDIO_ENCODER);
if (!AudioencElement) {
if (audio_enc == MM_AUDIO_CODEC_AMR && channel == 2) {
audio_caps = gst_caps_new_simple("audio/x-raw",
- "channels", G_TYPE_INT, 1,
- NULL);
+ "channels", G_TYPE_INT, 1,
+ NULL);
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "auto-audio-convert", TRUE);
MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "acaps", audio_caps);
gst_caps_unref(audio_caps);
}
_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_RECORD,
- "UseAudioEncoderQueue",
- &use_aenc_queue);
+ CONFIGURE_CATEGORY_MAIN_RECORD,
+ "UseAudioEncoderQueue",
+ &use_aenc_queue);
if (use_aenc_queue) {
_MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_AENC_QUE, "use-aenc-queue", err);
- MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst,"max-size-time", 0);
- MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst,"max-size-buffers", 0);
+ MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst, "max-size-time", 0);
+ MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst, "max-size-buffers", 0);
}
}
if (profile != MM_CAMCORDER_ENCBIN_PROFILE_IMAGE) {
/* for recording */
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_RECORD,
- "RecordsinkElement",
- &RecordsinkElement );
+ CONFIGURE_CATEGORY_MAIN_RECORD,
+ "RecordsinkElement",
+ &RecordsinkElement);
_mmcamcorder_conf_get_value_element_name(RecordsinkElement, &gst_element_rsink_name);
_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_SINK, gst_element_rsink_name, NULL, element_list, err);
return MM_ERROR_NONE;
-pipeline_creation_error :
+pipeline_creation_error:
_mmcamcorder_remove_all_handlers(handle, _MMCAMCORDER_HANDLER_VIDEOREC);
_MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCSINK_ENCBIN);
GstPad *srcpad = NULL;
GstBus *bus = NULL;
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
/* Sub pipeline */
err = _mmcamcorder_create_preview_elements((MMHandleType)hcamcorder);
- if (err != MM_ERROR_NONE) {
+ if (err != MM_ERROR_NONE)
goto pipeline_creation_error;
- }
/* Set data probe function */
if (sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst) {
if (srcpad) {
MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_PREVIEW,
- __mmcamcorder_video_dataprobe_preview, hcamcorder);
+ __mmcamcorder_video_dataprobe_preview, hcamcorder);
+
gst_object_unref(srcpad);
srcpad = NULL;
} else {
}
/* set dataprobe for video recording */
- if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+ if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264)
srcpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "src");
- } else {
+ else
srcpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "src");
- }
+
MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_PREVIEW,
- __mmcamcorder_video_dataprobe_push_buffer_to_record, hcamcorder);
+ __mmcamcorder_video_dataprobe_push_buffer_to_record, hcamcorder);
gst_object_unref(srcpad);
srcpad = NULL;
/* Get video display information */
err = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_DISPLAY_RECT_X, &retx,
- MMCAM_DISPLAY_RECT_Y, &rety,
- MMCAM_DISPLAY_RECT_WIDTH, &retwidth,
- MMCAM_DISPLAY_RECT_HEIGHT, &retheight,
- MMCAM_DISPLAY_ROTATION, &rotation,
- MMCAM_DISPLAY_FLIP, &flip,
- MMCAM_DISPLAY_VISIBLE, &visible,
- MMCAM_DISPLAY_HANDLE, (void**)&overlay, &size,
- MMCAM_DISPLAY_MODE, &display_mode,
- MMCAM_DISPLAY_GEOMETRY_METHOD, &display_geometry_method,
- MMCAM_DISPLAY_SCALE, &zoom_attr,
- MMCAM_DISPLAY_EVAS_DO_SCALING, &do_scaling,
- NULL);
+ MMCAM_DISPLAY_RECT_X, &retx,
+ MMCAM_DISPLAY_RECT_Y, &rety,
+ MMCAM_DISPLAY_RECT_WIDTH, &retwidth,
+ MMCAM_DISPLAY_RECT_HEIGHT, &retheight,
+ MMCAM_DISPLAY_ROTATION, &rotation,
+ MMCAM_DISPLAY_FLIP, &flip,
+ MMCAM_DISPLAY_VISIBLE, &visible,
+ MMCAM_DISPLAY_HANDLE, (void**)&overlay, &size,
+ MMCAM_DISPLAY_MODE, &display_mode,
+ MMCAM_DISPLAY_GEOMETRY_METHOD, &display_geometry_method,
+ MMCAM_DISPLAY_SCALE, &zoom_attr,
+ MMCAM_DISPLAY_EVAS_DO_SCALING, &do_scaling,
+ NULL);
if (err != MM_ERROR_NONE) {
if (err_name) {
_mmcam_dbg_err("failed to get attributes [%s][0x%x]", err_name, err);
MMCAMCORDER_G_OBJECT_SET(vsink, "device-scaler", display_scaler);
#endif /* _MMCAMCORDER_RM_SUPPORT */
- } else if (!strcmp(videosink_name, "evasimagesink") ||
- !strcmp(videosink_name, "evaspixmapsink")) {
+ } else if (!strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "evaspixmapsink")) {
_mmcam_dbg_log("videosink : %s, handle : %p", videosink_name, overlay);
+
if (overlay) {
MMCAMCORDER_G_OBJECT_SET_POINTER(vsink, "evas-object", overlay);
MMCAMCORDER_G_OBJECT_SET(vsink, "origin-size", !do_scaling);
}
} else if (!strcmp(videosink_name, "waylandsink")) {
MMCamWaylandInfo *wl_info = (MMCamWaylandInfo *)overlay;
+
if (wl_info) {
_mmcam_dbg_log("wayland global surface id : %d", wl_info->global_surface_id);
gst_video_overlay_set_wl_window_wl_surface_id(GST_VIDEO_OVERLAY(vsink), (guintptr)wl_info->global_surface_id);
}
_mmcam_dbg_log("%s set: display_geometry_method[%d],origin-size[%d],visible[%d],rotate[%d],flip[%d]",
- videosink_name, display_geometry_method, origin_size, visible, rotation, flip);
+ videosink_name, display_geometry_method, origin_size, visible, rotation, flip);
/* Set attribute */
if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink") ||
if (display_geometry_method == MM_DISPLAY_METHOD_CUSTOM_ROI) {
g_object_set(vsink,
- "dst-roi-x", retx,
- "dst-roi-y", rety,
- "dst-roi-w", retwidth,
- "dst-roi-h", retheight,
- NULL);
+ "dst-roi-x", retx,
+ "dst-roi-y", rety,
+ "dst-roi-w", retwidth,
+ "dst-roi-h", retheight,
+ NULL);
}
}
int _mmcamcorder_vframe_stablize(MMHandleType handle)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
_mmcam_dbg_log("%d", _MMCAMCORDER_CAMSTABLE_COUNT);
mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- if (sc->cam_stability_count != _MMCAMCORDER_CAMSTABLE_COUNT) {
+ if (sc->cam_stability_count != _MMCAMCORDER_CAMSTABLE_COUNT)
sc->cam_stability_count = _MMCAMCORDER_CAMSTABLE_COUNT;
- }
return MM_ERROR_NONE;
}
/* Exif related information */
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control != NULL) {
- gst_camera_control_get_exif_info(control, &exif_info); //get video input device information
+ gst_camera_control_get_exif_info(control, &exif_info); /* get video input device information */
if (exif_info.focal_len_denominator != 0)
focal_len = ((double)exif_info.focal_len_numerator) / ((double) exif_info.focal_len_denominator);
} else {
/* Set values to attributes */
err = mm_camcorder_set_attributes(handle, &err_name,
- MMCAM_CAMERA_FOCAL_LENGTH, focal_len,
- NULL);
+ MMCAM_CAMERA_FOCAL_LENGTH, focal_len,
+ NULL);
if (err != MM_ERROR_NONE) {
_mmcam_dbg_err("Set attributes error(%s:%x)!", err_name, err);
SAFE_FREE(err_name);
return FALSE;
}
} else {
- _mmcam_dbg_warn( "Sub context isn't exist.");
+ _mmcam_dbg_warn("Sub context isn't exist.");
return FALSE;
}
static guint32 _mmcamcorder_convert_fourcc_string_to_value(const gchar* format_name)
{
- return format_name[0] | (format_name[1] << 8) | (format_name[2] << 16) | (format_name[3] << 24);
+ return format_name[0] | (format_name[1] << 8) | (format_name[2] << 16) | (format_name[3] << 24);
}
static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
caps = gst_pad_get_current_caps(pad);
if (caps == NULL) {
- _mmcam_dbg_warn( "Caps is NULL." );
+ _mmcam_dbg_warn("Caps is NULL.");
return GST_PAD_PROBE_OK;
}
/* clear stream data structure */
memset(&stream, 0x0, sizeof(MMCamcorderVideoStreamDataType));
- structure = gst_caps_get_structure( caps, 0 );
+ structure = gst_caps_get_structure(caps, 0);
gst_structure_get_int(structure, "width", &(stream.width));
gst_structure_get_int(structure, "height", &(stream.height));
+
if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
stream.format = MM_PIXEL_FORMAT_ENCODED_H264;
} else {
_mmcam_dbg_warn("get string error!!");
return GST_PAD_PROBE_OK;
}
+
fourcc = _mmcamcorder_convert_fourcc_string_to_value(string_format);
stream.format = _mmcamcorder_get_pixtype(fourcc);
}
+
gst_caps_unref(caps);
caps = NULL;
/*
- _mmcam_dbg_log( "Call video steramCb, data[%p], Width[%d],Height[%d], Format[%d]",
- GST_BUFFER_DATA(buffer), stream.width, stream.height, stream.format );
+ _mmcam_dbg_log("Call video steramCb, data[%p], Width[%d],Height[%d], Format[%d]",
+ GST_BUFFER_DATA(buffer), stream.width, stream.height, stream.format);
*/
if (stream.width == 0 || stream.height == 0) {
stream.data.yuv420sp.length_uv = stream.data.yuv420sp.length_y >> 1;
/*
_mmcam_dbg_log("format[%d][num_planes:%d] [Y]p:0x%x,size:%d [UV]p:0x%x,size:%d",
- stream.format, stream.num_planes,
- stream.data.yuv420sp.y, stream.data.yuv420sp.length_y,
- stream.data.yuv420sp.uv, stream.data.yuv420sp.length_uv);
+ stream.format, stream.num_planes,
+ stream.data.yuv420sp.y, stream.data.yuv420sp.length_y,
+ stream.data.yuv420sp.uv, stream.data.yuv420sp.length_uv);
*/
} else {
stream.data_type = MM_CAM_STREAM_DATA_YUV420P;
stream.data.yuv420p.length_v = stream.data.yuv420p.length_u;
/*
_mmcam_dbg_log("S420[num_planes:%d] [Y]p:0x%x,size:%d [U]p:0x%x,size:%d [V]p:0x%x,size:%d",
- stream.num_planes,
- stream.data.yuv420p.y, stream.data.yuv420p.length_y,
- stream.data.yuv420p.u, stream.data.yuv420p.length_u,
- stream.data.yuv420p.v, stream.data.yuv420p.length_v);
+ stream.num_planes,
+ stream.data.yuv420p.y, stream.data.yuv420p.length_y,
+ stream.data.yuv420p.u, stream.data.yuv420p.length_u,
+ stream.data.yuv420p.v, stream.data.yuv420p.length_v);
*/
}
} else {
stream.elevation[1] = stream.height >> 1;
/*
_mmcam_dbg_log("format[%d][num_planes:%d] [Y]p:0x%x,size:%d [UV]p:0x%x,size:%d",
- stream.format, stream.num_planes,
- stream.data.yuv420sp.y, stream.data.yuv420sp.length_y,
- stream.data.yuv420sp.uv, stream.data.yuv420sp.length_uv);
+ stream.format, stream.num_planes,
+ stream.data.yuv420sp.y, stream.data.yuv420sp.length_y,
+ stream.data.yuv420sp.uv, stream.data.yuv420sp.length_uv);
*/
} else {
stream.data_type = MM_CAM_STREAM_DATA_YUV420P;
stream.elevation[2] = stream.height >> 1;
/*
_mmcam_dbg_log("I420[num_planes:%d] [Y]p:0x%x,size:%d [U]p:0x%x,size:%d [V]p:0x%x,size:%d",
- stream.num_planes,
- stream.data.yuv420p.y, stream.data.yuv420p.length_y,
- stream.data.yuv420p.u, stream.data.yuv420p.length_u,
- stream.data.yuv420p.v, stream.data.yuv420p.length_v);
+ stream.num_planes,
+ stream.data.yuv420p.y, stream.data.yuv420p.length_y,
+ stream.data.yuv420p.u, stream.data.yuv420p.length_u,
+ stream.data.yuv420p.v, stream.data.yuv420p.length_v);
*/
}
}
stream.num_planes = 1;
/*
_mmcam_dbg_log("%c%c%c%c[num_planes:%d] [0]p:0x%x,size:%d",
- fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
- stream.num_planes, stream.data.yuv420.yuv, stream.data.yuv420.length_yuv);
+ fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
+ stream.num_planes, stream.data.yuv420.yuv, stream.data.yuv420.length_yuv);
*/
}
tbm_bo_unmap(stream.bo[i]);
}
}
+
_MMCAMCORDER_UNLOCK_VSTREAM_CALLBACK(hcamcorder);
/* Either metaBlock was mapped, or dataBlock, but not both. */
- if (metaBlock) {
+ if (metaBlock)
gst_memory_unmap(metaBlock, &mapinfo);
- }else {
+ else
gst_memory_unmap(dataBlock, &mapinfo);
- }
}
return GST_PAD_PROBE_OK;
mmf_return_val_if_fail(sc, GST_PAD_PROBE_DROP);
/* push buffer in appsrc to encode */
- if(!sc->info_video) {
+ if (!sc->info_video) {
_mmcam_dbg_warn("sc->info_video is NULL!!");
return FALSE;
}
/*
_mmcam_dbg_log("GST_BUFFER_FLAG_DELTA_UNIT is set : %d",
- GST_BUFFER_FLAG_IS_SET(buffer, GST_BUFFER_FLAG_DELTA_UNIT));
+ GST_BUFFER_FLAG_IS_SET(buffer, GST_BUFFER_FLAG_DELTA_UNIT));
*/
/* check first I frame */
}
}
} else {
- if(sc->info_video->is_firstframe) {
+ if (sc->info_video->is_firstframe) {
/* for image capture with encodebin(ex:emulator) */
if (sc->bencbin_capture && sc->info_image->capturing) {
g_mutex_lock(&hcamcorder->task_thread_lock);
{
int result = MM_CAMCORDER_MR475;
- if (bitrate< 5150) {
+ if (bitrate < 5150) {
result = MM_CAMCORDER_MR475; /*AMR475*/
- } else if (bitrate< 5900) {
+ } else if (bitrate < 5900) {
result = MM_CAMCORDER_MR515; /*AMR515*/
} else if (bitrate < 6700) {
result = MM_CAMCORDER_MR59; /*AMR59*/
- } else if (bitrate< 7400) {
+ } else if (bitrate < 7400) {
result = MM_CAMCORDER_MR67; /*AMR67*/
- } else if (bitrate< 7950) {
+ } else if (bitrate < 7950) {
result = MM_CAMCORDER_MR74; /*AMR74*/
} else if (bitrate < 10200) {
result = MM_CAMCORDER_MR795; /*AMR795*/
if (hcamcorder->error_code == MM_ERROR_NONE) {
if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
mmf_return_val_if_fail(sc->info_video, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- if (sc->info_video->b_commiting) {
+ if (sc->info_video->b_commiting)
_mmcamcorder_video_handle_eos((MMHandleType)hcamcorder);
- }
} else {
mmf_return_val_if_fail(sc->info_audio, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- if (sc->info_audio->b_commiting) {
+ if (sc->info_audio->b_commiting)
_mmcamcorder_audio_handle_eos((MMHandleType)hcamcorder);
- }
}
} else {
ret = hcamcorder->error_code;
char *err_name = NULL;
err = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_AUDIO_ENCODER, &audio_codec,
- MMCAM_FILE_FORMAT, &file_format,
- NULL);
+ MMCAM_AUDIO_ENCODER, &audio_codec,
+ MMCAM_FILE_FORMAT, &file_format,
+ NULL);
if (err != MM_ERROR_NONE) {
_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
SAFE_FREE(err_name);
file_format > MM_FILE_FORMAT_INVALID && file_format < MM_FILE_FORMAT_NUM) {
if (audiocodec_fileformat_compatibility_table[audio_codec][file_format] == 0) {
_mmcam_dbg_err("Audio codec[%d] and file format[%d] compatibility FAILED.",
- audio_codec, file_format);
+ audio_codec, file_format);
return MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE;
}
_mmcam_dbg_log("Audio codec[%d] and file format[%d] compatibility SUCCESS.",
- audio_codec, file_format);
+ audio_codec, file_format);
} else {
_mmcam_dbg_err("Audio codec[%d] or file format[%d] is INVALID.",
- audio_codec, file_format);
+ audio_codec, file_format);
return MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE;
}
char *err_name = NULL;
err = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_VIDEO_ENCODER, &video_codec,
- MMCAM_FILE_FORMAT, &file_format,
- NULL);
+ MMCAM_VIDEO_ENCODER, &video_codec,
+ MMCAM_FILE_FORMAT, &file_format,
+ NULL);
if (err != MM_ERROR_NONE) {
_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
SAFE_FREE(err_name);
file_format > MM_FILE_FORMAT_INVALID && file_format < MM_FILE_FORMAT_NUM) {
if (videocodec_fileformat_compatibility_table[video_codec][file_format] == 0) {
_mmcam_dbg_err("Video codec[%d] and file format[%d] compatibility FAILED.",
- video_codec, file_format);
+ video_codec, file_format);
return MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE;
}
_mmcam_dbg_log("Video codec[%d] and file format[%d] compatibility SUCCESS.",
- video_codec, file_format);
+ video_codec, file_format);
} else {
_mmcam_dbg_err("Video codec[%d] or file format[%d] is INVALID.",
- video_codec, file_format);
+ video_codec, file_format);
return MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE;
}
}
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_WIDTH, &width,
- MMCAM_CAMERA_HEIGHT, &height,
- MMCAM_CAMERA_FPS, &fps,
- NULL);
+ MMCAM_CAMERA_WIDTH, &width,
+ MMCAM_CAMERA_HEIGHT, &height,
+ MMCAM_CAMERA_FPS, &fps,
+ NULL);
_mmcam_dbg_log("set rotate %d", videosrc_rotate);
double motion_rate = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
- MMCAM_CAMERA_FPS_AUTO, &fps_auto,
- MMCAM_CAPTURE_WIDTH, &capture_width,
- MMCAM_CAPTURE_HEIGHT, &capture_height,
- MMCAM_VIDEO_WIDTH, &sc->info_video->video_width,
- MMCAM_VIDEO_HEIGHT, &sc->info_video->video_height,
- NULL);
+ MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
+ MMCAM_CAMERA_FPS_AUTO, &fps_auto,
+ MMCAM_CAPTURE_WIDTH, &capture_width,
+ MMCAM_CAPTURE_HEIGHT, &capture_height,
+ MMCAM_VIDEO_WIDTH, &sc->info_video->video_width,
+ MMCAM_VIDEO_HEIGHT, &sc->info_video->video_height,
+ NULL);
_mmcam_dbg_log("motion rate %f, capture size %dx%d, fps auto %d, video size %dx%d",
- motion_rate, capture_width, capture_height, fps_auto,
- sc->info_video->video_width, sc->info_video->video_height);
+ motion_rate, capture_width, capture_height, fps_auto,
+ sc->info_video->video_width, sc->info_video->video_height);
- if(motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
+ if (motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", fps);
} else {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", 0);
set_width = height;
set_height = width;
if (hcamcorder->device_type == MM_VIDEO_DEVICE_CAMERA1) {
- if (rotate == MM_VIDEO_INPUT_ROTATION_90) {
+ if (rotate == MM_VIDEO_INPUT_ROTATION_90)
set_rotate = 270;
- } else {
+ else
set_rotate = 90;
- }
}
} else {
set_width = width;
int caps_rotate = 0;
format_string = gst_structure_get_string(structure, "format");
- if (format_string) {
+ if (format_string)
caps_fourcc = _mmcamcorder_convert_fourcc_string_to_value(format_string);
- }
+
gst_structure_get_int(structure, "width", &caps_width);
gst_structure_get_int(structure, "height", &caps_height);
gst_structure_get_int(structure, "fps", &caps_fps);
_mmcam_dbg_log("No need to replace caps.");
} else {
_mmcam_dbg_log("current [%c%c%c%c %dx%d, fps %d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
- caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
- caps_width, caps_height, caps_fps, caps_rotate,
- fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
- set_width, set_height, fps, set_rotate);
+ caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
+ caps_width, caps_height, caps_fps, caps_rotate,
+ fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
+ set_width, set_height, fps, set_rotate);
do_set_caps = TRUE;
}
} else {
_mmcam_dbg_log("No need to replace caps.");
} else {
_mmcam_dbg_log("current [%c%c%c%c %dx%d, fps %d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
- caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
- caps_width, caps_height, caps_fps, caps_rotate,
- fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
- set_width, set_height, fps, set_rotate);
+ caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
+ caps_width, caps_height, caps_fps, caps_rotate,
+ fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
+ set_width, set_height, fps, set_rotate);
do_set_caps = TRUE;
}
}
_mmcam_dbg_log("No need to replace caps.");
} else {
_mmcam_dbg_log("current [%c%c%c%c %dx%d, fps %d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
- caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
- caps_width, caps_height, caps_fps, caps_rotate,
- fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
- set_width, set_height, fps, set_rotate);
+ caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
+ caps_width, caps_height, caps_fps, caps_rotate,
+ fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
+ set_width, set_height, fps, set_rotate);
do_set_caps = TRUE;
}
#endif /*_MMCAMCORDER_PRODUCT_TV */
return FALSE;
}
- decsink_struct = gst_caps_get_structure(decsink_caps,0);
+ decsink_struct = gst_caps_get_structure(decsink_caps, 0);
if (!decsink_struct) {
_mmcam_dbg_err("There are no structure from caps");
gst_object_unref(decsink_caps);
return FALSE;
}
- if(gst_structure_has_field(decsink_struct, "maxwidth")){
+ if (gst_structure_has_field(decsink_struct, "maxwidth"))
gst_structure_get_int(decsink_struct, "maxwidth", &maxwidth);
- }
- if(gst_structure_has_field(decsink_struct, "maxheight")){
+
+ if (gst_structure_has_field(decsink_struct, "maxheight"))
gst_structure_get_int(decsink_struct, "maxheight", &maxheight);
- }
#endif /* _MMCAMCORDER_PRODUCT_TV */
+
caps = gst_caps_new_simple("video/x-h264",
- "width", G_TYPE_INT, set_width,
- "height", G_TYPE_INT, set_height,
- "framerate", GST_TYPE_FRACTION, fps, 1,
- "stream-format", G_TYPE_STRING, "byte-stream",
+ "width", G_TYPE_INT, set_width,
+ "height", G_TYPE_INT, set_height,
+ "framerate", GST_TYPE_FRACTION, fps, 1,
+ "stream-format", G_TYPE_STRING, "byte-stream",
#ifdef _MMCAMCORDER_PRODUCT_TV
- "maxwidth", G_TYPE_INT, maxwidth,
- "maxheight", G_TYPE_INT, maxheight,
- "alignment", G_TYPE_STRING, "au",
+ "maxwidth", G_TYPE_INT, maxwidth,
+ "maxheight", G_TYPE_INT, maxheight,
+ "alignment", G_TYPE_STRING, "au",
#endif /* _MMCAMCORDER_PRODUCT_TV */
- NULL);
+ NULL);
#ifdef _MMCAMCORDER_PRODUCT_TV
gst_object_unref(decsink_caps);
strncpy(fourcc_string, (char*)&fourcc, sizeof(fourcc));
fourcc_string[sizeof(fourcc)] = '\0';
caps = gst_caps_new_simple("video/x-raw",
- "format", G_TYPE_STRING, fourcc_string,
- "width", G_TYPE_INT, set_width,
- "height", G_TYPE_INT, set_height,
- "framerate", GST_TYPE_FRACTION, fps, 1,
- "rotate", G_TYPE_INT, set_rotate,
- NULL);
+ "format", G_TYPE_STRING, fourcc_string,
+ "width", G_TYPE_INT, set_width,
+ "height", G_TYPE_INT, set_height,
+ "framerate", GST_TYPE_FRACTION, fps, 1,
+ "rotate", G_TYPE_INT, set_rotate,
+ NULL);
}
if (caps) {
mmf_return_val_if_fail(hcamcorder, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
_mmcam_dbg_log("Set FLIP %d", videosrc_flip);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "vflip", vflip);
} else {
_mmcam_dbg_warn("ITLV format does not support FLIP. Ignore FLIP[%d]",
- videosrc_flip);
+ videosrc_flip);
}
} else {
_mmcam_dbg_warn("element is NULL");
mmf_return_val_if_fail(handle, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
v_src = sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst;
mmf_return_val_if_fail(handle, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
v_src = sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst;
if (!v_src) {
}
/* check property of videosrc element - support VDIS */
- if(g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(v_src)), "enable-vdis-mode")) {
+ if (g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(v_src)), "enable-vdis-mode")) {
int video_width = 0;
int video_height = 0;
/* VDIS mode only supports NV12 and [720p or 1080p or 1088 * 1088] */
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_VIDEO_WIDTH, &video_width,
- MMCAM_VIDEO_HEIGHT, &video_height,
- NULL);
- if (sc->info_image->preview_format == MM_PIXEL_FORMAT_NV12 &&
- video_width >= 1080 && video_height >= 720) {
+ MMCAM_VIDEO_WIDTH, &video_width,
+ MMCAM_VIDEO_HEIGHT, &video_height,
+ NULL);
+
+ if (sc->info_image->preview_format == MM_PIXEL_FORMAT_NV12 && video_width >= 1080 && video_height >= 720) {
_mmcam_dbg_log("NV12, video size %dx%d, ENABLE video stabilization",
- video_width, video_height, stabilization);
+ video_width, video_height, stabilization);
/* set vdis mode */
g_object_set(G_OBJECT(v_src),
- "enable-vdis-mode", TRUE,
- NULL);
+ "enable-vdis-mode", TRUE,
+ NULL);
} else {
_mmcam_dbg_warn("invalid preview format %c%c%c%c or video size %dx%d",
- sc->fourcc, sc->fourcc>>8, sc->fourcc>>16, sc->fourcc>>24,
- video_width, video_height);
+ sc->fourcc, sc->fourcc>>8, sc->fourcc>>16, sc->fourcc>>24,
+ video_width, video_height);
return FALSE;
}
} else {
/* set vdis mode */
g_object_set(G_OBJECT(v_src),
- "enable-vdis-mode", FALSE,
- NULL);
+ "enable-vdis-mode", FALSE,
+ NULL);
_mmcam_dbg_log("DISABLE video stabilization");
}
mmf_return_val_if_fail(hcamcorder, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc) {
+ if (!sc)
return TRUE;
- }
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_FPS, &fps,
- NULL);
+ MMCAM_CAMERA_FPS, &fps,
+ NULL);
_mmcam_dbg_log("set %dx%d", width, height);
#ifdef _MMCAMCORDER_RM_SUPPORT
rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src,
- rm_device_request_s *info, void *cb_data);
+ rm_device_request_s *info, void *cb_data);
#endif /* _MMCAMCORDER_RM_SUPPORT */
#ifdef _MMCAMCORDER_USE_SET_ATTR_CB
static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data);
goto _ERR_DEFAULT_VALUE_INIT;
}
- if (MM_ERROR_NONE != mm_sound_register_focus_for_session(hcamcorder->sound_focus_id,
- getpid(),
- "media",
- _mmcamcorder_sound_focus_cb,
- hcamcorder)) {
+ ret = mm_sound_register_focus_for_session(hcamcorder->sound_focus_id,
+ getpid(), "media", _mmcamcorder_sound_focus_cb, hcamcorder);
+ if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("mm_sound_register_focus failed");
ret = MM_ERROR_POLICY_BLOCKED;
goto _ERR_DEFAULT_VALUE_INIT;
}
_mmcam_dbg_log("mm_sound_register_focus done - id %d, session type %d, flags 0x%x",
- hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags);
+ hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags);
} else {
_mmcam_dbg_log("_mm_session_util_read_information failed. skip sound focus function.");
hcamcorder->sound_focus_register = FALSE;
if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "UseConfCtrl", &UseConfCtrl);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "UseConfCtrl", &UseConfCtrl);
if (UseConfCtrl) {
int resolution_width = 0;
int resolution_height = 0;
MMCamAttrsInfo fps_info;
- _mmcam_dbg_log( "Enable Configure Control system." );
+ _mmcam_dbg_log("Enable Configure Control system.");
switch (info->videodev_type) {
case MM_VIDEO_DEVICE_CAMERA0:
_mmcamcorder_conf_get_value_string((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "ConfCtrlFile0", &ConfCtrlFile);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "ConfCtrlFile0", &ConfCtrlFile);
break;
case MM_VIDEO_DEVICE_CAMERA1:
_mmcamcorder_conf_get_value_string((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "ConfCtrlFile1", &ConfCtrlFile);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "ConfCtrlFile1", &ConfCtrlFile);
break;
default:
- _mmcam_dbg_err( "Not supported camera type." );
+ _mmcam_dbg_err("Not supported camera type.");
ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
goto _ERR_DEFAULT_VALUE_INIT;
}
/* Get device info, recommend preview fmt and display rotation from INI */
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "RecommendPreviewFormatCapture",
- &rcmd_fmt_capture);
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "RecommendPreviewFormatCapture",
+ &rcmd_fmt_capture);
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "RecommendPreviewFormatRecord",
- &rcmd_fmt_recording);
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "RecommendPreviewFormatRecord",
+ &rcmd_fmt_recording);
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "RecommendDisplayRotation",
- &rcmd_dpy_rotation);
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "RecommendDisplayRotation",
+ &rcmd_dpy_rotation);
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_CAPTURE,
- "PlayCaptureSound",
- &play_capture_sound);
+ CONFIGURE_CATEGORY_MAIN_CAPTURE,
+ "PlayCaptureSound",
+ &play_capture_sound);
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "DeviceCount",
- &camera_device_count);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "DeviceCount",
+ &camera_device_count);
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "FacingDirection",
- &camera_facing_direction);
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "FacingDirection",
+ &camera_facing_direction);
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_EFFECT,
- "BrightnessStepDenominator",
- &hcamcorder->brightness_step_denominator);
+ CONFIGURE_CATEGORY_CTRL_EFFECT,
+ "BrightnessStepDenominator",
+ &hcamcorder->brightness_step_denominator);
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAPTURE,
- "SupportZSL",
- &hcamcorder->support_zsl_capture);
+ CONFIGURE_CATEGORY_CTRL_CAPTURE,
+ "SupportZSL",
+ &hcamcorder->support_zsl_capture);
_mmcam_dbg_log("Recommend fmt[cap:%d,rec:%d], dpy rot %d, cap snd %d, dev cnt %d, cam facing dir %d, step denom %d, support zsl %d",
- rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation,
- play_capture_sound, camera_device_count, camera_facing_direction,
- hcamcorder->brightness_step_denominator, hcamcorder->support_zsl_capture);
+ rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation,
+ play_capture_sound, camera_device_count, camera_facing_direction,
+ hcamcorder->brightness_step_denominator, hcamcorder->support_zsl_capture);
/* Get UseZeroCopyFormat value from INI */
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "UseZeroCopyFormat",
- &(hcamcorder->use_zero_copy_format));
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "UseZeroCopyFormat",
+ &(hcamcorder->use_zero_copy_format));
/* Get SupportMediaPacketPreviewCb value from INI */
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "SupportMediaPacketPreviewCb",
- &(hcamcorder->support_media_packet_preview_cb));
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "SupportMediaPacketPreviewCb",
+ &(hcamcorder->support_media_packet_preview_cb));
/* Get UseVideoconvert value from INI */
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
- "UseVideoconvert",
- &hcamcorder->use_videoconvert);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+ "UseVideoconvert",
+ &hcamcorder->use_videoconvert);
ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
- MMCAM_CAMERA_WIDTH, &resolution_width,
- MMCAM_CAMERA_HEIGHT, &resolution_height,
- NULL);
+ MMCAM_CAMERA_WIDTH, &resolution_width,
+ MMCAM_CAMERA_HEIGHT, &resolution_height,
+ NULL);
mm_camcorder_get_fps_list_by_resolution((MMHandleType)hcamcorder, resolution_width, resolution_height, &fps_info);
resolution_width, resolution_height, fps_info.int_array.def);
if (camera_facing_direction == 1) {
- if (rcmd_dpy_rotation == MM_DISPLAY_ROTATION_270 || rcmd_dpy_rotation == MM_DISPLAY_ROTATION_90) {
+ if (rcmd_dpy_rotation == MM_DISPLAY_ROTATION_270 || rcmd_dpy_rotation == MM_DISPLAY_ROTATION_90)
camera_default_flip = MM_FLIP_VERTICAL;
- } else {
+ else
camera_default_flip = MM_FLIP_HORIZONTAL;
- }
+
_mmcam_dbg_log("camera_default_flip : [%d]", camera_default_flip);
}
mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
- MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
- MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction,
- MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture,
- MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording,
- MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation,
- MMCAM_SUPPORT_ZSL_CAPTURE, hcamcorder->support_zsl_capture,
- MMCAM_SUPPORT_ZERO_COPY_FORMAT, hcamcorder->use_zero_copy_format,
- MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB, hcamcorder->support_media_packet_preview_cb,
- MMCAM_CAMERA_FPS, fps_info.int_array.def,
- MMCAM_DISPLAY_FLIP, camera_default_flip,
- "capture-sound-enable", play_capture_sound,
- NULL);
+ MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
+ MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction,
+ MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture,
+ MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording,
+ MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation,
+ MMCAM_SUPPORT_ZSL_CAPTURE, hcamcorder->support_zsl_capture,
+ MMCAM_SUPPORT_ZERO_COPY_FORMAT, hcamcorder->use_zero_copy_format,
+ MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB, hcamcorder->support_media_packet_preview_cb,
+ MMCAM_CAMERA_FPS, fps_info.int_array.def,
+ MMCAM_DISPLAY_FLIP, camera_default_flip,
+ "capture-sound-enable", play_capture_sound,
+ NULL);
if (err_attr_name) {
_mmcam_dbg_err("Set %s FAILED.", err_attr_name);
SAFE_FREE(err_attr_name);
/* Get default value of brightness */
mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_attr_name,
- MMCAM_FILTER_BRIGHTNESS, &hcamcorder->brightness_default,
- NULL);
+ MMCAM_FILTER_BRIGHTNESS, &hcamcorder->brightness_default,
+ NULL);
if (err_attr_name) {
_mmcam_dbg_err("Get brightness FAILED.");
SAFE_FREE(err_attr_name);
}
_mmcam_dbg_log("Default brightness : %d", hcamcorder->brightness_default);
} else {
- _mmcam_dbg_log( "Disable Configure Control system." );
+ _mmcam_dbg_log("Disable Configure Control system.");
hcamcorder->conf_ctrl = NULL;
}
/* add DPM camera policy changed callback */
if (hcamcorder->dpm_context) {
- if (dpm_context_add_policy_changed_cb(hcamcorder->dpm_context,
- "camera", _mmcamcorder_dpm_camera_policy_changed_cb,
- (void *)hcamcorder, &hcamcorder->dpm_camera_cb_id) != DPM_ERROR_NONE) {
+ ret = dpm_context_add_policy_changed_cb(hcamcorder->dpm_context, "camera",
+ _mmcamcorder_dpm_camera_policy_changed_cb, (void *)hcamcorder, &hcamcorder->dpm_camera_cb_id);
+ if (ret != DPM_ERROR_NONE) {
_mmcam_dbg_err("add DPM changed cb failed, keep going...");
hcamcorder->dpm_camera_cb_id = 0;
}
}
} else {
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "DeviceCount",
- &camera_device_count);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "DeviceCount",
+ &camera_device_count);
+
mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
- MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
- NULL);
+ MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
+ NULL);
if (err_attr_name) {
_mmcam_dbg_err("Set %s FAILED.", err_attr_name);
SAFE_FREE(err_attr_name);
traceEnd(TTRACE_TAG_CAMERA);
if (!ret) {
- _mmcam_dbg_err( "Failed to initialize gstreamer!!" );
+ _mmcam_dbg_err("Failed to initialize gstreamer!!");
ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
goto _ERR_DEFAULT_VALUE_INIT;
}
/* Get videosink name for evas surface */
_mmcamcorder_conf_get_element((MMHandleType)hcamcorder, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
- "VideosinkElementEvas",
- &EvasSurfaceElement);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+ "VideosinkElementEvas",
+ &EvasSurfaceElement);
if (EvasSurfaceElement) {
int attr_index = 0;
const char *evassink_name = NULL;
}
} else {
_mmcam_dbg_warn("no need to unregister sound focus[%d, id %d]",
- hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
+ hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
}
/* release DPM related handle */
g_cond_clear(&hcamcorder->snd_info.open_cond);
g_mutex_clear(&hcamcorder->restart_preview_lock);
- if (hcamcorder->conf_ctrl) {
+ if (hcamcorder->conf_ctrl)
_mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_ctrl);
- }
- if (hcamcorder->conf_main) {
+ if (hcamcorder->conf_main)
_mmcamcorder_conf_release_info((MMHandleType)hcamcorder, &hcamcorder->conf_main);
- }
if (hcamcorder->model_name) {
free(hcamcorder->model_name);
/* Release SubContext and pipeline */
if (hcamcorder->sub_context) {
- if (hcamcorder->sub_context->element) {
+ if (hcamcorder->sub_context->element)
_mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
- }
_mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
hcamcorder->sub_context = NULL;
#ifdef _MMCAMCORDER_MURPHY_SUPPORT
/* de-initialize resource manager */
ret = _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
_mmcam_dbg_err("failed to de-initialize resource manager 0x%x", ret);
- }
#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
/* Remove idle function which is not called yet */
/* Remove exif info */
if (hcamcorder->exif_info) {
mm_exif_destory_exif_info(hcamcorder->exif_info);
- hcamcorder->exif_info=NULL;
-
+ hcamcorder->exif_info = NULL;
}
/* Release configure info */
- if (hcamcorder->conf_ctrl) {
+ if (hcamcorder->conf_ctrl)
_mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl);
- }
- if (hcamcorder->conf_main) {
+
+ if (hcamcorder->conf_main)
_mmcamcorder_conf_release_info(handle, &hcamcorder->conf_main);
- }
/* Remove messages which are not called yet */
_mmcamcorder_remove_message_all(handle);
if (hcamcorder->sound_focus_register && hcamcorder->sound_focus_id > 0) {
if (mm_sound_unregister_focus(hcamcorder->sound_focus_id) != MM_ERROR_NONE) {
_mmcam_dbg_err("mm_sound_unregister_focus[id %d] failed",
- hcamcorder->sound_focus_id);
+ hcamcorder->sound_focus_id);
} else {
_mmcam_dbg_log("mm_sound_unregister_focus[id %d] done",
- hcamcorder->sound_focus_id);
+ hcamcorder->sound_focus_id);
}
} else {
_mmcam_dbg_log("no need to unregister sound focus.[%d, id %d]",
- hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
+ hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
}
#ifdef _MMCAMCORDER_RM_SUPPORT
if (hcamcorder->rm_handle != 0) {
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
_ERR_CAMCORDER_CMD_PRECON:
- if (hcamcorder) {
+ if (hcamcorder)
_mmcam_dbg_err("Destroy fail (type %d, state %d)", hcamcorder->type, state);
- }
_mmcam_dbg_err("Destroy fail (ret %x)", ret);
}
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_MODE, &hcamcorder->type,
- NULL);
+ MMCAM_MODE, &hcamcorder->type,
+ NULL);
/* Get profile mode */
_mmcam_dbg_log("Profile mode [%d]", hcamcorder->type);
/* sound focus */
if (hcamcorder->sound_focus_register) {
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_PID_FOR_SOUND_FOCUS, &pid_for_sound_focus,
- NULL);
+ MMCAM_PID_FOR_SOUND_FOCUS, &pid_for_sound_focus,
+ NULL);
if (pid_for_sound_focus == 0) {
pid_for_sound_focus = getpid();
_mmcam_dbg_log("ETC - set sound focus watch callback - pid %d", pid_for_sound_focus);
ret_sound = mm_sound_set_focus_watch_callback_for_session(pid_for_sound_focus,
- FOCUS_FOR_BOTH,
- (mm_sound_focus_changed_watch_cb)_mmcamcorder_sound_focus_watch_cb,
- hcamcorder,
- &hcamcorder->sound_focus_watch_id);
+ FOCUS_FOR_BOTH,
+ (mm_sound_focus_changed_watch_cb)_mmcamcorder_sound_focus_watch_cb,
+ hcamcorder,
+ &hcamcorder->sound_focus_watch_id);
if (ret_sound != MM_ERROR_NONE) {
_mmcam_dbg_err("mm_sound_set_focus_watch_callback failed [0x%x]", ret_sound);
int resource_count = 0;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_PID_FOR_SOUND_FOCUS, &app_pid,
- NULL);
+ MMCAM_PID_FOR_SOUND_FOCUS, &app_pid,
+ NULL);
rci.app_pid = app_pid;
aul_app_get_appid_bypid(rci.app_pid, rci.app_id, sizeof(rci.app_id));
/* RM register */
if (hcamcorder->rm_handle == 0) {
iret = rm_register((rm_resource_cb)_mmcamcorder_rm_callback, (void*)hcamcorder,
- &(hcamcorder->rm_handle), &rci);
+ &(hcamcorder->rm_handle), &rci);
if (iret != RM_OK) {
_mmcam_dbg_err("rm_register fail");
ret = MM_ERROR_POLICY_BLOCKED;
}
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_FORMAT, &preview_format,
- NULL);
+ MMCAM_CAMERA_FORMAT, &preview_format,
+ NULL);
if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO && preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
-
resource_count = 0;
memset(&hcamcorder->request_resources, 0x0, sizeof(rm_category_request_s));
memset(&hcamcorder->returned_devices, 0x0, sizeof(rm_device_return_s));
hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER;
- _mmcam_dbg_log("request video decoder resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+ _mmcam_dbg_log("request video decoder resource - device category 0x%x", hcamcorder->request_resources.category_id[resource_count]);
resource_count++;
hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER;
hcamcorder->request_resources.request_num = resource_count + 1;
- _mmcam_dbg_log("request scaler resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
-
+ _mmcam_dbg_log("request scaler resource - device category 0x%x", hcamcorder->request_resources.category_id[resource_count]);
qret = rm_query(hcamcorder->rm_handle, RM_QUERY_ALLOCATION, &(hcamcorder->request_resources), &qret_avail);
resource_count = 0;
hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER_SUB;
- _mmcam_dbg_log("request video decoder resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+ _mmcam_dbg_log("request video decoder resource - device category 0x%x", hcamcorder->request_resources.category_id[resource_count]);
resource_count++;
hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER_SUB;
- _mmcam_dbg_log("request scaler resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+ _mmcam_dbg_log("request scaler resource - device category 0x%x", hcamcorder->request_resources.category_id[resource_count]);
}
resource_count++;
hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_CAMERA;
hcamcorder->request_resources.request_num = resource_count + 1;
- _mmcam_dbg_log("request camera resource - device category 0x%x",hcamcorder->request_resources.category_id[resource_count]);
+ _mmcam_dbg_log("request camera resource - device category 0x%x", hcamcorder->request_resources.category_id[resource_count]);
iret = rm_allocate_resources(hcamcorder->rm_handle, &(hcamcorder->request_resources), &hcamcorder->returned_devices);
if (iret != RM_OK) {
/* alloc sub context */
hcamcorder->sub_context = _mmcamcorder_alloc_subcontext(hcamcorder->type);
- if(!hcamcorder->sub_context) {
+ if (!hcamcorder->sub_context) {
ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
goto _ERR_CAMCORDER_CMD;
}
/* Set basic configure information */
- if (motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
+ if (motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE)
hcamcorder->sub_context->is_modified_rate = TRUE;
- }
_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_CAPTURE,
- "UseEncodebin",
- &(hcamcorder->sub_context->bencbin_capture));
+ CONFIGURE_CATEGORY_MAIN_CAPTURE,
+ "UseEncodebin",
+ &(hcamcorder->sub_context->bencbin_capture));
_mmcam_dbg_warn("UseEncodebin [%d]", hcamcorder->sub_context->bencbin_capture);
if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
/* get dual stream support info */
_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_RECORD,
- "SupportDualStream",
- &(hcamcorder->sub_context->info_video->support_dual_stream));
+ CONFIGURE_CATEGORY_MAIN_RECORD,
+ "SupportDualStream",
+ &(hcamcorder->sub_context->info_video->support_dual_stream));
_mmcam_dbg_warn("SupportDualStream [%d]", hcamcorder->sub_context->info_video->support_dual_stream);
}
if (socket_path == NULL) {
_mmcam_dbg_warn("REMOTE surface, but socket path is NULL -> to NullSink");
videosink_element_type = strdup("VideosinkElementNull");
- } else
+ } else {
videosink_element_type = strdup("VideosinkElementRemote");
+ }
break;
default:
videosink_element_type = strdup("VideosinkElementOverlay");
/* check string of videosink element */
if (videosink_element_type) {
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
- videosink_element_type,
- &hcamcorder->sub_context->VideosinkElement);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+ videosink_element_type,
+ &hcamcorder->sub_context->VideosinkElement);
free(videosink_element_type);
videosink_element_type = NULL;
} else {
_mmcam_dbg_warn("strdup failed(display_surface_type %d). Use default X type",
- display_surface_type);
+ display_surface_type);
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
- _MMCAMCORDER_DEFAULT_VIDEOSINK_TYPE,
- &hcamcorder->sub_context->VideosinkElement);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+ _MMCAMCORDER_DEFAULT_VIDEOSINK_TYPE,
+ &hcamcorder->sub_context->VideosinkElement);
}
_mmcamcorder_conf_get_value_element_name(hcamcorder->sub_context->VideosinkElement, &videosink_name);
/* get videoconvert element */
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
- "VideoconvertElement",
- &hcamcorder->sub_context->VideoconvertElement);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+ "VideoconvertElement",
+ &hcamcorder->sub_context->VideoconvertElement);
_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAPTURE,
- "SensorEncodedCapture",
- &(hcamcorder->sub_context->SensorEncodedCapture));
+ CONFIGURE_CATEGORY_CTRL_CAPTURE,
+ "SensorEncodedCapture",
+ &(hcamcorder->sub_context->SensorEncodedCapture));
_mmcam_dbg_log("Support sensor encoded capture : %d", hcamcorder->sub_context->SensorEncodedCapture);
if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) {
if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
ret = _mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, MM_CAMCORDER_RESOURCE_TYPE_VIDEO_OVERLAY);
- if(ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("could not prepare for video overlay resource");
ret = MM_ERROR_CAMCORDER_INTERNAL;
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
int ret_resource = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
if (ret_resource == MM_ERROR_RESOURCE_INVALID_STATE) {
_mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource");
- }
- else if (ret_resource != MM_ERROR_NONE) {
+ } else if (ret_resource != MM_ERROR_NONE) {
_mmcam_dbg_err("failed to release resource, ret_resource(0x%x)", ret_resource);
}
+
ret_resource = _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager);
- if (ret_resource != MM_ERROR_NONE) {
+ if (ret_resource != MM_ERROR_NONE)
_mmcam_dbg_err("failed to unprepare resource manager, ret_resource(0x%x)", ret_resource);
- }
}
#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
if (hcamcorder->sound_focus_register) {
if (hcamcorder->sound_focus_watch_id > 0) {
if (mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id) != MM_ERROR_NONE) {
- _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback[id %d] failed",
- hcamcorder->sound_focus_watch_id);
+ _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback[id %d] failed", hcamcorder->sound_focus_watch_id);
} else {
- _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback[id %d] done",
- hcamcorder->sound_focus_watch_id);
+ _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback[id %d] done", hcamcorder->sound_focus_watch_id);
}
}
if (hcamcorder->acquired_focus > 0) {
if (mm_sound_release_focus(0, hcamcorder->acquired_focus, NULL) != MM_ERROR_NONE) {
- _mmcam_dbg_err("mm_sound_release_focus[focus %d] failed",
- hcamcorder->acquired_focus);
+ _mmcam_dbg_err("mm_sound_release_focus[focus %d] failed", hcamcorder->acquired_focus);
} else {
- _mmcam_dbg_err("mm_sound_release_focus[focus %d] done",
- hcamcorder->acquired_focus);
+ _mmcam_dbg_err("mm_sound_release_focus[focus %d] done", hcamcorder->acquired_focus);
}
}
}
rm_device_request_s requested;
memset(&requested, 0x0, sizeof(rm_device_request_s));
requested.request_num = hcamcorder->returned_devices.allocated_num;
- for (idx = 0; idx < requested.request_num; idx++) {
+ for (idx = 0; idx < requested.request_num; idx++)
requested.device_id[idx] = hcamcorder->returned_devices.device_id[idx];
- }
+
iret = rm_deallocate_resources(hcamcorder->rm_handle, &requested);
if (iret != RM_OK)
_mmcam_dbg_err("Resource deallocation request failed ");
#endif /* _MMCAMCORDER_RM_SUPPORT*/
_ERR_CAMCORDER_CMD_PRECON:
- _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)",
- hcamcorder->type, state, ret);
+ _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)", hcamcorder->type, state, ret);
return ret;
}
}
_MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
ret = _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager);
+
_MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
_mmcam_dbg_err("failed to unprepare resource manager, ret(0x%x)", ret);
- }
}
#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
rm_device_request_s requested;
memset(&requested, 0x0, sizeof(rm_device_request_s));
requested.request_num = hcamcorder->returned_devices.allocated_num;
- for (idx = 0; idx < requested.request_num; idx++) {
+ for (idx = 0; idx < requested.request_num; idx++)
requested.device_id[idx] = hcamcorder->returned_devices.device_id[idx];
- }
+
iret = rm_deallocate_resources(hcamcorder->rm_handle, &requested);
if (iret != RM_OK)
_mmcam_dbg_err("Resource deallocation request failed ");
hcamcorder->command = NULL;
_mmcam_dbg_log("focus register %d, session flag 0x%x, state_change_by_system %d",
- hcamcorder->sound_focus_register, hcamcorder->session_flags, hcamcorder->state_change_by_system);
+ hcamcorder->sound_focus_register, hcamcorder->session_flags, hcamcorder->state_change_by_system);
/* release sound focus or unset sound focus watch callback */
if (hcamcorder->sound_focus_register) {
int ret_sound = MM_ERROR_NONE;
_mmcam_dbg_log("state_change_by_system %d, session flag 0x%x, acquired_focus %d, sound_focus_id %d, sound_focus_watch_id %d",
- hcamcorder->state_change_by_system, hcamcorder->session_flags, hcamcorder->acquired_focus,
- hcamcorder->sound_focus_id, hcamcorder->sound_focus_watch_id);
+ hcamcorder->state_change_by_system, hcamcorder->session_flags, hcamcorder->acquired_focus,
+ hcamcorder->sound_focus_id, hcamcorder->sound_focus_watch_id);
if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_FOCUS &&
hcamcorder->sound_focus_watch_id > 0) {
ret_sound = mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id);
if (ret_sound != MM_ERROR_NONE) {
- _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback failed [0x%x]",
- ret_sound);
+ _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback failed [0x%x]", ret_sound);
} else {
_mmcam_dbg_warn("mm_sound_unset_focus_watch_callback done");
}
} else {
_mmcam_dbg_warn("no need to unset watch callback.[state_change_by_system %d, sound_focus_watch_id %d]",
- hcamcorder->state_change_by_system, hcamcorder->sound_focus_watch_id);
+ hcamcorder->state_change_by_system, hcamcorder->sound_focus_watch_id);
}
if (hcamcorder->acquired_focus > 0) {
ret_sound = mm_sound_release_focus(0, hcamcorder->acquired_focus, NULL);
if (ret_sound != MM_ERROR_NONE) {
- _mmcam_dbg_warn("mm_sound_release_focus failed [0x%x]",
- ret_sound);
+ _mmcam_dbg_warn("mm_sound_release_focus failed [0x%x]", ret_sound);
} else {
_mmcam_dbg_log("mm_sound_release_focus done");
}
} else {
- _mmcam_dbg_warn("no need to release focus - current acquired focus %d",
- hcamcorder->acquired_focus);
+ _mmcam_dbg_warn("no need to release focus - current acquired focus %d", hcamcorder->acquired_focus);
}
}
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
- _mmcam_dbg_err("Unrealize fail (type %d, state %d, ret %x)",
- hcamcorder->type, state, ret);
+ _mmcam_dbg_err("Unrealize fail (type %d, state %d, ret %x)", hcamcorder->type, state, ret);
return ret;
}
int ret = MM_ERROR_NONE;
int state = MM_CAMCORDER_STATE_NONE;
int state_FROM = MM_CAMCORDER_STATE_READY;
- int state_TO =MM_CAMCORDER_STATE_PREPARE;
+ int state_TO = MM_CAMCORDER_STATE_PREPARE;
_MMCamcorderSubContext *sc = NULL;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
}
_mmcam_dbg_err("Start fail (type %d, state %d, ret %x)",
- hcamcorder->type, state, ret);
+ hcamcorder->type, state, ret);
return ret;
}
}
ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_STOP);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
- }
_mmcamcorder_set_state(handle, state_TO);
if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
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);
+ _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);
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);
+ _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);
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
- _mmcam_dbg_err("Stop fail (type %d, state %d, ret %x)",
- hcamcorder->type, state, ret);
+ _mmcam_dbg_err("Stop fail (type %d, state %d, ret %x)", hcamcorder->type, state, ret);
return ret;
}
}
state = _mmcamcorder_get_state(handle);
- if (state != state_FROM_0 &&
- state != state_FROM_1 &&
- state != state_FROM_2) {
+ if (state != state_FROM_0 && state != state_FROM_1 && state != state_FROM_2) {
_mmcam_dbg_err("Wrong state(%d)", state);
ret = MM_ERROR_CAMCORDER_INVALID_STATE;
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_CAPTURE);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_CMD;
- }
/* Do not change state when recording snapshot capture */
- if (state == state_FROM_0) {
+ if (state == state_FROM_0)
_mmcamcorder_set_state(handle, state_TO);
- }
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
/* Init break continuous shot attr */
- if (mm_camcorder_set_attributes(handle, NULL, "capture-break-cont-shot", 0, NULL) != MM_ERROR_NONE) {
+ if (mm_camcorder_set_attributes(handle, NULL, "capture-break-cont-shot", 0, NULL) != MM_ERROR_NONE)
_mmcam_dbg_warn("capture-break-cont-shot set 0 failed");
- }
return MM_ERROR_NONE;
_ERR_CAMCORDER_CMD:
- if (hcamcorder->capture_in_recording) {
+ if (hcamcorder->capture_in_recording)
hcamcorder->capture_in_recording = FALSE;
- }
_ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
_mmcam_dbg_err("Capture start fail (type %d, state %d, ret %x)",
- hcamcorder->type, state, ret);
+ hcamcorder->type, state, ret);
return ret;
}
}
ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_START);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
- }
_mmcamcorder_set_state(handle, state_TO);
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
_mmcam_dbg_err("Capture stop fail (type %d, state %d, ret %x)",
- hcamcorder->type, state, ret);
+ hcamcorder->type, state, ret);
return ret;
}
}
_mmcam_dbg_err("Record fail (type %d, state %d, ret %x)",
- hcamcorder->type, state, ret);
+ hcamcorder->type, state, ret);
return ret;
}
}
ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PAUSE);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
- }
_mmcamcorder_set_state(handle, state_TO);
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
- _mmcam_dbg_err("Pause fail (type %d, state %d, ret %x)",
- hcamcorder->type, state, ret);
+ _mmcam_dbg_err("Pause fail (type %d, state %d, ret %x)", hcamcorder->type, state, ret);
return ret;
}
hcamcorder->error_code = MM_ERROR_NONE;
ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_COMMIT);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
- }
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
- _mmcamcorder_set_state(handle,state_TO);
+ _mmcamcorder_set_state(handle, state_TO);
return MM_ERROR_NONE;
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
- _mmcam_dbg_err("Commit fail (type %d, state %d, ret %x)",
- hcamcorder->type, state, ret);
+ _mmcam_dbg_err("Commit fail (type %d, state %d, ret %x)", hcamcorder->type, state, ret);
return ret;
}
}
ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_CANCEL);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
- }
_mmcamcorder_set_state(handle, state_TO);
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
_mmcam_dbg_err("Cancel fail (type %d, state %d, ret %x)",
- hcamcorder->type, state, ret);
+ hcamcorder->type, state, ret);
return ret;
}
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- if (callback == NULL) {
+ if (callback == NULL)
_mmcam_dbg_warn("Message Callback is disabled, because application sets it to NULL");
- }
if (!_MMCAMCORDER_TRYLOCK_MESSAGE_CALLBACK(hcamcorder)) {
_mmcam_dbg_warn("Application's message callback is running now");
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- if (callback == NULL) {
+ if (callback == NULL)
_mmcam_dbg_warn("Video Stream Callback is disabled, because application sets it to NULL");
- }
if (!_MMCAMCORDER_TRYLOCK_VSTREAM_CALLBACK(hcamcorder)) {
_mmcam_dbg_warn("Application's video stream callback is running now");
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- if (callback == NULL) {
+ if (callback == NULL)
_mmcam_dbg_warn("Audio Stream Callback is disabled, because application sets it to NULL");
- }
if (!_MMCAMCORDER_TRYLOCK_ASTREAM_CALLBACK(hcamcorder)) {
_mmcam_dbg_warn("Application's audio stream callback is running now");
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- if (callback == NULL) {
+ if (callback == NULL)
_mmcam_dbg_warn("Video Capture Callback is disabled, because application sets it to NULLL");
- }
if (!_MMCAMCORDER_TRYLOCK_VCAPTURE_CALLBACK(hcamcorder)) {
_mmcam_dbg_warn("Application's video capture callback is running now");
if (state == MM_CAMCORDER_STATE_CAPTURING ||
state < MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_err( "Not proper state. state[%d]", state );
+ _mmcam_dbg_err("Not proper state. state[%d]", state);
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
return MM_ERROR_CAMCORDER_INVALID_STATE;
}
return MM_ERROR_NONE;
}
- control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
_mmcam_dbg_err("cast CAMERA_CONTROL failed");
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
/* Initialize lens position */
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
- MMCAM_CAMERA_AF_SCAN_RANGE, &af_range,
- NULL);
+ MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
+ MMCAM_CAMERA_AF_SCAN_RANGE, &af_range,
+ NULL);
sensor_af_range = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_AF_SCAN_RANGE, af_range);
sensor_focus_mode = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_FOCUS_MODE, focus_mode);
gst_camera_control_get_focus(control, ¤t_focus_mode, ¤t_af_range);
- if (current_focus_mode != sensor_focus_mode ||
- current_af_range != sensor_af_range) {
+ if (current_focus_mode != sensor_focus_mode || current_af_range != sensor_af_range) {
ret = gst_camera_control_set_focus(control, sensor_focus_mode, sensor_af_range);
} else {
- _mmcam_dbg_log("No need to init FOCUS [mode:%d, range:%d]", focus_mode, af_range );
+ _mmcam_dbg_log("No need to init FOCUS [mode:%d, range:%d]", focus_mode, af_range);
ret = TRUE;
}
}
state = _mmcamcorder_get_state(handle);
- if (state == MM_CAMCORDER_STATE_CAPTURING ||
- state < MM_CAMCORDER_STATE_PREPARE) {
+ if (state == MM_CAMCORDER_STATE_CAPTURING || state < MM_CAMCORDER_STATE_PREPARE) {
_mmcam_dbg_err("Not proper state. state[%d]", state);
_MMCAMCORDER_UNLOCK_CMD(handle);
return MM_ERROR_CAMCORDER_INVALID_STATE;
/* TODO : call a auto or manual focus function */
ret = mm_camcorder_get_attributes(handle, &err_attr_name,
- MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
- NULL);
+ MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
+ NULL);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_warn("Get focus-mode fail. (%s:%x)", err_attr_name, ret);
- SAFE_FREE (err_attr_name);
+ SAFE_FREE(err_attr_name);
_MMCAMCORDER_UNLOCK_CMD(handle);
return ret;
}
- if (focus_mode == MM_CAMCORDER_FOCUS_MODE_MANUAL) {
+ switch (focus_mode) {
+ case MM_CAMCORDER_FOCUS_MODE_MANUAL:
ret = _mmcamcorder_adjust_manual_focus(handle, direction);
- } else if (focus_mode == MM_CAMCORDER_FOCUS_MODE_AUTO ||
- focus_mode == MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO ||
- focus_mode == MM_CAMCORDER_FOCUS_MODE_CONTINUOUS) {
+ break;
+ case MM_CAMCORDER_FOCUS_MODE_AUTO:
+ case MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO:
+ case MM_CAMCORDER_FOCUS_MODE_CONTINUOUS:
ret = _mmcamcorder_adjust_auto_focus(handle);
- } else {
+ break;
+ default:
_mmcam_dbg_err("It doesn't adjust focus. Focusing mode(%d)", focus_mode);
ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
}
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
mmf_return_val_if_fail(_MMFCAMCORDER_FOCUS_TOTAL_LEVEL != 1, MM_ERROR_CAMCORDER_NOT_SUPPORTED);
mmf_return_val_if_fail((direction >= MM_CAMCORDER_MF_LENS_DIR_FORWARD) &&
- (direction <= MM_CAMCORDER_MF_LENS_DIR_BACKWARD),
- MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
+ (direction <= MM_CAMCORDER_MF_LENS_DIR_BACKWARD),
+ MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
return MM_ERROR_NONE;
}
- control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
_mmcam_dbg_err("cast CAMERA_CONTROL failed");
return MM_ERROR_CAMCORDER_INTERNAL;
}
/* TODO : get max, min level */
- if (max_level - min_level + 1 < _MMFCAMCORDER_FOCUS_TOTAL_LEVEL) {
+ if (max_level - min_level + 1 < _MMFCAMCORDER_FOCUS_TOTAL_LEVEL)
_mmcam_dbg_warn("Total level of manual focus of MMF is greater than that of the camera driver.");
- }
unit_level = ((float)max_level - (float)min_level)/(float)(_MMFCAMCORDER_FOCUS_TOTAL_LEVEL - 1);
return MM_ERROR_CAMCORDER_DEVICE_IO;
}
- //TODO : adjust unit level value
- if (direction == MM_CAMCORDER_MF_LENS_DIR_FORWARD) {
+ /* TODO : adjust unit level value */
+ if (direction == MM_CAMCORDER_MF_LENS_DIR_FORWARD)
focus_level = cur_level + unit_level;
- } else if (direction == MM_CAMCORDER_MF_LENS_DIR_BACKWARD) {
+ else if (direction == MM_CAMCORDER_MF_LENS_DIR_BACKWARD)
focus_level = cur_level - unit_level;
- }
- if (focus_level > max_level) {
+ if (focus_level > max_level)
focus_level = max_level;
- } else if (focus_level < min_level) {
+ else if (focus_level < min_level)
focus_level = min_level;
- }
if (!gst_camera_control_set_focus_level(control, focus_level)) {
_mmcam_dbg_err("Manual focusing fail.");
return MM_ERROR_NONE;
}
- control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control) {
/* Start AF */
ret = gst_camera_control_start_auto_focus(control);
}
state = _mmcamcorder_get_state(handle);
- if (state == MM_CAMCORDER_STATE_CAPTURING ||
- state < MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_err( "Not proper state. state[%d]", state );
+ if (state == MM_CAMCORDER_STATE_CAPTURING || state < MM_CAMCORDER_STATE_PREPARE) {
+ _mmcam_dbg_err("Not proper state. state[%d]", state);
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
return MM_ERROR_CAMCORDER_INVALID_STATE;
}
argc = malloc(sizeof(int));
argv = malloc(sizeof(gchar *) * max_argc);
- if (!argc || !argv) {
+ if (!argc || !argv)
goto ERROR;
- }
memset(argv, 0, sizeof(gchar *) * max_argc);
/* add gst_param */
_mmcamcorder_conf_get_value_string_array(conf,
- CONFIGURE_CATEGORY_MAIN_GENERAL,
- "GSTInitOption",
- &GSTInitOption);
+ CONFIGURE_CATEGORY_MAIN_GENERAL,
+ "GSTInitOption",
+ &GSTInitOption);
if (GSTInitOption != NULL && GSTInitOption->value) {
cnt_str = GSTInitOption->count;
- for( ; *argc < max_argc && *argc <= cnt_str ; (*argc)++ )
- {
+ for ( ; *argc < max_argc && *argc <= cnt_str ; (*argc)++)
argv[*argc] = g_strdup(GSTInitOption->value[(*argc)-1]);
- }
}
_mmcam_dbg_log("initializing gstreamer with following parameter[argc:%d]", *argc);
- for (i = 0; i < *argc; i++) {
+ for (i = 0; i < *argc; i++)
_mmcam_dbg_log("argv[%d] : %s", i, argv[i]);
- }
/* initializing gstreamer */
- ret = gst_init_check (argc, &argv, &err);
+ ret = gst_init_check(argc, &argv, &err);
if (!ret) {
- _mmcam_dbg_err("Could not initialize GStreamer: %s ",
- err ? err->message : "unknown error occurred");
- if (err) {
- g_error_free (err);
- }
+ _mmcam_dbg_err("Could not initialize GStreamer: %s ", err ? err->message : "unknown error occurred");
+ if (err)
+ g_error_free(err);
}
/* release */
_MMCAMCORDER_LOCK_STATE(handle);
old_state = hcamcorder->state;
- if(old_state != state) {
+ if (old_state != state) {
hcamcorder->state = state;
hcamcorder->target_state = state;
/* alloc info for each mode */
switch (type) {
case MM_CAMCORDER_MODE_AUDIO:
- sc->info_audio = g_malloc0( sizeof(_MMCamcorderAudioInfo));
- if(!sc->info_audio) {
+ sc->info_audio = g_malloc0(sizeof(_MMCamcorderAudioInfo));
+ if (!sc->info_audio) {
_mmcam_dbg_err("Failed to alloc info structure");
goto ALLOC_SUBCONTEXT_FAILED;
}
break;
case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
default:
- sc->info_image = g_malloc0( sizeof(_MMCamcorderImageInfo));
- if(!sc->info_image) {
+ sc->info_image = g_malloc0(sizeof(_MMCamcorderImageInfo));
+ if (!sc->info_image) {
_mmcam_dbg_err("Failed to alloc info structure");
goto ALLOC_SUBCONTEXT_FAILED;
}
/* init sound status */
sc->info_image->sound_status = _SOUND_STATUS_INIT;
- sc->info_video = g_malloc0( sizeof(_MMCamcorderVideoInfo));
- if(!sc->info_video) {
+ sc->info_video = g_malloc0(sizeof(_MMCamcorderVideoInfo));
+ if (!sc->info_video) {
_mmcam_dbg_err("Failed to alloc info structure");
goto ALLOC_SUBCONTEXT_FAILED;
}
/* alloc element array */
sc->element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->element_num);
- if(!sc->element) {
+ if (!sc->element) {
_mmcam_dbg_err("Failed to alloc element structure");
goto ALLOC_SUBCONTEXT_FAILED;
}
sc->encode_element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->encode_element_num);
- if(!sc->encode_element) {
+ if (!sc->encode_element) {
_mmcam_dbg_err("Failed to alloc encode element structure");
goto ALLOC_SUBCONTEXT_FAILED;
}
if (sc) {
SAFE_G_FREE(sc->info_audio);
SAFE_G_FREE(sc->info_image);
- if (sc->info_video) {
+ if (sc->info_video)
g_mutex_clear(&sc->info_video->size_check_lock);
- }
+
SAFE_G_FREE(sc->info_video);
if (sc->element) {
free(sc->element);
mmf_return_val_if_fail(hcamcorder, FALSE);
mmf_return_val_if_fail(message, FALSE);
- //_mmcam_dbg_log("message type=(%d)", GST_MESSAGE_TYPE(message));
+ /* _mmcam_dbg_log("message type=(%d)", GST_MESSAGE_TYPE(message)); */
switch (GST_MESSAGE_TYPE(message)) {
case GST_MESSAGE_UNKNOWN:
{
GError *err;
gchar *debug;
- gst_message_parse_warning (message, &err, &debug);
+ gst_message_parse_warning(message, &err, &debug);
_mmcam_dbg_warn("GSTWARN: %s", err->message);
__mmcamcorder_handle_gst_warning((MMHandleType)hcamcorder, message, err);
- g_error_free (err);
- g_free (debug);
+ g_error_free(err);
+ g_free(debug);
break;
}
case GST_MESSAGE_INFO:
if (message->src == (GstObject*)pipeline) {
vnewstate = gst_structure_get_value(gst_message_get_structure(message), "new-state");
newstate = (GstState)vnewstate->data[0].v_int;
- _mmcam_dbg_log("GST_MESSAGE_STATE_CHANGED[%s]",gst_element_state_get_name(newstate));
+ _mmcam_dbg_log("GST_MESSAGE_STATE_CHANGED[%s]", gst_element_state_get_name(newstate));
}
}
}
_mmcam_dbg_log("GST_MESSAGE_ANY");
break;
case GST_MESSAGE_QOS:
-// _mmcam_dbg_log("GST_MESSAGE_QOS");
+ /* _mmcam_dbg_log("GST_MESSAGE_QOS"); */
break;
default:
_mmcam_dbg_log("not handled message type=(%d)", GST_MESSAGE_TYPE(message));
element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
/* check domain[RESOURCE] and element[VIDEOSRC] */
- if (err->domain == GST_RESOURCE_ERROR &&
- GST_ELEMENT_CAST(message->src) == element) {
+ if (err->domain == GST_RESOURCE_ERROR && GST_ELEMENT_CAST(message->src) == element) {
switch (err->code) {
case GST_RESOURCE_ERROR_BUSY:
_mmcam_dbg_err("Camera device [busy]");
case GST_RESOURCE_ERROR_OPEN_WRITE:
_mmcam_dbg_err("Camera device [open failed]");
hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
- //sc->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN; // SECURITY PART REQUEST PRIVILEGE
+ /* sc->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN; // SECURITY PART REQUEST PRIVILEGE */
break;
case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
_mmcam_dbg_err("Camera device [open failed]");
GstCameraControlFaceDetectInfo *fd_info = NULL;
MMCamFaceDetectInfo *cam_fd_info = NULL;
- if (g_value) {
+ if (g_value)
fd_info = (GstCameraControlFaceDetectInfo *)g_value_get_pointer(g_value);
- }
if (fd_info == NULL) {
_mmcam_dbg_warn("fd_info is NULL");
cam_fd_info->face_info[i].rect.height = fd_info->face_info[i].rect.height;
/*
_mmcam_dbg_log("id %d, score %d, [%d,%d,%dx%d]",
- fd_info->face_info[i].id,
- fd_info->face_info[i].score,
- fd_info->face_info[i].rect.x,
- fd_info->face_info[i].rect.y,
- fd_info->face_info[i].rect.width,
- fd_info->face_info[i].rect.height);
+ fd_info->face_info[i].id,
+ fd_info->face_info[i].score,
+ fd_info->face_info[i].rect.x,
+ fd_info->face_info[i].rect.y,
+ fd_info->face_info[i].rect.width,
+ fd_info->face_info[i].rect.height);
*/
}
} else {
void _mmcamcorder_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
- mm_sound_focus_state_e focus_state, const char *reason_for_change,
- const char *additional_info, void *user_data)
+ mm_sound_focus_state_e focus_state, const char *reason_for_change,
+ const char *additional_info, void *user_data)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data);
int current_state = MM_CAMCORDER_STATE_NONE;
mmf_return_if_fail((MMHandleType)hcamcorder);
current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
- if (current_state <= MM_CAMCORDER_STATE_NONE ||
- current_state >= MM_CAMCORDER_STATE_NUM) {
+ if (current_state <= MM_CAMCORDER_STATE_NONE || current_state >= MM_CAMCORDER_STATE_NUM) {
_mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state);
return;
}
_mmcam_dbg_log("sound focus callback : focus state %d, reason %s",
- focus_state, reason_for_change ? reason_for_change : "N/A");
+ focus_state, reason_for_change ? reason_for_change : "N/A");
if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
_mmcam_dbg_warn("session flag is UNINTERRUPTIBLE. do nothing.");
hcamcorder->acquired_focus &= ~focus_type;
_mmcam_dbg_log("FOCUS is released [type %d, remained focus %d] : Stop pipeline[state:%d]",
- focus_type, hcamcorder->acquired_focus, current_state);
+ focus_type, hcamcorder->acquired_focus, current_state);
__mmcamcorder_force_stop(hcamcorder);
hcamcorder->acquired_focus |= focus_type;
_mmcam_dbg_log("FOCUS is acquired [type %d, new focus %d]",
- focus_type, hcamcorder->acquired_focus);
+ focus_type, hcamcorder->acquired_focus);
msg.id = MM_MESSAGE_READY_TO_RESUME;
_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
void _mmcamcorder_sound_focus_watch_cb(mm_sound_focus_type_e focus_type, mm_sound_focus_state_e focus_state,
- const char *reason_for_change, const char *additional_info, void *user_data)
+ const char *reason_for_change, const char *additional_info, void *user_data)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data);
int current_state = MM_CAMCORDER_STATE_NONE;
}
_mmcam_dbg_log("sound focus watch callback : focus state %d, reason %s",
- focus_state, reason_for_change ? reason_for_change : "N/A");
+ focus_state, reason_for_change ? reason_for_change : "N/A");
if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
_mmcam_dbg_warn("session flag is UNINTERRUPTIBLE. do nothing.");
mmf_return_if_fail(value);
current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
- if (current_state <= MM_CAMCORDER_STATE_NONE ||
- current_state >= MM_CAMCORDER_STATE_NUM) {
+ if (current_state <= MM_CAMCORDER_STATE_NONE || current_state >= MM_CAMCORDER_STATE_NUM) {
_mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state);
return;
}
switch (type) {
case MM_CAMCORDER_MODE_AUDIO:
ret = _mmcamcorder_create_audio_pipeline(handle);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
return ret;
- }
+
break;
case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
default:
ret = _mmcamcorder_create_preview_pipeline(handle);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
return ret;
- }
/* connect capture signal */
if (!sc->bencbin_capture) {
ret = _mmcamcorder_connect_capture_signal(handle);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
return ret;
- }
}
break;
}
traceEnd(TTRACE_TAG_CAMERA);
}
#ifdef _MMCAMCORDER_GET_DEVICE_INFO
- if (!_mmcamcorder_get_device_info(handle)) {
+ if (!_mmcamcorder_get_device_info(handle))
_mmcam_dbg_err("Getting device information error!!");
- }
#endif
_mmcam_dbg_log("ret[%x]", ret);
GstMessage *gst_msg = NULL;
while ((gst_msg = gst_bus_pop(bus)) != NULL) {
_mmcamcorder_pipeline_cb_message(bus, gst_msg, (gpointer)hcamcorder);
- gst_message_unref( gst_msg );
+ gst_message_unref(gst_msg);
gst_msg = NULL;
}
- gst_object_unref( bus );
+ gst_object_unref(bus);
bus = NULL;
}
/* checking unreleased element */
- for (i = 0 ; i < element_num ; i++ ) {
+ for (i = 0 ; i < element_num ; i++) {
if (element[i].gst) {
if (GST_IS_ELEMENT(element[i].gst)) {
_mmcam_dbg_warn("Still alive element - ID[%d], name [%s], ref count[%d], status[%s]",
- element[i].id,
- GST_OBJECT_NAME(element[i].gst),
- GST_OBJECT_REFCOUNT(element[i].gst),
- gst_element_state_get_name(GST_STATE(element[i].gst)));
+ element[i].id,
+ GST_OBJECT_NAME(element[i].gst),
+ GST_OBJECT_REFCOUNT(element[i].gst),
+ gst_element_state_get_name(GST_STATE(element[i].gst)));
g_object_weak_unref(G_OBJECT(element[i].gst), (GWeakNotify)_mmcamcorder_element_release_noti, sc);
} else {
_mmcam_dbg_warn("The element[%d] is still aliving, check it", element[i].id);
for (k = 0; k < _MMCAMCORDER_STATE_SET_COUNT; k++) {
setChangeReturn = gst_element_set_state(pipeline, target_state);
- _mmcam_dbg_log("gst_element_set_state[%d] return %d",
- target_state, setChangeReturn);
+ _mmcam_dbg_log("gst_element_set_state[%d] return %d", target_state, setChangeReturn);
+
if (setChangeReturn != GST_STATE_CHANGE_FAILURE) {
getChangeReturn = gst_element_get_state(pipeline, &pipeline_state, NULL, get_timeout);
switch (getChangeReturn) {
/* if caturing isn't finished, waiting for 2 sec to finish real capture operation. check 'info->capturing'. */
mm_camcorder_set_attributes((MMHandleType)hcamcorder, NULL,
- MMCAM_CAPTURE_BREAK_CONTINUOUS_SHOT, TRUE,
- NULL);
+ MMCAM_CAPTURE_BREAK_CONTINUOUS_SHOT, TRUE,
+ NULL);
- for (i = 0; i < 20 && info->capturing; i++) {
+ for (i = 0; i < 20 && info->capturing; i++)
usleep(100000);
- }
- if (i == 20) {
+ if (i == 20)
_mmcam_dbg_err("Timeout. Can't check stop capturing.");
- }
- while ((itr_cnt--) && ((result = _mmcamcorder_capture_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
- _mmcam_dbg_warn("Can't stop capturing.(%x)", result);
- }
+ while ((itr_cnt--) && ((result = _mmcamcorder_capture_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE))
+ _mmcam_dbg_warn("Can't stop capturing.(%x)", result);
break;
}
while ((itr_cnt--) && ((result = _mmcamcorder_commit((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
_mmcam_dbg_warn("Can't commit.(%x)", result);
}
+
break;
}
case MM_CAMCORDER_STATE_PREPARE:
while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
_mmcam_dbg_warn("Can't stop preview.(%x)", result);
}
+
break;
}
case MM_CAMCORDER_STATE_READY:
if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE) {
_mmcam_dbg_warn("Can't unrealize.(%x)", result);
}
+
break;
}
case MM_CAMCORDER_STATE_NULL:
current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
}
- _mmcam_dbg_warn( "Done." );
+ _mmcam_dbg_warn("Done.");
return;
}
if (message->src) {
msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
_mmcam_dbg_err("-Msg src : [%s] Domain : [%s] Error : [%s] Code : [%d] is tranlated to error code : [0x%x]",
- msg_src_element, g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
+ msg_src_element, g_quark_to_string(error->domain), error->message, error->code, msg.param.code);
} else {
_mmcam_dbg_err("Domain : [%s] Error : [%s] Code : [%d] is tranlated to error code : [0x%x]",
- g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
+ g_quark_to_string(error->domain), error->message, error->code, msg.param.code);
}
#ifdef _MMCAMCORDER_SKIP_GST_FLOW_ERROR
element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst);
if (GST_ELEMENT_CAST(message->src) == element) {
- if (code == GST_CORE_ERROR_NEGOTIATION) {
+ if (code == GST_CORE_ERROR_NEGOTIATION)
return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
- } else {
+ else
return MM_ERROR_CAMCORDER_ENCODER;
- }
}
/* General */
- switch (code)
- {
- case GST_CORE_ERROR_STATE_CHANGE:
- return MM_ERROR_CAMCORDER_GST_STATECHANGE;
- case GST_CORE_ERROR_NEGOTIATION:
- return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
- case GST_CORE_ERROR_MISSING_PLUGIN:
- case GST_CORE_ERROR_SEEK:
- case GST_CORE_ERROR_NOT_IMPLEMENTED:
- case GST_CORE_ERROR_FAILED:
- case GST_CORE_ERROR_TOO_LAZY:
- case GST_CORE_ERROR_PAD:
- case GST_CORE_ERROR_THREAD:
- case GST_CORE_ERROR_EVENT:
- case GST_CORE_ERROR_CAPS:
- case GST_CORE_ERROR_TAG:
- case GST_CORE_ERROR_CLOCK:
- case GST_CORE_ERROR_DISABLED:
- default:
- return MM_ERROR_CAMCORDER_GST_CORE;
- break;
+ switch (code) {
+ case GST_CORE_ERROR_STATE_CHANGE:
+ return MM_ERROR_CAMCORDER_GST_STATECHANGE;
+ case GST_CORE_ERROR_NEGOTIATION:
+ return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
+ case GST_CORE_ERROR_MISSING_PLUGIN:
+ case GST_CORE_ERROR_SEEK:
+ case GST_CORE_ERROR_NOT_IMPLEMENTED:
+ case GST_CORE_ERROR_FAILED:
+ case GST_CORE_ERROR_TOO_LAZY:
+ case GST_CORE_ERROR_PAD:
+ case GST_CORE_ERROR_THREAD:
+ case GST_CORE_ERROR_EVENT:
+ case GST_CORE_ERROR_CAPS:
+ case GST_CORE_ERROR_TAG:
+ case GST_CORE_ERROR_CLOCK:
+ case GST_CORE_ERROR_DISABLED:
+ default:
+ return MM_ERROR_CAMCORDER_GST_CORE;
+ break;
}
}
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
- GstElement *element =NULL;
+ GstElement *element = NULL;
- mmf_return_val_if_fail( hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
}
-static gboolean __mmcamcorder_handle_gst_warning (MMHandleType handle, GstMessage *message, GError *error)
+static gboolean __mmcamcorder_handle_gst_warning(MMHandleType handle, GstMessage *message, GError *error)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
gchar *debug = NULL;
} else if (error->domain == GST_RESOURCE_ERROR) {
_mmcam_dbg_warn("GST warning: GST_RESOURCE domain");
__mmcamcorder_gst_handle_resource_warning(handle, message, error);
- } else if (error->domain == GST_STREAM_ERROR ) {
+ } else if (error->domain == GST_STREAM_ERROR) {
_mmcam_dbg_warn("GST warning: GST_STREAM domain");
} else {
_mmcam_dbg_warn("This error domain(%d) is not defined.", error->domain);
err = NULL;
}
if (debug != NULL) {
- _mmcam_dbg_err ("Debug: %s", debug);
+ _mmcam_dbg_err("Debug: %s", debug);
g_free(debug);
debug = NULL;
}
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
- GstElement *element =NULL;
+ GstElement *element = NULL;
gchar *msg_src_element;
- mmf_return_val_if_fail( hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
if (error->code == GST_RESOURCE_ERROR_FAILED) {
msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
_mmcam_dbg_warn("-Msg src:[%s] Domain:[%s] Error:[%s]",
- msg_src_element, g_quark_to_string(error->domain), error->message);
+ msg_src_element, g_quark_to_string(error->domain), error->message);
return MM_ERROR_NONE;
}
}
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
_mmcam_dbg_warn("Entered ");
pad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "sink");
- if(!pad) {
+ if (!pad) {
_mmcam_dbg_err("static pad is NULL");
return MM_ERROR_CAMCORDER_INVALID_STATE;
}
sink_caps = gst_pad_get_current_caps(pad);
- gst_object_unref( pad );
- if(!sink_caps) {
+ gst_object_unref(pad);
+ if (!sink_caps) {
_mmcam_dbg_err("fail to get caps");
return MM_ERROR_CAMCORDER_INVALID_STATE;
}
}
#ifdef _MMCAMCORDER_RM_SUPPORT
rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src,
- rm_device_request_s *info, void* cb_data)
+ rm_device_request_s *info, void* cb_data)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(cb_data);
int current_state = MM_CAMCORDER_STATE_NONE;
- rm_cb_result cb_res = RM_CB_RESULT_OK;
+ rm_cb_result cb_res = RM_CB_RESULT_OK;
- mmf_return_val_if_fail((MMHandleType)hcamcorder, RM_CB_RESULT_OK);
+ mmf_return_val_if_fail((MMHandleType)hcamcorder, RM_CB_RESULT_OK);
current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
- if (current_state <= MM_CAMCORDER_STATE_NONE ||
- current_state >= MM_CAMCORDER_STATE_NUM) {
+ if (current_state <= MM_CAMCORDER_STATE_NONE || current_state >= MM_CAMCORDER_STATE_NUM) {
_mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state);
}
_MMCAMCORDER_UNLOCK_ASM(hcamcorder);
- return cb_res;
+ return cb_res;
}
#endif /* _MMCAMCORDER_RM_SUPPORT */
/*===========================================================================================
| |
| INCLUDE FILES |
-| |
+| |
========================================================================================== */
#include "mm_camcorder_internal.h"
#include "mm_camcorder_platform.h"
| LOCAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------*/
-
-// Rule 1. 1:1 match except NONE.
-// Rule 2. MSL should be Superset.
-// Rule 3. sensor value should not be same as _MMCAMCORDER_SENSOR_ENUM_NONE.
+/*
+ * Rule 1. 1:1 match except NONE.
+ * Rule 2. MSL should be Superset.
+ * Rule 3. sensor value should not be same as _MMCAMCORDER_SENSOR_ENUM_NONE.
+*/
static int __enum_conv_whitebalance[MM_CAMCORDER_WHITE_BALANCE_NUM] ;
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_whitebalance =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_whitebalance = {
MM_CAMCORDER_WHITE_BALANCE_NUM,
__enum_conv_whitebalance,
CONFIGURE_CATEGORY_CTRL_EFFECT,
static int __enum_conv_colortone[MM_CAMCORDER_COLOR_TONE_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_colortone =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_colortone = {
MM_CAMCORDER_COLOR_TONE_NUM,
__enum_conv_colortone,
CONFIGURE_CATEGORY_CTRL_EFFECT,
static int __enum_conv_iso[MM_CAMCORDER_ISO_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_iso =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_iso = {
MM_CAMCORDER_ISO_NUM,
__enum_conv_iso,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
static int __enum_conv_prgrm[MM_CAMCORDER_SCENE_MODE_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_prgrm =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_prgrm = {
MM_CAMCORDER_SCENE_MODE_NUM,
__enum_conv_prgrm,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
static int __enum_conv_focus_mode[MM_CAMCORDER_FOCUS_MODE_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_focus_mode =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_focus_mode = {
MM_CAMCORDER_FOCUS_MODE_NUM,
__enum_conv_focus_mode,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
static int __enum_conv_focus_type[MM_CAMCORDER_AUTO_FOCUS_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_focus_type =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_focus_type = {
MM_CAMCORDER_AUTO_FOCUS_NUM,
__enum_conv_focus_type,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
static int __enum_conv_ae_type[MM_CAMCORDER_AUTO_EXPOSURE_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_ae_type =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_ae_type = {
MM_CAMCORDER_AUTO_EXPOSURE_NUM,
__enum_conv_ae_type,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
static int __enum_conv_strobe_ctrl[MM_CAMCORDER_STROBE_CONTROL_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_strobe_ctrl =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_strobe_ctrl = {
MM_CAMCORDER_STROBE_CONTROL_NUM,
__enum_conv_strobe_ctrl,
CONFIGURE_CATEGORY_CTRL_STROBE,
static int __enum_conv_strobe_mode[MM_CAMCORDER_STROBE_MODE_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_strobe_mode =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_strobe_mode = {
MM_CAMCORDER_STROBE_MODE_NUM,
__enum_conv_strobe_mode,
CONFIGURE_CATEGORY_CTRL_STROBE,
static int __enum_conv_wdr_ctrl[MM_CAMCORDER_WDR_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_wdr_ctrl =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_wdr_ctrl = {
MM_CAMCORDER_WDR_NUM,
__enum_conv_wdr_ctrl,
CONFIGURE_CATEGORY_CTRL_EFFECT,
static int __enum_conv_flip_ctrl[MM_CAMCORDER_FLIP_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_flip_ctrl =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_flip_ctrl = {
MM_CAMCORDER_FLIP_NUM,
__enum_conv_flip_ctrl,
CONFIGURE_CATEGORY_CTRL_EFFECT,
static int __enum_conv_rotation_ctrl[MM_CAMCORDER_ROTATION_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_rotation_ctrl =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_rotation_ctrl = {
MM_CAMCORDER_ROTATION_NUM,
__enum_conv_rotation_ctrl,
CONFIGURE_CATEGORY_CTRL_EFFECT,
static int __enum_conv_ahs[MM_CAMCORDER_AHS_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_ahs =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_ahs = {
MM_CAMCORDER_AHS_NUM,
__enum_conv_ahs,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
static int __enum_conv_video_stabilization[MM_CAMCORDER_VIDEO_STABILIZATION_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_video_stabilization =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_video_stabilization = {
MM_CAMCORDER_VIDEO_STABILIZATION_NUM,
__enum_conv_video_stabilization,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
static int __enum_conv_hdr_capture[MM_CAMCORDER_HDR_CAPTURE_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_hdr_capture =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_hdr_capture = {
MM_CAMCORDER_HDR_CAPTURE_NUM,
__enum_conv_hdr_capture,
CONFIGURE_CATEGORY_CTRL_CAPTURE,
static int __enum_conv_detect_mode[MM_CAMCORDER_DETECT_MODE_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_detect_mode =
-{
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_detect_mode = {
MM_CAMCORDER_DETECT_MODE_NUM,
__enum_conv_detect_mode,
CONFIGURE_CATEGORY_CTRL_DETECT,
| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------*/
/* STATIC INTERNAL FUNCTION */
-static int __mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default );
+static int __mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default);
/*===========================================================================================
| |
| FUNCTION DEFINITIONS |
-| |
+| |
========================================================================================== */
/*---------------------------------------------------------------------------
| GLOBAL FUNCTION DEFINITIONS: |
---------------------------------------------------------------------------*/
-//convert MSL value to sensor value
+/* convert MSL value to sensor value */
int _mmcamcorder_convert_msl_to_sensor(MMHandleType handle, int attr_idx, int mslval)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderInfoConverting *info = NULL;
- int i =0;
+ int i = 0;
int size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- //_mmcam_dbg_log("attr_idx(%d), mslval(%d)", attr_idx, mslval);
+ /* _mmcam_dbg_log("attr_idx(%d), mslval(%d)", attr_idx, mslval); */
info = hcamcorder->caminfo_convert;
- for (i = 0; i < size; i++)
- {
- if (info[i].attr_idx == attr_idx)
- {
+ for (i = 0; i < size; i++) {
+ if (info[i].attr_idx == attr_idx) {
_MMCamcorderEnumConvert * enum_convert = NULL;
enum_convert = info[i].enum_convert;
- if (enum_convert == NULL)
- {
- //_mmcam_dbg_log("enum_convert is NULL. Just return the original value.");
+ if (enum_convert == NULL) {
+ /* _mmcam_dbg_log("enum_convert is NULL. Just return the original value."); */
return mslval;
}
- if (enum_convert->enum_arr == NULL)
- {
+ if (enum_convert->enum_arr == NULL) {
_mmcam_dbg_warn("Unexpected error. Array pointer of enum_convert is NULL. Just return the original value.");
return mslval;
}
- if( enum_convert->total_enum_num > mslval && mslval >= 0 )
- {
- //_mmcam_dbg_log("original value(%d) -> converted value(%d)", mslval, enum_convert->enum_arr[mslval]);
+ if (enum_convert->total_enum_num > mslval && mslval >= 0) {
+ /* _mmcam_dbg_log("original value(%d) -> converted value(%d)", mslval, enum_convert->enum_arr[mslval]); */
return enum_convert->enum_arr[mslval];
- }
- else
- {
- _mmcam_dbg_warn( "Input mslval[%d] is invalid(out of array[idx:%d,size:%d]), so can not convert. Just return the original value.", mslval, attr_idx, enum_convert->total_enum_num );
+ } else {
+ _mmcam_dbg_warn("Input mslval[%d] is invalid(out of array[idx:%d,size:%d]), so can not convert. Just return the original value.", mslval, attr_idx, enum_convert->total_enum_num);
return mslval;
}
}
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- //_mmcam_dbg_log("prev resolution w:%d, h:%d", width, height);
+ /* _mmcam_dbg_log("prev resolution w:%d, h:%d", width, height); */
infoW = (MMCamAttrsInfo*)calloc(1, sizeof(MMCamAttrsInfo));
if (infoW == NULL) {
mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_WIDTH, infoW);
mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_HEIGHT, infoH);
- for(i=0; i < infoW->int_array.count; i++) {
- //_mmcam_dbg_log("width :%d, height : %d\n", infoW->int_array.array[i], infoH->int_array.array[i]);
- if(infoW->int_array.array[i] == width && infoH->int_array.array[i] == height) {
+ for (i = 0; i < infoW->int_array.count; i++) {
+ /* _mmcam_dbg_log("width :%d, height : %d\n", infoW->int_array.array[i], infoH->int_array.array[i]); */
+ if (infoW->int_array.array[i] == width && infoH->int_array.array[i] == height) {
valid_check = true;
snprintf(nameFps, 10, "FPS%d", i);
_mmcam_dbg_log("nameFps : %s!!!", nameFps);
free(infoH);
infoH = NULL;
- if(!valid_check) {
+ if (!valid_check) {
_mmcam_dbg_err("FAILED : Can't find the valid resolution from attribute.");
return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
}
return MM_ERROR_NONE;
}
-//convert sensor value to MSL value
+/* convert sensor value to MSL value */
int _mmcamcorder_convert_sensor_to_msl(MMHandleType handle, int attr_idx, int sensval)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
info = hcamcorder->caminfo_convert;
- for( i = 0 ; i < size ; i++ )
- {
- if( info[i].attr_idx == attr_idx )
- {
+ for (i = 0 ; i < size ; i++) {
+ if (info[i].attr_idx == attr_idx) {
_MMCamcorderEnumConvert * enum_convert = NULL;
enum_convert = info[i].enum_convert;
- if( enum_convert == NULL )
- {
- //_mmcam_dbg_log("enum_convert is NULL. Just return the original value.");
+ if (enum_convert == NULL) {
+ /* _mmcam_dbg_log("enum_convert is NULL. Just return the original value."); */
return sensval;
}
- if( enum_convert->enum_arr == NULL )
- {
+ if (enum_convert->enum_arr == NULL) {
_mmcam_dbg_warn("Unexpected error. Array pointer of enum_convert is NULL. Just return the original value.");
return sensval;
}
- for( j = 0 ; j < enum_convert->total_enum_num ; j++ )
- {
- if( sensval == enum_convert->enum_arr[j] )
- {
- //_mmcam_dbg_log("original value(%d) -> converted value(%d)", sensval, j);
+ for (j = 0 ; j < enum_convert->total_enum_num ; j++) {
+ if (sensval == enum_convert->enum_arr[j]) {
+ /* _mmcam_dbg_log("original value(%d) -> converted value(%d)", sensval, j); */
return j;
}
}
}
static int
-__mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default )
+__mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default)
{
int i = 0;
int valid_count = 0;
int new_default = _MMCAMCORDER_SENSOR_ENUM_NONE;
for (i = 0; i < original_count; i++) {
- if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE) {
+ if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE)
valid_count++;
- }
}
if (valid_count > 0) {
}
}
}
- }
- else {
+ } else {
valid_count = 0;
}
}
- if (new_default != _MMCAMCORDER_SENSOR_ENUM_NONE) {
+ if (new_default != _MMCAMCORDER_SENSOR_ENUM_NONE)
*valid_default = new_default;
- }
return valid_count;
}
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- attrs = MMF_CAMCORDER_ATTRS (handle);
+ attrs = MMF_CAMCORDER_ATTRS(handle);
mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
camera_conf *conf_info = NULL;
- for (i = 0; i < table_size ; i++ )
- {
+ for (i = 0; i < table_size; i++) {
/*
- _mmcam_dbg_log( "%d,%d,%d,%d,%s,%d",
- info[i].type,
- info[i].category,
- info[i].attr_idx,
- info[i].attr_idx_pair,
- info[i].keyword,
- info[i].conv_type );
+ _mmcam_dbg_log("%d,%d,%d,%d,%s,%d",
+ info[i].type,
+ info[i].category,
+ info[i].attr_idx,
+ info[i].attr_idx_pair,
+ info[i].keyword,
+ info[i].conv_type);
*/
- if( info[i].type == CONFIGURE_TYPE_MAIN )
- {
+ if (info[i].type == CONFIGURE_TYPE_MAIN) {
conf_info = hcamcorder->conf_main;
- /*_mmcam_dbg_log( "MAIN configure [%s]", info[i].keyword );*/
- }
- else
- {
+ /*_mmcam_dbg_log("MAIN configure [%s]", info[i].keyword);*/
+ } else {
conf_info = hcamcorder->conf_ctrl;
- /*_mmcam_dbg_log( "CTRL configure [%s]", info[i].keyword );*/
+ /*_mmcam_dbg_log("CTRL configure [%s]", info[i].keyword);*/
}
- switch(info[i].conv_type)
+ switch (info[i].conv_type) {
+ case MM_CAMCONVERT_TYPE_INT:
{
- case MM_CAMCONVERT_TYPE_INT:
- {
- int ivalue = 0;
-
- if (!_mmcamcorder_conf_get_value_int(handle, conf_info, info[i].category, info[i].keyword, &ivalue))
- {
- ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
- break; //skip to set
- }
+ int ivalue = 0;
- ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, ivalue);
- break;
+ if (!_mmcamcorder_conf_get_value_int(handle, conf_info, info[i].category, info[i].keyword, &ivalue)) {
+ ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+ break; /* skip to set */
}
- case MM_CAMCONVERT_TYPE_INT_ARRAY:
- {
- int *iarray = NULL;
- int iarray_size = 0;
- int idefault = 0;
- type_int_array *tarray = NULL;
-
- if (!_mmcamcorder_conf_get_value_int_array( conf_info, info[i].category, info[i].keyword, &tarray ))
- {
- ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
- break; //skip to set
- }
- if( tarray )
- {
- idefault = tarray->default_value;
+ ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, ivalue);
+ break;
+ }
+ case MM_CAMCONVERT_TYPE_INT_ARRAY:
+ {
+ int *iarray = NULL;
+ int iarray_size = 0;
+ int idefault = 0;
+ type_int_array *tarray = NULL;
+
+ if (!_mmcamcorder_conf_get_value_int_array(conf_info, info[i].category, info[i].keyword, &tarray)) {
+ ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+ break; /* skip to set */
+ }
- if( info[i].enum_convert )
- {
- iarray_size = __mmcamcorder_get_valid_array(tarray->value, tarray->count, &iarray, &idefault);
- }
- else
- {
- iarray = tarray->value;
- iarray_size = tarray->count;
- }
+ if (tarray) {
+ idefault = tarray->default_value;
- if( iarray_size > 0 )
- {
- /*
- _mmcam_dbg_log("INT Array. attr idx=%d array=%p, size=%d, default=%d",
- info[i].attr_idx, iarray, iarray_size, idefault);
- */
+ if (info[i].enum_convert) {
+ iarray_size = __mmcamcorder_get_valid_array(tarray->value, tarray->count, &iarray, &idefault);
+ } else {
+ iarray = tarray->value;
+ iarray_size = tarray->count;
+ }
- /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
- //mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
- mmf_attrs_set_valid_array(attrs, info[i].attr_idx, iarray, iarray_size, idefault);
+ if (iarray_size > 0) {
+ /*
+ _mmcam_dbg_log("INT Array. attr idx=%d array=%p, size=%d, default=%d",
+ info[i].attr_idx, iarray, iarray_size, idefault);
+ */
- ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, idefault);
- }
+ /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
+ /* mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY); */
+ mmf_attrs_set_valid_array(attrs, info[i].attr_idx, iarray, iarray_size, idefault);
+
+ ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, idefault);
}
+ }
- if (iarray && iarray != tarray->value )
- free(iarray);
+ if (iarray && iarray != tarray->value)
+ free(iarray);
- break;
- }
- case MM_CAMCONVERT_TYPE_INT_RANGE:
- {
- type_int_range *irange = NULL;
-
- if (!_mmcamcorder_conf_get_value_int_range(conf_info, info[i].category, info[i].keyword, &irange))
- {
- ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
- break; //skip to set
- }
+ break;
+ }
+ case MM_CAMCONVERT_TYPE_INT_RANGE:
+ {
+ type_int_range *irange = NULL;
- if( irange )
- {
- //_mmcam_dbg_log("INT Range. m:%d, s:%d, min=%d, max=%d", info[i].main_key, info[i].sub_key1, irange->min, irange->max);
- /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
- //mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_RANGE);
- mmf_attrs_set_valid_range(attrs, info[i].attr_idx, irange->min, irange->max, irange->default_value);
+ if (!_mmcamcorder_conf_get_value_int_range(conf_info, info[i].category, info[i].keyword, &irange)) {
+ ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+ break; /* skip to set */
+ }
- ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, irange->default_value);
- }
+ if (irange) {
+ /* _mmcam_dbg_log("INT Range. m:%d, s:%d, min=%d, max=%d", info[i].main_key, info[i].sub_key1, irange->min, irange->max); */
+ /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
+ /* mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_RANGE); */
+ mmf_attrs_set_valid_range(attrs, info[i].attr_idx, irange->min, irange->max, irange->default_value);
- break;
+ ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, irange->default_value);
}
- case MM_CAMCONVERT_TYPE_STRING:
- {
- const char *cString = NULL;
- unsigned int iString_len = 0;
-
- if (!_mmcamcorder_conf_get_value_string(handle, conf_info, info[i].category, info[i].keyword, &cString ))
- {
- ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
- break; //skip to set
- }
- //_mmcam_dbg_log("String. m:%d, s:%d, cString=%s", info[i].main_key, info[i].sub_key1, cString);
- //strlen makes a crash when null pointer is passed.
- if (cString)
- iString_len = strlen(cString);
- else
- iString_len = 0;
+ break;
+ }
+ case MM_CAMCONVERT_TYPE_STRING:
+ {
+ const char *cString = NULL;
+ unsigned int iString_len = 0;
- ret = mm_attrs_set_string(attrs, info[i].attr_idx, cString, iString_len);
- break;
+ if (!_mmcamcorder_conf_get_value_string(handle, conf_info, info[i].category, info[i].keyword, &cString)) {
+ ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+ break; /* skip to set */
}
- case MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY:
- {
- type_int_pair_array *pair_array = NULL;
- /*_mmcam_dbg_log("INT PAIR Array. type:%d, attr_idx:%d, attr_idx_pair:%d", info[i].type, info[i].attr_idx, info[i].attr_idx_pair);*/
+ /* _mmcam_dbg_log("String. m:%d, s:%d, cString=%s", info[i].main_key, info[i].sub_key1, cString); */
+ /* strlen makes a crash when null pointer is passed. */
+ if (cString)
+ iString_len = strlen(cString);
+ else
+ iString_len = 0;
- if (!_mmcamcorder_conf_get_value_int_pair_array(conf_info, info[i].category, info[i].keyword, &pair_array))
- {
- ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
- break; //skip to set
- }
+ ret = mm_attrs_set_string(attrs, info[i].attr_idx, cString, iString_len);
+ break;
+ }
+ case MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY:
+ {
+ type_int_pair_array *pair_array = NULL;
- if( pair_array && pair_array->count > 0 )
- {
- /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
- //mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
- mmf_attrs_set_valid_array(attrs, info[i].attr_idx,
- pair_array->value[0],
- pair_array->count,
- pair_array->default_value[0]);
- /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
- //mmf_attrs_set_valid_type(attrs, info[i].attr_idx_pair, MM_ATTRS_VALID_TYPE_INT_ARRAY);
- mmf_attrs_set_valid_array(attrs, info[i].attr_idx_pair,
- pair_array->value[1],
- pair_array->count,
- pair_array->default_value[1]);
-
- mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, pair_array->default_value[0]);
- mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx_pair, pair_array->default_value[1]);
- }
- break;
+ /*_mmcam_dbg_log("INT PAIR Array. type:%d, attr_idx:%d, attr_idx_pair:%d", info[i].type, info[i].attr_idx, info[i].attr_idx_pair);*/
+
+ if (!_mmcamcorder_conf_get_value_int_pair_array(conf_info, info[i].category, info[i].keyword, &pair_array)) {
+ ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+ break; /* skip to set */
}
- case MM_CAMCONVERT_TYPE_USER:
- default:
- _mmcam_dbg_log("default : s:%d", info[i].attr_idx);
- break;
+ if (pair_array && pair_array->count > 0) {
+ /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
+ /* mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY); */
+ mmf_attrs_set_valid_array(attrs, info[i].attr_idx,
+ pair_array->value[0],
+ pair_array->count,
+ pair_array->default_value[0]);
+ /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
+ /* mmf_attrs_set_valid_type(attrs, info[i].attr_idx_pair, MM_ATTRS_VALID_TYPE_INT_ARRAY); */
+ mmf_attrs_set_valid_array(attrs, info[i].attr_idx_pair,
+ pair_array->value[1],
+ pair_array->count,
+ pair_array->default_value[1]);
+
+ mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, pair_array->default_value[0]);
+ mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx_pair, pair_array->default_value[1]);
+ }
+ break;
+ }
+
+ case MM_CAMCONVERT_TYPE_USER:
+ default:
+ _mmcam_dbg_log("default : s:%d", info[i].attr_idx);
+ break;
}
}
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- _mmcamcorder_conf_get_value_int_array( hcamcorder->conf_ctrl, convert->category, convert->keyword, &array );
+ _mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl, convert->category, convert->keyword, &array);
- if( array )
- {
+ if (array)
convert->enum_arr = array->value;
- }
return MM_ERROR_NONE;
}
double _mmcamcorder_convert_volume(int mslVal)
{
double newVal = -1;
- switch (mslVal)
- {
- case 0:
- newVal = 0;
- break;
- case 1:
- newVal = 1;
- break;
- default:
- _mmcam_dbg_warn("out of range");
- break;
+ switch (mslVal) {
+ case 0:
+ newVal = 0;
+ break;
+ case 1:
+ newVal = 1;
+ break;
+ default:
+ _mmcam_dbg_warn("out of range");
+ break;
}
return newVal;
}
-
-
#define MRP_RESOURCE_TYPE_EXCLUSIVE FALSE
const char* mm_camcorder_resource_str[MM_CAMCORDER_RESOURCE_MAX] = {
- "camera",
- "video_overlay"
+ "camera",
+ "video_overlay"
};
#define MMCAMCORDER_CHECK_RESOURCE_MANAGER_INSTANCE(x_camcorder_resource_manager) \
_mmcam_dbg_err("no resource manager instance"); \
return MM_ERROR_INVALID_ARGUMENT; \
} \
-} while(0);
+} while (0);
#define MMCAMCORDER_CHECK_CONNECTION_RESOURCE_MANAGER(x_camcorder_resource_manager) \
do { \
return MM_ERROR_RESOURCE_NOT_INITIALIZED; \
} \
} \
-} while(0);
+} while (0);
static char *__mmcamcorder_resource_state_to_str(mrp_res_resource_state_t st)
{
}
for (i = 0; i < resource_names->num_strings; i++) {
resource = mrp_res_get_resource_by_name(rset, resource_names->strings[i]);
- if (resource) {
+ if (resource)
_mmcam_dbg_log(" - available resource: %s", resource->name);
- }
}
mrp_res_free_string_array(resource_names);
}
if (res == NULL) {
_mmcam_dbg_warn(" -- %s not present in resource set", mm_camcorder_resource_str[i]);
} else {
- _mmcam_dbg_log(" -- resource name [%s] -> [%s]",
- res->name, __mmcamcorder_resource_state_to_str(res->state));
+ _mmcam_dbg_log(" -- resource name [%s] -> [%s]", res->name, __mmcamcorder_resource_state_to_str(res->state));
}
}
return MM_ERROR_RESOURCE_INTERNAL;
}
- if (!mrp_res_set_autorelease(TRUE, resource_manager->rset)) {
+ if (!mrp_res_set_autorelease(TRUE, resource_manager->rset))
_mmcam_dbg_warn(" - could not set autorelease flag!");
- }
return MM_ERROR_NONE;
}
{
mrp_res_resource_t *resource = NULL;
resource = mrp_res_create_resource(resource_manager->rset,
- resource_name,
- MRP_RESOURCE_TYPE_MANDATORY,
- MRP_RESOURCE_TYPE_EXCLUSIVE);
+ resource_name,
+ MRP_RESOURCE_TYPE_MANDATORY,
+ MRP_RESOURCE_TYPE_EXCLUSIVE);
if (resource == NULL) {
_mmcam_dbg_err(" - could not include resource[%s]", resource_name);
return MM_ERROR_RESOURCE_INTERNAL;
MMCAMCORDER_CHECK_RESOURCE_MANAGER_INSTANCE(resource_manager);
MMCAMCORDER_CHECK_CONNECTION_RESOURCE_MANAGER(resource_manager);
- if (!resource_manager->rset) {
+ if (!resource_manager->rset)
ret = __mmcamcorder_resource_create_resource_set(resource_manager);
- }
+
if (ret == MM_ERROR_NONE) {
ret = __mmcamcorder_resource_include_resource(resource_manager, mm_camcorder_resource_str[resource_type]);
} else {
/* check sound play enable */
mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
- "capture-sound-enable", &sound_enable,
- 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;
}
- if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE02)) {
+ if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE02))
volume_gain = "shutter2";
- } else if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_STOP)) {
+ else if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_STOP))
volume_gain = "camcording";
- }
_mmcam_dbg_log("Play start - sample name [%s]", sample_name);
/* check sound play enable */
mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
- "capture-sound-enable", &sound_enable,
- 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");
/*---------------------------------------------------------------------------------------
| GLOBAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
-#define EXIF_SET_ERR( return_type,tag_id) \
- _mmcam_dbg_err("error=%x,tag=%x",return_type,tag_id); \
+#define EXIF_SET_ERR(return_type, tag_id) \
+ _mmcam_dbg_err("error=%x,tag=%x", return_type, tag_id); \
if (return_type == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) { \
goto exit; \
}
_MMCAMCORDER_PIPELINE_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCODE_MAIN_PIPE, "capture_pipeline", err);
err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder, MM_CAMCORDER_ENCBIN_PROFILE_IMAGE);
- if (err != MM_ERROR_NONE) {
+ if (err != MM_ERROR_NONE)
return err;
- }
/* add element and encodesink bin to encode main pipeline */
gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
- sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
- NULL);
+ sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
+ NULL);
/* Link each element : appsrc - capsfilter - encodesink bin */
srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst, "src");
/* connect handoff signal to get capture data */
MMCAMCORDER_SIGNAL_CONNECT(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
- _MMCAMCORDER_HANDLER_STILLSHOT, "handoff",
- G_CALLBACK(__mmcamcorder_handoff_callback),
- hcamcorder);
+ _MMCAMCORDER_HANDLER_STILLSHOT, "handoff",
+ G_CALLBACK(__mmcamcorder_handoff_callback),
+ hcamcorder);
return MM_ERROR_NONE;
if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
_mmcam_dbg_warn("connect capture signal to _MMCAMCORDER_VIDEOSRC_SRC");
MMCAMCORDER_SIGNAL_CONNECT(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst,
- _MMCAMCORDER_HANDLER_STILLSHOT, "still-capture",
- G_CALLBACK(__mmcamcorder_image_capture_cb),
- hcamcorder);
+ _MMCAMCORDER_HANDLER_STILLSHOT, "still-capture",
+ G_CALLBACK(__mmcamcorder_image_capture_cb),
+ hcamcorder);
return MM_ERROR_NONE;
} else {
/* ref element before remove it from pipeline */
gst_object_ref(sink_element);
- if (!gst_bin_remove(GST_BIN(sc->element[_MMCAMCORDER_MAIN_PIPE].gst), sink_element)) {
+ if (!gst_bin_remove(GST_BIN(sc->element[_MMCAMCORDER_MAIN_PIPE].gst), sink_element))
_mmcam_dbg_warn("failed to remove sink element from pipeline");
- }
/* set sink element pointer to attribute */
mm_attrs_get_index((MMHandleType)attrs, MMCAM_DISPLAY_REUSE_ELEMENT, &attr_index);
}
_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_CAPTURE,
- "UseCaptureMode",
- &UseCaptureMode);
+ CONFIGURE_CATEGORY_MAIN_CAPTURE,
+ "UseCaptureMode",
+ &UseCaptureMode);
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "VideosrcElement",
- &VideosrcElement);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "VideosrcElement",
+ &VideosrcElement);
_mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
info->capturing = TRUE;
ret = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_IMAGE_ENCODER, &image_encoder,
- MMCAM_CAMERA_WIDTH, &width,
- MMCAM_CAMERA_HEIGHT, &height,
- MMCAM_CAMERA_FPS, &fps,
- MMCAM_CAPTURE_FORMAT, &cap_format,
- MMCAM_CAPTURE_WIDTH, &info->width,
- MMCAM_CAPTURE_HEIGHT, &info->height,
- MMCAM_CAPTURE_COUNT, &info->count,
- MMCAM_CAPTURE_INTERVAL, &info->interval,
- MMCAM_STROBE_MODE, &strobe_mode,
- MMCAM_TAG_ORIENTATION, &tag_orientation,
- NULL);
+ MMCAM_IMAGE_ENCODER, &image_encoder,
+ MMCAM_CAMERA_WIDTH, &width,
+ MMCAM_CAMERA_HEIGHT, &height,
+ MMCAM_CAMERA_FPS, &fps,
+ MMCAM_CAPTURE_FORMAT, &cap_format,
+ MMCAM_CAPTURE_WIDTH, &info->width,
+ MMCAM_CAPTURE_HEIGHT, &info->height,
+ MMCAM_CAPTURE_COUNT, &info->count,
+ MMCAM_CAPTURE_INTERVAL, &info->interval,
+ MMCAM_STROBE_MODE, &strobe_mode,
+ MMCAM_TAG_ORIENTATION, &tag_orientation,
+ NULL);
if (err_name) {
_mmcam_dbg_warn("get_attributes err %s, ret 0x%x", err_name, ret);
SAFE_FREE(err_name);
}
_mmcam_dbg_log("preview(%dx%d,fmt:%d), capture(%dx%d,fmt:%d), count(%d), hdr mode(%d), interval (%d)",
- width, height, info->preview_format, info->width, info->height, cap_format,
- info->count, info->hdr_capture_mode, info->interval);
+ width, height, info->preview_format, info->width, info->height, cap_format,
+ info->count, info->hdr_capture_mode, info->interval);
/* check state */
if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
_mmcam_dbg_log("Sensor JPEG Capture [is_modified_size:%d]", is_modified_size);
} else {
/* no need to encode internally if ITLV format */
- if (info->preview_format != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+ if (info->preview_format != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY)
sc->internal_encode = TRUE;
- }
+
cap_fourcc = _mmcamcorder_get_fourcc(info->preview_format, image_encoder, hcamcorder->use_zero_copy_format);
_mmcam_dbg_log("MSL JPEG Capture : capture fourcc %c%c%c%c",
- cap_fourcc, cap_fourcc>>8, cap_fourcc>>16, cap_fourcc>>24);
+ cap_fourcc, cap_fourcc>>8, cap_fourcc>>16, cap_fourcc>>24);
}
} else {
cap_fourcc = _mmcamcorder_get_fourcc(cap_format, MM_IMAGE_CODEC_INVALID, hcamcorder->use_zero_copy_format);
}
if (UseCaptureMode) {
- if (width != MMFCAMCORDER_HIGHQUALITY_WIDTH || height != MMFCAMCORDER_HIGHQUALITY_HEIGHT) {
+ if (width != MMFCAMCORDER_HIGHQUALITY_WIDTH || height != MMFCAMCORDER_HIGHQUALITY_HEIGHT)
need_change = 1;
- }
} else {
- if (width != info->width || height != info->height) {
+ if (width != info->width || height != info->height)
need_change = 1;
- }
}
if (need_change) {
}
mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_CAMERA_ROTATION, &rotation,
- NULL);
+ MMCAM_CAMERA_ROTATION, &rotation,
+ NULL);
if (err_name) {
_mmcam_dbg_warn("get_attributes err %s", err_name);
SAFE_FREE(err_name);
}
ret = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_IMAGE_ENCODER_QUALITY, &cap_jpeg_quality,
- NULL);
+ MMCAM_IMAGE_ENCODER_QUALITY, &cap_jpeg_quality,
+ NULL);
if (err_name) {
_mmcam_dbg_warn("get_attributes err %s, ret 0x%x", err_name, ret);
SAFE_FREE(err_name);
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_IENC].gst, "quality", cap_jpeg_quality);
/* set handoff signal as TRUE */
- MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,"signal-handoffs", TRUE);
+ MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "signal-handoffs", TRUE);
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
/* Prepare for the shutter sound when it's the bencbin mode capture */
}
cmd_done:
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
info->capturing = FALSE;
- }
return ret;
}
info = sc->info_image;
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "VideosrcElement",
- &VideosrcElement);
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "VideosrcElement",
+ &VideosrcElement);
_mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
/* This case is starting of preview */
ret = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_CAMERA_FPS_AUTO, &fps_auto,
- MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
- NULL);
+ MMCAM_CAMERA_FPS_AUTO, &fps_auto,
+ MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
+ NULL);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, ret);
- SAFE_FREE (err_name);
+ SAFE_FREE(err_name);
}
_mmcam_dbg_log("focus mode %d", focus_mode);
}
while (current_framecount >= sc->kpi.video_framecount &&
- try_count++ < _MMCAMCORDER_CAPTURE_STOP_CHECK_COUNT) {
+ try_count++ < _MMCAMCORDER_CAPTURE_STOP_CHECK_COUNT) {
usleep(_MMCAMCORDER_CAPTURE_STOP_CHECK_INTERVAL);
}
}
}
_mmcam_dbg_log("Wait Frame Done. count before[%d],after[%d], try_count[%d]",
- current_framecount, sc->kpi.video_framecount, try_count);
+ current_framecount, sc->kpi.video_framecount, try_count);
} else {
ret = _mmcamcorder_remove_stillshot_pipeline(handle);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto cmd_error;
- }
if (info->resolution_change) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto cmd_error;
- }
/* check if resolution need to rollback */
mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_CAMERA_WIDTH, &width,
- MMCAM_CAMERA_HEIGHT, &height,
- MMCAM_CAMERA_FPS, &fps,
- MMCAM_CAMERA_ROTATION, &rotation,
- NULL);
+ MMCAM_CAMERA_WIDTH, &width,
+ MMCAM_CAMERA_HEIGHT, &height,
+ MMCAM_CAMERA_FPS, &fps,
+ MMCAM_CAMERA_ROTATION, &rotation,
+ NULL);
if (err_name) {
_mmcam_dbg_warn("get_attributes err %s, ret 0x%x", err_name, ret);
SAFE_FREE(err_name);
}
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto cmd_error;
- }
}
}
/* sound finalize */
- if (info->type == _MMCamcorder_MULTI_SHOT) {
+ if (info->type == _MMCamcorder_MULTI_SHOT)
_mmcamcorder_sound_finalize(handle);
- }
} else {
if (info->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "bitrate", H264_PREVIEW_BITRATE);
traceEnd(TTRACE_TAG_CAMERA);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto cmd_error;
- }
/* get sound status/volume level and register changed_cb */
if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_OFF &&
/* check strobe and set OFF if PERMANENT mode */
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_STROBE_MODE, &strobe_mode,
- NULL);
+ MMCAM_STROBE_MODE, &strobe_mode,
+ NULL);
if (strobe_mode == MM_CAMCORDER_STROBE_MODE_PERMANENT &&
GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
_mmcam_dbg_log("current strobe mode is PERMANENT, set OFF");
pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
- if(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst) {
- _mmcam_dbg_log("pipeline is exist so need to remove pipeline and sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst=%p",sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst);
+ if (sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst) {
+ _mmcam_dbg_log("pipeline is exist so need to remove pipeline and sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst=%p",
+ sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst);
_mmcamcorder_remove_recorder_pipeline(handle);
}
}
-void __mmcamcorder_init_stillshot_info (MMHandleType handle)
+void __mmcamcorder_init_stillshot_info(MMHandleType handle)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
_mmcam_dbg_log("capture type[%d], capture send count[%d]", info->type, info->capture_send_count);
- if (info->type ==_MMCamcorder_SINGLE_SHOT || info->capture_send_count == info->count) {
+ if (info->type == _MMCamcorder_SINGLE_SHOT || info->capture_send_count == info->count) {
info->capture_cur_count = 0;
info->capture_send_count = 0;
info->multi_shot_stop = TRUE;
} else {
_mmcam_dbg_log("data=%p, length=%d", original->data, original->length);
}
+
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
} else {
/* original is input/output param. save original values to local var. */
if (thumbnail) {
if (thumbnail->data && thumbnail->length > 0) {
_mmcam_dbg_log("thumbnail is added!thumbnail->data=%p thumbnail->width=%d ,thumbnail->height=%d",
- thumbnail->data, thumbnail->width, thumbnail->height);
+ thumbnail->data, thumbnail->width, thumbnail->height);
/* add thumbnail exif info */
ret = mm_exif_add_thumbnail_info(hcamcorder->exif_info,
- thumbnail->data,
- thumbnail->width,
- thumbnail->height,
- thumbnail->length);
+ thumbnail->data,
+ thumbnail->width,
+ thumbnail->height,
+ thumbnail->length);
} else {
_mmcam_dbg_err("Skip adding thumbnail (data=%p, length=%d)",
- thumbnail->data, thumbnail->length);
+ thumbnail->data, thumbnail->length);
}
}
} else {
if (ret == MM_ERROR_NONE) {
/* write jpeg with exif */
- ret = mm_exif_write_exif_jpeg_to_memory(&original->data, &original->length ,hcamcorder->exif_info, data, datalen);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("mm_exif_write_exif_jpeg_to_memory error! [0x%x]",ret);
- }
+ ret = mm_exif_write_exif_jpeg_to_memory(&original->data, &original->length, hcamcorder->exif_info, data, datalen);
+ if (ret != MM_ERROR_NONE)
+ _mmcam_dbg_err("mm_exif_write_exif_jpeg_to_memory error! [0x%x]", ret);
}
_mmcam_dbg_log("END ret 0x%x", ret);
gst_buffer_unmap(gst_sample_get_buffer(sample), &mapinfo);
_mmcam_dbg_warn("buffer data[%p],size[%dx%d],length[%d],format[%d]",
- capture_data->data, capture_data->width, capture_data->height,
- capture_data->length, capture_data->format);
+ capture_data->data, capture_data->width, capture_data->height,
+ capture_data->length, capture_data->format);
return;
GET_FAILED:
/* if tag enable and doesn't provide exif, we make it */
_mmcam_dbg_log("Add exif information if existed(thumbnail[%p])", thumbnail);
- if (thumbnail && thumbnail->data) {
+ if (thumbnail && thumbnail->data)
return __mmcamcorder_capture_save_exifinfo(handle, dest, thumbnail, provide_exif);
- } else {
+ else
return __mmcamcorder_capture_save_exifinfo(handle, dest, NULL, provide_exif);
- }
}
_mmcam_dbg_err("START - current state %d", current_state);
/* check capture state */
- if (info->type == _MMCamcorder_MULTI_SHOT && info->capture_send_count > 0) {
+ if (info->type == _MMCamcorder_MULTI_SHOT && info->capture_send_count > 0)
mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, "capture-break-cont-shot", &stop_cont_shot, NULL);
- }
if (!info->capturing || stop_cont_shot) {
- _mmcam_dbg_warn("stop command[%d] or not capturing state[%d]. skip this...",
- stop_cont_shot, info->capturing);
+ _mmcam_dbg_warn("stop command[%d] or not capturing state[%d]. skip this...", stop_cont_shot, info->capturing);
/*free GstBuffer*/
- if (sample1) {
+ if (sample1)
gst_sample_unref(sample1);
- }
- if (sample2) {
+
+ if (sample2)
gst_sample_unref(sample2);
- }
- if (sample3) {
+
+ if (sample3)
gst_sample_unref(sample3);
- }
return;
}
_mmcam_dbg_err("sample1[%p] is NULL or gst_buffer_map failed", sample1);
MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INTERNAL);
goto error;
- }else{
- if ( (mapinfo1.data == NULL) && (mapinfo1.size == 0) ){
+ } else {
+ if ((mapinfo1.data == NULL) && (mapinfo1.size == 0)) {
_mmcam_dbg_err("mapinfo1 is wrong (%p, size %d)", mapinfo1.data, mapinfo1.size);
MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INTERNAL);
gst_buffer_unmap(gst_sample_get_buffer(sample1), &mapinfo1);
goto error;
- }else
+ } else {
__mmcamcorder_get_capture_data_from_buffer(&dest, pixtype_main, sample1);
+ }
}
- if ( !sample2 || !gst_buffer_map(gst_sample_get_buffer(sample2), &mapinfo2, GST_MAP_READ) ) {
+ if (!sample2 || !gst_buffer_map(gst_sample_get_buffer(sample2), &mapinfo2, GST_MAP_READ))
_mmcam_dbg_log("sample2[%p] is NULL or gst_buffer_map failed. Not Error.", sample2);
- }
- if ( !sample3 || !gst_buffer_map(gst_sample_get_buffer(sample3), &mapinfo3, GST_MAP_READ)) {
+
+ if (!sample3 || !gst_buffer_map(gst_sample_get_buffer(sample3), &mapinfo3, GST_MAP_READ))
_mmcam_dbg_log("sample3[%p] is NULL or gst_buffer_map failed. Not Error.", sample3);
- }
/* Screennail image buffer */
attrs = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(hcamcorder);
ret = mmf_attribute_set_data(item_screennail, &scrnail, sizeof(scrnail));
_mmcam_dbg_log("Screennail set attribute data %p, size %d, ret %x", &scrnail, sizeof(scrnail), ret);
} else {
- _mmcam_dbg_log("Sample3 has wrong pointer. Not Error. (sample3=%p)",sample3);
+ _mmcam_dbg_log("Sample3 has wrong pointer. Not Error. (sample3=%p)", sample3);
mmf_attribute_set_data(item_screennail, NULL, 0);
}
/* Thumbnail image buffer */
if (sample2 && mapinfo2.data && (mapinfo2.size != 0)) {
- _mmcam_dbg_log("Thumbnail (buffer2=%p)",gst_sample_get_buffer(sample2));
+ _mmcam_dbg_log("Thumbnail (buffer2=%p)", gst_sample_get_buffer(sample2));
pixtype_thumb = _mmcamcorder_get_pixel_format(gst_sample_get_caps(sample2));
__mmcamcorder_get_capture_data_from_buffer(&thumb, pixtype_thumb, sample2);
} else {
char height[10];
ExifEntry *entry = NULL;
- exif_loader_write (l, dest.data, dest.length);
+ exif_loader_write(l, dest.data, dest.length);
/* Get a pointer to the EXIF data */
ed = exif_loader_get_data(l);
l = NULL;
if (ed) {
entry = exif_content_get_entry(ed->ifd[EXIF_IFD_1], EXIF_TAG_IMAGE_WIDTH);
- if (entry != NULL) {
- exif_entry_get_value(entry,width,10);
- }
+ if (entry != NULL)
+ exif_entry_get_value(entry, width, 10);
+
entry = NULL;
entry = exif_content_get_entry(ed->ifd[EXIF_IFD_1], EXIF_TAG_IMAGE_LENGTH);
- if (entry != NULL) {
- exif_entry_get_value(entry,height , 10);
- }
+ if (entry != NULL)
+ exif_entry_get_value(entry, height, 10);
+
entry = NULL;
/* Make sure the image had a thumbnail before trying to write it */
if (ed->data && ed->size) {
thumb.data = malloc(ed->size);
- memcpy(thumb.data,ed->data,ed->size);
+ memcpy(thumb.data, ed->data, ed->size);
thumb.length = ed->size;
thumb.format = MM_PIXEL_FORMAT_ENCODED;
thumb.width = atoi(width);
/* calculate thumbnail size */
thumb_width = THUMBNAIL_WIDTH;
thumb_height = (thumb_width * encode_src.height) / encode_src.width;
- if (thumb_height % 2 != 0) {
+ if (thumb_height % 2 != 0)
thumb_height += 1;
- }
_mmcam_dbg_log("need to resize : thumbnail size %dx%d, format %d",
- thumb_width, thumb_height, encode_src.format);
+ thumb_width, thumb_height, encode_src.format);
if ((encode_src.format == MM_PIXEL_FORMAT_UYVY ||
encode_src.format == MM_PIXEL_FORMAT_YUYV) &&
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("encode THUMBNAIL done - data %p, length %d", internal_thumb_data, internal_thumb_length);
thumb.data = internal_thumb_data;
thumb.length = internal_thumb_length;
_mmcam_dbg_warn("thumb_raw_data is NULL");
}
} else {
- // no raw data src for thumbnail
+ /* no raw data src for thumbnail */
_mmcam_dbg_log("no need to encode thumbnail");
}
}
/* Encode JPEG */
if (sc->internal_encode && pixtype_main != MM_PIXEL_FORMAT_ENCODED) {
mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
- MMCAM_IMAGE_ENCODER_QUALITY, &capture_quality,
- NULL);
+ MMCAM_IMAGE_ENCODER_QUALITY, &capture_quality,
+ NULL);
_mmcam_dbg_log("Start Internal Encode - capture_quality %d", capture_quality);
ret = _mmcamcorder_encode_jpeg(mapinfo1.data, dest.width, dest.height,
}
/* create EXIF info */
- if(!provide_exif){ // make new exif
+ if (!provide_exif) { /* make new exif */
ret = mm_exif_create_exif_info(&(hcamcorder->exif_info));
- } else { // load from jpeg buffer dest.data
+ } else { /* load from jpeg buffer dest.data */
ret = mm_exif_load_exif_info(&(hcamcorder->exif_info), dest.data, dest.length);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("Failed to load exif_info [%x], try to create EXIF", ret);
_mmcam_dbg_err("Failed to create exif_info [%x], but keep going...", ret);
} else {
/* add basic exif info */
- if(!provide_exif) {
+ if (!provide_exif) {
_mmcam_dbg_log("add basic exif info");
ret = __mmcamcorder_set_exif_basic_info((MMHandleType)hcamcorder, dest.width, dest.height);
} else {
mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, MMCAM_TAG_ENABLE, &tag_enable, NULL);
/* Set extra data for JPEG if tag enabled and doesn't provide EXIF */
- if (dest.format == MM_PIXEL_FORMAT_ENCODED){
+ if (dest.format == MM_PIXEL_FORMAT_ENCODED) {
if (tag_enable) {
mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
- MMCAM_IMAGE_ENCODER, &codectype,
- NULL);
+ MMCAM_IMAGE_ENCODER, &codectype,
+ NULL);
_mmcam_dbg_log("codectype %d", codectype);
switch (codectype) {
if (hcamcorder->vcapture_cb) {
_mmcam_dbg_log("APPLICATION CALLBACK START");
- if (thumb.data) {
+ if (thumb.data)
ret = hcamcorder->vcapture_cb(&dest, &thumb, hcamcorder->vcapture_cb_param);
- } else {
+ else
ret = hcamcorder->vcapture_cb(&dest, NULL, hcamcorder->vcapture_cb_param);
- }
+
_mmcam_dbg_log("APPLICATION CALLBACK END");
} else {
_mmcam_dbg_err("Capture callback is NULL.");
}
/* Release jpeg data */
- if (pixtype_main == MM_PIXEL_FORMAT_ENCODED) {
+ if (pixtype_main == MM_PIXEL_FORMAT_ENCODED)
__mmcamcorder_release_jpeg_data((MMHandleType)hcamcorder, &dest, tag_enable, provide_exif);
- }
error:
/* Check end condition and set proper value */
}
/* release internal allocated data */
- if (sc->internal_encode) {
+ if (sc->internal_encode)
compare_data = internal_main_data;
- } else {
+ else
compare_data = mapinfo1.data;
- }
+
if (dest.data && compare_data &&
dest.data != compare_data) {
_mmcam_dbg_log("release internal allocated data %p", dest.data);
int ret = MM_ERROR_NONE;
mm_camcorder_get_attributes(handle, NULL, MMCAM_TAG_ORIENTATION, &value, NULL);
- _mmcam_dbg_log("get orientation [%d]",value);
- if (value == 0) {
+ _mmcam_dbg_log("get orientation [%d]", value);
+ if (value == 0)
value = MM_EXIF_ORIENTATION;
- }
exif_set_short((unsigned char *)&eshort, exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_ORIENTATION,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort);
- if (ret != MM_ERROR_NONE) {
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort);
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_MAKER_NOTE);
- }
exit:
return ed;
if (make) {
_mmcam_dbg_log("maker [%s]", make);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_MAKE,
- EXIF_FORMAT_ASCII, strlen(make)+1, (const char *)make);
+ EXIF_FORMAT_ASCII, strlen(make)+1, (const char *)make);
free(make);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_MAKE);
- }
} else {
ret = MM_ERROR_CAMCORDER_LOW_MEMORY;
EXIF_SET_ERR(ret, EXIF_TAG_MAKE);
if (hcamcorder->software_version) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_SOFTWARE, EXIF_FORMAT_ASCII,
- strlen(hcamcorder->software_version)+1, (const char *)hcamcorder->software_version);
+ strlen(hcamcorder->software_version)+1, (const char *)hcamcorder->software_version);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("set software_version[%s] failed", hcamcorder->software_version);
} else {
if (hcamcorder->model_name) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_MODEL, EXIF_FORMAT_ASCII,
- strlen(hcamcorder->model_name)+1, (const char *)hcamcorder->model_name);
+ strlen(hcamcorder->model_name)+1, (const char *)hcamcorder->model_name);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("set model name[%s] failed", hcamcorder->model_name);
} else {
ret = mm_camcorder_get_attributes(handle, NULL, MMCAM_TAG_GPS_ENABLE, &gps_enable, NULL);
if (ret == MM_ERROR_NONE && gps_enable) {
- ExifByte GpsVersion[4]={2,2,0,0};
+ ExifByte GpsVersion[4] = {2, 2, 0, 0};
_mmcam_dbg_log("Tag for GPS is ENABLED.");
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_VERSION_ID,
- EXIF_FORMAT_BYTE, 4, (const char *)&GpsVersion);
- if (ret != MM_ERROR_NONE) {
+ EXIF_FORMAT_BYTE, 4, (const char *)&GpsVersion);
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_VERSION_ID);
- }
ret = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_TAG_LATITUDE, &latitude,
- MMCAM_TAG_LONGITUDE, &longitude,
- MMCAM_TAG_ALTITUDE, &altitude, NULL);
+ MMCAM_TAG_LATITUDE, &latitude,
+ MMCAM_TAG_LONGITUDE, &longitude,
+ MMCAM_TAG_ALTITUDE, &altitude, NULL);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("failed to get gps info [%x][%s]", ret, err_name);
SAFE_FREE(err_name);
if (latitude < 0) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE_REF,
- EXIF_FORMAT_ASCII, 2, "S");
+ EXIF_FORMAT_ASCII, 2, "S");
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_GPS_LATITUDE_REF);
}
+
latitude = -latitude;
} else if (latitude > 0) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE_REF,
- EXIF_FORMAT_ASCII, 2, "N");
+ EXIF_FORMAT_ASCII, 2, "N");
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_GPS_LATITUDE_REF);
}
}
deg = (unsigned int)(latitude);
- min = (unsigned int)((latitude-deg)*60);
- sec = (unsigned int)(((latitude-deg)*3600)-min*60);
+ min = (unsigned int)((latitude-deg) * 60);
+ sec = (unsigned int)(((latitude-deg) * 3600) - min * 60);
_mmcam_dbg_log("f_latitude deg[%d], min[%d], sec[%d]", deg, min, sec);
b = malloc(3 * sizeof(ExifRational));
rData.denominator = 1;
exif_set_rational(b, exif_data_get_byte_order(ed), rData);
rData.numerator = min;
- exif_set_rational(b+8, exif_data_get_byte_order(ed), rData);
+ exif_set_rational(b + 8, exif_data_get_byte_order(ed), rData);
rData.numerator = sec;
- exif_set_rational(b+16, exif_data_get_byte_order(ed), rData);
+ exif_set_rational(b + 16, exif_data_get_byte_order(ed), rData);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE,
- EXIF_FORMAT_RATIONAL, 3, (const char *)b);
+ EXIF_FORMAT_RATIONAL, 3, (const char *)b);
free(b);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_LATITUDE);
- }
} else {
_mmcam_dbg_warn("malloc failed");
}
if (longitude < 0) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE_REF,
- EXIF_FORMAT_ASCII, 2, "W");
+ EXIF_FORMAT_ASCII, 2, "W");
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_GPS_LONGITUDE_REF);
}
+
longitude = -longitude;
} else if (longitude > 0) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE_REF,
- EXIF_FORMAT_ASCII, 2, "E");
+ EXIF_FORMAT_ASCII, 2, "E");
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_GPS_LONGITUDE_REF);
}
}
deg = (unsigned int)(longitude);
- min = (unsigned int)((longitude-deg)*60);
- sec = (unsigned int)(((longitude-deg)*3600)-min*60);
+ min = (unsigned int)((longitude-deg) * 60);
+ sec = (unsigned int)(((longitude-deg) * 3600) - min * 60);
_mmcam_dbg_log("longitude deg[%d], min[%d], sec[%d]", deg, min, sec);
b = malloc(3 * sizeof(ExifRational));
rData.numerator = sec;
exif_set_rational(b+16, exif_data_get_byte_order(ed), rData);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE,
- EXIF_FORMAT_RATIONAL, 3, (const char *)b);
+ EXIF_FORMAT_RATIONAL, 3, (const char *)b);
free(b);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_LONGITUDE);
- }
} else {
_mmcam_dbg_warn("malloc failed");
}
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_ALTITUDE_REF,
- EXIF_FORMAT_BYTE, 1, (const char *)&alt_ref);
+ EXIF_FORMAT_BYTE, 1, (const char *)&alt_ref);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("error [%x], tag [%x]", ret, EXIF_TAG_GPS_ALTITUDE_REF);
if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) {
rData.denominator = 100;
exif_set_rational(b, exif_data_get_byte_order(ed), rData);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_ALTITUDE,
- EXIF_FORMAT_RATIONAL, 1, (const char *)b);
+ EXIF_FORMAT_RATIONAL, 1, (const char *)b);
free(b);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_ALTITUDE);
- }
} else {
_mmcam_dbg_warn("malloc failed");
}
exif_set_rational(b + 16, exif_data_get_byte_order(ed), rData);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_TIME_STAMP,
- EXIF_FORMAT_RATIONAL, 3, (const char *)b);
+ EXIF_FORMAT_RATIONAL, 3, (const char *)b);
free(b);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_TIME_STAMP);
- }
} else {
- _mmcam_dbg_warn( "malloc failed." );
+ _mmcam_dbg_warn("malloc failed.");
}
}
}
/* cause it should include NULL char */
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_DATE_STAMP,
- EXIF_FORMAT_ASCII, date_stamp_len + 1, (const char *)date_stamp);
- if (ret != MM_ERROR_NONE) {
+ EXIF_FORMAT_ASCII, date_stamp_len + 1, (const char *)date_stamp);
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_DATE_STAMP);
- }
}
}
_mmcam_dbg_log("Processing method [%s]", processing_method);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_PROCESSING_METHOD,
- EXIF_FORMAT_UNDEFINED, processing_method_len, (const char *)processing_method);
+ EXIF_FORMAT_UNDEFINED, processing_method_len, (const char *)processing_method);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_GPS_PROCESSING_METHOD);
}
}
}
} else {
- _mmcam_dbg_log( "Tag for GPS is DISABLED." );
+ _mmcam_dbg_log("Tag for GPS is DISABLED.");
}
exit:
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
ed = exif_data_new_from_data(imagedata, imgln);
- //ed = mm_exif_get_exif_from_info(hcamcorder->exif_info);
+ /*ed = mm_exif_get_exif_from_info(hcamcorder->exif_info);*/
if (ed == NULL) {
_mmcam_dbg_err("get exif data error!!");
/*0. EXIF_TAG_EXIF_VERSION */
ExifVersion = MM_EXIF_VERSION;
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXIF_VERSION,
- EXIF_FORMAT_UNDEFINED, 4, (const char *)&ExifVersion);
- if (ret != MM_ERROR_NONE) {
+ EXIF_FORMAT_UNDEFINED, 4, (const char *)&ExifVersion);
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_EXIF_VERSION);
- }
/*1. EXIF_TAG_IMAGE_WIDTH */ /*EXIF_TAG_PIXEL_X_DIMENSION*/
value = image_width;
exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_WIDTH,
- EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]);
- if (ret != MM_ERROR_NONE) {
+ EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]);
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_IMAGE_WIDTH);
- }
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_X_DIMENSION,
- EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
- if (ret != MM_ERROR_NONE) {
+ EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_PIXEL_X_DIMENSION);
- }
+
_mmcam_dbg_log("width[%d]", value);
/*2. EXIF_TAG_IMAGE_LENGTH*/ /*EXIF_TAG_PIXEL_Y_DIMENSION*/
value = image_height;
- exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order (ed), value);
+ exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_LENGTH,
- EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]);
+ EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_IMAGE_LENGTH);
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_Y_DIMENSION,
- EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
+ EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_PIXEL_Y_DIMENSION);
}
+
_mmcam_dbg_log("height[%d]", value);
/*4. EXIF_TAG_DATE_TIME */
localtime_r(&t, &tm);
snprintf((char *)b, 20, "%04i:%02i:%02i %02i:%02i:%02i",
- tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
- tm.tm_hour, tm.tm_min, tm.tm_sec);
+ tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+ tm.tm_hour, tm.tm_min, tm.tm_sec);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_DATE_TIME, EXIF_FORMAT_ASCII, 20, (const char *)b);
if (ret != MM_ERROR_NONE) {
- if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) {
+ if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY)
free(b);
- }
+
EXIF_SET_ERR(ret, EXIF_TAG_DATE_TIME);
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_ORIGINAL, EXIF_FORMAT_ASCII, 20, (const char *)b);
if (ret != MM_ERROR_NONE) {
- if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) {
+ if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY)
free(b);
- }
+
EXIF_SET_ERR(ret, EXIF_TAG_DATE_TIME_ORIGINAL);
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_DIGITIZED, EXIF_FORMAT_ASCII, 20, (const char *)b);
if (ret != MM_ERROR_NONE) {
- if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) {
+ if (ret == (int)MM_ERROR_CAMCORDER_LOW_MEMORY)
free(b);
- }
+
EXIF_SET_ERR(ret, EXIF_TAG_DATE_TIME_DIGITIZED);
}
if (description) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_DESCRIPTION,
- EXIF_FORMAT_ASCII, strlen(description), (const char *)description);
+ EXIF_FORMAT_ASCII, strlen(description), (const char *)description);
free(description);
str_value = NULL;
str_val_len = 0;
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_IMAGE_DESCRIPTION);
- }
} else {
_mmcam_dbg_err("strdup failed for [%s]", str_value);
}
char software[50] = {0,};
unsigned int len = 0;
- len = snprintf(software, sizeof(software), "%x.%x ", avsys_exif_info.software_used>>8,(avsys_exif_info.software_used & 0xff));
+ len = snprintf(software, sizeof(software), "%x.%x ", avsys_exif_info.software_used>>8, (avsys_exif_info.software_used & 0xff));
_mmcam_dbg_log("software [%s], len [%d]", software, len);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_SOFTWARE,
- EXIF_FORMAT_ASCII, len, (const char *)software);
+ EXIF_FORMAT_ASCII, len, (const char *)software);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_SOFTWARE);
}
/*FIXME : get user comment from real user */
user_comment = strdup(MM_USER_COMMENT);
if (user_comment) {
- _mmcam_dbg_log("user_comment=%s",user_comment);
+ _mmcam_dbg_log("user_comment=%s", user_comment);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_USER_COMMENT,
- EXIF_FORMAT_ASCII, strlen(user_comment), (const char *)user_comment);
+ EXIF_FORMAT_ASCII, strlen(user_comment), (const char *)user_comment);
free(user_comment);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_USER_COMMENT);
- }
} else {
ret = MM_ERROR_CAMCORDER_LOW_MEMORY;
EXIF_SET_ERR(ret, EXIF_TAG_USER_COMMENT);
if (control != NULL) {
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.colorspace);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_COLOR_SPACE,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_COLOR_SPACE);
}
/*10. EXIF_TAG_COMPONENTS_CONFIGURATION */
if (control != NULL) {
config = avsys_exif_info.component_configuration;
- _mmcam_dbg_log("EXIF_TAG_COMPONENTS_CONFIGURATION [%4x] ",config);
+ _mmcam_dbg_log("EXIF_TAG_COMPONENTS_CONFIGURATION [%4x] ", config);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_COMPONENTS_CONFIGURATION,
- EXIF_FORMAT_UNDEFINED, 4, (const char *)&config);
+ EXIF_FORMAT_UNDEFINED, 4, (const char *)&config);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_COMPONENTS_CONFIGURATION);
}
ExifRational rData;
_mmcam_dbg_log("EXIF_TAG_EXPOSURE_TIME numerator [%d], denominator [%d]",
- avsys_exif_info.exposure_time_numerator, avsys_exif_info.exposure_time_denominator);
+ avsys_exif_info.exposure_time_numerator, avsys_exif_info.exposure_time_denominator);
b = malloc(sizeof(ExifRational));
if (b) {
exif_set_rational(b, exif_data_get_byte_order(ed), rData);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_TIME,
- EXIF_FORMAT_RATIONAL, 1, (const char *)b);
+ EXIF_FORMAT_RATIONAL, 1, (const char *)b);
free(b);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_TIME);
}
} else {
_mmcam_dbg_log("Skip set EXIF_TAG_EXPOSURE_TIME numerator [%d], denominator [%d]",
- avsys_exif_info.exposure_time_numerator, avsys_exif_info.exposure_time_denominator);
+ avsys_exif_info.exposure_time_numerator, avsys_exif_info.exposure_time_denominator);
}
/*15. EXIF_TAG_FNUMBER */
ExifRational rData;
_mmcam_dbg_log("EXIF_TAG_FNUMBER numerator [%d], denominator [%d]",
- avsys_exif_info.aperture_f_num_numerator, avsys_exif_info.aperture_f_num_denominator);
+ avsys_exif_info.aperture_f_num_numerator, avsys_exif_info.aperture_f_num_denominator);
b = malloc(sizeof(ExifRational));
if (b) {
rData.denominator = avsys_exif_info.aperture_f_num_denominator;
exif_set_rational(b, exif_data_get_byte_order(ed), rData);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FNUMBER,
- EXIF_FORMAT_RATIONAL, 1, (const char *)b);
+ EXIF_FORMAT_RATIONAL, 1, (const char *)b);
free(b);
- if(ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_FNUMBER);
}
} else {
- _mmcam_dbg_warn( "malloc failed." );
+ _mmcam_dbg_warn("malloc failed.");
}
} else {
_mmcam_dbg_log("Skip set EXIF_TAG_FNUMBER numerator [%d], denominator [%d]",
- avsys_exif_info.aperture_f_num_numerator, avsys_exif_info.aperture_f_num_denominator);
+ avsys_exif_info.aperture_f_num_numerator, avsys_exif_info.aperture_f_num_denominator);
}
/*16. EXIF_TAG_EXPOSURE_PROGRAM*/
value = MM_EXPOSURE_PROGRAM;
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_PROGRAM,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_PROGRAM);
- }
/*17. EXIF_TAG_ISO_SPEED_RATINGS*/
if (avsys_exif_info.iso) {
_mmcam_dbg_log("EXIF_TAG_ISO_SPEED_RATINGS [%d]", avsys_exif_info.iso);
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.iso);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_ISO_SPEED_RATINGS);
}
ExifSRational rsData;
_mmcam_dbg_log("EXIF_TAG_SHUTTER_SPEED_VALUE numerator [%d], denominator [%d]",
- avsys_exif_info.shutter_speed_numerator, avsys_exif_info.shutter_speed_denominator);
+ avsys_exif_info.shutter_speed_numerator, avsys_exif_info.shutter_speed_denominator);
b = malloc(sizeof(ExifSRational));
if (b) {
rsData.denominator = avsys_exif_info.shutter_speed_denominator;
exif_set_srational(b, exif_data_get_byte_order(ed), rsData);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SHUTTER_SPEED_VALUE,
- EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
+ EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
free(b);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_SHUTTER_SPEED_VALUE);
}
} else {
_mmcam_dbg_log("Skip set EXIF_TAG_SHUTTER_SPEED_VALUE numerator [%d], denominator [%d]",
- avsys_exif_info.shutter_speed_numerator, avsys_exif_info.shutter_speed_denominator);
+ avsys_exif_info.shutter_speed_numerator, avsys_exif_info.shutter_speed_denominator);
}
/*19. EXIF_TAG_APERTURE_VALUE*/
rData.denominator = 1;
exif_set_rational(b, exif_data_get_byte_order(ed), rData);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_APERTURE_VALUE,
- EXIF_FORMAT_RATIONAL, 1, (const char *)b);
+ EXIF_FORMAT_RATIONAL, 1, (const char *)b);
free(b);
- if(ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_APERTURE_VALUE);
}
} else {
ExifSRational rsData;
_mmcam_dbg_log("EXIF_TAG_BRIGHTNESS_VALUE numerator [%d], denominator [%d]",
- avsys_exif_info.brigtness_numerator, avsys_exif_info.brightness_denominator);
+ avsys_exif_info.brigtness_numerator, avsys_exif_info.brightness_denominator);
b = malloc(sizeof(ExifSRational));
if (b) {
rsData.denominator = avsys_exif_info.brightness_denominator;
exif_set_srational(b, exif_data_get_byte_order(ed), rsData);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_BRIGHTNESS_VALUE,
- EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
+ EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
free(b);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_BRIGHTNESS_VALUE);
}
} else {
- _mmcam_dbg_warn( "malloc failed." );
+ _mmcam_dbg_warn("malloc failed.");
}
} else {
_mmcam_dbg_log("Skip set EXIF_TAG_BRIGHTNESS_VALUE numerator [%d], denominatorr [%d]",
- avsys_exif_info.brigtness_numerator, avsys_exif_info.brightness_denominator);
+ avsys_exif_info.brigtness_numerator, avsys_exif_info.brightness_denominator);
}
/*21. EXIF_TAG_EXPOSURE_BIAS_VALUE*/
ExifSRational rsData;
_mmcam_dbg_log("EXIF_TAG_BRIGHTNESS_VALUE %d, default %d, step denominator %d",
- value, hcamcorder->brightness_default, hcamcorder->brightness_step_denominator);
+ value, hcamcorder->brightness_default, hcamcorder->brightness_step_denominator);
b = malloc(sizeof(ExifSRational));
if (b) {
}
exif_set_srational(b, exif_data_get_byte_order(ed), rsData);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_BIAS_VALUE,
- EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
+ EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
free(b);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_BIAS_VALUE);
rData.denominator = 1;
exif_set_rational(b, exif_data_get_byte_order(ed), rData);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_MAX_APERTURE_VALUE,
- EXIF_FORMAT_RATIONAL, 1, b);
+ EXIF_FORMAT_RATIONAL, 1, b);
free(b);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_MAX_APERTURE_VALUE);
/*24. EXIF_TAG_METERING_MODE */
if (control != NULL) {
- exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed),avsys_exif_info.metering_mode);
+ exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.metering_mode);
_mmcam_dbg_log("EXIF_TAG_METERING_MODE [%d]", avsys_exif_info.metering_mode);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_METERING_MODE,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_METERING_MODE);
}
/*26. EXIF_TAG_FLASH*/
if (control != NULL) {
- exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order (ed),avsys_exif_info.flash);
+ exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.flash);
_mmcam_dbg_log("EXIF_TAG_FLASH [%d]", avsys_exif_info.flash);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FLASH,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_FLASH);
}
ExifRational rData;
_mmcam_dbg_log("EXIF_TAG_FOCAL_LENGTH numerator [%d], denominator [%d]",
- avsys_exif_info.focal_len_numerator, avsys_exif_info.focal_len_denominator);
+ avsys_exif_info.focal_len_numerator, avsys_exif_info.focal_len_denominator);
b = malloc(sizeof(ExifRational));
if (b) {
rData.denominator = avsys_exif_info.focal_len_denominator;
exif_set_rational(b, exif_data_get_byte_order(ed), rData);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH,
- EXIF_FORMAT_RATIONAL, 1, (const char *)b);
+ EXIF_FORMAT_RATIONAL, 1, (const char *)b);
free(b);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_FOCAL_LENGTH);
}
} else {
_mmcam_dbg_log("Skip set EXIF_TAG_FOCAL_LENGTH numerator [%d], denominator [%d]",
- avsys_exif_info.focal_len_numerator, avsys_exif_info.focal_len_denominator);
+ avsys_exif_info.focal_len_numerator, avsys_exif_info.focal_len_denominator);
}
/*28. EXIF_TAG_SENSING_METHOD*/
/*FIXME*/
value = MM_SENSING_MODE;
- exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order (ed),value);
+ exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SENSING_METHOD,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_SENSING_METHOD);
}
value = MM_FILE_SOURCE;
exif_set_long(&elong[cntl], exif_data_get_byte_order(ed),value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FILE_SOURCE,
- EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]);
+ EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_FILE_SOURCE);
}
value = MM_SCENE_TYPE;
exif_set_long(&elong[cntl], exif_data_get_byte_order(ed),value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SCENE_TYPE,
- EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]);
+ EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_SCENE_TYPE);
}
/*31. EXIF_TAG_EXPOSURE_MODE*/
/*FIXME*/
value = MM_EXPOSURE_MODE;
- exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed),value);
+ exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_MODE,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_MODE);
- }
-
/*32. EXIF_TAG_WHITE_BALANCE*/
ret = mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_WB, &value, NULL);
int set_value = 0;
_mmcam_dbg_log("WHITE BALANCE [%d]", value);
- if (value == MM_CAMCORDER_WHITE_BALANCE_AUTOMATIC) {
+ if (value == MM_CAMCORDER_WHITE_BALANCE_AUTOMATIC)
set_value = 0;
- } else {
+ else
set_value = 1;
- }
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), set_value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_WHITE_BALANCE,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_WHITE_BALANCE);
}
exif_set_long(&elong[cntl], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_DIGITAL_ZOOM_RATIO,
- EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
+ EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_DIGITAL_ZOOM_RATIO);
}
value = MM_FOCAL_LENGTH_35MMFILM;
exif_set_short(&eshort[cnts], exif_data_get_byte_order(ed),value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM);
}
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), scene_capture_type);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SCENE_CAPTURE_TYPE,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_SCENE_CAPTURE_TYPE);
}
value = MM_GAIN_CONTROL;
exif_set_long(&elong[cntl], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_GAIN_CONTROL,
- EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
+ EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_GAIN_CONTROL);
}
int level = 0;
_mmcamcorder_conf_get_value_int_range(hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_EFFECT,
- "Contrast",
- &irange);
+ CONFIGURE_CATEGORY_CTRL_EFFECT,
+ "Contrast",
+ &irange);
if (irange != NULL) {
mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_CONTRAST, &value, NULL);
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), level);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_CONTRAST,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_CONTRAST);
}
int level = 0;
_mmcamcorder_conf_get_value_int_range(hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_EFFECT,
- "Saturation",
- &irange);
+ CONFIGURE_CATEGORY_CTRL_EFFECT,
+ "Saturation",
+ &irange);
if (irange != NULL) {
mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SATURATION, &value, NULL);
} else if (value < irange->default_value) {
level = MM_VALUE_LOW;
} else {
- level=MM_VALUE_HARD;
+ level = MM_VALUE_HARD;
}
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), level);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SATURATION,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_SATURATION);
}
int level = 0;
_mmcamcorder_conf_get_value_int_range(hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_EFFECT,
- "Sharpness",
- &irange);
+ CONFIGURE_CATEGORY_CTRL_EFFECT,
+ "Sharpness",
+ &irange);
if (irange != NULL) {
mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SHARPNESS, &value, NULL);
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), level);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SHARPNESS,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_SHARPNESS);
}
_mmcam_dbg_log("DISTANCE_RANGE [%d]", value);
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SUBJECT_DISTANCE_RANGE,
- EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
+ EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
if (ret != MM_ERROR_NONE) {
EXIF_SET_ERR(ret, EXIF_TAG_SUBJECT_DISTANCE_RANGE);
}
_mmcam_dbg_log("");
ret = mm_exif_set_exif_to_info(hcamcorder->exif_info, ed);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
_mmcam_dbg_err("mm_exif_set_exif_to_info err!! [%x]", ret);
- }
exit:
_mmcam_dbg_log("finished!! [%x]", ret);
- if (ed) {
- exif_data_unref (ed);
- }
+ if (ed)
+ exif_data_unref(ed);
return ret;
}
#define TIME_STRING_MAX_LEN 64
#define __MMCAMCORDER_CAPTURE_WAIT_TIMEOUT 5
-#define FPUTC_CHECK(x_char, x_file)\
-{\
- if (fputc(x_char, x_file) == EOF) \
- {\
- _mmcam_dbg_err("[Critical] fputc() returns fail.\n"); \
- return FALSE;\
- }\
+#define FPUTC_CHECK(x_char, x_file) \
+{ \
+ if (fputc(x_char, x_file) == EOF) { \
+ _mmcam_dbg_err("[Critical] fputc() returns fail.\n"); \
+ return FALSE; \
+ } \
}
-#define FPUTS_CHECK(x_str, x_file)\
-{\
- if (fputs(x_str, x_file) == EOF) \
- {\
- _mmcam_dbg_err("[Critical] fputs() returns fail.\n");\
- SAFE_G_FREE(str); \
- return FALSE;\
- }\
+#define FPUTS_CHECK(x_str, x_file) \
+{ \
+ if (fputs(x_str, x_file) == EOF) { \
+ _mmcam_dbg_err("[Critical] fputs() returns fail.\n"); \
+ SAFE_G_FREE(str); \
+ return FALSE; \
+ } \
}
/*---------------------------------------------------------------------------
---------------------------------------------------------------------------*/
/* STATIC INTERNAL FUNCTION */
-//static gint skip_mdat(FILE *f);
+//static gint skip_mdat(FILE *f);
static guint16 get_language_code(const char *str);
static gchar* str_to_utf8(const gchar *str);
static inline gboolean write_tag(FILE *f, const gchar *tag);
/*===========================================================================================
| |
| FUNCTION DEFINITIONS |
-| |
+| |
========================================================================================== */
/*---------------------------------------------------------------------------
| GLOBAL FUNCTION DEFINITIONS: |
return MM_ERROR_NONE;
}
- end_time = g_get_monotonic_time()+ (time_out * G_TIME_SPAN_MILLISECOND);
+ 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");
size_t read_item = 0;
guchar buf[8];
- if (do_rewind) {
+ if (do_rewind)
rewind(f);
- }
while ((read_item = fread(&buf, sizeof(guchar), 8, f)) > 0) {
uint64_t buf_size = 0;
buf_size = _mmcamcorder_get_container_size(buf);
/* if size of mdat is 1, it means largesize is used.(bigger than 4GB) */
- if (buf_fourcc == MMCAM_FOURCC('m','d','a','t') &&
+ if (buf_fourcc == MMCAM_FOURCC('m', 'd', 'a', 't') &&
buf_size == 1) {
read_item = fread(&buf, sizeof(guchar), 8, f);
if (read_item < 8) {
size_t read_item = 0;
guchar buf[8];
- if (do_rewind) {
+ if (do_rewind)
rewind(f);
- }
while ((read_item = fread(&buf, sizeof(guchar), 8, f)) > 0) {
uint64_t buf_size = 0;
if (tag_fourcc == buf_fourcc) {
_mmcam_dbg_log("find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
return TRUE;
- } else if (buf_fourcc == MMCAM_FOURCC('m','o','o','v') &&
- tag_fourcc != buf_fourcc) {
- if (_mmcamcorder_find_fourcc(f, tag_fourcc, FALSE)) {
+ } else if (buf_fourcc == MMCAM_FOURCC('m', 'o', 'o', 'v') &&
+ tag_fourcc != buf_fourcc) {
+ if (_mmcamcorder_find_fourcc(f, tag_fourcc, FALSE))
return TRUE;
- } else {
+ else
continue;
- }
} else {
_mmcam_dbg_log("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc));
buf_size = _mmcamcorder_get_container_size(buf);
/* if size of mdat is 1, it means largesize is used.(bigger than 4GB) */
- if (buf_fourcc == MMCAM_FOURCC('m','d','a','t') &&
+ if (buf_fourcc == MMCAM_FOURCC('m', 'd', 'a', 't') &&
buf_size == 1) {
read_item = fread(&buf, sizeof(guchar), 8, f);
if (read_item < 8) {
gboolean _mmcamcorder_update_size(FILE *f, gint64 prev_pos, gint64 curr_pos)
{
_mmcam_dbg_log("size : %"G_GINT64_FORMAT"", curr_pos-prev_pos);
- if(fseeko(f, prev_pos, SEEK_SET) != 0)
- {
+ if (fseeko(f, prev_pos, SEEK_SET) != 0) {
_mmcam_dbg_err("fseeko() fail");
return FALSE;
}
if (!write_to_32(f, curr_pos -prev_pos))
return FALSE;
- if(fseeko(f, curr_pos, SEEK_SET) != 0)
- {
+ if (fseeko(f, curr_pos, SEEK_SET) != 0) {
_mmcam_dbg_err("fseeko() fail");
return FALSE;
}
_mmcam_dbg_log("");
- if((pos = ftello(f))<0)
- {
+ if ((pos = ftello(f)) < 0) {
_mmcam_dbg_err("ftello() returns negative value");
return FALSE;
}
- if(!write_to_32(f, 0)) //size
+ if (!write_to_32(f, 0)) //size
return FALSE;
- if(!write_tag(f, "loci")) // type
+ if (!write_tag(f, "loci")) // type
return FALSE;
FPUTC_CHECK(0, f); // version
- if(!write_to_24(f, 0)) // flags
+ if (!write_to_24(f, 0)) // flags
return FALSE;
- if(!write_to_16(f, get_language_code("eng"))) // language
+ if (!write_to_16(f, get_language_code("eng"))) // language
return FALSE;
str = str_to_utf8("location_name");
FPUTC_CHECK('\0', f);
FPUTC_CHECK(0, f); //role
- if(!write_to_32(f, info.longitude)) // Longitude
+ if (!write_to_32(f, info.longitude)) // Longitude
return FALSE;
- if(!write_to_32(f, info.latitude)) // Latitude
+ if (!write_to_32(f, info.latitude)) // Latitude
return FALSE;
- if(! write_to_32(f, info.altitude)) // Altitude
+ if (!write_to_32(f, info.altitude)) // Altitude
return FALSE;
str = str_to_utf8("Astronomical_body");
FPUTC_CHECK('\0', f);
- if((current_pos = ftello(f))<0)
- {
+ if ((current_pos = ftello(f)) < 0) {
_mmcam_dbg_err("ftello() returns negative value");
return FALSE;
}
- if(! _mmcamcorder_update_size(f, pos, current_pos))
+ if (!_mmcamcorder_update_size(f, pos, current_pos))
return FALSE;
return TRUE;
}
-void _mmcamcorder_write_Latitude(FILE *f,int value) {
+void _mmcamcorder_write_Latitude(FILE *f, int value)
+{
char s_latitude[9];
int l_decimal = 0;
int l_below_decimal = 0;
l_decimal = value / 10000;
if (value < 0) {
- if( l_decimal == 0) {
+ if (l_decimal == 0)
snprintf(s_latitude, 5, "-%.2d.", l_decimal);
- } else {
+ else
snprintf(s_latitude, 5, "%.2d.", l_decimal);
- }
} else {
snprintf(s_latitude, 5, "+%.2d.", l_decimal);
}
l_below_decimal = value - (l_decimal * 10000);
- if (l_below_decimal < 0) {
+ if (l_below_decimal < 0)
l_below_decimal = -l_below_decimal;
- }
+
snprintf(&s_latitude[4], 5, "%.4d", l_below_decimal);
write_tag(f, s_latitude);
}
-void _mmcamcorder_write_Longitude(FILE *f,int value) {
+void _mmcamcorder_write_Longitude(FILE *f, int value)
+{
char s_longitude[10];
int l_decimal = 0;
int l_below_decimal = 0;
l_decimal = value / 10000;
if (value < 0) {
- if( l_decimal == 0) {
+ if (l_decimal == 0)
snprintf(s_longitude, 6, "-%.3d.", l_decimal);
- } else {
+ else
snprintf(s_longitude, 6, "%.3d.", l_decimal);
- }
} else {
snprintf(s_longitude, 6, "+%.3d.", l_decimal);
}
l_below_decimal = value - (l_decimal * 10000);
- if (l_below_decimal < 0) {
+ if (l_below_decimal < 0)
l_below_decimal = -l_below_decimal;
- }
+
snprintf(&s_longitude[5], 5, "%.4d", l_below_decimal);
write_tag(f, s_longitude);
// 0x15c7 -> encode in english
#define D_INFO_GEOGRAPH 0x001215c7
-gboolean _mmcamcorder_write_geodata(FILE *f,_MMCamcorderLocationInfo info) {
-
+gboolean _mmcamcorder_write_geodata(FILE *f, _MMCamcorderLocationInfo info)
+{
gint64 current_pos, pos;
_mmcam_dbg_log("");
- if((pos = ftello(f))<0)
- {
+ if ((pos = ftello(f)) < 0) {
_mmcam_dbg_err("ftello() returns negative value");
return FALSE;
}
- if(!write_to_32(f, 0)) //size
+ if (!write_to_32(f, 0)) //size
return FALSE;
// tag -> .xyz
- if(!write_tag(f, D_GEOGRAPH)) // type
+ if (!write_tag(f, D_GEOGRAPH)) // type
return FALSE;
- if(!write_to_32(f, D_INFO_GEOGRAPH))
+ if (!write_to_32(f, D_INFO_GEOGRAPH))
return FALSE;
- _mmcamcorder_write_Latitude(f,info.latitude);
- _mmcamcorder_write_Longitude(f,info.longitude);
+ _mmcamcorder_write_Latitude(f, info.latitude);
+ _mmcamcorder_write_Longitude(f, info.longitude);
FPUTC_CHECK(0x2F, f);
- if((current_pos = ftello(f))<0)
- {
+ if ((current_pos = ftello(f)) < 0) {
_mmcam_dbg_err("ftello() returns negative value");
return FALSE;
}
- if(! _mmcamcorder_update_size(f, pos, current_pos))
+ if (!_mmcamcorder_update_size(f, pos, current_pos))
return FALSE;
return TRUE;
return TRUE;
}
- if ((pos = ftello(f))<0) {
+ if ((pos = ftello(f)) < 0) {
_mmcam_dbg_err("ftello() returns negative value");
return FALSE;
}
return FALSE;
}
- if (!_mmcamcorder_write_geodata(f,geotag)) {
+ if (!_mmcamcorder_write_geodata(f, geotag)) {
_mmcam_dbg_err("failed to write geodata");
return FALSE;
}
}
- if ((current_pos = ftello(f))<0) {
+ if ((current_pos = ftello(f)) < 0) {
_mmcam_dbg_err("ftello() returns negative value");
return FALSE;
}
write_to_32(f, 0x40000000);
_mmcam_dbg_log("orientation : %d, write data 0x%x 0x%x 0x%x 0x%x",
- orientation, a, b, c, d);
+ orientation, a, b, c, d);
return TRUE;
}
return -1;
}
- if (stat_path.st_dev != stat_root.st_dev) {
+ if (stat_path.st_dev != stat_root.st_dev)
is_internal = FALSE;
- }
} else {
_mmcam_dbg_warn("root_directory is NULL, assume that it's internal storage.");
}
- if (is_internal) {
+ if (is_internal)
ret = storage_get_internal_memory_size(&vfs);
- } else {
+ else
ret = storage_get_external_memory_size(&vfs);
- }
if (ret < 0) {
*free_space = 0;
g_mutex_unlock(&gdbus_info->sync_mutex);
- if (sync_play && ret == MM_ERROR_NONE) {
+ if (sync_play && ret == MM_ERROR_NONE)
ret = __gdbus_wait_for_cb_return(gdbus_info, G_DBUS_CB_TIMEOUT_MSEC);
- }
return ret;
}
if (item->category & category) {
if (item->object && GST_IS_PAD(item->object)) {
_mmcam_dbg_log("Remove buffer probe on [%s:%s] - [ID : %lu], [Category : %x]",
- GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category);
+ GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category);
gst_pad_remove_probe(GST_PAD(item->object), item->handler_id);
} else {
_mmcam_dbg_warn("Remove buffer probe faild, the pad is null or not pad, just remove item from list and free it");
if (item->object && item->object == object) {
if (GST_IS_PAD(item->object)) {
_mmcam_dbg_log("Remove buffer probe on [%s:%s] - [ID : %lu], [Category : %x]",
- GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category);
+ GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category);
gst_pad_remove_probe(GST_PAD(item->object), item->handler_id);
} else {
_mmcam_dbg_warn("Remove buffer probe faild, the pad is null or not pad, just remove item from list and free it");
if (item->category & category) {
if (item->object && GST_IS_PAD(item->object)) {
_mmcam_dbg_log("Remove event probe on [%s:%s] - [ID : %lu], [Category : %x]",
- GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category);
+ GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category);
gst_pad_remove_probe(GST_PAD(item->object), item->handler_id);
} else {
_mmcam_dbg_warn("Remove event probe faild, the pad is null or not pad, just remove item from list and free it");
if (item->object && GST_IS_ELEMENT(item->object)) {
if (g_signal_handler_is_connected(item->object, item->handler_id)) {
_mmcam_dbg_log("Disconnect signal from [%s] : [ID : %lu], [Category : %x]",
- GST_OBJECT_NAME(item->object), item->handler_id, item->category);
+ GST_OBJECT_NAME(item->object), item->handler_id, item->category);
g_signal_handler_disconnect(item->object, item->handler_id);
} else {
_mmcam_dbg_warn("Signal was not connected, cannot disconnect it : [%s] [ID : %lu], [Category : %x]",
- GST_OBJECT_NAME(item->object), item->handler_id, item->category);
+ GST_OBJECT_NAME(item->object), item->handler_id, item->category);
}
} else {
_mmcam_dbg_err("Fail to Disconnecting signal, the element is null or not element, just remove item from list and free it");
_mmcam_dbg_log("ENTER");
- if(hcamcorder->signals)
+ if (hcamcorder->signals)
_mmcamcorder_disconnect_signal((MMHandleType)hcamcorder, category);
- if(hcamcorder->event_probes)
+ if (hcamcorder->event_probes)
_mmcamcorder_remove_event_probe((MMHandleType)hcamcorder, category);
- if(hcamcorder->buffer_probes)
+ if (hcamcorder->buffer_probes)
_mmcamcorder_remove_buffer_probe((MMHandleType)hcamcorder, category);
_mmcam_dbg_log("LEAVE");
void _mmcamcorder_element_release_noti(gpointer data, GObject *where_the_object_was)
{
- int i=0;
+ int i = 0;
_MMCamcorderSubContext *sc = (_MMCamcorderSubContext *)data;
mmf_return_if_fail(sc);
for (i = 0 ; i < _MMCAMCORDER_PIPELINE_ELEMENT_NUM ; i++) {
if (sc->element[i].gst && (G_OBJECT(sc->element[i].gst) == where_the_object_was)) {
- _mmcam_dbg_warn("The element[%d][%p] is finalized",
- sc->element[i].id, sc->element[i].gst);
+ _mmcam_dbg_warn("The element[%d][%p] is finalized", sc->element[i].id, sc->element[i].gst);
sc->element[i].gst = NULL;
sc->element[i].id = _MMCAMCORDER_NONE;
return;
for (i = 0 ; i < _MMCAMCORDER_ENCODE_PIPELINE_ELEMENT_NUM ; i++) {
if (sc->encode_element[i].gst && (G_OBJECT(sc->encode_element[i].gst) == where_the_object_was)) {
- _mmcam_dbg_warn("The encode element[%d][%p] is finalized",
- sc->encode_element[i].id, sc->encode_element[i].gst);
+ _mmcam_dbg_warn("The encode element[%d][%p] is finalized", sc->encode_element[i].id, sc->encode_element[i].gst);
sc->encode_element[i].gst = NULL;
sc->encode_element[i].id = _MMCAMCORDER_ENCODE_NONE;
return;
_MMCAMCORDER_LOCK_MESSAGE_CALLBACK(hcamcorder);
- if ((hcamcorder) && (hcamcorder->msg_cb)) {
+ if ((hcamcorder) && (hcamcorder->msg_cb))
hcamcorder->msg_cb(item->id, (MMMessageParamType*)(&(item->param)), hcamcorder->msg_cb_param);
- }
_MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder);
item->param.data = NULL;
item->param.size = 0;
}
- } else if (item->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED ||
- item->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) {
+ } else if (item->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED || item->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) {
MMCamRecordingReport *report = (MMCamRecordingReport *)item->param.data;
if (report) {
- if (report->recording_filename) {
+ if (report->recording_filename)
SAFE_G_FREE(report->recording_filename);
- }
+
SAFE_G_FREE(report);
item->param.data = NULL;
}
mmf_return_val_if_fail(hcamcorder, FALSE);
mmf_return_val_if_fail(data, FALSE);
- switch (data->id)
- {
- case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
- case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
- case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_RM:
- data->param.union_type = MM_MSG_UNION_STATE;
- break;
- case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
- data->param.union_type = MM_MSG_UNION_RECORDING_STATUS;
- break;
- case MM_MESSAGE_CAMCORDER_FIRMWARE_UPDATE:
- data->param.union_type = MM_MSG_UNION_FIRMWARE;
- break;
- case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
- data->param.union_type = MM_MSG_UNION_REC_VOLUME_DB;
- break;
- case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
- case MM_MESSAGE_CAMCORDER_MAX_SIZE:
- case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
- case MM_MESSAGE_CAMCORDER_ERROR:
- case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED:
- case MM_MESSAGE_CAMCORDER_CAPTURED:
- case MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED:
- case MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED:
- case MM_MESSAGE_READY_TO_RESUME:
- default:
- data->param.union_type = MM_MSG_UNION_CODE;
- break;
+ switch (data->id) {
+ case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
+ case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
+ case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_RM:
+ data->param.union_type = MM_MSG_UNION_STATE;
+ break;
+ case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
+ data->param.union_type = MM_MSG_UNION_RECORDING_STATUS;
+ break;
+ case MM_MESSAGE_CAMCORDER_FIRMWARE_UPDATE:
+ data->param.union_type = MM_MSG_UNION_FIRMWARE;
+ break;
+ case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
+ data->param.union_type = MM_MSG_UNION_REC_VOLUME_DB;
+ break;
+ case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
+ case MM_MESSAGE_CAMCORDER_MAX_SIZE:
+ case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
+ case MM_MESSAGE_CAMCORDER_ERROR:
+ case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED:
+ case MM_MESSAGE_CAMCORDER_CAPTURED:
+ case MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED:
+ case MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED:
+ case MM_MESSAGE_READY_TO_RESUME:
+ default:
+ data->param.union_type = MM_MSG_UNION_CODE;
+ break;
}
#ifdef _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK
#else /* _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK */
_MMCAMCORDER_LOCK_MESSAGE_CALLBACK(hcamcorder);
- if (hcamcorder->msg_cb) {
+ if (hcamcorder->msg_cb)
hcamcorder->msg_cb(data->id, (MMMessageParamType*)(&(data->param)), hcamcorder->msg_cb_param);
- } else {
+ else
_mmcam_dbg_log("message callback is NULL. message id %d", data->id);
- }
_MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder);
SAFE_G_FREE(cam_fd_info);
data->param.size = 0;
}
- } else if (data->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED ||
- data->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) {
+ } else if (data->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED || data->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) {
MMCamRecordingReport *report = (MMCamRecordingReport *)data->param.data;
if (report) {
SAFE_G_FREE(report->recording_filename);
item->param.size = 0;
}
SAFE_G_FREE(cam_fd_info);
- } else if (item->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED ||
- item->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) {
+ } else if (item->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED || item->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) {
MMCamRecordingReport *report = (MMCamRecordingReport *)item->param.data;
- if (report) {
+ if (report)
SAFE_G_FREE(report->recording_filename);
- }
+
SAFE_G_FREE(report);
}
end_time = g_get_monotonic_time() + (100 * G_TIME_SPAN_MILLISECOND);
- if (_MMCAMCORDER_WAIT_UNTIL(handle, end_time)) {
+ if (_MMCAMCORDER_WAIT_UNTIL(handle, end_time))
_mmcam_dbg_warn("signal received");
- } else {
+ else
_mmcam_dbg_warn("timeout");
- }
}
}
}
MMPixelFormatType type = 0;
unsigned int fourcc = 0;
- mmf_return_val_if_fail( caps != NULL, MM_PIXEL_FORMAT_INVALID );
+ mmf_return_val_if_fail(caps != NULL, MM_PIXEL_FORMAT_INVALID);
- structure = gst_caps_get_structure (caps, 0);
- media_type = gst_structure_get_name (structure);
+ structure = gst_caps_get_structure(caps, 0);
+ media_type = gst_structure_get_name(structure);
if (media_type == NULL) {
_mmcam_dbg_err("failed to get media_type");
return MM_PIXEL_FORMAT_INVALID;
}
- gst_video_info_init (&media_info);
+ gst_video_info_init(&media_info);
- if (!strcmp (media_type, "image/jpeg") ) {
+ if (!strcmp(media_type, "image/jpeg")) {
_mmcam_dbg_log("It is jpeg.");
type = MM_PIXEL_FORMAT_ENCODED;
- } else if (!strcmp (media_type, "video/x-raw") &&
+ } else if (!strcmp(media_type, "video/x-raw") &&
gst_video_info_from_caps(&media_info, caps) &&
GST_VIDEO_INFO_IS_YUV(&media_info)) {
_mmcam_dbg_log("It is yuv.");
fourcc = gst_video_format_to_fourcc(GST_VIDEO_INFO_FORMAT(&media_info));
type = _mmcamcorder_get_pixtype(fourcc);
- } else if (!strcmp (media_type, "video/x-raw") &&
+ } else if (!strcmp(media_type, "video/x-raw") &&
gst_video_info_from_caps(&media_info, caps) &&
GST_VIDEO_INFO_IS_RGB(&media_info)) {
_mmcam_dbg_log("It is rgb.");
type = MM_PIXEL_FORMAT_RGB888;
- } else if (!strcmp (media_type, "video/x-h264")) {
+ } else if (!strcmp(media_type, "video/x-h264")) {
_mmcam_dbg_log("It is H264");
type = MM_PIXEL_FORMAT_ENCODED_H264;
} else {
- _mmcam_dbg_err("Not supported format [%s]",media_type);
+ _mmcam_dbg_err("Not supported format [%s]", media_type);
type = MM_PIXEL_FORMAT_INVALID;
}
switch (pixtype) {
case MM_PIXEL_FORMAT_NV12:
- if (use_zero_copy_format) {
- fourcc = GST_MAKE_FOURCC ('S', 'N', '1', '2');
- } else {
- fourcc = GST_MAKE_FOURCC ('N', 'V', '1', '2');
- }
+ if (use_zero_copy_format)
+ fourcc = GST_MAKE_FOURCC('S', 'N', '1', '2');
+ else
+ fourcc = GST_MAKE_FOURCC('N', 'V', '1', '2');
+
break;
case MM_PIXEL_FORMAT_NV21:
- if (use_zero_copy_format) {
- fourcc = GST_MAKE_FOURCC ('S', 'N', '2', '1');
- } else {
- fourcc = GST_MAKE_FOURCC ('N', 'V', '2', '1');
- }
+ if (use_zero_copy_format)
+ fourcc = GST_MAKE_FOURCC('S', 'N', '2', '1');
+ else
+ fourcc = GST_MAKE_FOURCC('N', 'V', '2', '1');
+
break;
case MM_PIXEL_FORMAT_YUYV:
- if (use_zero_copy_format) {
- fourcc = GST_MAKE_FOURCC ('S', 'U', 'Y', 'V');
- } else {
- fourcc = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');
- }
+ if (use_zero_copy_format)
+ fourcc = GST_MAKE_FOURCC('S', 'U', 'Y', 'V');
+ else
+ fourcc = GST_MAKE_FOURCC('Y', 'U', 'Y', '2');
+
break;
case MM_PIXEL_FORMAT_UYVY:
- if (use_zero_copy_format) {
- fourcc = GST_MAKE_FOURCC ('S', 'Y', 'V', 'Y');
- } else {
- fourcc = GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y');
- }
+ if (use_zero_copy_format)
+ fourcc = GST_MAKE_FOURCC('S', 'Y', 'V', 'Y');
+ else
+ fourcc = GST_MAKE_FOURCC('U', 'Y', 'V', 'Y');
+
break;
case MM_PIXEL_FORMAT_I420:
- if (use_zero_copy_format) {
- fourcc = GST_MAKE_FOURCC ('S', '4', '2', '0');
- } else {
- fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
- }
+ if (use_zero_copy_format)
+ fourcc = GST_MAKE_FOURCC('S', '4', '2', '0');
+ else
+ fourcc = GST_MAKE_FOURCC('I', '4', '2', '0');
+
break;
case MM_PIXEL_FORMAT_YV12:
- fourcc = GST_MAKE_FOURCC ('Y', 'V', '1', '2');
+ fourcc = GST_MAKE_FOURCC('Y', 'V', '1', '2');
break;
case MM_PIXEL_FORMAT_422P:
- fourcc = GST_MAKE_FOURCC ('4', '2', '2', 'P');
+ fourcc = GST_MAKE_FOURCC('4', '2', '2', 'P');
break;
case MM_PIXEL_FORMAT_RGB565:
- fourcc = GST_MAKE_FOURCC ('R', 'G', 'B', 'P');
+ fourcc = GST_MAKE_FOURCC('R', 'G', 'B', 'P');
break;
case MM_PIXEL_FORMAT_RGB888:
- fourcc = GST_MAKE_FOURCC ('R', 'G', 'B', ' ');
+ fourcc = GST_MAKE_FOURCC('R', 'G', 'B', ' ');
break;
case MM_PIXEL_FORMAT_ENCODED:
if (codectype == MM_IMAGE_CODEC_JPEG) {
- fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G');
+ fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G');
} else if (codectype == MM_IMAGE_CODEC_JPEG_SRW) {
- fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G'); /*TODO: JPEG+SamsungRAW format */
+ fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G'); /*TODO: JPEG+SamsungRAW format */
} else if (codectype == MM_IMAGE_CODEC_SRW) {
- fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G'); /*TODO: SamsungRAW format */
+ fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G'); /*TODO: SamsungRAW format */
} else if (codectype == MM_IMAGE_CODEC_PNG) {
- fourcc = GST_MAKE_FOURCC ('P', 'N', 'G', ' ');
+ fourcc = GST_MAKE_FOURCC('P', 'N', 'G', ' ');
} else {
/* Please let us know what other fourcces are. ex) BMP, GIF?*/
- fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G');
+ fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G');
}
break;
case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY:
- fourcc = GST_MAKE_FOURCC('I','T','L','V');
+ fourcc = GST_MAKE_FOURCC('I', 'T', 'L', 'V');
break;
case MM_PIXEL_FORMAT_ENCODED_H264:
- fourcc = GST_MAKE_FOURCC('H','2','6','4');
+ fourcc = GST_MAKE_FOURCC('H', '2', '6', '4');
break;
default:
_mmcam_dbg_log("Not proper pixel type[%d]. Set default - I420", pixtype);
- if (use_zero_copy_format) {
- fourcc = GST_MAKE_FOURCC ('S', '4', '2', '0');
- } else {
- fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
- }
+ if (use_zero_copy_format)
+ fourcc = GST_MAKE_FOURCC('S', '4', '2', '0');
+ else
+ fourcc = GST_MAKE_FOURCC('I', '4', '2', '0');
+
break;
}
char *pfourcc = (char*)&fourcc;
_mmcam_dbg_log("fourcc(%c%c%c%c)",
- pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]);
+ pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]);
*/
switch (fourcc) {
- case GST_MAKE_FOURCC ('S', 'N', '1', '2'):
- case GST_MAKE_FOURCC ('N', 'V', '1', '2'):
+ case GST_MAKE_FOURCC('S', 'N', '1', '2'):
+ case GST_MAKE_FOURCC('N', 'V', '1', '2'):
pixtype = MM_PIXEL_FORMAT_NV12;
break;
- case GST_MAKE_FOURCC ('S', 'N', '2', '1'):
- case GST_MAKE_FOURCC ('N', 'V', '2', '1'):
+ case GST_MAKE_FOURCC('S', 'N', '2', '1'):
+ case GST_MAKE_FOURCC('N', 'V', '2', '1'):
pixtype = MM_PIXEL_FORMAT_NV21;
break;
- case GST_MAKE_FOURCC ('S', 'U', 'Y', 'V'):
- case GST_MAKE_FOURCC ('Y', 'U', 'Y', 'V'):
- case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
+ case GST_MAKE_FOURCC('S', 'U', 'Y', 'V'):
+ case GST_MAKE_FOURCC('Y', 'U', 'Y', 'V'):
+ case GST_MAKE_FOURCC('Y', 'U', 'Y', '2'):
pixtype = MM_PIXEL_FORMAT_YUYV;
break;
- case GST_MAKE_FOURCC ('S', 'Y', 'V', 'Y'):
- case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'):
+ case GST_MAKE_FOURCC('S', 'Y', 'V', 'Y'):
+ case GST_MAKE_FOURCC('U', 'Y', 'V', 'Y'):
pixtype = MM_PIXEL_FORMAT_UYVY;
break;
- case GST_MAKE_FOURCC ('S', '4', '2', '0'):
- case GST_MAKE_FOURCC ('I', '4', '2', '0'):
+ case GST_MAKE_FOURCC('S', '4', '2', '0'):
+ case GST_MAKE_FOURCC('I', '4', '2', '0'):
pixtype = MM_PIXEL_FORMAT_I420;
break;
- case GST_MAKE_FOURCC ('Y', 'V', '1', '2'):
+ case GST_MAKE_FOURCC('Y', 'V', '1', '2'):
pixtype = MM_PIXEL_FORMAT_YV12;
break;
- case GST_MAKE_FOURCC ('4', '2', '2', 'P'):
+ case GST_MAKE_FOURCC('4', '2', '2', 'P'):
pixtype = MM_PIXEL_FORMAT_422P;
break;
- case GST_MAKE_FOURCC ('R', 'G', 'B', 'P'):
+ case GST_MAKE_FOURCC('R', 'G', 'B', 'P'):
pixtype = MM_PIXEL_FORMAT_RGB565;
break;
- case GST_MAKE_FOURCC ('R', 'G', 'B', '3'):
+ case GST_MAKE_FOURCC('R', 'G', 'B', '3'):
pixtype = MM_PIXEL_FORMAT_RGB888;
break;
- case GST_MAKE_FOURCC ('A', 'R', 'G', 'B'):
- case GST_MAKE_FOURCC ('x', 'R', 'G', 'B'):
+ case GST_MAKE_FOURCC('A', 'R', 'G', 'B'):
+ case GST_MAKE_FOURCC('x', 'R', 'G', 'B'):
pixtype = MM_PIXEL_FORMAT_ARGB;
break;
- case GST_MAKE_FOURCC ('B', 'G', 'R', 'A'):
- case GST_MAKE_FOURCC ('B', 'G', 'R', 'x'):
- case GST_MAKE_FOURCC ('S', 'R', '3', '2'):
+ case GST_MAKE_FOURCC('B', 'G', 'R', 'A'):
+ case GST_MAKE_FOURCC('B', 'G', 'R', 'x'):
+ case GST_MAKE_FOURCC('S', 'R', '3', '2'):
pixtype = MM_PIXEL_FORMAT_RGBA;
break;
- case GST_MAKE_FOURCC ('J', 'P', 'E', 'G'):
- case GST_MAKE_FOURCC ('P', 'N', 'G', ' '):
+ case GST_MAKE_FOURCC('J', 'P', 'E', 'G'):
+ case GST_MAKE_FOURCC('P', 'N', 'G', ' '):
pixtype = MM_PIXEL_FORMAT_ENCODED;
break;
/*FIXME*/
- case GST_MAKE_FOURCC ('I', 'T', 'L', 'V'):
+ case GST_MAKE_FOURCC('I', 'T', 'L', 'V'):
pixtype = MM_PIXEL_FORMAT_ITLV_JPEG_UYVY;
break;
- case GST_MAKE_FOURCC ('H', '2', '6', '4'):
+ case GST_MAKE_FOURCC('H', '2', '6', '4'):
pixtype = MM_PIXEL_FORMAT_ENCODED_H264;
break;
default:
- _mmcam_dbg_log("Not supported fourcc type(%c%c%c%c)",
- fourcc, fourcc>>8, fourcc>>16, fourcc>>24);
+ _mmcam_dbg_log("Not supported fourcc type(%c%c%c%c)", fourcc, fourcc>>8, fourcc>>16, fourcc>>24);
pixtype = MM_PIXEL_FORMAT_INVALID;
break;
}
element = (_MMCamcorderGstElement*)local_list->data;
if (element && element->gst) {
if (!gst_bin_add(bin, GST_ELEMENT(element->gst))) {
- _mmcam_dbg_err( "Add element [%s] to bin [%s] FAILED",
- GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
- GST_ELEMENT_NAME(GST_ELEMENT(bin)) );
+ _mmcam_dbg_err("Add element [%s] to bin [%s] FAILED",
+ GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
+ GST_ELEMENT_NAME(GST_ELEMENT(bin)));
return FALSE;
} else {
_mmcam_dbg_log("Add element [%s] to bin [%s] OK",
- GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
- GST_ELEMENT_NAME(GST_ELEMENT(bin)));
+ GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
+ GST_ELEMENT_NAME(GST_ELEMENT(bin)));
}
}
local_list = local_list->next;
if (pre_element && pre_element->gst && element && element->gst) {
if (_MM_GST_ELEMENT_LINK(GST_ELEMENT(pre_element->gst), GST_ELEMENT(element->gst))) {
_mmcam_dbg_log("Link [%s] to [%s] OK",
- GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
- GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
+ GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
+ GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
} else {
_mmcam_dbg_err("Link [%s] to [%s] FAILED",
- GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
- GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
+ GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)),
+ GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
return FALSE;
}
}
unsigned char *dst_tmp_data = NULL;
if (!src_data || !dst_data || !dst_width || !dst_height || !dst_length) {
- _mmcam_dbg_err("something is NULL %p,%p,%p,%p,%p",
- src_data, dst_data, dst_width, dst_height, dst_length);
+ _mmcam_dbg_err("something is NULL %p,%p,%p,%p,%p", src_data, dst_data, dst_width, dst_height, dst_length);
return FALSE;
}
return FALSE;
}
- _mmcam_dbg_log("src size %dx%d -> dst size %dx%d",
- src_width, src_height, *dst_width, *dst_height);
+ _mmcam_dbg_log("src size %dx%d -> dst size %dx%d", src_width, src_height, *dst_width, *dst_height);
/* get length of resized image */
mm_ret = mm_util_get_image_size(input_format, *dst_width, *dst_height, dst_length);
return FALSE;
}
- mm_ret = mm_util_resize_image(src_data, src_width, src_height, input_format,
- dst_tmp_data, dst_width, dst_height);
+ mm_ret = mm_util_resize_image(src_data, src_width, src_height, input_format, dst_tmp_data, dst_width, dst_height);
+
if (mm_ret != MM_ERROR_NONE) {
GST_ERROR("mm_util_resize_image failed 0x%x", ret);
free(dst_tmp_data);
switch (src_format) {
case MM_PIXEL_FORMAT_NV12:
//jpeg_format = MM_UTIL_JPEG_FMT_NV12;
- ret_conv = _mmcamcorder_convert_NV12_to_I420(src_data,src_width,src_height,&converted_src,&converted_src_size);
+ ret_conv = _mmcamcorder_convert_NV12_to_I420(src_data, src_width, src_height, &converted_src, &converted_src_size);
jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
break;
case MM_PIXEL_FORMAT_NV16:
break;
case MM_PIXEL_FORMAT_YUYV:
//jpeg_format = MM_UTIL_JPEG_FMT_YUYV;
- ret_conv = _mmcamcorder_convert_YUYV_to_I420(src_data,src_width,src_height,&converted_src,&converted_src_size);
+ ret_conv = _mmcamcorder_convert_YUYV_to_I420(src_data, src_width, src_height, &converted_src, &converted_src_size);
jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
break;
case MM_PIXEL_FORMAT_UYVY:
//jpeg_format = MM_UTIL_JPEG_FMT_UYVY;
- ret_conv = _mmcamcorder_convert_UYVY_to_I420(src_data,src_width,src_height,&converted_src,&converted_src_size);
+ ret_conv = _mmcamcorder_convert_UYVY_to_I420(src_data, src_width, src_height, &converted_src, &converted_src_size);
jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
break;
case MM_PIXEL_FORMAT_I420:
}
ret = mm_util_jpeg_encode_to_memory(result_data, (int *)result_length,
- converted_src, src_width, src_height,
- jpeg_format, jpeg_quality);
+ converted_src, src_width, src_height, jpeg_format, jpeg_quality);
if (converted_src && (converted_src != src_data)) {
free(converted_src);
jump_width = ratio_width << 1;
_mmcam_dbg_warn("[src %dx%d] [dst %dx%d] [line width %d] [ratio width %d, height %d]",
- src_width, src_height, dst_width, dst_height,
- line_width, ratio_width, ratio_height);
+ src_width, src_height, dst_width, dst_height, line_width, ratio_width, ratio_height);
for (i = 0 ; i < src_height ; i += ratio_height) {
line_base = i * line_width;
j += jump_width;
src_index = line_base + j;
- if (src_index % 4 == 0) {
+ if (src_index % 4 == 0)
result[k++] = src[src_index+2];
- } else {
+ else
result[k++] = src[src_index];
- }
+
result[k++] = src[src_index+1];
}
}
static guint16 get_language_code(const char *str)
{
- return (guint16) (((str[0]-0x60) & 0x1F) << 10) + (((str[1]-0x60) & 0x1F) << 5) + ((str[2]-0x60) & 0x1F);
+ return (guint16)(((str[0]-0x60) & 0x1F) << 10) + (((str[1]-0x60) & 0x1F) << 5) + ((str[2]-0x60) & 0x1F);
}
static gchar * str_to_utf8(const gchar *str)
{
- return g_convert (str, -1, "UTF-8", "ASCII", NULL, NULL, NULL);
+ return g_convert(str, -1, "UTF-8", "ASCII", NULL, NULL, NULL);
}
static inline gboolean write_tag(FILE *f, const gchar *tag)
{
- while(*tag)
+ while (*tag)
FPUTC_CHECK(*tag++, f);
return TRUE;
int dst_cs = MM_UTIL_IMG_FMT_RGB888;
unsigned int dst_size = 0;
- if (src_fmt == COLOR_FORMAT_YUYV)
- {
+ if (src_fmt == COLOR_FORMAT_YUYV) {
_mmcam_dbg_log("Convert YUYV to RGB888\n");
src_cs = MM_UTIL_IMG_FMT_YUYV;
- }
- else if (src_fmt == COLOR_FORMAT_UYVY)
- {
+ } else if (src_fmt == COLOR_FORMAT_UYVY) {
_mmcam_dbg_log("Convert UYVY to RGB888\n");
src_cs = MM_UTIL_IMG_FMT_UYVY;
- }
- else if (src_fmt == COLOR_FORMAT_NV12)
- {
+ } else if (src_fmt == COLOR_FORMAT_NV12) {
_mmcam_dbg_log("Convert NV12 to RGB888\n");
src_cs = MM_UTIL_IMG_FMT_NV12;
- }
- else
- {
+ } else {
_mmcam_dbg_err("NOT supported format [%d]\n", src_fmt);
return FALSE;
}
}
*dst = malloc(dst_size);
- if (*dst == NULL)
- {
+ if (*dst == NULL) {
_mmcam_dbg_err("malloc failed\n");
return FALSE;
}
*dst_len = dst_size;
ret = mm_util_convert_colorspace(src, width, height, src_cs, *dst, dst_cs);
- if(ret == 0)
- {
+ if (ret == 0) {
_mmcam_dbg_log("Convert [dst_size:%d] OK.\n", dst_size);
return TRUE;
- }
- else
- {
+ } else {
free(*dst);
*dst = NULL;
dst_data[dst_y_offset++] = src[src_offset++]; /*Y*/
if (i % 2 == 0) {
- if (j % 4 == 0) {
+ if (j % 4 == 0)
dst_data[dst_u_offset++] = src[src_offset++]; /*U*/
- } else {
+ else
dst_data[dst_v_offset++] = src[src_offset++]; /*V*/
- }
} else {
src_offset++;
}
*dst = dst_data;
*dst_len = dst_size;
- _mmcam_dbg_log("DONE: YUVY -> I420 : %dx%d, dst data %p, size %d",
- width, height, *dst, dst_size);
+ _mmcam_dbg_log("DONE: YUVY -> I420 : %dx%d, dst data %p, size %d", width, height, *dst, dst_size);
return TRUE;
}
for (i = 0 ; i < height ; i++) {
for (j = 0 ; j < loop_length ; j += 2) {
if (i % 2 == 0) {
- if (j % 4 == 0) {
+ if (j % 4 == 0)
dst_data[dst_u_offset++] = src[src_offset++]; /*U*/
- } else {
+ else
dst_data[dst_v_offset++] = src[src_offset++]; /*V*/
- }
} else {
src_offset++;
}
*dst = dst_data;
*dst_len = dst_size;
- _mmcam_dbg_log("DONE: UYVY -> I420 : %dx%d, dst data %p, size %d",
- width, height, *dst, dst_size);
+ _mmcam_dbg_log("DONE: UYVY -> I420 : %dx%d, dst data %p, size %d", width, height, *dst, dst_size);
return TRUE;
}
/* set U and V */
for (i = 0 ; i < loop_length ; i++) {
- if (i % 2 == 0) {
+ if (i % 2 == 0)
dst_data[dst_u_offset++] = src[src_offset++];
- } else {
+ else
dst_data[dst_v_offset++] = src[src_offset++];
- }
}
*dst = dst_data;
*dst_len = dst_size;
- _mmcam_dbg_log("DONE: NV12 -> I420 : %dx%d, dst data %p, size %d",
- width, height, *dst, dst_size);
+ _mmcam_dbg_log("DONE: NV12 -> I420 : %dx%d, dst data %p, size %d", width, height, *dst, dst_size);
return TRUE;
}
*/
/*=======================================================================================
-| INCLUDE FILES |
+| INCLUDE FILES |
=======================================================================================*/
#include <gst/video/cameracontrol.h>
#include <gst/app/gstappsrc.h>
#include "mm_camcorder_videorec.h"
/*---------------------------------------------------------------------------------------
-| GLOBAL VARIABLE DEFINITIONS for internal |
+| GLOBAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
-#define _MMCAMCORDER_LOCATION_INFO // for add gps information
-#define MAX_ERROR_MESSAGE_LEN 128
+#define _MMCAMCORDER_LOCATION_INFO /* for add gps information */
+#define MAX_ERROR_MESSAGE_LEN 128
/*---------------------------------------------------------------------------------------
-| LOCAL VARIABLE DEFINITIONS for internal |
+| LOCAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
-#define _MMCAMCORDER_MINIMUM_FRAME 5
-#define _MMCAMCORDER_RETRIAL_COUNT 10
-#define _MMCAMCORDER_FRAME_WAIT_TIME 200000 /* ms */
-#define _OFFSET_COMPOSITION_MATRIX 40L
-#define _GOP_GEN_INTERVAL 1000000000 /*nano seconds*/
+#define _MMCAMCORDER_MINIMUM_FRAME 5
+#define _MMCAMCORDER_RETRIAL_COUNT 10
+#define _MMCAMCORDER_FRAME_WAIT_TIME 200000 /* ms */
+#define _OFFSET_COMPOSITION_MATRIX 40L
+#define _GOP_GEN_INTERVAL 1000000000 /*nano seconds*/
/*---------------------------------------------------------------------------------------
-| LOCAL FUNCTION PROTOTYPES: |
+| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------------------*/
/* STATIC INTERNAL FUNCTION */
static gboolean __mmcamcorder_video_stream_cb(GstElement *element, GstSample *sample, gpointer u_data);
/*
_mmcam_dbg_log("ENTER - push_encoding_buffer %d, buffer %p, MALLOCDATA %p, size %d",
- sc->info_video->push_encoding_buffer, buffer, GST_BUFFER_MALLOCDATA(buffer), GST_BUFFER_SIZE(buffer));
+ sc->info_video->push_encoding_buffer, buffer, GST_BUFFER_MALLOCDATA(buffer), GST_BUFFER_SIZE(buffer));
*/
/* push buffer in appsrc to encode */
GstFlowReturn ret = 0;
GstClock *pipe_clock = NULL;
- if(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst) {
- if(sc->info_video->is_firstframe) {
+ if (sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst) {
+ if (sc->info_video->is_firstframe) {
sc->info_video->is_firstframe = FALSE;
pipe_clock = GST_ELEMENT_CLOCK(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst);
if (pipe_clock) {
}
}
} else {
- if(sc->info_video->is_firstframe) {
+ if (sc->info_video->is_firstframe) {
sc->info_video->is_firstframe = FALSE;
sc->info_video->base_video_ts = GST_BUFFER_PTS(buffer);
}
}
- GST_BUFFER_PTS(buffer) = GST_BUFFER_PTS (buffer) - sc->info_video->base_video_ts;
+ GST_BUFFER_PTS(buffer) = GST_BUFFER_PTS(buffer) - sc->info_video->base_video_ts;
ret = gst_app_src_push_buffer((GstAppSrc *)sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst, buffer);
- if (ret != GST_FLOW_OK &&
- ret != GST_FLOW_FLUSHING) {
+ if (ret != GST_FLOW_OK && ret != GST_FLOW_FLUSHING) {
_mmcam_dbg_err("gst_app_src_push_buffer failed [0x%x]", ret);
gst_buffer_unref(buffer);
buffer = NULL;
/*_mmcam_dbg_log("push buffer result : 0x%x", ret);*/
} else {
_mmcam_dbg_warn("unref video buffer immediately - push encoding buffer %d",
- sc->info_video->push_encoding_buffer);
+ sc->info_video->push_encoding_buffer);
gst_buffer_unref(buffer);
buffer = NULL;
_mmcam_dbg_warn("start");
err = _mmcamcorder_check_videocodec_fileformat_compatibility(handle);
- if (err != MM_ERROR_NONE) {
+ if (err != MM_ERROR_NONE)
return err;
- }
/* Main pipeline */
- if(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst) {
+ if (sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst) {
_mmcam_dbg_log("pipeline is exist so need to remove pipeline _MMCAMCORDER_ENCODE_MAIN_PIPE = %p",
- sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst);
+ sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst);
_mmcamcorder_remove_recorder_pipeline((MMHandleType)hcamcorder);
}
/* get audio disable */
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_AUDIO_DISABLE, &audio_disable,
- NULL);
+ MMCAM_AUDIO_DISABLE, &audio_disable,
+ NULL);
- if (sc->is_modified_rate || audio_disable) {
+ if (sc->is_modified_rate || audio_disable)
sc->audio_disable = TRUE;
- } else {
+ else
sc->audio_disable = FALSE;
- }
+
_mmcam_dbg_log("AUDIO DISABLE : %d (is_modified_rate %d, audio_disable %d)",
- sc->audio_disable, sc->is_modified_rate, audio_disable);
+ sc->audio_disable, sc->is_modified_rate, audio_disable);
if (sc->audio_disable == FALSE) {
/* create audiosrc bin */
err = _mmcamcorder_create_audiosrc_bin((MMHandleType)hcamcorder);
- if (err != MM_ERROR_NONE) {
+ if (err != MM_ERROR_NONE)
return err;
- }
}
err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder, MM_CAMCORDER_ENCBIN_PROFILE_VIDEO);
- if (err != MM_ERROR_NONE) {
+ if (err != MM_ERROR_NONE)
return err;
- }
if (sc->audio_disable == FALSE) {
gst_bin_add(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
- sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst);
+ sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst);
}
/* add element and encodesink bin to encode main pipeline */
gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
- sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
- NULL);
+ sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
+ NULL);
/* Link each element : appsrc - capsfilter - encodesink bin */
srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst, "src");
_MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, pipeline_creation_error);
if (sc->audio_disable == FALSE) {
- srcpad = gst_element_get_static_pad (sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, "src");
- sinkpad = gst_element_get_static_pad (sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, "audio_sink0");
+ srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, "src");
+ sinkpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, "audio_sink0");
_MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, pipeline_creation_error);
}
_mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_RECORD,
- "RecordsinkElement",
- &RecordsinkElement);
+ CONFIGURE_CATEGORY_MAIN_RECORD,
+ "RecordsinkElement",
+ &RecordsinkElement);
_mmcamcorder_conf_get_value_element_name(RecordsinkElement, &gst_element_rsink_name);
/* set data probe function */
if (sc->audio_disable == FALSE) {
sinkpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst, "sink");
MMCAMCORDER_ADD_BUFFER_PROBE(sinkpad, _MMCAMCORDER_HANDLER_VIDEOREC,
- __mmcamcorder_audioque_dataprobe, hcamcorder);
+ __mmcamcorder_audioque_dataprobe, hcamcorder);
gst_object_unref(sinkpad);
sinkpad = NULL;
/* for voice mute */
srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, "src");
MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_VIDEOREC,
- __mmcamcorder_audio_dataprobe_audio_mute, hcamcorder);
+ __mmcamcorder_audio_dataprobe_audio_mute, hcamcorder);
gst_object_unref(srcpad);
srcpad = NULL;
if (sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst) {
srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst, "src");
MMCAMCORDER_ADD_EVENT_PROBE(srcpad, _MMCAMCORDER_HANDLER_VIDEOREC,
- __mmcamcorder_eventprobe_monitor, hcamcorder);
+ __mmcamcorder_eventprobe_monitor, hcamcorder);
gst_object_unref(srcpad);
srcpad = NULL;
}
if (sc->encode_element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst) {
srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst, "src");
MMCAMCORDER_ADD_EVENT_PROBE(srcpad, _MMCAMCORDER_HANDLER_VIDEOREC,
- __mmcamcorder_eventprobe_monitor, hcamcorder);
+ __mmcamcorder_eventprobe_monitor, hcamcorder);
gst_object_unref(srcpad);
srcpad = NULL;
}
if (sc->audio_disable) {
sinkpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst, "sink");
MMCAMCORDER_ADD_BUFFER_PROBE(sinkpad, _MMCAMCORDER_HANDLER_VIDEOREC,
- __mmcamcorder_video_dataprobe_audio_disable, hcamcorder);
+ __mmcamcorder_video_dataprobe_audio_disable, hcamcorder);
gst_object_unref(sinkpad);
sinkpad = NULL;
}
if (!strcmp(gst_element_rsink_name, "filesink")) {
srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst, "src");
MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_VIDEOREC,
- __mmcamcorder_video_dataprobe_record, hcamcorder);
+ __mmcamcorder_video_dataprobe_record, hcamcorder);
gst_object_unref(srcpad);
srcpad = NULL;
srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst, "src");
MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_VIDEOREC,
- __mmcamcorder_audio_dataprobe_check, hcamcorder);
+ __mmcamcorder_audio_dataprobe_check, hcamcorder);
gst_object_unref(srcpad);
srcpad = NULL;
}
return MM_ERROR_NONE;
pipeline_creation_error:
- for (i = _MMCAMCORDER_AUDIOSRC_BIN ; i <= _MMCAMCORDER_ENCSINK_SINK ; i++) {
+ for (i = _MMCAMCORDER_AUDIOSRC_BIN ; i <= _MMCAMCORDER_ENCSINK_SINK ; i++)
_MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, i);
- }
+
_MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCODE_MAIN_PIPE);
return err;
}
/* release audiosrc bin */
gst_bin_remove(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
- sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst);
+ sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst);
/*
To avoid conflicting between old elements and newly created elements,
It's because the pipeline of audio recording destroys at the same time,
and '_mmcamcorder_element_release_noti' will perfom removing handle.
*/
- //_mmcamcorder_remove_element_handle(handle, (void *)sc->encode_element, _MMCAMCORDER_ENCODE_MAIN_PIPE, _MMCAMCORDER_ENCSINK_SINK);
+ /* _mmcamcorder_remove_element_handle(handle, (void *)sc->encode_element,
+ _MMCAMCORDER_ENCODE_MAIN_PIPE, _MMCAMCORDER_ENCSINK_SINK); */
_mmcam_dbg_log("Encoder pipeline removed");
}
info->record_dual_stream = FALSE;
ret = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_CAMERA_FPS, &fps,
- MMCAM_CAMERA_WIDTH, &(info->preview_width),
- MMCAM_CAMERA_HEIGHT, &(info->preview_height),
- MMCAM_VIDEO_WIDTH, &(info->video_width),
- MMCAM_VIDEO_HEIGHT, &(info->video_height),
- MMCAM_FILE_FORMAT, &fileformat,
- MMCAM_TARGET_FILENAME, &temp_filename, &size,
- MMCAM_TARGET_MAX_SIZE, &imax_size,
- MMCAM_TARGET_TIME_LIMIT, &imax_time,
- MMCAM_FILE_FORMAT, &(info->fileformat),
- MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
- MMCAM_ROOT_DIRECTORY, &hcamcorder->root_directory, &root_directory_length,
- NULL);
+ MMCAM_CAMERA_FPS, &fps,
+ MMCAM_CAMERA_WIDTH, &(info->preview_width),
+ MMCAM_CAMERA_HEIGHT, &(info->preview_height),
+ MMCAM_VIDEO_WIDTH, &(info->video_width),
+ MMCAM_VIDEO_HEIGHT, &(info->video_height),
+ MMCAM_FILE_FORMAT, &fileformat,
+ MMCAM_TARGET_FILENAME, &temp_filename, &size,
+ MMCAM_TARGET_MAX_SIZE, &imax_size,
+ MMCAM_TARGET_TIME_LIMIT, &imax_time,
+ MMCAM_FILE_FORMAT, &(info->fileformat),
+ MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
+ MMCAM_ROOT_DIRECTORY, &hcamcorder->root_directory, &root_directory_length,
+ NULL);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, ret);
- SAFE_FREE (err_name);
+ SAFE_FREE(err_name);
goto _ERR_CAMCORDER_VIDEO_COMMAND;
}
}
/* set max size */
- if (imax_size <= 0) {
+ if (imax_size <= 0)
info->max_size = 0; /* do not check */
- } else {
+ else
info->max_size = ((guint64)imax_size) << 10; /* to byte */
- }
/* set max time */
- if (imax_time <= 0) {
+ if (imax_time <= 0)
info->max_time = 0; /* do not check */
- } else {
+ else
info->max_time = ((guint64)imax_time) * 1000; /* to millisecond */
- }
dir_name = g_path_get_dirname(temp_filename);
if (dir_name) {
if (file_system_type == MSDOS_SUPER_MAGIC &&
(info->max_size == 0 || info->max_size > FAT32_FILE_SYSTEM_MAX_SIZE)) {
_mmcam_dbg_warn("FAT32 and too large max[%"G_GUINT64_FORMAT"], set max as %"G_GUINT64_FORMAT,
- info->max_size, FAT32_FILE_SYSTEM_MAX_SIZE);
+ info->max_size, FAT32_FILE_SYSTEM_MAX_SIZE);
info->max_size = FAT32_FILE_SYSTEM_MAX_SIZE;
} else {
_mmcam_dbg_warn("file system 0x%x, max size %"G_GUINT64_FORMAT,
- file_system_type, info->max_size);
+ file_system_type, info->max_size);
}
} else {
_mmcam_dbg_warn("_mmcamcorder_get_file_system_type failed");
if ((ret_free_space == -1) || free_space <= (_MMCAMCORDER_MINIMUM_SPACE<<1)) {
_mmcam_dbg_err("OUT of STORAGE [ret_free_space:%d or free space [%" G_GUINT64_FORMAT "] is smaller than [%d]",
- ret_free_space, free_space, (_MMCAMCORDER_MINIMUM_SPACE<<1));
+ ret_free_space, free_space, (_MMCAMCORDER_MINIMUM_SPACE<<1));
return MM_ERROR_OUT_OF_STORAGE;
}
if (info->video_width == 0 || info->video_height == 0) {
_mmcam_dbg_warn("video size is invalid [%dx%d] use preview size [%dx%d]",
- info->video_width, info->video_height, info->preview_width, info->preview_height);
+ info->video_width, info->video_height, info->preview_width, info->preview_height);
info->video_width = info->preview_width;
info->video_height = info->preview_height;
}
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "video-width", info->video_width);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "video-height", info->video_height);
} else if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264 &&
- info->preview_width == info->video_width &&
- info->preview_height == info->video_height) {
+ info->preview_width == info->video_width &&
+ info->preview_height == info->video_height) {
_mmcam_dbg_log("H264 preview mode and same resolution");
/* No need to restart preview */
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_VIDEO_COMMAND;
- }
if (!_mmcamcorder_set_camera_resolution(handle, info->video_width, info->video_height)) {
ret = MM_ERROR_CAMCORDER_INTERNAL;
/* Start preview again with new setting */
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_VIDEO_COMMAND;
- }
if (motion_rate < 1.0) {
_mmcam_dbg_warn("wait for stabilization of frame");
}
_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_RECORD,
- "DropVideoFrame",
- &(sc->drop_vframe));
+ CONFIGURE_CATEGORY_MAIN_RECORD,
+ "DropVideoFrame",
+ &(sc->drop_vframe));
_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_RECORD,
- "PassFirstVideoFrame",
- &(sc->pass_first_vframe));
+ CONFIGURE_CATEGORY_MAIN_RECORD,
+ "PassFirstVideoFrame",
+ &(sc->pass_first_vframe));
_mmcam_dbg_log("Drop video frame count[%d], Pass fisrt video frame count[%d]",
- sc->drop_vframe, sc->pass_first_vframe);
+ sc->drop_vframe, sc->pass_first_vframe);
info->record_drop_count = (guint)motion_rate;
info->record_motion_rate = motion_rate;
- if (sc->is_modified_rate) {
+ if (sc->is_modified_rate)
info->record_timestamp_ratio = (_MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE/motion_rate);
- } else {
+ else
info->record_timestamp_ratio = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
- }
_mmcam_dbg_warn("recording fps %d, motion rate %f, timestamp_ratio %f",
- fps, info->record_motion_rate, info->record_timestamp_ratio);
+ fps, info->record_motion_rate, info->record_timestamp_ratio);
/* set push buffer flag */
info->push_encoding_buffer = PUSH_ENCODING_BUFFER_INIT;
/* connect video stream cb signal */
/*130826 Connect video stream cb for handling fast record frame cb*/
if (info->record_dual_stream) {
- if (_mmcamcorder_connect_video_stream_cb_signal((MMHandleType)hcamcorder) != MM_ERROR_NONE) {
+ if (_mmcamcorder_connect_video_stream_cb_signal((MMHandleType)hcamcorder) != MM_ERROR_NONE)
goto _ERR_CAMCORDER_VIDEO_COMMAND;
- }
}
/* start video stream */
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);
+ ret = _mmcamcorder_video_prepare_record((MMHandleType)hcamcorder);
if (ret != MM_ERROR_NONE) {
g_mutex_unlock(&hcamcorder->task_thread_lock);
goto _ERR_CAMCORDER_VIDEO_COMMAND;
basetime wouldn't change if you set (GstClockTime)0.
3. Move set start time position below PAUSED of pipeline.
*/
- //gst_element_set_start_time(GST_ELEMENT(sc->element[_MMCAMCORDER_MAIN_PIPE].gst), (GstClockTime)1);
- //gst_element_set_start_time(GST_ELEMENT(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst), (GstClockTime)1);
+ /*
+ gst_element_set_start_time(GST_ELEMENT(sc->element[_MMCAMCORDER_MAIN_PIPE].gst), (GstClockTime)1);
+ gst_element_set_start_time(GST_ELEMENT(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst), (GstClockTime)1);
+ */
info->video_frame_count = 0;
info->is_firstframe = TRUE;
CameraControlChannel = item->data;
_mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label);
if (!strcmp(CameraControlChannel->label, "new-gop")) {
- //gst_camera_control_set_value(CameraControl, CameraControlChannel, 1);
+ /* gst_camera_control_set_value(CameraControl, CameraControlChannel, 1); */
break;
}
}
- if (item == NULL) {
+ if (item == NULL)
_mmcam_dbg_warn("failed to find new-gop control channel");
- }
}
} else {
_mmcam_dbg_warn("Can't cast Video source into camera control or not H264 prevew format[%d]",
- sc->info_image->preview_format);
+ sc->info_image->preview_format);
}
} else {
/* Resume case */
CameraControlChannel = item->data;
_mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label);
if (!strcmp(CameraControlChannel->label, "new-gop")) {
- //gst_camera_control_set_value(CameraControl, CameraControlChannel, 1);
+ /* gst_camera_control_set_value(CameraControl, CameraControlChannel, 1); */
break;
}
}
- if (item == NULL) {
+ if (item == NULL)
_mmcam_dbg_warn("failed to find new-gop control channel");
- }
}
}
if (info->video_frame_count >= _MMCAMCORDER_MINIMUM_FRAME) {
break;
} else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
- _mmcam_dbg_err("Pause fail, frame count %llu",
- info->video_frame_count);
+ _mmcam_dbg_err("Pause fail, frame count %llu", info->video_frame_count);
return MM_ERROR_CAMCORDER_INVALID_CONDITION;
} else {
- _mmcam_dbg_warn("Waiting for enough video frame, retrial[%d], frame %llu",
- count, info->video_frame_count);
+ _mmcam_dbg_warn("Waiting for enough video frame, retrial[%d], frame %llu", count, info->video_frame_count);
}
usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
break;
} else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
_mmcam_dbg_err("Pause fail, frame count VIDEO[%llu], AUDIO [%llu]",
- info->video_frame_count, info->audio_frame_count);
+ info->video_frame_count, info->audio_frame_count);
return MM_ERROR_CAMCORDER_INVALID_CONDITION;
} else {
_mmcam_dbg_warn("Waiting for enough frames, retrial [%d], VIDEO[%llu], AUDIO [%llu]",
- count, info->video_frame_count, info->audio_frame_count);
+ count, info->video_frame_count, info->audio_frame_count);
}
usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
info->push_encoding_buffer = PUSH_ENCODING_BUFFER_STOP;
ret = _mmcamcorder_remove_recorder_pipeline((MMHandleType)hcamcorder);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_VIDEO_COMMAND;
- }
/* set recording hint */
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "recording-hint", FALSE);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
- ret =_mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
+ ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
/* check decoder recreation */
if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_VIDEO_COMMAND;
- }
/* reset restart_preview for inset window layout */
info->restart_preview = FALSE;
goto _ERR_CAMCORDER_VIDEO_COMMAND;
}
- ret =_mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
- if (ret != MM_ERROR_NONE) {
+ ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_VIDEO_COMMAND;
- }
}
/* remove target file */
break;
} else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
_mmcam_dbg_err("Commit fail, frame count is %llu, capturing %d",
- info->video_frame_count, hcamcorder->capture_in_recording);
+ info->video_frame_count, hcamcorder->capture_in_recording);
if (info->video_frame_count >= _MMCAMCORDER_MINIMUM_FRAME) {
_mmcam_dbg_warn("video frames are enough. keep going...");
}
} else {
_mmcam_dbg_warn("Waiting for enough video frame, retrial [%d], frame %llu, capturing %d",
- count, info->video_frame_count, hcamcorder->capture_in_recording);
+ count, info->video_frame_count, hcamcorder->capture_in_recording);
}
} else {
/* check both of video and audio frame */
break;
} else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
_mmcam_dbg_err("Commit fail, VIDEO[%llu], AUDIO [%llu], capturing %d",
- info->video_frame_count, info->audio_frame_count, hcamcorder->capture_in_recording);
+ info->video_frame_count, info->audio_frame_count, hcamcorder->capture_in_recording);
if (info->video_frame_count >= _MMCAMCORDER_MINIMUM_FRAME && info->audio_frame_count) {
_mmcam_dbg_warn("video/audio frames are enough. keep going...");
return MM_ERROR_CAMCORDER_INVALID_CONDITION;
} else {
_mmcam_dbg_warn("Waiting for enough frames, retrial [%d], VIDEO[%llu], AUDIO [%llu], capturing %d",
- count, info->video_frame_count, info->audio_frame_count, hcamcorder->capture_in_recording);
+ count, info->video_frame_count, info->audio_frame_count, hcamcorder->capture_in_recording);
}
}
/* Wait EOS */
_mmcam_dbg_log("Start to wait EOS");
- ret =_mmcamcorder_get_eos_message(handle);
+ ret = _mmcamcorder_get_eos_message(handle);
if (ret != MM_ERROR_NONE) {
info->b_commiting = FALSE;
goto _ERR_CAMCORDER_VIDEO_COMMAND;
return MM_ERROR_NONE;
_ERR_CAMCORDER_VIDEO_COMMAND:
- if (command == _MMCamcorder_CMD_RECORD) {
+ if (command == _MMCamcorder_CMD_RECORD)
_mmcamcorder_remove_recorder_pipeline((MMHandleType)hcamcorder);
- }
return ret;
}
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_RECORDER_TAG_ENABLE, &enabletag,
- NULL);
+ MMCAM_RECORDER_TAG_ENABLE, &enabletag,
+ NULL);
ret = _mmcamcorder_remove_recorder_pipeline((MMHandleType)hcamcorder);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
_mmcam_dbg_warn("_MMCamcorder_CMD_COMMIT:__mmcamcorder_remove_recorder_pipeline failed. error[%x]", ret);
- }
/* set recording hint */
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "recording-hint", FALSE);
if (info->max_size > 0) {
_mmcamcorder_get_file_size(info->filename, &file_size);
_mmcam_dbg_log("MAX size %lld byte - created filesize %lld byte",
- info->max_size, file_size);
+ info->max_size, file_size);
if (file_size > info->max_size) {
_MMCamcorderMsgItem message;
/* recover preview size */
_mmcamcorder_set_camera_resolution(handle, info->preview_width, info->preview_height);
- ret =_mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
+ ret = _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
/* Do not return when error is occurred.
Recording file was created successfully, but starting pipeline failed */
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("Recording report fail(%s). Out of memory.", info->filename);
} else {
report->recording_filename = g_strdup(info->filename);
- msg.param.data= report;
+ msg.param.data = report;
msg.param.code = 1;
_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
}
* @remarks
* @see
*/
-static GstPadProbeReturn __mmcamcorder_eventprobe_monitor(GstPad *pad, GstPadProbeInfo *info, gpointer u_data){
+static GstPadProbeReturn __mmcamcorder_eventprobe_monitor(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
+{
GstEvent *event = GST_PAD_PROBE_INFO_EVENT(info);
switch (GST_EVENT_TYPE(event)) {
case GST_EVENT_UNKNOWN:
case GST_EVENT_NAVIGATION:
case GST_EVENT_LATENCY:
/* downstream serialized events */
- case GST_EVENT_SEGMENT :
+ case GST_EVENT_SEGMENT:
case GST_EVENT_TAG:
case GST_EVENT_BUFFERSIZE:
_mmcam_dbg_log("[%s:%s] gots %s", GST_DEBUG_PAD_NAME(pad), GST_EVENT_TYPE_NAME(event));
_MMCamcorderMsgItem msg;
guint64 buffer_size = 0;
guint64 trailer_size = 0;
+ guint64 max_size = 0;
mmf_return_val_if_fail(hcamcorder, GST_PAD_PROBE_OK);
mmf_return_val_if_fail(buffer, GST_PAD_PROBE_DROP);
}
/* check max size of recorded file */
- if (videoinfo->max_size > 0 &&
- videoinfo->max_size < videoinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE) {
+ max_size = videoinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE;
+ if (videoinfo->max_size > 0 && videoinfo->max_size < max_size) {
GstState pipeline_state = GST_STATE_VOID_PENDING;
GstElement *pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
_mmcam_dbg_warn("Max size!!! Recording is paused.");
_mmcam_dbg_warn("Max size : [%" G_GUINT64_FORMAT "], current file size : [%" G_GUINT64_FORMAT "]," \
- " buffer size : [%" G_GUINT64_FORMAT "], trailer size : [%" G_GUINT64_FORMAT "]",
- videoinfo->max_size, videoinfo->filesize, buffer_size, trailer_size);
+ " buffer size : [%" G_GUINT64_FORMAT "], trailer size : [%" G_GUINT64_FORMAT "]",
+ videoinfo->max_size, videoinfo->filesize, buffer_size, trailer_size);
if (!sc->isMaxsizePausing) {
sc->isMaxsizePausing = TRUE;
gst_element_get_state(pipeline, &pipeline_state, NULL, -1) ;
- if (pipeline_state == GST_STATE_PLAYING) {
+ if (pipeline_state == GST_STATE_PLAYING)
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
- }
msg.id = MM_MESSAGE_CAMCORDER_MAX_SIZE;
_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
guint64 buffer_size = 0;
guint64 trailer_size = 0;
guint64 queued_buffer = 0;
+ guint64 max_size = 0;
char *dir_name = NULL;
GstBuffer *buffer = GST_PAD_PROBE_INFO_BUFFER(info);
GstMapInfo mapinfo;
videoinfo->video_frame_count++;
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); */
+ info->video_frame_count); */
g_mutex_lock(&videoinfo->size_check_lock);
videoinfo->filesize += buffer_size;
g_mutex_unlock(&videoinfo->size_check_lock);
if (sc->ferror_count == 2 && sc->ferror_send == FALSE) {
sc->ferror_send = TRUE;
msg.id = MM_MESSAGE_CAMCORDER_ERROR;
- if (ret == -2) {
+ if (ret == -2)
msg.param.code = MM_ERROR_FILE_NOT_FOUND;
- } else {
+ else
msg.param.code = MM_ERROR_FILE_READ;
- }
+
_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
} else {
sc->ferror_count++;
if (sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst) {
MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst, "current-level-bytes", &aq_size);
}
+
if (sc->encode_element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst) {
MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst, "current-level-bytes", &vq_size);
}
if (free_space < (_MMCAMCORDER_MINIMUM_SPACE + buffer_size + trailer_size + queued_buffer)) {
_mmcam_dbg_warn("No more space for recording!!! Recording is paused.");
_mmcam_dbg_warn("Free Space : [%" G_GUINT64_FORMAT "], trailer size : [%" G_GUINT64_FORMAT "]," \
- " buffer size : [%" G_GUINT64_FORMAT "], queued buffer size : [%" G_GUINT64_FORMAT "]", \
- free_space, trailer_size, buffer_size, queued_buffer);
+ " buffer size : [%" G_GUINT64_FORMAT "], queued buffer size : [%" G_GUINT64_FORMAT "]", \
+ free_space, trailer_size, buffer_size, queued_buffer);
if (!sc->isMaxsizePausing) {
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
g_mutex_lock(&videoinfo->size_check_lock);
/* check max size of recorded file */
- if (videoinfo->max_size > 0 &&
- videoinfo->max_size < videoinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE) {
+ max_size = videoinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE;
+ if (videoinfo->max_size > 0 && videoinfo->max_size < max_size) {
GstState pipeline_state = GST_STATE_VOID_PENDING;
GstElement *pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
_mmcam_dbg_warn("Max size!!! Recording is paused.");
_mmcam_dbg_warn("Max size : [%" G_GUINT64_FORMAT "], current file size : [%" G_GUINT64_FORMAT "]," \
- " buffer size : [%" G_GUINT64_FORMAT "], trailer size : [%" G_GUINT64_FORMAT "]",
- videoinfo->max_size, videoinfo->filesize, buffer_size, trailer_size);
+ " buffer size : [%" G_GUINT64_FORMAT "], trailer size : [%" G_GUINT64_FORMAT "]",
+ videoinfo->max_size, videoinfo->filesize, buffer_size, trailer_size);
if (!sc->isMaxsizePausing) {
sc->isMaxsizePausing = TRUE;
gst_element_get_state(pipeline, &pipeline_state, NULL, -1) ;
- if (pipeline_state == GST_STATE_PLAYING) {
+ if (pipeline_state == GST_STATE_PLAYING)
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
- }
msg.id = MM_MESSAGE_CAMCORDER_MAX_SIZE;
_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
/* check max time */
if (videoinfo->max_time > 0 && rec_pipe_time > videoinfo->max_time) {
_mmcam_dbg_warn("Current time : [%" G_GUINT64_FORMAT "], Maximum time : [%" G_GUINT64_FORMAT "]", \
- rec_pipe_time, videoinfo->max_time);
+ rec_pipe_time, videoinfo->max_time);
if (!sc->isMaxtimePausing) {
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
/*
_mmcam_dbg_log("time [%" GST_TIME_FORMAT "], size [%d]",
- GST_TIME_ARGS(rec_pipe_time), msg.param.recording_status.filesize);
+ GST_TIME_ARGS(rec_pipe_time), msg.param.recording_status.filesize);
*/
if (videoinfo->record_timestamp_ratio != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
/*
_mmcam_dbg_log("record_motion_rate %d, videoinfo->record_drop_count %d",
- record_motion_rate, videoinfo->record_drop_count);
+ record_motion_rate, videoinfo->record_drop_count);
*/
/* drop some frame if fast motion */
videoinfo = sc->info_video;
if (!GST_CLOCK_TIME_IS_VALID(GST_BUFFER_PTS(buffer))) {
- _mmcam_dbg_err( "Buffer timestamp is invalid, check it");
+ _mmcam_dbg_err("Buffer timestamp is invalid, check it");
return GST_PAD_PROBE_OK;
}
if (videoinfo->max_time > 0 && rec_pipe_time > videoinfo->max_time) {
_mmcam_dbg_warn("Current time : [%" G_GUINT64_FORMAT "], Maximum time : [%" G_GUINT64_FORMAT "]", \
- rec_pipe_time, videoinfo->max_time);
+ rec_pipe_time, videoinfo->max_time);
if (!sc->isMaxtimePausing) {
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
/*
_mmcam_dbg_log("audio data probe :: time [%" GST_TIME_FORMAT "], size [%lld KB]",
- GST_TIME_ARGS(rec_pipe_time), msg.param.recording_status.filesize);
+ GST_TIME_ARGS(rec_pipe_time), msg.param.recording_status.filesize);
*/
return GST_PAD_PROBE_OK;
/*_mmcam_dbg_log("AUDIO SRC time stamp : [%" GST_TIME_FORMAT "] \n", GST_TIME_ARGS(GST_BUFFER_PTS(buffer)));*/
err = mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_name,
- MMCAM_AUDIO_VOLUME, &volume,
- MMCAM_AUDIO_FORMAT, &format,
- MMCAM_AUDIO_CHANNEL, &channel,
- NULL);
+ MMCAM_AUDIO_VOLUME, &volume,
+ MMCAM_AUDIO_FORMAT, &format,
+ MMCAM_AUDIO_CHANNEL, &channel,
+ NULL);
if (err != MM_ERROR_NONE) {
_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
SAFE_FREE(err_name);
gst_buffer_map(buffer, &mapinfo, GST_MAP_READWRITE);
/* Set audio stream NULL */
- if (volume == 0.0) {
+ if (volume == 0.0)
memset(mapinfo.data, 0, mapinfo.size);
- }
/* CALL audio stream callback */
if (hcamcorder->astream_cb && buffer && mapinfo.data && mapinfo.size > 0) {
}
/*_mmcam_dbg_log("Call video steramCb, data[%p], Width[%d],Height[%d], Format[%d]",
- GST_BUFFER_DATA(buffer), width, height, format);*/
+ GST_BUFFER_DATA(buffer), width, height, format);*/
stream.data = (void *)mapinfo.data;
stream.format = format;
_MMCAMCORDER_LOCK_ASTREAM_CALLBACK(hcamcorder);
- if (hcamcorder->astream_cb) {
+ if (hcamcorder->astream_cb)
hcamcorder->astream_cb(&stream, hcamcorder->astream_cb_param);
- }
_MMCAMCORDER_UNLOCK_ASTREAM_CALLBACK(hcamcorder);
}
int gps_enable = 0;
char *err_name = NULL;
char err_msg[MAX_ERROR_MESSAGE_LEN] = {'\0',};
- _MMCamcorderLocationInfo location_info = {0,0,0};
- _MMCamcorderLocationInfo geo_info = {0,0,0};
+ _MMCamcorderLocationInfo location_info = {0, 0, 0};
+ _MMCamcorderLocationInfo geo_info = {0, 0, 0};
_MMCamcorderVideoInfo *info = NULL;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
}
mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_TAG_LATITUDE, &latitude,
- MMCAM_TAG_LONGITUDE, &longitude,
- MMCAM_TAG_ALTITUDE, &altitude,
- MMCAM_TAG_VIDEO_ORIENTATION, &orientation,
- MMCAM_TAG_GPS_ENABLE, &gps_enable,
- NULL);
+ MMCAM_TAG_LATITUDE, &latitude,
+ MMCAM_TAG_LONGITUDE, &longitude,
+ MMCAM_TAG_ALTITUDE, &altitude,
+ MMCAM_TAG_VIDEO_ORIENTATION, &orientation,
+ MMCAM_TAG_GPS_ENABLE, &gps_enable,
+ NULL);
if (err_name) {
_mmcam_dbg_warn("Get tag attrs fail. (%s:%x)", err_name, err);
- SAFE_FREE (err_name);
+ SAFE_FREE(err_name);
}
location_info.longitude = _mmcamcorder_double_to_fix(longitude);
/* find udta container.
if, there are udta container, write loci box after that
else, make udta container and write loci box. */
- if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('u','d','t','a'), TRUE)) {
+ if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('u', 'd', 't', 'a'), TRUE)) {
size_t nread = 0;
_mmcam_dbg_log("find udta container");
/* read size */
- if (fseek(f, -8L, SEEK_CUR) != 0) {
+ if (fseek(f, -8L, SEEK_CUR) != 0)
goto fail;
- }
udta_pos = ftello(f);
- if (udta_pos < 0) {
+ if (udta_pos < 0)
goto ftell_fail;
- }
nread = fread(&buf, sizeof(char), sizeof(buf), f);
udta_size = _mmcamcorder_get_container_size(buf);
/* goto end of udta and write 'loci' box */
- if (fseek(f, (udta_size-4L), SEEK_CUR) != 0) {
+ if (fseek(f, (udta_size-4L), SEEK_CUR) != 0)
goto fail;
- }
if (gps_enable) {
if (!_mmcamcorder_write_loci(f, location_info)) {
}
current_pos = ftello(f);
- if (current_pos < 0) {
+ if (current_pos < 0)
goto ftell_fail;
- }
- if (!_mmcamcorder_update_size(f, udta_pos, current_pos)) {
+ if (!_mmcamcorder_update_size(f, udta_pos, current_pos))
goto fail;
- }
} else {
_mmcam_dbg_log("No udta container");
- if (fseek(f, 0, SEEK_END) != 0) {
+ if (fseek(f, 0, SEEK_END) != 0)
goto fail;
- }
if (!_mmcamcorder_write_udta(f, gps_enable, location_info, geo_info)) {
_mmcam_dbg_err("failed to write udta");
/* find moov container.
update moov container size. */
- if((current_pos = ftello(f))<0)
+ if ((current_pos = ftello(f)) < 0)
goto ftell_fail;
- if (_mmcamcorder_find_tag(f, MMCAM_FOURCC('m','o','o','v'), TRUE)) {
+ if (_mmcamcorder_find_tag(f, MMCAM_FOURCC('m', 'o', 'o', 'v'), TRUE)) {
gint64 internal_pos = ftello(f);
_mmcam_dbg_log("found moov container");
- if (fseek(f, -8L, SEEK_CUR) !=0) {
+ if (fseek(f, -8L, SEEK_CUR) != 0)
goto fail;
- }
moov_pos = ftello(f);
- if (moov_pos < 0) {
+ if (moov_pos < 0)
goto ftell_fail;
- }
- if (!_mmcamcorder_update_size(f, moov_pos, current_pos)) {
+ if (!_mmcamcorder_update_size(f, moov_pos, current_pos))
goto fail;
- }
/* add orientation info */
if (fseeko(f, internal_pos, SEEK_SET) < 0) {
goto fail;
}
- if (!_mmcamcorder_find_tag(f, MMCAM_FOURCC('t','r','a','k'), FALSE)) {
+ if (!_mmcamcorder_find_tag(f, MMCAM_FOURCC('t', 'r', 'a', 'k'), FALSE)) {
_mmcam_dbg_err("failed to find [trak] tag");
goto fail;
}
- if (!_mmcamcorder_find_tag(f, MMCAM_FOURCC('t','k','h','d'), FALSE)) {
+ if (!_mmcamcorder_find_tag(f, MMCAM_FOURCC('t', 'k', 'h', 'd'), FALSE)) {
_mmcam_dbg_err("failed to find [tkhd] tag");
goto fail;
}
if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
_mmcam_dbg_warn("connect video stream cb signal to _MMCAMCORDER_VIDEOSRC_SRC");
MMCAMCORDER_SIGNAL_CONNECT(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst,
- _MMCAMCORDER_HANDLER_VIDEOREC, "video-stream-cb",
- G_CALLBACK(__mmcamcorder_video_stream_cb),
- hcamcorder);
+ _MMCAMCORDER_HANDLER_VIDEOREC, "video-stream-cb",
+ G_CALLBACK(__mmcamcorder_video_stream_cb),
+ hcamcorder);
return MM_ERROR_NONE;
} else {
_mmcam_dbg_err("videosrc element is not created yet");
_mmcam_dbg_warn("start");
/* create encoding pipeline */
- ret =_mmcamcorder_create_recorder_pipeline((MMHandleType)hcamcorder);
- if (ret != MM_ERROR_NONE) {
+ ret = _mmcamcorder_create_recorder_pipeline((MMHandleType)hcamcorder);
+ if (ret != MM_ERROR_NONE)
goto _ERR_PREPARE_RECORD;
- }
if (info->filename == NULL) {
char *temp_filename = NULL;
int size = 0;
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_TARGET_FILENAME, &temp_filename, &size,
- NULL);
- if (temp_filename) {
+ MMCAM_TARGET_FILENAME, &temp_filename, &size,
+ NULL);
+ if (temp_filename)
info->filename = g_strdup(temp_filename);
- }
if (!info->filename) {
_mmcam_dbg_err("strdup[src:%p] was failed", temp_filename);
sc->previous_slot_time = 0;
ret = _mmcamcorder_gst_set_state(handle, sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst, GST_STATE_PAUSED);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_PREPARE_RECORD;
- }
_mmcam_dbg_warn("done");