AC_SUBST(MM_COMMON_CFLAGS)
AC_SUBST(MM_COMMON_LIBS)
-PKG_CHECK_MODULES(MM_LOG, mm-log)
-AC_SUBST(MM_LOG_CFLAGS)
-AC_SUBST(MM_LOG_LIBS)
-
PKG_CHECK_MODULES(MM_SOUND, mm-sound)
AC_SUBST(MM_SOUND_CFLAGS)
AC_SUBST(MM_SOUND_LIBS)
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)
+PKG_CHECK_MODULES(GIO, gio-2.0)
+AC_SUBST(GIO_CFLAGS)
+AC_SUBST(GIO_LIBS)
+
PKG_CHECK_MODULES(MMSOUND, mm-sound)
AC_SUBST(MMSOUND_CFLAGS)
AC_SUBST(MMSOUND_LIBS)
AC_SUBST(MMUTIL_IMGP_CFLAGS)
AC_SUBST(MMUTIL_IMGP_LIBS)
+PKG_CHECK_MODULES(MMUTIL_JPEG, mmutil-jpeg)
+AC_SUBST(MMUTIL_JPEG_CFLAGS)
+AC_SUBST(MMUTIL_JPEG_LIBS)
+
PKG_CHECK_MODULES(SNDFILE, sndfile)
AC_SUBST(SNDFILE_CFLAGS)
AC_SUBST(SNDFILE_LIBS)
-PKG_CHECK_MODULES(CAMSRCJPEGENC, camsrcjpegenc)
-AC_SUBST(CAMSRCJPEGENC_CFLAGS)
-AC_SUBST(CAMSRCJPEGENC_LIBS)
-
PKG_CHECK_MODULES(VCONF, vconf)
AC_SUBST(VCONF_CFLAGS)
AC_SUBST(VCONF_LIBS)
AC_SUBST(SYSTEMINFO_CFLAGS)
AC_SUBST(SYSTEMINFO_LIBS)
+PKG_CHECK_MODULES(TBM, libtbm)
+AC_SUBST(TBM_CFLAGS)
+AC_SUBST(TBM_LIBS)
+
# Checks for header files.
AC_HEADER_STDC
AC_CHECK_HEADERS([fcntl.h memory.h stdlib.h string.h sys/time.h unistd.h])
<request>
<domain name="_" />
</request>
+ <assign>
+ <filesystem path="/usr/bin/mm_camcorder_testsuite" label="_" exec_label="none" />
+ </assign>
</manifest>
Name: libmm-camcorder
Summary: Camera and recorder library
-Version: 0.9.4
+Version: 0.10.0
Release: 0
Group: Multimedia/Libraries
License: Apache-2.0
Requires(post): /usr/bin/vconftool
Requires(post): /sbin/ldconfig
Requires(postun): /sbin/ldconfig
+BuildRequires: pkgconfig(glib-2.0)
+BuildRequires: pkgconfig(gio-2.0)
BuildRequires: pkgconfig(capi-system-info)
BuildRequires: pkgconfig(mm-common)
BuildRequires: pkgconfig(mm-sound)
BuildRequires: pkgconfig(libexif)
BuildRequires: pkgconfig(mmutil-imgp)
-BuildRequires: pkgconfig(mm-log)
+BuildRequires: pkgconfig(mmutil-jpeg)
BuildRequires: pkgconfig(gstreamer-base-1.0)
+BuildRequires: pkgconfig(gstreamer-video-1.0)
+BuildRequires: pkgconfig(gstreamer-app-1.0)
%if %{with wayland}
BuildRequires: pkgconfig(gstreamer-wayland-1.0)
BuildRequires: pkgconfig(wayland-client)
%endif
BuildRequires: pkgconfig(sndfile)
-BuildRequires: pkgconfig(camsrcjpegenc)
BuildRequires: pkgconfig(libpulse)
BuildRequires: pkgconfig(vconf)
-BuildRequires: gst-plugins-base-devel
BuildRequires: gstreamer-devel
+BuildRequires: pkgconfig(libtbm)
%description
Camera and recorder library.
/sbin/ldconfig
vconftool set -t int memory/camera/state 0 -i -u 5000 -s system::vconf_multimedia
+vconftool set -t int memory/camera/pid 0 -i -u 5000 -s system::vconf_multimedia
+vconftool set -t int memory/camera/flash_state 0 -i -u 5000 -s system::vconf_multimedia
+vconftool set -t int memory/recorder/state 0 -i -u 5000 -s system::vconf_multimedia
+vconftool set -t int memory/recorder/pid 0 -i -u 5000 -s system::vconf_multimedia
vconftool set -t int file/camera/shutter_sound_policy 0 -u 5000 -s system::vconf_inhouse
%postun -p /sbin/ldconfig
$(GST_PLUGIN_BASE_CFLAGS) \
$(GST_VIDEO_CFLAGS) \
$(GST_APP_CFLAGS) \
- $(MM_LOG_CFLAGS) \
$(EXIF_CFLAGS) \
$(MM_COMMON_CFLAGS) \
$(MMSOUND_CFLAGS) \
$(SNDFILE_CFLAGS) \
- $(CAMSRCJPEGENC_CFLAGS) \
$(VCONF_CFLAGS) \
$(MMUTIL_IMGP_CFLAGS) \
+ $(MMUTIL_JPEG_CFLAGS) \
+ $(TBM_CFLAGS) \
$(SYSTEMINFO_CFLAGS)
libmmfcamcorder_la_LIBADD = \
+ $(GLIB_LIBS) \
+ $(GIO_LIBS) \
$(GST_LIBS) \
$(GST_PLUGIN_BASE_LIBS) \
$(GST_VIDEO_LIBS) \
$(GST_APP_LIBS) \
$(MM_COMMON_LIBS) \
- $(MM_LOG_LIBS) \
$(EXIF_LIBS) \
$(MMSOUND_LIBS) \
$(SNDFILE_LIBS) \
- $(CAMSRCJPEGENC_LIBS) \
$(VCONF_LIBS) \
- $(MMUTIL_IMGP_LIBS)
+ $(MMUTIL_IMGP_LIBS) \
+ $(MMUTIL_JPEG_LIBS) \
+ $(TBM_LIBS)
libmmfcamcorder_la_CFLAGS += -DMMF_LOG_OWNER=0x010 -D_FILE_OFFSET_BITS=64
libmmfcamcorder_la_CFLAGS += -fdata-sections -ffunction-sections -Wl,--gc-sections
+libmmfcamcorder_la_LDFLAGS = -Wl,--gc-sections \
+ -Wl,-init,_mmcamcorder_constructor
libmmfcamcorder_la_LIBADD += $(SYSTEMINFO_LIBS)
if WAYLAND_SUPPORT
/**
* Recommend rotation of display
*/
-#define MMCAM_RECOMMEND_DISPLAY_ROTATION "recommend-display-rotation"
+#define MMCAM_RECOMMEND_DISPLAY_ROTATION "recommend-display-rotation"
/**
* Recommend width of camera preview.
* This attribute can be used with #mm_camcorder_get_attribute_info and #MMCamcorderPreviewType.
* @see mm_camcorder_get_attribute_info, MMCamcorderPreviewType
*/
-#define MMCAM_RECOMMEND_CAMERA_WIDTH "recommend-camera-width"
+#define MMCAM_RECOMMEND_CAMERA_WIDTH "recommend-camera-width"
/**
* Recommend height of camera preview
* This attribute can be used with #mm_camcorder_get_attribute_info and #MMCamcorderPreviewType.
* @see mm_camcorder_get_attribute_info, MMCamcorderPreviewType
*/
-#define MMCAM_RECOMMEND_CAMERA_HEIGHT "recommend-camera-height"
+#define MMCAM_RECOMMEND_CAMERA_HEIGHT "recommend-camera-height"
/**
* Flip of video input stream.
* @see MMFlipType (in mm_types.h)
*/
-#define MMCAM_CAMERA_FLIP "camera-flip"
+#define MMCAM_CAMERA_FLIP "camera-flip"
/**
* Support Zero Shutter Lag capture
*/
-#define MMCAM_SUPPORT_ZSL_CAPTURE "support-zsl-capture"
+#define MMCAM_SUPPORT_ZSL_CAPTURE "support-zsl-capture"
/**
* Support zero copy format
*/
-#define MMCAM_SUPPORT_ZERO_COPY_FORMAT "support-zero-copy-format"
+#define MMCAM_SUPPORT_ZERO_COPY_FORMAT "support-zero-copy-format"
/**
* Support media packet callback
*/
-#define MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB "support-media-packet-preview-cb"
+#define MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB "support-media-packet-preview-cb"
+/**
+ * Enable to write tags for recorded file
+ */
+#define MMCAM_RECORDER_TAG_ENABLE "recorder-tag-enable"
/*=======================================================================================
| ENUM DEFINITIONS |
MM_CAM_STREAM_DATA_YUV420SP, /**< YUV420 SemiPlannar type - 2 planes */
MM_CAM_STREAM_DATA_YUV420P, /**< YUV420 Plannar type - 3 planes */
MM_CAM_STREAM_DATA_YUV422P, /**< YUV422 Plannar type - 3 planes */
+ MM_CAM_STREAM_DATA_ENCODED /**< Encoded data type - 1 plane */
} MMCamStreamData;
MMCamAttrsValidType validity_type;
/**
- * A union that describes validity of the attribute.
+ * A union that describes validity of the attribute.
* Only when type is 'MM_CAM_ATTRS_TYPE_INT' or 'MM_CAM_ATTRS_TYPE_DOUBLE',
* the attribute can have validity.
*/
unsigned char *v;
unsigned int length_v;
} yuv420p, yuv422p;
+ struct {
+ unsigned char *data;
+ unsigned int length_data;
+ } encoded;
} data; /**< pointer of captured stream */
MMCamStreamData data_type; /**< data type */
unsigned int length_total; /**< total length of stream buffer (in byte)*/
unsigned int timestamp; /**< timestamp of stream buffer (msec)*/
void *bo[BUFFER_MAX_PLANE_NUM]; /**< TBM buffer object */
void *internal_buffer; /**< Internal buffer pointer */
+ int stride[BUFFER_MAX_PLANE_NUM]; /**< Stride of each plane */
+ int elevation[BUFFER_MAX_PLANE_NUM]; /**< Elevation of each plane */
} MMCamcorderVideoStreamDataType;
/**
+ * mm_camcorder_get_fps_list_by_resolution:\n
+ * Get detail information of the fps configure. To manager fps, an user may want to know the supported fps list by the current preview resolution,
+ * Gives attribute information structure, from the configure data.
+ * Depending on the 'validity_type', validity union would be different. To know about the type of union, please refer 'MMCamAttrsInfo'.
+ *
+ * @param[in] camcorder Specifies the camcorder handle.
+ * @param[in] width width value of the current Preview resolution.
+ * @param[in] height height value of the current Preview resolution.
+ * @param[out] fps_info a structure that holds information related with the attribute.
+ * @return This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
+ * Please refer 'mm_error.h' to know the exact meaning of the error.
+ * @pre None
+ * @post None
+ * @remarks If the function succeeds, 'info' holds detail information about the attribute, such as type,
+ * flag, validity_type, validity_values, and default values.
+ * @see mm_camcorder_get_attributes, mm_camcorder_set_attributes
+ * @par example
+ * @code
+
+#include <mm_camcorder.h>
+
+gboolean getting_info_from_attribute()
+{
+ MMCamAttrsInfo info;
+ int err;
+
+ err = mm_camcorder_get_fps_list_by_resolution(handle, width, height, &info);
+ if (err < 0) {
+ printf("Fail to call mm_camcorder_get_attribute_info()");
+ return FALSE;
+ }
+
+ //Now 'info' has many information about 'MMCAM_CAPTURE_HEIGHT'
+
+ return TRUE;
+}
+ * @endcode
+ */
+int mm_camcorder_get_fps_list_by_resolution(MMHandleType camcorder, int width, int height, MMCamAttrsInfo *fps_info);
+
+
+/**
* mm_camcorder_init_focusing:\n
* Initialize focusing. \n
* This function stops focusing action and adjust the camera lens to initial position.
MM_CAM_SUPPORT_ZSL_CAPTURE,
MM_CAM_SUPPORT_ZERO_COPY_FORMAT,
MM_CAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB,
+ MM_CAM_RECORDER_TAG_ENABLE,
MM_CAM_ATTRIBUTE_NUM
}MMCamcorderAttrsID;
int _mmcamcorder_create_preview_pipeline(MMHandleType handle);
/* plug-in related */
-void _mmcamcorder_negosig_handler(GstElement *videosrc, MMHandleType handle);
void _mmcamcorder_ready_to_encode_callback(GstElement *element, guint size, gpointer handle);
/* etc */
} \
elist = g_list_append(elist, &(element[eid]));
+#define _MMCAMCORDER_ELEMENT_MAKE2(sub_context, element, eid, name /*char* */, nickname /*char* */, err) \
+ if (element[eid].gst != NULL) { \
+ _mmcam_dbg_err("The element is existed. element_id=[%d], name=[%s]", eid, name); \
+ gst_object_unref(element[eid].gst); \
+ } \
+ element[eid].gst = gst_element_factory_make(name, nickname); \
+ if (element[eid].gst == NULL) { \
+ _mmcam_dbg_err("Element creation fail. element_id=[%d], name=[%s]", eid, name); \
+ err = MM_ERROR_CAMCORDER_RESOURCE_CREATION; \
+ } else { \
+ _mmcam_dbg_log("Element creation done. element_id=[%d], name=[%s]", eid, name); \
+ element[eid].id = eid; \
+ g_object_weak_ref(G_OBJECT(element[eid].gst), (GWeakNotify)_mmcamcorder_element_release_noti, sub_context); \
+ err = MM_ERROR_NONE; \
+ } \
+
#define _MMCAMCORDER_ELEMENT_MAKE_IGNORE_ERROR(sub_context, element, eid, name /*char* */, nickname /*char* */, elist) \
if (element[eid].gst != NULL) { \
_mmcam_dbg_err("The element is existed. element_id=[%d], name=[%s]", eid, name); \
#define _MM_GST_ELEMENT_LINK_MANY gst_element_link_many
#define _MM_GST_ELEMENT_LINK gst_element_link
+#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)\
#define _MMCAMCORDER_STATE_SET_COUNT 3 /* checking interval */
#define _MMCAMCORDER_STATE_CHECK_TOTALTIME 5000000L /* total wating time for state change */
-#define _MMCAMCORDER_STATE_CHECK_INTERVAL 5000 /* checking interval */
+#define _MMCAMCORDER_STATE_CHECK_INTERVAL (50*1000) /* checking interval - 50ms*/
/**
* Default videosink type
#define _MMCAMCORDER_TRYLOCK(handle) _MMCAMCORDER_TRYLOCK_FUNC(_MMCAMCORDER_GET_LOCK(handle))
#define _MMCAMCORDER_UNLOCK(handle) _MMCAMCORDER_UNLOCK_FUNC(_MMCAMCORDER_GET_LOCK(handle))
+#define _MMCAMCORDER_GET_COND(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).cond)
+#define _MMCAMCORDER_WAIT(handle) pthread_cond_wait(&_MMCAMCORDER_GET_COND(handle), &_MMCAMCORDER_GET_LOCK(handle))
+#define _MMCAMCORDER_TIMED_WAIT(handle, timeout) pthread_cond_timedwait(&_MMCAMCORDER_GET_COND(handle), &_MMCAMCORDER_GET_LOCK(handle), &timeout)
+#define _MMCAMCORDER_SIGNAL(handle) pthread_cond_signal(&_MMCAMCORDER_GET_COND(handle));
+#define _MMCAMCORDER_BROADCAST(handle) pthread_cond_broadcast(&_MMCAMCORDER_GET_COND(handle));
+
/* for command */
#define _MMCAMCORDER_GET_CMD_LOCK(handle) (_MMCAMCORDER_CAST_MTSAFE(handle).cmd_lock)
#define _MMCAMCORDER_LOCK_CMD(handle) _MMCAMCORDER_LOCK_FUNC(_MMCAMCORDER_GET_CMD_LOCK(handle))
*/
typedef struct {
pthread_mutex_t lock; /**< Mutex (for general use) */
+ pthread_cond_t cond; /**< Condition (for general use) */
pthread_mutex_t cmd_lock; /**< Mutex (for command) */
pthread_mutex_t asm_lock; /**< Mutex (for ASM) */
pthread_mutex_t state_lock; /**< Mutex (for state change) */
GstClockTime pause_time; /**< amount of time while pipeline is in PAUSE state.*/
GstClockTime stillshot_time; /**< pipeline time of capturing moment*/
gboolean is_modified_rate; /**< whether recording motion rate is modified or not */
- gboolean error_occurs; /**< flag for error */
- int error_code; /**< error code for internal gstreamer error */
gboolean ferror_send; /**< file write/seek error **/
guint ferror_count; /**< file write/seek error count **/
GstClockTime previous_slot_time;
gboolean capture_in_recording; /**< Flag for capture while recording */
+ guint64 system_memory; /* system memory size, do not use this size for recording*/
+
+ gboolean error_occurs; /**< flag for error */
+ int error_code; /**< error code for internal gstreamer error */
+
/* task thread */
pthread_t task_thread; /**< thread for task */
pthread_mutex_t task_thread_lock; /**< mutex for task thread */
GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data);
/**
+ * This function is callback function of main pipeline.
+ * Once this function is registered with certain pipeline using gst_bus_set_sync_handler(),
+ * this callback will be called every time when there is upcomming message from pipeline.
+ * Basically, this function is used as sync error handling function, now.
+ *
+ * @param[in] bus pointer of buf that called this function.
+ * @param[in] message callback message from pipeline.
+ * @param[in] data user data.
+ * @return This function returns true on success, or false value with error
+ * @remarks
+ * @see __mmcamcorder_create_audiop_with_encodebin()
+ *
+ */
+GstBusSyncReply _mmcamcorder_audio_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data);
+
+
+/**
* This function create main pipeline according to type.
*
* @param[in] handle Handle of camcorder context.
#define _MMCAMCORDER_SENSOR_ENUM_NONE -255
/* camera information related */
-#define CAMINFO_CONVERT_NUM 41
+#define CAMINFO_CONVERT_NUM 40
/*=======================================================================================
========================================================================================*/
int _mmcamcorder_convert_msl_to_sensor(MMHandleType handle, int attr_idx, int mslval);
int _mmcamcorder_convert_sensor_to_msl(MMHandleType handle, int attr_idx, int sensval);
+int _mmcamcorder_get_fps_array_by_resolution(MMHandleType handle, int width, int height, MMCamAttrsInfo* fps_info);
int _mmcamcorder_set_converted_value(MMHandleType handle, _MMCamcorderEnumConvert *convert);
int _mmcamcorder_init_convert_table(MMHandleType handle);
| GLOBAL DEFINITIONS AND DECLARATIONS FOR CAMCORDER |
========================================================================================*/
+
/*=======================================================================================
| MACRO DEFINITIONS |
========================================================================================*/
/*=======================================================================================
| MACRO DEFINITIONS |
========================================================================================*/
-#define _MMCAMCORDER_CAPTURE_STOP_CHECK_INTERVAL 5000
-#define _MMCAMCORDER_CAPTURE_STOP_CHECK_COUNT 600
+#define _MMCAMCORDER_CAPTURE_STOP_CHECK_INTERVAL (50*1000)
+#define _MMCAMCORDER_CAPTURE_STOP_CHECK_COUNT 60
+
#define _MNOTE_VALUE_NONE 0
-#define _SOUND_STATUS_INIT -1
+#define _SOUND_STATUS_INIT -1
/*=======================================================================================
| ENUM DEFINITIONS |
int preview_format; /**< Preview format */
int hdr_capture_mode; /**< HDR Capture mode */
gboolean sound_status; /**< sound status of system */
- unsigned int volume_level; /**< media volume level of system */
gboolean played_capture_sound; /**< whether play capture sound when capture starts */
} _MMCamcorderImageInfo;
/*=======================================================================================
| INCLUDE FILES |
========================================================================================*/
-#include <camsrcjpegenc.h>
#include <linux/magic.h>
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] - [ID : %lu], [Category : %x] ", GST_OBJECT_NAME(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);
pthread_mutex_t lock; /**< mutex for item */
} _MMCamcorderMsgItem;
-/**
- * Structure of zero copy image buffer
- */
-#define SCMN_IMGB_MAX_PLANE (4)
-
-/* image buffer definition ***************************************************
-
- +------------------------------------------+ ---
- | | ^
- | a[], p[] | |
- | +---------------------------+ --- | |
- | | | ^ | |
- | |<---------- w[] ---------->| | | |
- | | | | | |
- | | | |
- | | | h[] | e[]
- | | | |
- | | | | | |
- | | | | | |
- | | | v | |
- | +---------------------------+ --- | |
- | | v
- +------------------------------------------+ ---
-
- |<----------------- s[] ------------------>|
-*/
-
-typedef struct
-{
- /* width of each image plane */
- int w[SCMN_IMGB_MAX_PLANE];
- /* height of each image plane */
- int h[SCMN_IMGB_MAX_PLANE];
- /* stride of each image plane */
- int s[SCMN_IMGB_MAX_PLANE];
- /* elevation of each image plane */
- int e[SCMN_IMGB_MAX_PLANE];
- /* user space address of each image plane */
- void *a[SCMN_IMGB_MAX_PLANE];
- /* physical address of each image plane, if needs */
- void *p[SCMN_IMGB_MAX_PLANE];
- /* color space type of image */
- int cs;
- /* left postion, if needs */
- int x;
- /* top position, if needs */
- int y;
- /* to align memory */
- int __dummy2;
- /* arbitrary data */
- int data[16];
- /* dmabuf or ion fd */
- int fd[SCMN_IMGB_MAX_PLANE];
- /* flag for buffer share */
- int buf_share_method;
- /* Y plane size */
- int y_size;
- /* UV plane size */
- int uv_size;
- /* Tizen buffer object of each image plane */
- void *bo[SCMN_IMGB_MAX_PLANE];
-} SCMN_IMGB;
/*=======================================================================================
| CONSTANT DEFINITIONS |
#define NANO_SEC_PER_MILI_SEC 1000000
#define _MMCAMCORDER_HANDLER_CATEGORY_ALL \
(_MMCAMCORDER_HANDLER_PREVIEW | _MMCAMCORDER_HANDLER_VIDEOREC |_MMCAMCORDER_HANDLER_STILLSHOT | _MMCAMCORDER_HANDLER_AUDIOREC)
+#define G_DBUS_REPLY_TIMEOUT (120 * 1000)
/*=======================================================================================
| GLOBAL FUNCTION PROTOTYPES |
/* JPEG encode */
gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsigned int src_height,
int src_format, unsigned int src_length, unsigned int jpeg_quality,
- void **result_data, unsigned int *result_length, int enc_type);
+ void **result_data, unsigned int *result_length);
/* resize */
gboolean _mmcamcorder_resize_frame(unsigned char *src_data, unsigned int src_width, unsigned int src_height, unsigned int src_length, int src_format,
unsigned char **dst_data, unsigned int *dst_width, unsigned int *dst_height, unsigned int *dst_length);
/* find top level tag only, do not use this function for finding sub level tags.
tag_fourcc is Four-character-code (FOURCC) */
gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc, gboolean do_rewind);
+gboolean _mmcamcorder_find_fourcc(FILE *f, guint32 tag_fourcc, gboolean do_rewind);
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_udta(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);
gboolean _mmcamcorder_update_composition_matrix(FILE *f, int orientation);
/* File system */
int _mmcamcorder_get_freespace(const gchar *path, guint64 *free_space);
+int _mmcamcorder_get_freespace_except_system(guint64 *free_space);
int _mmcamcorder_get_file_size(const char *filename, guint64 *size);
int _mmcamcorder_get_file_system_type(const gchar *path, int *file_system_type);
gboolean _mmcamcorder_check_file_path(const gchar *path);
/* Task */
void *_mmcamcorder_util_task_thread_func(void *data);
+/* device */
+int _mmcamcorder_get_device_flash_brightness(int *brightness);
+
#ifdef __cplusplus
}
#endif
return _mmcamcorder_get_attribute_info(camcorder, attribute_name, info);
}
+int mm_camcorder_get_fps_list_by_resolution(MMHandleType camcorder, int width, int height, MMCamAttrsInfo *fps_info)
+{
+ return _mmcamcorder_get_fps_array_by_resolution(camcorder, width, height, fps_info);
+}
+
int mm_camcorder_init_focusing(MMHandleType camcorder)
{
{
MMHandleType attrs = 0;
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 );
}
if (ret == MM_ERROR_NONE) {
+ hcamcorder->error_code = MM_ERROR_NONE;
ret = mm_attrs_set_valist(attrs, err_attr_name, attribute_name, var_args);
}
_MMCAMCORDER_UNLOCK_CMD(handle);
if (ret != MM_ERROR_NONE) {
+ if (hcamcorder->error_code != MM_ERROR_NONE) {
+ _mmcam_dbg_err("error_code is not NONE. origin 0x%x, modified 0x%x", ret, hcamcorder->error_code);
+ ret = hcamcorder->error_code;
+ hcamcorder->error_code = MM_ERROR_NONE;
+ }
+
_mmcam_dbg_err("failed error code 0x%x - handle %p", ret, (mmf_camcorder_t *)handle);
}
attr = MMF_CAMCORDER_ATTRS(handle);
mmf_return_val_if_fail(attr, FALSE);
- _mmcam_dbg_log("(%d)", attr_idx);
+ /*_mmcam_dbg_log("(%d)", attr_idx);*/
current_state = _mmcamcorder_get_state(handle);
if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
return TRUE;
}
- control = GST_CAMERA_CONTROL( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst );
- gst_camera_control_set_capture_command( control, GST_CAMERA_CONTROL_CAPTURE_COMMAND_STOP_MULTISHOT );
-
- _mmcam_dbg_warn( "Commit Break continuous shot : Set command OK. current state[%d]", current_state );
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (control) {
+ gst_camera_control_set_capture_command(control, GST_CAMERA_CONTROL_CAPTURE_COMMAND_STOP_MULTISHOT);
+ _mmcam_dbg_warn("Commit Break continuous shot : Set command OK. current state[%d]", current_state);
+ } else {
+ _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 );
}
bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
+ MMCamAttrsInfo fps_info;
+ int resolution_width = 0;
+ int resolution_height = 0;
+ int i;
+ int ret;
+
_mmcam_dbg_log("FPS(%d)", value->value.i_val);
- return TRUE;
+
+ ret = mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_CAMERA_WIDTH, &resolution_width,
+ MMCAM_CAMERA_HEIGHT, &resolution_height,
+ NULL);
+
+ if(ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("FAILED : coult not get resolution values.");
+ return FALSE;
+ }
+
+ ret = mm_camcorder_get_fps_list_by_resolution(handle, resolution_width, resolution_height, &fps_info);
+
+ if(ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("FAILED : coult not get FPS values by resolution.");
+ return FALSE;
+ }
+
+ for(i=0; i<fps_info.int_array.count; 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);
+ return FALSE;
}
}
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_zoom(control, zoom_type, zoom_level);
if (ret) {
_mmcam_dbg_log("Succeed in operating Zoom[%d].", zoom_level);
}
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 );
if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
if (gst_camera_control_get_focus(control, &cur_focus_mode, &cur_focus_range)) {
- if (gst_camera_control_set_focus(control, set_focus_mode, cur_focus_range)) {
- _mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal);
- return TRUE;
+ if (set_focus_mode != cur_focus_mode) {
+ if (gst_camera_control_set_focus(control, set_focus_mode, cur_focus_range)) {
+ _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_warn("Failed to set AF mode[%d]", mslVal);
+ _mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal);
+ return TRUE;
}
} else {
- _mmcam_dbg_err("failed to get focus mode");
- return FALSE;
+ _mmcam_dbg_warn("Failed to get AF mode, so do not set new AF mode[%d]", mslVal);
}
}
} else {
int current_state = MM_CAMCORDER_STATE_NONE;
int mslVal = 0;
int newVal = 0;
+ int cur_focus_mode = 0;
+ int cur_focus_range = 0;
int msl_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
int converted_mode = 0;
newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal);
current_state = _mmcamcorder_get_state(handle);
- if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("af scan range will be changed later.(state=%d)", current_state);
+ if (current_state < MM_CAMCORDER_STATE_PREPARE) {
+ _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
}
}
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 );
- if (gst_camera_control_set_focus(control, converted_mode, newVal)) {
- //_mmcam_dbg_log( "Succeed in setting AF mode[%d]", mslVal );
- return TRUE;
+ 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);
+ 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);
+ return TRUE;
+ }
} else {
- _mmcam_dbg_warn( "Failed to set AF mode[%d]", mslVal );
+ _mmcam_dbg_warn("Failed to get AF mode, so do not set new AF mode[%d]", mslVal);
}
} else {
_mmcam_dbg_log("pointer of video src is null");
}
+
return FALSE;
}
if( do_set )
{
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_get_auto_focus_area( control, &get_area );
if( !ret )
}
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) {
}
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (control == NULL) {
+ _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ return FALSE;
+ }
+
if (gst_camera_control_get_wdr(control, &cur_value)) {
if (newVal != cur_value) {
if (gst_camera_control_set_wdr(control, newVal)) {
/* get string */
filename = mmf_value_get_string(value, &size);
+ if (filename == NULL) {
+ _mmcam_dbg_err("NULL filename");
+ return FALSE;
+ }
if (sc->info_video) {
if (sc->info_video->filename) {
return FALSE;
}
- _mmcam_dbg_log("label(%s): MSL(%d)->Sensor(%d)", control_label, mslNewVal, newVal);
+ /*_mmcam_dbg_log("label(%s): MSL(%d)->Sensor(%d)", control_label, mslNewVal, newVal);*/
if (!GST_IS_COLOR_BALANCE(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
_mmcam_dbg_log("Can't cast Video source into color balance.");
}
balance = GST_COLOR_BALANCE(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (balance == NULL) {
+ _mmcam_dbg_err("cast COLOR_BALANCE failed");
+ return FALSE;
+ }
+
controls = gst_color_balance_list_channels(balance);
if (controls == NULL) {
_mmcam_dbg_log("There is no list of colorbalance controls");
}
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, GST_CAMERA_CONTROL_PROGRAM_MODE, newVal, 0);
if (ret) {
_mmcam_dbg_log("Succeed in setting program mode[%d].", mslVal);
/* Get videosink name */
_mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
- if (!strcmp(videosink_name, "xvimagesink") ||
+ if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "evasimagesink") ||
!strcmp(videosink_name, "evaspixmapsink")) {
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);
/* Get videosink name */
_mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
- if (!strcmp(videosink_name, "xvimagesink") ||
+ if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "evasimagesink") ||
!strcmp(videosink_name, "evaspixmapsink")) {
method = value->value.i_val;
MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-geometry-method", method);
{
bool bret = FALSE;
_MMCamcorderSubContext *sc = NULL;
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
int strobe_type, mslVal, newVal, cur_value;
int current_state = MM_CAMCORDER_STATE_NONE;
+ int set_flash_state = -1;
+
+ if (hcamcorder == NULL) {
+ _mmcam_dbg_err("NULL handle");
+ return FALSE;
+ }
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
if (!sc)
return TRUE;
- _mmcam_dbg_log( "Commit : strobe attribute(%d)", attr_idx );
+ /*_mmcam_dbg_log( "Commit : strobe attribute(%d)", attr_idx );*/
- //status check
- current_state = _mmcamcorder_get_state( handle);
+ mslVal = value->value.i_val;
+ /* check flash state */
+ if (attr_idx == MM_CAM_STROBE_MODE) {
+ int flash_brightness = 0;
+
+ /* get current flash brightness */
+ if (_mmcamcorder_get_device_flash_brightness(&flash_brightness) != MM_ERROR_NONE) {
+ _mmcam_dbg_err("_mmcamcorder_get_device_flash_brightness failed");
+ hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
+ return FALSE;
+ }
+
+ _mmcam_dbg_log("flash brightness %d", flash_brightness);
+
+ if (flash_brightness > 0 &&
+ mslVal != MM_CAMCORDER_STROBE_MODE_OFF) {
+ /* other module already turned on flash */
+ hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_BUSY;
+ _mmcam_dbg_err("other module already turned on flash. avoid to set flash mode here.");
+ return FALSE;
+ } else {
+ /* flash is OFF state, this case will set flash state key */
+ if (mslVal == MM_CAMCORDER_STROBE_MODE_OFF) {
+ set_flash_state = VCONFKEY_CAMERA_FLASH_STATE_OFF;
+ } else {
+ set_flash_state = VCONFKEY_CAMERA_FLASH_STATE_ON;
+ }
+
+ _mmcam_dbg_log("keep going, and will set flash state key %d", set_flash_state);
+ }
+ }
+
+ /* check state */
+ current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
_mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
+
+ if (set_flash_state != -1) {
+ _mmcam_dbg_log("set VCONFKEY_CAMERA_FLASH_STATE : %d", set_flash_state);
+ vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, set_flash_state);
+ vconf_set_int(VCONFKEY_CAMERA_PID, (int)getpid());
+ }
+
return TRUE;
} else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
_mmcam_dbg_warn("invalid state[capturing]");
+ hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
- mslVal = value->value.i_val;
-
switch (attr_idx) {
case MM_CAM_STROBE_CONTROL:
strobe_type = GST_CAMERA_CONTROL_STROBE_CONTROL;
bret = FALSE;
} else {
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (control == NULL) {
+ _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ return FALSE;
+ }
if (gst_camera_control_get_strobe(control, strobe_type, &cur_value)) {
if (newVal != cur_value) {
}
}
+ if (bret == TRUE && set_flash_state != -1) {
+ _mmcam_dbg_log("set VCONFKEY_CAMERA_FLASH_STATE : %d", set_flash_state);
+ vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, set_flash_state);
+ vconf_set_int(VCONFKEY_CAMERA_PID, (int)getpid());
+ }
+
return bret;
}
return FALSE;
}
- _mmcam_dbg_log("Commit : HDR Capture %d", value->value.i_val);
+ /*_mmcam_dbg_log("Commit : HDR Capture %d", value->value.i_val);*/
/* check whether set or not */
if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
return TRUE;
}
- _mmcam_dbg_log("Commit : detect attribute(%d)", attr_idx);
+ /*_mmcam_dbg_log("Commit : detect attribute(%d)", attr_idx);*/
/* state check */
current_state = _mmcamcorder_get_state( handle);
bret = FALSE;
} else {
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (control == NULL) {
+ _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ return FALSE;
+ }
if (gst_camera_control_get_detect(control, detect_type, ¤t_value)) {
if (current_value == set_value) {
switch (info.validity_type) {
case MM_ATTRS_VALID_TYPE_INT_ARRAY:
- _mmcam_dbg_log("int array count %d", info.int_array.count)
+ /*
+ _mmcam_dbg_log("int array count %d", info.int_array.count);
+ */
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) {
return FALSE;
}
break;
case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
- _mmcam_dbg_log("double array count %d", info.double_array.count)
+ /*
+ _mmcam_dbg_log("double array count %d", info.double_array.count);
+ */
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) {
return FALSE;
}
#define _MMCAMCORDER_AUDIO_MINIMUM_SPACE (100*1024)
#define _MMCAMCORDER_AUDIO_MARGIN_SPACE (1*1024)
#define _MMCAMCORDER_RETRIAL_COUNT 10
-#define _MMCAMCORDER_FRAME_WAIT_TIME 20000 /* micro second */
+#define _MMCAMCORDER_FRAME_WAIT_TIME 200000 /* micro second */
#define _MMCAMCORDER_FREE_SPACE_CHECK_INTERVAL 10
/*---------------------------------------------------------------------------------------
static GstPadProbeReturn __mmcamcorder_audio_dataprobe_voicerecorder(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
static GstPadProbeReturn __mmcamcorder_audio_dataprobe_record(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
static int __mmcamcorder_create_audiop_with_encodebin(MMHandleType handle);
-static void __mmcamcorder_audiorec_pad_added_cb(GstElement *element, GstPad *pad, MMHandleType handle);
+static gboolean __mmcamcorder_audio_add_metadata_info_m4a(MMHandleType handle);
/*=======================================================================================
| FUNCTION DEFINITIONS |
gst_object_unref(srcpad);
srcpad = NULL;
- if (info->bMuxing) {
- MMCAMCORDER_SIGNAL_CONNECT(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst,
- _MMCAMCORDER_HANDLER_AUDIOREC,
- "pad-added",
- __mmcamcorder_audiorec_pad_added_cb,
- hcamcorder);
- } else {
- 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);
- 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);
+ gst_object_unref(srcpad);
+ srcpad = NULL;
bus = gst_pipeline_get_bus(GST_PIPELINE(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst));
hcamcorder->pipeline_cb_event_id = gst_bus_add_watch(bus, (GstBusFunc)_mmcamcorder_pipeline_cb_message, hcamcorder);
/* set sync callback */
- gst_bus_set_sync_handler(bus, gst_bus_sync_signal_handler, hcamcorder, NULL);
+ gst_bus_set_sync_handler(bus, _mmcamcorder_audio_pipeline_bus_sync_callback, hcamcorder, NULL);
gst_object_unref(bus);
bus = NULL;
int err = 0;
int size=0;
guint64 free_space = 0;
+ guint64 free_space_exceptsystem = 0;
char *dir_name = NULL;
char *err_attr_name = NULL;
dir_name = g_path_get_dirname(info->filename);
if (dir_name) {
err = _mmcamcorder_get_freespace(dir_name, &free_space);
- _mmcam_dbg_warn("current space for recording - %s :[%" G_GUINT64_FORMAT "]" ,dir_name, free_space);
+ if(_mmcamcorder_check_file_path(dir_name)) {
+ if (_mmcamcorder_get_freespace_except_system(&free_space_exceptsystem) == MM_ERROR_NONE) {
+ hcamcorder->system_memory = free_space - free_space_exceptsystem;
+ free_space = free_space - hcamcorder->system_memory;
+ } else {
+ hcamcorder->system_memory = 0;
+ }
+ }
+
+ _mmcam_dbg_warn("current space - %s [%" G_GUINT64_FORMAT "], system [%" G_GUINT64_FORMAT "]",
+ dir_name, free_space, hcamcorder->system_memory);
if (_mmcamcorder_get_file_system_type(dir_name, &file_system_type) == 0) {
/* MSDOS_SUPER_MAGIC : 0x4d44 */
return FALSE;
}
+/* START TAG HERE */
+ // 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 = strdup(info->filename);
msg.param.data= report;
int err = MM_ERROR_UNKNOWN;
char *err_name = NULL;
GstBuffer *buffer = GST_PAD_PROBE_INFO_BUFFER(info);
- GstMapInfo mapinfo = GST_MAP_INFO_INIT;
+ GstMapInfo mapinfo;
mmf_return_val_if_fail(hcamcorder, GST_PAD_PROBE_OK);
+ memset(&mapinfo, 0x0, sizeof(GstMapInfo));
+
/* Set volume to audio input */
err = mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_name,
MMCAM_AUDIO_VOLUME, &volume,
}
-static void
-__mmcamcorder_audiorec_pad_added_cb(GstElement *element, GstPad *pad, MMHandleType handle)
-{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
-
- _mmcam_dbg_log("ENTER(%s)", GST_PAD_NAME(pad));
- //FIXME : the name of audio sink pad of wavparse, oggmux doesn't have 'audio'. How could I handle the name?
- if((strstr(GST_PAD_NAME(pad), "audio")) || (strstr(GST_PAD_NAME(pad), "sink")))
- {
- MMCAMCORDER_ADD_BUFFER_PROBE(pad, _MMCAMCORDER_HANDLER_AUDIOREC,
- __mmcamcorder_audio_dataprobe_record, hcamcorder);
- }
- else
- {
- _mmcam_dbg_warn("Unknow pad is added, check it : [%s]", GST_PAD_NAME(pad));
- }
-
- return;
-}
-
-
static GstPadProbeReturn __mmcamcorder_audio_dataprobe_record(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
{
static int count = 0;
if (count++ == 0) {
gint free_space_ret = _mmcamcorder_get_freespace(filename, &free_space);
+ if(_mmcamcorder_check_file_path(filename) && hcamcorder->system_memory) {
+ free_space = free_space - hcamcorder->system_memory;
+ }
+
/*_mmcam_dbg_log("check free space for recording");*/
switch (free_space_ret) {
return GST_PAD_PROBE_DROP;
}
}
+
+/* START TAG HERE */
+static gboolean __mmcamcorder_audio_add_metadata_info_m4a(MMHandleType handle)
+{
+ FILE *f = NULL;
+ guchar buf[4];
+ guint64 udta_size = 0;
+ gint64 current_pos = 0;
+ gint64 moov_pos = 0;
+ gint64 udta_pos = 0;
+ // supporting audio geo tag for mobile
+ int gps_enable = 0;
+ char *err_name = NULL;
+ gdouble longitude = 0;
+ gdouble latitude = 0;
+ gdouble altitude = 0;
+ _MMCamcorderLocationInfo geo_info = {0,0,0};
+ _MMCamcorderLocationInfo loc_info = {0,0,0};
+
+ char err_msg[128] = {'\0',};
+
+ _MMCamcorderAudioInfo *info = NULL;
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderSubContext *sc = NULL;
+
+ 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);
+ mmf_return_val_if_fail(sc->info_audio, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
+ info = sc->info_audio;
+ mm_camcorder_get_attributes(handle, &err_name,
+ MMCAM_TAG_GPS_ENABLE, &gps_enable,
+ NULL);
+
+ if (gps_enable) {
+ mm_camcorder_get_attributes(handle, &err_name,
+ 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);
+ geo_info.longitude = longitude *10000;
+ geo_info.latitude = latitude *10000;
+ geo_info.altitude = altitude *10000;
+ }
+
+ f = fopen(info->filename, "rb+");
+ if (f == NULL) {
+ strerror_r(errno, err_msg, 128);
+ _mmcam_dbg_err("file open failed [%s]", err_msg);
+ if (err_name) {
+ free(err_name);
+ err_name = NULL;
+ }
+ return FALSE;
+ }
+
+ /* 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)) {
+ size_t nread = 0;
+
+ _mmcam_dbg_log("find udta container");
+
+ /* read size */
+ if (fseek(f, -8L, SEEK_CUR) != 0) {
+ goto fail;
+ }
+
+ udta_pos = ftell(f);
+ if (udta_pos < 0) {
+ goto ftell_fail;
+ }
+
+ nread = fread(&buf, sizeof(char), sizeof(buf), f);
+
+ _mmcam_dbg_log("recorded file fread %d", nread);
+
+ udta_size = _mmcamcorder_get_container_size(buf);
+
+ /* goto end of udta and write 'smta' box */
+ if (fseek(f, (udta_size-4L), SEEK_CUR) != 0) {
+ goto fail;
+ }
+
+ if (gps_enable) {
+ if (!_mmcamcorder_write_loci(f, loc_info)) {
+ goto fail;
+ }
+
+ if (!_mmcamcorder_write_geodata( f, geo_info )) {
+ goto fail;
+ }
+ }
+
+ current_pos = ftell(f);
+ if (current_pos < 0) {
+ goto ftell_fail;
+ }
+
+ 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) {
+ goto fail;
+ }
+
+ if (!_mmcamcorder_write_udta(f, gps_enable, loc_info, geo_info)) {
+ goto fail;
+ }
+ }
+
+ /* find moov container.
+ update moov container size. */
+ if((current_pos = ftell(f))<0)
+ goto ftell_fail;
+
+ 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) {
+ goto fail;
+ }
+
+ moov_pos = ftell(f);
+ if (moov_pos < 0) {
+ goto ftell_fail;
+ }
+
+ if (!_mmcamcorder_update_size(f, moov_pos, current_pos)) {
+ goto fail;
+ }
+
+
+ } else {
+ _mmcam_dbg_err("No 'moov' container");
+ goto fail;
+ }
+
+ fclose(f);
+ if (err_name) {
+ free(err_name);
+ err_name = NULL;
+ }
+ return TRUE;
+
+fail:
+ fclose(f);
+ if (err_name) {
+ free(err_name);
+ err_name = NULL;
+ }
+ return FALSE;
+
+ftell_fail:
+ _mmcam_dbg_err("ftell() returns negative value.");
+ fclose(f);
+ if (err_name) {
+ free(err_name);
+ err_name = NULL;
+ }
+ return FALSE;
+}
+
+/* END TAG HERE */
+
int count_token = 0;
int read_main = 0;
- char *buffer_string = (char*)g_malloc0(sizeof(char)*BUFFER_LENGTH_STRING);
+ char *buffer_string = NULL;
char *buffer_details[BUFFER_NUM_DETAILS];
char *buffer_token[BUFFER_NUM_TOKEN];
char *token = NULL;
_mmcam_dbg_log( "" );
- camera_conf* new_conf = (camera_conf*)g_malloc0(sizeof(camera_conf));
+ camera_conf* new_conf = (camera_conf *)g_malloc0(sizeof(camera_conf));
+ if (new_conf == NULL) {
+ _mmcam_dbg_err("new_conf alloc failed : %d", sizeof(camera_conf));
+ *configure_info = NULL;
+ return MM_ERROR_CAMCORDER_LOW_MEMORY;
+ }
- if( new_conf == NULL )
- {
- _mmcam_dbg_err( "Failed to create new configure structure.type[%d]", type );
+ buffer_string = (char*)g_malloc0(sizeof(char) * BUFFER_LENGTH_STRING);
+ if (buffer_string == NULL) {
+ _mmcam_dbg_err("buffer_string alloc failed : %d", sizeof(char) * BUFFER_LENGTH_STRING);
*configure_info = NULL;
- SAFE_FREE( buffer_string );
+ g_free(new_conf);
return MM_ERROR_CAMCORDER_LOW_MEMORY;
}
_mmcamcorder_conf_init(handle, type, &new_conf);
- if( fd == NULL )
- {
+ if (fd == NULL) {
_mmcam_dbg_err("failed file descriptor fail");
- SAFE_FREE( buffer_string );
- SAFE_FREE( new_conf );
+ *configure_info = NULL;
+ g_free(buffer_string);
+ g_free(new_conf);
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
count_token = 0;
token = strtok_r( buffer_string, delimiters, &user_ptr );
- if ((token) && (token[0] == ';'))
+ if ((token) && (token[0] == ';') && (length_read > -1))
{
/*_mmcam_dbg_log( "Comment - Nothing to do" );*/
continue;
}
}
- /*
- _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 )
{
SAFE_FREE( buffer_string );
- _mmcam_dbg_log( "Done." );
+ /*_mmcam_dbg_log( "Done." );*/
return MM_ERROR_NONE;
}
-void _mmcamcorder_conf_release_info(MMHandleType handle, camera_conf** configure_info)
+void _mmcamcorder_conf_release_info(MMHandleType handle, camera_conf **configure_info)
{
- int i, j, k, type, count, category_num;
- camera_conf* temp_conf = (*configure_info);
-
- type_int2* temp_int;
- type_int_range* temp_int_range;
- type_int_array* temp_int_array;
- type_int_pair_array* temp_int_pair_array;
- type_string2* temp_string;
- type_string_array* temp_string_array;
- type_element2* temp_element;
+ int i = 0;
+ int j = 0;
+ int k = 0;
+ int type = CONFIGURE_VALUE_INT;
+ int count = 0;
+ int category_num = CONFIGURE_CATEGORY_MAIN_NUM;
+ camera_conf *temp_conf = (*configure_info);
+
+ type_int2 *temp_int = NULL;
+ type_int_range *temp_int_range = NULL;
+ type_int_array *temp_int_array = NULL;
+ type_int_pair_array *temp_int_pair_array = NULL;
+ type_string2 *temp_string = NULL;
+ type_string_array *temp_string_array = NULL;
+ type_element2 *temp_element = NULL;
- _mmcam_dbg_log( "Entered..." );
+ _mmcam_dbg_log("Entered...");
- mmf_return_if_fail( temp_conf );
+ 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 )
- {
+ 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) {
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 )
- {
- case CONFIGURE_VALUE_INT:
- {
- temp_int = (type_int2*)(temp_conf->info[i]->detail_info[j]);
- SAFE_FREE( temp_int->name );
- }
- break;
- case CONFIGURE_VALUE_INT_RANGE:
- {
- temp_int_range = (type_int_range*)(temp_conf->info[i]->detail_info[j]);
- SAFE_FREE( temp_int_range->name );
- }
- break;
- case CONFIGURE_VALUE_INT_ARRAY:
- {
- temp_int_array = (type_int_array*)(temp_conf->info[i]->detail_info[j]);
- SAFE_FREE( temp_int_array->name );
- SAFE_FREE( temp_int_array->value );
- }
- break;
- case CONFIGURE_VALUE_INT_PAIR_ARRAY:
- {
- temp_int_pair_array = (type_int_pair_array*)(temp_conf->info[i]->detail_info[j]);
- SAFE_FREE( temp_int_pair_array->name );
- SAFE_FREE( temp_int_pair_array->value[0] );
- SAFE_FREE( temp_int_pair_array->value[1] );
- }
- break;
- case CONFIGURE_VALUE_STRING:
- {
- temp_string = (type_string2*)(temp_conf->info[i]->detail_info[j]);
- SAFE_FREE( temp_string->name );
- SAFE_FREE( temp_string->value );
- }
- break;
- case CONFIGURE_VALUE_STRING_ARRAY:
- {
- temp_string_array = (type_string_array*)(temp_conf->info[i]->detail_info[j]);
- SAFE_FREE( temp_string_array->name );
-
+ if (_mmcamcorder_conf_get_value_type(handle, temp_conf->type, i, ((type_element*)(temp_conf->info[i]->detail_info[j]))->name, &type)) {
+ switch (type) {
+ case CONFIGURE_VALUE_INT:
+ temp_int = (type_int2*)(temp_conf->info[i]->detail_info[j]);
+ SAFE_FREE(temp_int->name);
+ break;
+ case CONFIGURE_VALUE_INT_RANGE:
+ temp_int_range = (type_int_range*)(temp_conf->info[i]->detail_info[j]);
+ SAFE_FREE(temp_int_range->name);
+ break;
+ case CONFIGURE_VALUE_INT_ARRAY:
+ temp_int_array = (type_int_array*)(temp_conf->info[i]->detail_info[j]);
+ SAFE_FREE(temp_int_array->name);
+ SAFE_FREE(temp_int_array->value);
+ break;
+ case CONFIGURE_VALUE_INT_PAIR_ARRAY:
+ temp_int_pair_array = (type_int_pair_array*)(temp_conf->info[i]->detail_info[j]);
+ SAFE_FREE(temp_int_pair_array->name);
+ SAFE_FREE(temp_int_pair_array->value[0]);
+ SAFE_FREE(temp_int_pair_array->value[1]);
+ break;
+ case CONFIGURE_VALUE_STRING:
+ temp_string = (type_string2*)(temp_conf->info[i]->detail_info[j]);
+ SAFE_FREE(temp_string->name);
+ SAFE_FREE(temp_string->value);
+ break;
+ case CONFIGURE_VALUE_STRING_ARRAY:
+ temp_string_array = (type_string_array*)(temp_conf->info[i]->detail_info[j]);
+ SAFE_FREE(temp_string_array->name);
+ if (temp_string_array->value) {
count = temp_string_array->count;
- for( k = 0 ; k < count ; k++ )
- {
- SAFE_FREE( temp_string_array->value[k] );
+ for (k = 0 ; k < count ; k++) {
+ SAFE_FREE(temp_string_array->value[k]);
}
- SAFE_FREE( temp_string_array->value );
- SAFE_FREE( temp_string_array->default_value );
+ g_free(temp_string_array->value);
+ temp_string_array->value = NULL;
}
- break;
- case CONFIGURE_VALUE_ELEMENT:
- {
- temp_element = (type_element2*)(temp_conf->info[i]->detail_info[j]);
- SAFE_FREE( temp_element->name );
- SAFE_FREE( temp_element->element_name );
+ SAFE_FREE(temp_string_array->default_value);
+ break;
+ case CONFIGURE_VALUE_ELEMENT:
+ temp_element = (type_element2*)(temp_conf->info[i]->detail_info[j]);
+ SAFE_FREE(temp_element->name);
+ SAFE_FREE(temp_element->element_name);
+ if (temp_element->value_int) {
count = temp_element->count_int;
- for( k = 0 ; k < count ; k++ )
- {
- SAFE_FREE( temp_element->value_int[k]->name );
- SAFE_FREE( temp_element->value_int[k] );
+ for (k = 0 ; k < count ; k++) {
+ SAFE_FREE(temp_element->value_int[k]->name);
+ SAFE_FREE(temp_element->value_int[k]);
}
- SAFE_FREE( temp_element->value_int );
+ g_free(temp_element->value_int);
+ }
+ if (temp_element->value_string) {
count = temp_element->count_string;
- for( k = 0 ; k < count ; k++ )
- {
- SAFE_FREE( temp_element->value_string[k]->name );
- SAFE_FREE( temp_element->value_string[k]->value );
- SAFE_FREE( temp_element->value_string[k] );
+ for (k = 0 ; k < count ; k++) {
+ SAFE_FREE(temp_element->value_string[k]->name);
+ SAFE_FREE(temp_element->value_string[k]->value);
+ SAFE_FREE(temp_element->value_string[k]);
}
- SAFE_FREE( temp_element->value_string );
+ g_free(temp_element->value_string);
}
- break;
- default:
- _mmcam_dbg_warn("unknown type %d", type);
- break;
+ break;
+ default:
+ _mmcam_dbg_warn("unknown type %d", type);
+ break;
}
}
- SAFE_FREE( temp_conf->info[i]->detail_info[j] );
+ SAFE_FREE(temp_conf->info[i]->detail_info[j]);
temp_conf->info[i]->detail_info[j] = NULL;
}
- SAFE_FREE( temp_conf->info[i]->detail_info );
+ SAFE_FREE(temp_conf->info[i]->detail_info);
temp_conf->info[i]->detail_info = NULL;
- SAFE_FREE( temp_conf->info[i] );
+ SAFE_FREE(temp_conf->info[i]);
temp_conf->info[i] = NULL;
}
}
- SAFE_FREE( (*configure_info)->info );
- SAFE_FREE( (*configure_info) );
+ SAFE_FREE((*configure_info)->info);
+ SAFE_FREE((*configure_info));
- _mmcam_dbg_log( "Done." );
+ _mmcam_dbg_log("Done.");
}
int _mmcamcorder_conf_get_value_type(MMHandleType handle, int type, int category, const char* name, int* value_type)
mmf_return_val_if_fail( buffer_details, FALSE );
(*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;
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;
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] );
int count_value = count_token - 2;
type_int_array* new_int_array;
- new_int_array = (type_int_array*)g_malloc0( sizeof(type_int_array) );
- new_int_array->name = get_new_string( buffer_token[0] );
+ 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) {
+ if (new_int_array->name) {
+ free(new_int_array->name);
+ new_int_array->name = NULL;
+ }
+ free(new_int_array);
+ new_int_array = NULL;
+ _mmcam_dbg_err("allocation failed");
+ break;
+ }
new_int_array->count = count_value;
/*_mmcam_dbg_log("INT ARRAY - name[%s]", new_int_array->name);*/
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) );
+ 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_malloc( sizeof(int)*(count_value) );
+ if ( new_int_pair_array->value[0] == NULL ) {
+ if (new_int_pair_array->name) {
+ free( new_int_pair_array->name );
+ new_int_pair_array->name = NULL;
+ }
+ free( new_int_pair_array );
+ new_int_pair_array = NULL;
+ _mmcam_dbg_err("allocation failed");
+ break;
+ }
new_int_pair_array->value[1] = (int*)g_malloc( sizeof(int)*(count_value) );
+ if ( new_int_pair_array->value[1] == NULL ) {
+ free( new_int_pair_array->value[0] );
+ new_int_pair_array->value[0] = NULL;
+ if (new_int_pair_array->name) {
+ free( new_int_pair_array->name );
+ new_int_pair_array->name = NULL;
+ }
+ free( new_int_pair_array );
+ new_int_pair_array = NULL;
+ _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);*/
{
type_string2* new_string;
- new_string = (type_string2*)g_malloc0( sizeof(type_string2) );
+ 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;
int count_value = count_token - 2;
type_string_array* new_string_array;
- new_string_array = (type_string_array*)g_malloc0( sizeof(type_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 );;
-
+ new_string_array->value = (char**)g_malloc0( sizeof(char*)*count_value );
+ if ( new_string_array->value == NULL ) {
+ if (new_string_array->name) {
+ free(new_string_array->name);
+ new_string_array->name = NULL;
+ }
+ free(new_string_array);
+ new_string_array = NULL;
+ _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] );
{
type_element2* new_element;
- new_element = (type_element2*)g_malloc0( sizeof(type_element2) );
+ 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] );
/* add int values */
if ( new_element->count_int > 0 ) {
new_element->value_int = (type_int2**)g_malloc0( sizeof(type_int2*)*(new_element->count_int) );
-
- for ( j = 0 ; j < new_element->count_int ; j++ ) {
- new_element->value_int[j] = (type_int2*)g_malloc( sizeof(type_int2) );
- 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)] );
- /*
- _mmcam_dbg_log(" Element INT[%d] - name[%s],value[%d]",
- j, new_element->value_int[j]->name, new_element->value_int[j]->value);
- */
+ if ( new_element->value_int) {
+ for ( j = 0 ; j < new_element->count_int ; j++ ) {
+ new_element->value_int[j] = (type_int2*)g_malloc( 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);
+ */
+ }
+ } else {
+ _mmcam_dbg_err("allocation failed");
}
}
else
/* add string values */
if ( new_element->count_string > 0 ) {
new_element->value_string = (type_string2**)g_malloc0( sizeof(type_string2*)*(new_element->count_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) );
- 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);
- */
+ 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 {
new_element->value_string = NULL;
}
-int _mmcamcorder_conf_add_info_with_caps(MMHandleType handle, int type, conf_detail** info, char** buffer_details, int category, int count_details)
-{
- const int BUFFER_NUM_TOKEN = 256;
-
- int i = 0;
- int j = 0;
- int count_token = 0;
- int value_type = 0;
- char *token = NULL;
- char *buffer_token[BUFFER_NUM_TOKEN];
- char *user_ptr = NULL;
-
- const char* delimiters = " |=,\t\n";
- const char* delimiters_sub = " |\t\n";
- const char* delimiters_3rd = "|\n";
-
- //_mmcam_dbg_log( "" );
-
- mmf_return_val_if_fail( buffer_details, FALSE );
-
- (*info) = (conf_detail*)g_malloc0( sizeof(conf_detail) );
- (*info)->detail_info = (void**)g_malloc0( sizeof(void*)*count_details );
- (*info)->count = count_details;
-
- //g_print( "Count[%d]\n", (*info)->count );
- //g_print( "Pointer[%x]\n", (*info) );
-
- 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 );
-
- 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] );
- 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] );
- continue;
- }
-
- if( value_type != CONFIGURE_VALUE_STRING && value_type != CONFIGURE_VALUE_STRING_ARRAY )
- {
- 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 );
- }
-
- if( count_token < 2 )
- {
- (*info)->detail_info[i] = NULL;
- _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 );
-
- if( value_type == CONFIGURE_VALUE_STRING_ARRAY )
- {
- 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 );
- }
- }
- else // CONFIGURE_VALUE_STRING
- {
- token = strtok_r( NULL, delimiters_3rd, &user_ptr );
-
- if( 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] );
- continue;
- }
- }
-
- switch( value_type )
- {
- case CONFIGURE_VALUE_INT:
- {
- type_int* new_int;
-
- new_int = (type_int*)g_malloc0( sizeof(type_int) );
- 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) );
- 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) );
- new_int_array->name = get_new_string( buffer_token[0] );
- new_int_array->value = (int*)g_malloc0( sizeof(int)*count_value );
- 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] );
- }
-
- 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;
- 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) );
- new_int_pair_array->name = get_new_string( buffer_token[0] );
- new_int_pair_array->value[0] = (int*)g_malloc( sizeof(int)*(count_value) );
- new_int_pair_array->value[1] = (int*)g_malloc( sizeof(int)*(count_value) );
- 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->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;
-
- new_string = (type_string2*)g_malloc0( sizeof(type_string2) );
- 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;
-
- //_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 = (type_string_array*)g_malloc0( sizeof(type_string_array) );
- 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 );;
-
- //_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_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;
-
- new_element = (type_element2*)g_malloc0( sizeof(type_element2) );
- 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->value_int = (type_int2**)g_malloc0( sizeof(type_int2*)*(new_element->count_int) );
-
- for( j = 0 ; j < new_element->count_int ; j++ )
- {
- new_element->value_int[j] = (type_int2*)g_malloc( sizeof(type_int2) );
- 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)] );
- //_mmcam_dbg_log( " Element INT[%d] - name[%s],value[%d]", j, new_element->value_int[j]->name, new_element->value_int[j]->value );
- }
- }
- else
- {
- new_element->value_int = NULL;
- }
-
- /* add string values */
- if( new_element->count_string > 0 )
- {
- new_element->value_string = (type_string2**)g_malloc0( sizeof(type_string2*)*(new_element->count_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) );
- 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
- {
- new_element->value_string = NULL;
- }
-
- (*info)->detail_info[i] = (void*)new_element;
- break;
- }
- default:
- break;
- }
- }
-
- //_mmcam_dbg_log( "Done." );
-
- return TRUE;
-}
-
-
int _mmcamcorder_conf_get_value_int(MMHandleType handle, camera_conf* configure_info, int category, const char* name, int* value)
{
int i, count;
*value = NULL;
- _mmcam_dbg_warn( "Faild to get int range... check it...Category[%d],Name[%s]", category, name );
+ /*_mmcam_dbg_warn( "Faild to get int range... check it...Category[%d],Name[%s]", category, name );*/
return FALSE;
}
*value = NULL;
- _mmcam_dbg_warn( "Faild to get int array... check it...Category[%d],Name[%s]", category, name );
+ /*_mmcam_dbg_warn( "Faild to get int array... check it...Category[%d],Name[%s]", category, name );*/
return FALSE;
}
*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;
}
if( element->count_int == 0 )
{
- _mmcam_dbg_log( "There is no integer property to set in INI file[%s].", element->name );
+ /*_mmcam_dbg_log( "There is no integer property to set in INI file[%s].", element->name );*/
}
else
{
{
MMCAMCORDER_G_OBJECT_SET( gst, element->value_int[i]->name, element->value_int[i]->value );
+ /*
_mmcam_dbg_log( "Element[%s] Set[%s] -> integer[%d]",
element->element_name,
element->value_int[i]->name,
element->value_int[i]->value );
+ */
}
}
codec_index = MM_AUDIO_CODEC_VORBIS;
}
- _mmcam_dbg_log("audio codec index %d", codec_index);
+ /*_mmcam_dbg_log("audio codec index %d", codec_index);*/
return codec_index;
}
codec_index = MM_VIDEO_CODEC_THEORA;
}
- _mmcam_dbg_log("video codec index %d", codec_index);
+ /*_mmcam_dbg_log("video codec index %d", codec_index);*/
return codec_index;
}
}
- _mmcam_dbg_log("mux index %d", mux_index);
+ /*_mmcam_dbg_log("mux index %d", mux_index);*/
return mux_index;
}
mmf_return_val_if_fail(hcamcorder, 0);
- _mmcam_dbg_log("conf_category:%d", conf_category);
+ /*_mmcam_dbg_log("conf_category:%d", conf_category);*/
configure_info = hcamcorder->conf_main;
int count = configure_info->info[conf_category]->count;
conf_detail *info = configure_info->info[conf_category];
- _mmcam_dbg_log("count[%d], info[%p]", count, info);
+ /*_mmcam_dbg_log("count[%d], info[%p]", count, info);*/
if (count <= 0 || !info) {
return total_count;
}
arr = (int*) g_malloc0(count * sizeof(int));
+ if (arr == NULL) {
+ _mmcam_dbg_err("malloc failed : %d", count * sizeof(int));
+ return 0;
+ }
for (i = 0 ; i < count ; i++) {
if (info->detail_info[i] == NULL) {
arr[total_count++] = fmt;
}
- _mmcam_dbg_log("name:%s, fmt:%d", name, fmt);
+ /*_mmcam_dbg_log("name:%s, fmt:%d", name, fmt);*/
}
}
/* get ExifData from info*/
ed = mm_exif_get_exif_from_info(info);
+ if (ed == NULL) {
+ _mmcam_dbg_err("mm_exif_get_exif_from_info failed");
+ return MM_ERROR_CAMCORDER_INTERNAL;
+ }
+
ed->data = thumbnail;
ed->size = len;
x = malloc(sizeof(mm_exif_info_t));
if (x) {
x->data = malloc(s);
- memcpy((char*)x->data, b, s);
- x->size = s;
- *info = x;
- _mmcam_dbg_warn("load EXIF : data %p, size %d", x->data, x->size);
+ if (x->data) {
+ memcpy((char*)x->data, b, s);
+ x->size = s;
+ *info = x;
+ _mmcam_dbg_warn("load EXIF : data %p, size %d", x->data, x->size);
+ } else {
+ _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("mm_exif_info_t malloc failed");
}
#include <sys/time.h>
#include <unistd.h>
+#include <tbm_bufmgr.h>
#include "mm_camcorder_internal.h"
#include "mm_camcorder_gstcommon.h"
_mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
_MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSINK_QUE, "queue", "videosink_queue", element_list, err);
+
+ /* Add color converting element */
+ if (!strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "ximagesink")) {
+ _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSINK_CLS, "videoconvert", "videosrc_convert", element_list, err);
+ }
+
_MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSINK_SINK, videosink_name, "videosink_sink", element_list, err);
if (strcmp(videosink_name, "fakesink") != 0) {
last_element = (_MMCamcorderGstElement*)(g_list_last(element_list)->data);
pad = gst_element_get_static_pad(last_element->gst, "src");
- if ((gst_element_add_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, gst_ghost_pad_new("src", pad) )) < 0) {
+ if (!gst_element_add_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, gst_ghost_pad_new("src", pad))) {
gst_object_unref(pad);
pad = NULL;
_mmcam_dbg_err("failed to create ghost pad on _MMCAMCORDER_AUDIOSRC_BIN.");
int auto_audio_convert = 0;
int auto_audio_resample = 0;
int auto_color_space = 0;
- char *gst_element_venc_name = NULL;
+ const char *gst_element_venc_name = NULL;
const char *gst_element_aenc_name = NULL;
const char *gst_element_ienc_name = NULL;
const char *gst_element_mux_name = NULL;
const char *str_aar = NULL;
const char *str_acs = NULL;
char *err_name = NULL;
-
+ const char *videoconvert_name = NULL;
GstCaps *audio_caps = NULL;
GstCaps *video_caps = NULL;
GstPad *pad = NULL;
}
if (!pad) {
_mmcam_dbg_err("get videosrc_que src pad failed");
+ err = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
goto pipeline_creation_error;
}
if (video_caps) {
char *caps_str = NULL;
- 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);
+ 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);
+ }
caps_str = gst_caps_to_string(video_caps);
- _mmcam_dbg_log("video caps [%s], set size %dx%d",
- caps_str, sc->info_video->video_width, sc->info_video->video_height);
+ _mmcam_dbg_log("encodebin caps [%s]", caps_str);
free(caps_str);
caps_str = NULL;
- MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst, "caps", video_caps);
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst, "caps", video_caps);
+ gst_caps_unref(video_caps);
+ video_caps = NULL;
} else {
_mmcam_dbg_err("create recording pipeline caps failed");
+ err = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
goto pipeline_creation_error;
}
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "auto-colorspace", auto_color_space);
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "use-video-toggle", FALSE);
+ /* get video convert element name */
+ _mmcamcorder_conf_get_value_element_name(sc->VideoconvertElement, &videoconvert_name);
+
/* Codec */
if (profile == MM_CAMCORDER_ENCBIN_PROFILE_VIDEO) {
int use_venc_queue = 0;
if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
gst_element_venc_name = strdup("capsfilter");
} else {
- _mmcamcorder_conf_get_value_element_name(VideoencElement, (const char **)(&gst_element_venc_name));
+ _mmcamcorder_conf_get_value_element_name(VideoencElement, &gst_element_venc_name);
}
if (gst_element_venc_name) {
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "venc-name", gst_element_venc_name);
_MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_VENC, "video-encode", err);
-
- _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
- 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->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
- free(gst_element_venc_name);
- gst_element_venc_name = NULL;
- MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst, "caps", video_caps);
- }
} else {
_mmcam_dbg_err("Fail to get video encoder name");
err = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
goto pipeline_creation_error;
}
+
+ /* set color space converting element */
+ if (auto_color_space) {
+ _mmcam_dbg_log("set video convert element [%s]", videoconvert_name);
+
+ MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "vconv-name", videoconvert_name);
+ _MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_VCONV, "video-convert", err);
+
+ /* set colorspace plugin property setting */
+ _mmcamcorder_conf_set_value_element_property(sc->encode_element[_MMCAMCORDER_ENCSINK_VCONV].gst, sc->VideoconvertElement);
+
+ /* 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 (video_caps) {
+ MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "vcaps", video_caps);
+ MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_VCONV].gst, "dst-buffer-num", _MMCAMCORDER_CONVERT_OUTPUT_BUFFER_NUM);
+
+ gst_caps_unref(video_caps);
+ video_caps = NULL;
+ } else {
+ _mmcam_dbg_warn("failed to create caps");
+ }
+ } else {
+ _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) {
+ _MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_VENC_QUE, "use-venc-queue", err);
+ }
+
+ if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+ free(gst_element_venc_name);
+ gst_element_venc_name = NULL;
+ }
}
if (sc->audio_disable == FALSE &&
if (profile == MM_CAMCORDER_ENCBIN_PROFILE_VIDEO) {
pad = gst_element_get_request_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "video");
- if (gst_element_add_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, gst_ghost_pad_new("video_sink0", pad)) < 0) {
+ if (!gst_element_add_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, gst_ghost_pad_new("video_sink0", pad))) {
gst_object_unref(pad);
pad = NULL;
_mmcam_dbg_err("failed to create ghost video_sink0 on _MMCAMCORDER_ENCSINK_BIN.");
if (sc->audio_disable == FALSE) {
pad = gst_element_get_request_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "audio");
- if (gst_element_add_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, gst_ghost_pad_new("audio_sink0", pad)) < 0) {
+ if (!gst_element_add_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, gst_ghost_pad_new("audio_sink0", pad))) {
gst_object_unref(pad);
pad = NULL;
_mmcam_dbg_err("failed to create ghost audio_sink0 on _MMCAMCORDER_ENCSINK_BIN.");
}
} else if (profile == MM_CAMCORDER_ENCBIN_PROFILE_AUDIO) {
pad = gst_element_get_request_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "audio");
- if (gst_element_add_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, gst_ghost_pad_new("audio_sink0", pad)) < 0) {
+ if (!gst_element_add_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, gst_ghost_pad_new("audio_sink0", pad))) {
gst_object_unref(pad);
pad = NULL;
_mmcam_dbg_err("failed to create ghost audio_sink0 on _MMCAMCORDER_ENCSINK_BIN.");
} else {
/* for stillshot */
pad = gst_element_get_request_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "image");
- if (gst_element_add_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, gst_ghost_pad_new("image_sink0", pad)) < 0) {
+ if (!gst_element_add_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, gst_ghost_pad_new("image_sink0", pad))) {
gst_object_unref(pad);
pad = NULL;
_mmcam_dbg_err("failed to create ghost image_sink0 on _MMCAMCORDER_ENCSINK_BIN.");
return MM_ERROR_NONE;
pipeline_creation_error :
+ _mmcamcorder_remove_all_handlers(handle, _MMCAMCORDER_HANDLER_VIDEOREC);
+
_MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCSINK_ENCBIN);
_MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCSINK_SRC);
_MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCSINK_FILT);
gst_object_unref(bus);
bus = NULL;
- /* Below signals are meaningfull only when video source is using. */
- MMCAMCORDER_SIGNAL_CONNECT(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst,
- _MMCAMCORDER_HANDLER_PREVIEW,
- "nego-complete",
- _mmcamcorder_negosig_handler,
- hcamcorder);
-
return MM_ERROR_NONE;
pipeline_creation_error:
}
-void _mmcamcorder_negosig_handler(GstElement *videosrc, MMHandleType handle)
-{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
- _MMCamcorderSubContext *sc = NULL;
-
- _mmcam_dbg_log("");
-
- mmf_return_if_fail(hcamcorder);
- mmf_return_if_fail(hcamcorder->sub_context);
- sc = MMF_CAMCORDER_SUBCONTEXT(handle);
-
- /* kernel was modified. No need to set.
- _mmcamcorder_set_attribute_to_camsensor(handle);
- */
-
- if (sc->cam_stability_count != _MMCAMCORDER_CAMSTABLE_COUNT) {
- sc->cam_stability_count = _MMCAMCORDER_CAMSTABLE_COUNT;
- }
-
- if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
- _MMCamcorderImageInfo *info = NULL;
- info = sc->info_image;
- if (info->resolution_change == TRUE) {
- _mmcam_dbg_log("open toggle of stillshot sink.");
- MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
- info->resolution_change = FALSE;
- }
- }
-}
-
-
void _mmcamcorder_ready_to_encode_callback(GstElement *element, guint size, gpointer handle)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
return TRUE;
}
-static guint32 _mmcamcorder_convert_fourcc_string_to_value(const gchar* format_name){
+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);
}
static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
{
int current_state = MM_CAMCORDER_STATE_NONE;
+ int i = 0;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
_MMCamcorderSubContext *sc = NULL;
GstBuffer *buffer = GST_PAD_PROBE_INFO_BUFFER(info);
GstMemory *dataBlock = NULL;
GstMemory *metaBlock = NULL;
- GstMapInfo mapinfo = GST_MAP_INFO_INIT;
+ GstMapInfo mapinfo;
mmf_return_val_if_fail(buffer, GST_PAD_PROBE_DROP);
mmf_return_val_if_fail(gst_buffer_n_memory(buffer) , GST_PAD_PROBE_DROP);
sc = MMF_CAMCORDER_SUBCONTEXT(u_data);
mmf_return_val_if_fail(sc, GST_PAD_PROBE_DROP);
+ memset(&mapinfo, 0x0, sizeof(GstMapInfo));
+
current_state = hcamcorder->state;
if (sc->drop_vframe > 0) {
if (kpi->init_video_time.tv_sec == kpi->last_video_time.tv_sec &&
kpi->init_video_time.tv_usec == kpi->last_video_time.tv_usec &&
kpi->init_video_time.tv_usec == 0) {
+ /*
_mmcam_dbg_log("START to measure FPS");
+ */
gettimeofday(&(kpi->init_video_time), NULL);
}
int state = MM_CAMCORDER_STATE_NULL;
unsigned int fourcc = 0;
MMCamcorderVideoStreamDataType stream;
- SCMN_IMGB *scmn_imgb = NULL;
+ MMVideoBuffer *mm_buf = NULL;
state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
if (state < MM_CAMCORDER_STATE_PREPARE) {
if (hcamcorder->use_zero_copy_format && gst_buffer_n_memory(buffer) > 1) {
metaBlock = gst_buffer_peek_memory(buffer, 1);
gst_memory_map(metaBlock, &mapinfo, GST_MAP_READ);
- scmn_imgb = (SCMN_IMGB *)mapinfo.data;
+ mm_buf = (MMVideoBuffer *)mapinfo.data;
}
/* set data pointers */
if (stream.format == MM_PIXEL_FORMAT_NV12 ||
stream.format == MM_PIXEL_FORMAT_NV21 ||
stream.format == MM_PIXEL_FORMAT_I420) {
- if (scmn_imgb) {
+ if (mm_buf) {
if (stream.format == MM_PIXEL_FORMAT_NV12 ||
stream.format == MM_PIXEL_FORMAT_NV21) {
stream.data_type = MM_CAM_STREAM_DATA_YUV420SP;
stream.num_planes = 2;
- stream.data.yuv420sp.y = scmn_imgb->a[0];
+ stream.data.yuv420sp.y = mm_buf->data[0];
stream.data.yuv420sp.length_y = stream.width * stream.height;
- stream.data.yuv420sp.uv = scmn_imgb->a[1];
+ stream.data.yuv420sp.uv = mm_buf->data[1];
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);
+ */
} else {
stream.data_type = MM_CAM_STREAM_DATA_YUV420P;
stream.num_planes = 3;
- stream.data.yuv420p.y = scmn_imgb->a[0];
+ stream.data.yuv420p.y = mm_buf->data[0];
stream.data.yuv420p.length_y = stream.width * stream.height;
- stream.data.yuv420p.u = scmn_imgb->a[1];
+ stream.data.yuv420p.u = mm_buf->data[1];
stream.data.yuv420p.length_u = stream.data.yuv420p.length_y >> 2;
- stream.data.yuv420p.v = scmn_imgb->a[2];
+ stream.data.yuv420p.v = mm_buf->data[2];
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);
+ */
}
} else {
gst_memory_map(dataBlock, &mapinfo, GST_MAP_READWRITE);
stream.data.yuv420sp.length_y = stream.width * stream.height;
stream.data.yuv420sp.uv = stream.data.yuv420sp.y + stream.data.yuv420sp.length_y;
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);
+ */
} else {
stream.data_type = MM_CAM_STREAM_DATA_YUV420P;
stream.num_planes = 3;
stream.data.yuv420p.length_u = stream.data.yuv420p.length_y >> 2;
stream.data.yuv420p.v = stream.data.yuv420p.u + stream.data.yuv420p.length_u;
stream.data.yuv420p.length_v = stream.data.yuv420p.length_u;
-
+ /*
_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);
+ */
}
}
} else {
- if (scmn_imgb) {
+ if (mm_buf) {
gst_memory_unmap(metaBlock, &mapinfo);
metaBlock = NULL;
}
}
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);
+ */
+ }
+
+ /* set tbm bo */
+ if (mm_buf && mm_buf->type == MM_VIDEO_BUFFER_TYPE_TBM_BO) {
+ /* set bo, stride and elevation */
+ for (i = 0 ; i < MM_VIDEO_BUFFER_PLANE_MAX ; i++) {
+ stream.bo[i] = (void *)mm_buf->handle.bo[i];
+ stream.stride[i] = mm_buf->stride_width[i];
+ stream.elevation[i] = mm_buf->stride_height[i];
+ }
+
+ /* set gst buffer */
+ stream.internal_buffer = buffer;
}
/* call application callback */
_MMCAMCORDER_LOCK_VSTREAM_CALLBACK(hcamcorder);
if (hcamcorder->vstream_cb) {
hcamcorder->vstream_cb(&stream, hcamcorder->vstream_cb_param);
+
+ for (i = 0 ; i < MM_VIDEO_BUFFER_PLANE_MAX && stream.bo[i] ; i++) {
+ tbm_bo_map(stream.bo[i], TBM_DEVICE_CPU, TBM_OPTION_READ|TBM_OPTION_WRITE);
+ tbm_bo_unmap(stream.bo[i]);
+ }
}
_MMCAMCORDER_UNLOCK_VSTREAM_CALLBACK(hcamcorder);
/* Either metaBlock was mapped, or dataBlock, but not both. */
GST_BUFFER_PTS(buffer) = GST_BUFFER_PTS(buffer) - sc->info_video->base_video_ts;
GST_BUFFER_DTS(buffer) = GST_BUFFER_PTS(buffer);
- capsfilter_pad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst, "src");
-// gst_buffer_set_caps(buffer, GST_PAD_CAPS(capsfilter_pad));
- gst_object_unref(capsfilter_pad);
- capsfilter_pad = NULL;
-
_mmcam_dbg_log("buffer %p, timestamp %"GST_TIME_FORMAT, buffer, GST_TIME_ARGS(GST_BUFFER_PTS(buffer)));
- {
- char *caps_string = gst_caps_to_string(gst_pad_get_current_caps(pad));
- if (caps_string) {
- _mmcam_dbg_log("%s", caps_string);
- free(caps_string);
- caps_string = NULL;
+
+ if (0) {
+ GstCaps *caps = gst_pad_get_current_caps(pad);
+ if (caps) {
+ char *caps_string = gst_caps_to_string(caps);
+ if (caps_string) {
+ _mmcam_dbg_log("%s", caps_string);
+ free(caps_string);
+ caps_string = NULL;
+ }
+ gst_caps_unref(caps);
+ caps = NULL;
+ } else {
+ _mmcam_dbg_warn("failed to get caps from pad");
}
}
sc->info_video->prev_preview_ts = GST_BUFFER_PTS(buffer);
}
- //_mmcam_dbg_log("return TRUE");
-
return GST_PAD_PROBE_OK;
}
if (sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst) {
/* Get videosink name */
_mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
- if (!strcmp(videosink_name, "xvimagesink") ||
+ if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "evasimagesink") ||
!strcmp(videosink_name, "evaspixmapsink")) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
"rotate", display_rotate);
if (sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst) {
/* Get videosink name */
_mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
- if (!strcmp(videosink_name, "xvimagesink") ||
+ if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "evasimagesink") ||
!strcmp(videosink_name, "evaspixmapsink")) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
"flip", display_flip);
mmf_return_val_if_fail(handle, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- mmf_return_val_if_fail(sc, TRUE);
+ if (!sc) {
+ return TRUE;
+ }
v_src = sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst;
if (!v_src) {
========================================================================================*/
#include <stdio.h>
#include <string.h>
+#include <fcntl.h>
#include <gst/gst.h>
#include <gst/gstutils.h>
#include <gst/gstpad.h>
+#include <sys/time.h>
#include <mm_error.h>
#include "mm_camcorder_internal.h"
#include <gst/video/colorbalance.h>
#include <gst/video/cameracontrol.h>
+#include <asm/types.h>
#include <system_info.h>
/*---------------------------------------------------------------------------------------
| GLOBAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
+int g_mm_camcorder_type = -255;
+struct sigaction mm_camcorder_int_old_action;
+struct sigaction mm_camcorder_abrt_old_action;
+struct sigaction mm_camcorder_segv_old_action;
+struct sigaction mm_camcorder_term_old_action;
+struct sigaction mm_camcorder_sys_old_action;
/*---------------------------------------------------------------------------------------
| LOCAL VARIABLE DEFINITIONS for internal |
#define __MMCAMCORDER_CMD_ITERATE_MAX 3
#define __MMCAMCORDER_SET_GST_STATE_TIMEOUT 3
#define __MMCAMCORDER_SOUND_WAIT_TIMEOUT 3
+#define __MMCAMCORDER_PATH_CAMERA_RESOURCE "/usr/share/sounds/mm-camcorder/camera_resource"
+#define __MMCAMCORDER_PATH_RECORDER_RESOURCE "/usr/share/sounds/mm-camcorder/recorder_resource"
+
/*---------------------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data);
#endif /* _MMCAMCORDER_USE_SET_ATTR_CB */
+static void __mm_camcorder_signal_handler(int signo);
+static void _mmcamcorder_constructor() __attribute__((constructor));
+
/*=======================================================================================
| FUNCTION DEFINITIONS |
=======================================================================================*/
| GLOBAL FUNCTION DEFINITIONS: |
---------------------------------------------------------------------------------------*/
+static void __mm_camcorder_signal_handler(int signo)
+{
+ pid_t my_pid = getpid();
+ pid_t vconf_recorder_pid = -1;
+ pid_t vconf_camera_pid = -1;
+ int vconf_flash_state = VCONFKEY_CAMERA_FLASH_STATE_OFF;
+
+ _mmcam_dbg_warn("start - signo [%d], pid [%d], device type [%d]", signo, my_pid, g_mm_camcorder_type);
+
+ /* reset vconf key */
+ switch (g_mm_camcorder_type) {
+ case MM_VIDEO_DEVICE_NONE:
+ vconf_get_int(VCONFKEY_RECORDER_PID, (int *)&vconf_recorder_pid);
+ if (my_pid == vconf_recorder_pid) {
+ vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL);
+ vconf_set_int(VCONFKEY_RECORDER_PID, -1);
+ _mmcam_dbg_warn("set recorder state NULL");
+ } else {
+ _mmcam_dbg_warn("different pid : my[%d] vconf[%d]", my_pid, vconf_recorder_pid);
+ }
+ break;
+ case MM_VIDEO_DEVICE_CAMERA0:
+ case MM_VIDEO_DEVICE_CAMERA1:
+ vconf_get_int(VCONFKEY_CAMERA_FLASH_STATE, &vconf_flash_state);
+ vconf_get_int(VCONFKEY_CAMERA_PID, (int *)&vconf_camera_pid);
+ if (my_pid == vconf_camera_pid &&
+ vconf_flash_state == VCONFKEY_CAMERA_FLASH_STATE_ON) {
+ vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, VCONFKEY_CAMERA_FLASH_STATE_OFF);
+ vconf_set_int(VCONFKEY_CAMERA_PID, -1);
+ _mmcam_dbg_warn("set camera flash state OFF");
+ }
+
+ vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL);
+ _mmcam_dbg_warn("set camera state NULL");
+ break;
+ default:
+ _mmcam_dbg_warn("unknown type [%d]", g_mm_camcorder_type);
+ break;
+ }
+
+ /* call old signal handler */
+ switch (signo) {
+ case SIGINT:
+ sigaction(SIGINT, &mm_camcorder_int_old_action, NULL);
+ raise(signo);
+ break;
+ case SIGABRT:
+ sigaction(SIGABRT, &mm_camcorder_abrt_old_action, NULL);
+ raise(signo);
+ break;
+ case SIGSEGV:
+ sigaction(SIGSEGV, &mm_camcorder_segv_old_action, NULL);
+ raise(signo);
+ break;
+ case SIGTERM:
+ sigaction(SIGTERM, &mm_camcorder_term_old_action, NULL);
+ raise(signo);
+ break;
+ case SIGSYS:
+ sigaction(SIGSYS, &mm_camcorder_sys_old_action, NULL);
+ raise(signo);
+ break;
+ default:
+ break;
+ }
+
+ _mmcam_dbg_warn("done");
+
+ return;
+}
+
+
+static void _mmcamcorder_constructor()
+{
+ struct sigaction mm_camcorder_action;
+ mm_camcorder_action.sa_handler = __mm_camcorder_signal_handler;
+ mm_camcorder_action.sa_flags = SA_NOCLDSTOP;
+
+ _mmcam_dbg_warn("start");
+
+ sigemptyset(&mm_camcorder_action.sa_mask);
+
+ sigaction(SIGINT, &mm_camcorder_action, &mm_camcorder_int_old_action);
+ sigaction(SIGABRT, &mm_camcorder_action, &mm_camcorder_abrt_old_action);
+ sigaction(SIGSEGV, &mm_camcorder_action, &mm_camcorder_segv_old_action);
+ sigaction(SIGTERM, &mm_camcorder_action, &mm_camcorder_term_old_action);
+ sigaction(SIGSYS, &mm_camcorder_action, &mm_camcorder_sys_old_action);
+
+ _mmcam_dbg_warn("done");
+
+ return;
+}
+
+
/* Internal command functions {*/
int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
{
int play_capture_sound = TRUE;
int camera_device_count = MM_VIDEO_DEVICE_NUM;
int camera_facing_direction = MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR;
+ int resource_fd = -1;
char *err_attr_name = NULL;
const char *ConfCtrlFile = NULL;
mmf_camcorder_t *hcamcorder = NULL;
hcamcorder->capture_in_recording = FALSE;
pthread_mutex_init(&((hcamcorder->mtsafe).lock), NULL);
+ pthread_cond_init(&((hcamcorder->mtsafe).cond), NULL);
pthread_mutex_init(&((hcamcorder->mtsafe).cmd_lock), NULL);
pthread_mutex_init(&((hcamcorder->mtsafe).asm_lock), NULL);
pthread_mutex_init(&((hcamcorder->mtsafe).state_lock), NULL);
hcamcorder->device_type = info->videodev_type;
_mmcam_dbg_warn("Device Type : %d", hcamcorder->device_type);
+ if (hcamcorder->device_type == MM_VIDEO_DEVICE_NONE) {
+ resource_fd = open(__MMCAMCORDER_PATH_RECORDER_RESOURCE, O_RDONLY);
+ } else {
+ resource_fd = open(__MMCAMCORDER_PATH_CAMERA_RESOURCE, O_RDONLY);
+ }
+
+ if (resource_fd < 0) {
+ _mmcam_dbg_log("open error %s : cur %d",strerror(errno),errno);
+ if(errno == EPERM || errno == EACCES) {
+ ret = MM_ERROR_COMMON_INVALID_PERMISSION;
+ } else {
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ }
+ goto _ERR_DEFAULT_VALUE_INIT;
+ } else {
+ close(resource_fd);
+ resource_fd = -1;
+ _mmcam_dbg_warn("permission check done");
+ }
+
/* Get Camera Configure information from Camcorder INI file */
_mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &hcamcorder->conf_main);
"UseConfCtrl", &UseConfCtrl);
if (UseConfCtrl) {
+ int resolution_width = 0;
+ int resolution_height = 0;
+ MMCamAttrsInfo fps_info;
+
_mmcam_dbg_log( "Enable Configure Control system." );
switch (info->videodev_type) {
"SupportMediaPacketPreviewCb",
&(hcamcorder->support_media_packet_preview_cb));
+ ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, 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);
+
_mmcam_dbg_log("UseZeroCopyFormat : %d", hcamcorder->use_zero_copy_format);
_mmcam_dbg_log("SupportMediaPacketPreviewCb : %d", hcamcorder->support_media_packet_preview_cb);
+ _mmcam_dbg_log("res : %d X %d, Default FPS by resolution : %d", resolution_width, resolution_height, fps_info.int_array.def);
mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
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,
"capture-sound-enable", play_capture_sound,
NULL);
if (err_attr_name) {
_mmcam_dbg_log( "Disable Configure Control system." );
hcamcorder->conf_ctrl = NULL;
}
+ } else {
+ _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
+ 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);
+ if (err_attr_name) {
+ _mmcam_dbg_err("Set %s FAILED.", err_attr_name);
+ free(err_attr_name);
+ err_attr_name = NULL;
+ }
}
ret = __mmcamcorder_gstreamer_init(hcamcorder->conf_main);
_mmcam_dbg_log("created handle %p", hcamcorder);
+ /* set device type */
+ g_mm_camcorder_type = info->videodev_type;
+
*handle = (MMHandleType)hcamcorder;
return MM_ERROR_NONE;
_ERR_DEFAULT_VALUE_INIT:
/* Release lock, cond */
pthread_mutex_destroy(&((hcamcorder->mtsafe).lock));
+ pthread_cond_destroy(&((hcamcorder->mtsafe).cond));
pthread_mutex_destroy(&((hcamcorder->mtsafe).cmd_lock));
pthread_mutex_destroy(&((hcamcorder->mtsafe).asm_lock));
pthread_mutex_destroy(&((hcamcorder->mtsafe).state_lock));
hcamcorder->software_version = NULL;
}
+ if (hcamcorder->task_thread) {
+ pthread_mutex_lock(&(hcamcorder->task_thread_lock));
+ _mmcam_dbg_log("send signal for task thread exit");
+ hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT;
+ pthread_cond_signal(&(hcamcorder->task_thread_cond));
+ pthread_mutex_unlock(&(hcamcorder->task_thread_lock));
+ pthread_join(hcamcorder->task_thread, NULL);
+ }
+ pthread_mutex_destroy(&(hcamcorder->task_thread_lock));
+ pthread_cond_destroy(&(hcamcorder->task_thread_cond));
+
/* Release handle */
memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
free(hcamcorder);
hcamcorder->setting_event_id = 0;
}
+ /* check current strobe mode */
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ pid_t my_pid = getpid();
+ int camera_pid = -1;
+ vconf_get_int(VCONFKEY_CAMERA_PID, &camera_pid);
+
+ if (camera_pid > -1 && my_pid == camera_pid) {
+ int strobe_mode = MM_CAMCORDER_STROBE_MODE_OFF;
+
+ vconf_set_int(VCONFKEY_CAMERA_PID, -1);
+ _mmcam_dbg_log("reset camera pid");
+
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_STROBE_MODE, &strobe_mode,
+ NULL);
+ if (strobe_mode != MM_CAMCORDER_STROBE_MODE_OFF) {
+ /* set OFF state of vconf key */
+ vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, VCONFKEY_CAMERA_FLASH_STATE_OFF);
+ _mmcam_dbg_log("reset flash state");
+ }
+ }
+ }
+
/* Remove attributes */
if (hcamcorder->attributes) {
_mmcamcorder_dealloc_attribute(handle, hcamcorder->attributes);
/* Release lock, cond */
pthread_mutex_destroy(&((hcamcorder->mtsafe).lock));
+ pthread_cond_destroy(&((hcamcorder->mtsafe).cond));
pthread_mutex_destroy(&((hcamcorder->mtsafe).cmd_lock));
pthread_mutex_destroy(&((hcamcorder->mtsafe).asm_lock));
pthread_mutex_destroy(&((hcamcorder->mtsafe).state_lock));
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- _mmcam_dbg_log("");
+ /*_mmcam_dbg_log("");*/
if (!hcamcorder) {
_mmcam_dbg_err("Not initialized");
/* Get profile mode */
_mmcam_dbg_log("Profile mode [%d]", hcamcorder->type);
- /* set camera state to vconf key */
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_DISPLAY_SURFACE, &display_surface_type,
+ MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
+ NULL);
+
+ /* set camera/recorder state to vconf key */
if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
int vconf_camera_state = 0;
/* get current camera state of vconf key */
vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
- vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN);
-
+ if (vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN)) {
+ _mmcam_dbg_log("VCONF ERROR %s : cur %d",strerror(errno),errno);
+ if(errno == EPERM || errno == EACCES) {
+ ret = MM_ERROR_COMMON_INVALID_PERMISSION;
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ }
+ }
_mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN);
- }
+ } else {
+ int vconf_recorder_state = 0;
+
+ /* get current recorder state of vconf key */
+ vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
+ if (vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED)) {
+ _mmcam_dbg_log("VCONF ERROR %s : cur %d",strerror(errno),errno);
+ if (errno == EPERM || errno == EACCES) {
+ ret = MM_ERROR_COMMON_INVALID_PERMISSION;
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ }
+ }
- mm_camcorder_get_attributes(handle, NULL,
- MMCAM_DISPLAY_SURFACE, &display_surface_type,
- MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
- NULL);
+ _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
+ vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED);
+ }
/* alloc sub context */
hcamcorder->sub_context = _mmcamcorder_alloc_subcontext(hcamcorder->type);
if(!hcamcorder->sub_context) {
ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
- goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ goto _ERR_CAMCORDER_CMD;
}
/* Set basic configure information */
ret = _mmcamcorder_create_pipeline(handle, hcamcorder->type);
if (ret != MM_ERROR_NONE) {
/* check internal error of gstreamer */
- if (hcamcorder->sub_context->error_code != MM_ERROR_NONE) {
- ret = hcamcorder->sub_context->error_code;
+ if (hcamcorder->error_code != MM_ERROR_NONE) {
+ ret = hcamcorder->error_code;
_mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
}
/* release sub context */
_mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
hcamcorder->sub_context = NULL;
- goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ goto _ERR_CAMCORDER_CMD;
}
/* set command function */
_mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
_mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
hcamcorder->sub_context = NULL;
- goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ goto _ERR_CAMCORDER_CMD;
}
_mmcamcorder_set_state(handle, state_TO);
return MM_ERROR_NONE;
-_ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
- _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
-
-_ERR_CAMCORDER_CMD_PRECON:
- _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)",
- hcamcorder->type, state, ret);
-
+_ERR_CAMCORDER_CMD:
/* rollback camera state to vconf key */
if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
int vconf_camera_state = 0;
_mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL);
+ } else {
+ int vconf_recorder_state = 0;
+
+ /* get current recorder state of vconf key */
+ vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
+ vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL);
+
+ _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
+ vconf_recorder_state, VCONFKEY_RECORDER_STATE_NULL);
}
+_ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
+ _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
+
+_ERR_CAMCORDER_CMD_PRECON:
+ _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)",
+ hcamcorder->type, state, ret);
+
return ret;
}
hcamcorder->command = NULL;
- /* check who calls unrealize. it's no need to set ASM state if caller is ASM */
- if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_ASM) {
- /* TODO */
- }
/* set camera state to vconf key */
if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
_mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL);
+ } else {
+ int vconf_recorder_state = 0;
+
+ /* get current recorder state of vconf key */
+ vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
+ vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL);
+
+ _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
+ vconf_recorder_state, VCONFKEY_RECORDER_STATE_NULL);
}
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
}
/* initialize error code */
- hcamcorder->sub_context->error_code = MM_ERROR_NONE;
+ hcamcorder->error_code = MM_ERROR_NONE;
/* set attributes related sensor */
if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_START);
if (ret != MM_ERROR_NONE) {
/* check internal error of gstreamer */
- if (hcamcorder->sub_context->error_code != MM_ERROR_NONE) {
- ret = hcamcorder->sub_context->error_code;
+ if (hcamcorder->error_code != MM_ERROR_NONE) {
+ ret = hcamcorder->error_code;
_mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
}
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
_ERR_CAMCORDER_CMD_PRECON:
/* check internal error of gstreamer */
- if (hcamcorder->sub_context &&
- hcamcorder->sub_context->error_code != MM_ERROR_NONE) {
- ret = hcamcorder->sub_context->error_code;
- hcamcorder->sub_context->error_code = MM_ERROR_NONE;
+ if (hcamcorder->error_code != MM_ERROR_NONE) {
+ ret = hcamcorder->error_code;
+ hcamcorder->error_code = MM_ERROR_NONE;
_mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
}
}
/* initialize error code */
- hcamcorder->sub_context->error_code = MM_ERROR_NONE;
+ hcamcorder->error_code = MM_ERROR_NONE;
ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_RECORD);
if (ret != MM_ERROR_NONE) {
/* check internal error of gstreamer */
- if (hcamcorder->sub_context->error_code != MM_ERROR_NONE) {
- ret = hcamcorder->sub_context->error_code;
+ if (hcamcorder->error_code != MM_ERROR_NONE) {
+ ret = hcamcorder->error_code;
_mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
}
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
_mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING);
+ } else {
+ int vconf_recorder_state = 0;
+
+ /* get current recorder state of vconf key */
+ vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
+ vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_RECORDING);
+
+ _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
+ vconf_recorder_state, VCONFKEY_RECORDER_STATE_RECORDING);
}
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
_ERR_CAMCORDER_CMD_PRECON:
/* check internal error of gstreamer */
- if (hcamcorder->sub_context &&
- hcamcorder->sub_context->error_code != MM_ERROR_NONE) {
- ret = hcamcorder->sub_context->error_code;
- hcamcorder->sub_context->error_code = MM_ERROR_NONE;
+ if (hcamcorder->error_code != MM_ERROR_NONE) {
+ ret = hcamcorder->error_code;
+ hcamcorder->error_code = MM_ERROR_NONE;
_mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
}
_mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE);
+ } else {
+ int vconf_recorder_state = 0;
+
+ /* get current recorder state of vconf key */
+ vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
+ vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_RECORDING_PAUSE);
+
+ _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
+ vconf_recorder_state, VCONFKEY_RECORDER_STATE_RECORDING_PAUSE);
}
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
_mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
- }
+ } else {
+ int vconf_recorder_state = 0;
- /* check who calls unrealize. it's no need to set ASM state if caller is ASM */
- if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_ASM) {
- /* TODO */
+ /* get current recorder state of vconf key */
+ vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
+ vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED);
+
+ _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
+ vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED);
}
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
_mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
+ } else {
+ int vconf_recorder_state = 0;
+
+ /* get current recorder state of vconf key */
+ vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
+ vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED);
+
+ _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
+ vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED);
}
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- _mmcam_dbg_log("");
+ /*_mmcam_dbg_log("");*/
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
return MM_ERROR_NONE;
}
+
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;
+ }
ret = gst_camera_control_stop_auto_focus(control);
if (!ret) {
mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
mmf_return_val_if_fail(direction, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
- _mmcam_dbg_log("");
+ /*_mmcam_dbg_log("");*/
if (!_MMCAMCORDER_TRYLOCK_CMD(handle)) {
_mmcam_dbg_err("Another command is running.");
_mmcam_dbg_log("Can't cast Video source into camera control.");
return MM_ERROR_NONE;
}
+
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) {
mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- _mmcam_dbg_log("");
+ /*_mmcam_dbg_log("");*/
sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
_mmcam_dbg_log("Can't cast Video source into camera control.");
return MM_ERROR_NONE;
}
+
control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (control) {
+ /* Start AF */
+ ret = gst_camera_control_start_auto_focus(control);
+ } else {
+ _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ ret = FALSE;
+ }
- /* Start AF */
- ret = gst_camera_control_start_auto_focus(control);
if (ret) {
_mmcam_dbg_log("Auto focusing start success.");
return MM_ERROR_NONE;
mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- _mmcam_dbg_log("");
+ /*_mmcam_dbg_log("");*/
sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
return MM_ERROR_NONE;
}
- control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
- ret = gst_camera_control_stop_auto_focus(control);
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (control) {
+ ret = gst_camera_control_stop_auto_focus(control);
+ } else {
+ _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ ret = FALSE;
+ }
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
_MMCAMCORDER_LOCK_STATE(handle);
state = hcamcorder->state;
- _mmcam_dbg_log("state=%d",state);
+ /*_mmcam_dbg_log("state=%d",state);*/
_MMCAMCORDER_UNLOCK_STATE(handle);
mmf_return_if_fail(hcamcorder);
- _mmcam_dbg_log("");
+ /*_mmcam_dbg_log("");*/
_MMCAMCORDER_LOCK_STATE(handle);
_mmcam_dbg_log("set state[%d] and send state-changed message", state);
- /* To discern who changes the state */
- switch (hcamcorder->state_change_by_system) {
- case _MMCAMCORDER_STATE_CHANGE_BY_ASM:
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM;
- break;
- case _MMCAMCORDER_STATE_CHANGE_NORMAL:
- default:
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
- msg.param.state.code = MM_ERROR_NONE;
- break;
- }
-
+ msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
+ msg.param.state.code = MM_ERROR_NONE;
msg.param.state.previous = old_state;
msg.param.state.current = state;
- _mmcam_dbg_log("_mmcamcroder_send_message : msg : %p, id:%x", &msg, msg.id);
+ /*_mmcam_dbg_log("_mmcamcroder_send_message : msg : %p, id:%x", &msg, msg.id);*/
_mmcamcroder_send_message(handle, &msg);
}
int i;
_MMCamcorderSubContext *sc = NULL;
- _mmcam_dbg_log("");
+ /*_mmcam_dbg_log("");*/
/* alloc container */
sc = (_MMCamcorderSubContext *)malloc(sizeof(_MMCamcorderSubContext));
sc->encode_element[i].gst = NULL;
}
+ sc->fourcc = 0x80000000;
sc->cam_stability_count = 0;
sc->drop_vframe = 0;
sc->pass_first_vframe = 0;
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- _mmcam_dbg_log("");
+ /*_mmcam_dbg_log("");*/
switch (type) {
case MM_CAMCORDER_MODE_AUDIO:
if (sc->element[_MMCAMCORDER_MAIN_PIPE].gst) {
pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
if (message->src == (GstObject*)pipeline) {
- vnewstate = (GValue*)gst_structure_get_value(gst_message_get_structure(message), "new-state");
+ 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));
}
{
GstClock *pipe_clock = NULL;
gst_message_parse_new_clock(message, &pipe_clock);
- _mmcam_dbg_log("GST_MESSAGE_NEW_CLOCK : %s", (pipe_clock ? GST_OBJECT_NAME (pipe_clock) : "NULL"));
+ /*_mmcam_dbg_log("GST_MESSAGE_NEW_CLOCK : %s", (clock ? GST_OBJECT_NAME (clock) : "NULL"));*/
break;
}
case GST_MESSAGE_STRUCTURE_CHANGE:
_mmcam_dbg_log("GST_MESSAGE_STRUCTURE_CHANGE");
break;
case GST_MESSAGE_STREAM_STATUS:
- _mmcam_dbg_log("GST_MESSAGE_STREAM_STATUS");
+ /*_mmcam_dbg_log("GST_MESSAGE_STREAM_STATUS");*/
break;
case GST_MESSAGE_APPLICATION:
_mmcam_dbg_log("GST_MESSAGE_APPLICATION");
break;
case GST_MESSAGE_ELEMENT:
- _mmcam_dbg_log("GST_MESSAGE_ELEMENT");
+ /*_mmcam_dbg_log("GST_MESSAGE_ELEMENT");*/
break;
case GST_MESSAGE_SEGMENT_START:
_mmcam_dbg_log("GST_MESSAGE_SEGMENT_START");
_mmcam_dbg_log("GST_MESSAGE_ASYNC_START");
break;
case GST_MESSAGE_ASYNC_DONE:
- _mmcam_dbg_log("GST_MESSAGE_ASYNC_DONE");
+ /*_mmcam_dbg_log("GST_MESSAGE_ASYNC_DONE");*/
break;
case GST_MESSAGE_ANY:
_mmcam_dbg_log("GST_MESSAGE_ANY");
switch (err->code) {
case GST_RESOURCE_ERROR_BUSY:
_mmcam_dbg_err("Camera device [busy]");
- sc->error_code = MM_ERROR_CAMCORDER_DEVICE_BUSY;
+ hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_BUSY;
break;
case GST_RESOURCE_ERROR_OPEN_WRITE:
_mmcam_dbg_err("Camera device [open failed]");
- sc->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
+ hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
//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]");
- sc->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN;
+ hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN;
break;
case GST_RESOURCE_ERROR_OPEN_READ:
_mmcam_dbg_err("Camera device [register trouble]");
- sc->error_code = MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE;
+ hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE;
break;
case GST_RESOURCE_ERROR_NOT_FOUND:
_mmcam_dbg_err("Camera device [device not found]");
- sc->error_code = MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND;
+ hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND;
break;
case GST_RESOURCE_ERROR_TOO_LAZY:
_mmcam_dbg_err("Camera device [timeout]");
- sc->error_code = MM_ERROR_CAMCORDER_DEVICE_TIMEOUT;
+ hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_TIMEOUT;
break;
case GST_RESOURCE_ERROR_SETTINGS:
_mmcam_dbg_err("Camera device [not supported]");
- sc->error_code = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
+ hcamcorder->error_code = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
break;
case GST_RESOURCE_ERROR_FAILED:
_mmcam_dbg_err("Camera device [working failed].");
- sc->error_code = MM_ERROR_CAMCORDER_DEVICE_IO;
+ hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_IO;
break;
default:
_mmcam_dbg_err("Camera device [General(%d)]", err->code);
- sc->error_code = MM_ERROR_CAMCORDER_DEVICE;
+ hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE;
break;
}
- sc->error_occurs = TRUE;
+ hcamcorder->error_occurs = TRUE;
}
g_error_free(err);
/* store error code and drop this message if cmd is running */
- if (sc->error_code != MM_ERROR_NONE) {
+ if (hcamcorder->error_code != MM_ERROR_NONE) {
_MMCamcorderMsgItem msg;
/* post error to application */
- sc->error_occurs = TRUE;
+ hcamcorder->error_occurs = TRUE;
msg.id = MM_MESSAGE_CAMCORDER_ERROR;
- msg.param.code = sc->error_code;
+ msg.param.code = hcamcorder->error_code;
_mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
goto DROP_MESSAGE;
}
return GST_BUS_PASS;
-
DROP_MESSAGE:
gst_message_unref(message);
message = NULL;
}
+GstBusSyncReply _mmcamcorder_audio_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data)
+{
+ GstElement *element = NULL;
+ GError *err = NULL;
+ gchar *debug_info = NULL;
+
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
+ _MMCamcorderSubContext *sc = NULL;
+
+ mmf_return_val_if_fail(hcamcorder, GST_BUS_PASS);
+ mmf_return_val_if_fail(message, GST_BUS_PASS);
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
+ mmf_return_val_if_fail(sc, GST_BUS_PASS);
+
+ if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) {
+ /* parse error message */
+ gst_message_parse_error(message, &err, &debug_info);
+
+ if (debug_info) {
+ _mmcam_dbg_err("GST ERROR : %s", debug_info);
+ g_free(debug_info);
+ debug_info = NULL;
+ }
+
+ if (!err) {
+ _mmcam_dbg_warn("failed to parse error message");
+ return GST_BUS_PASS;
+ }
+
+ /* set videosrc element to compare */
+ element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst);
+
+ /* check domain[RESOURCE] and element[VIDEOSRC] */
+ if (err->domain == GST_RESOURCE_ERROR &&
+ GST_ELEMENT_CAST(message->src) == element) {
+ _MMCamcorderMsgItem msg;
+ switch (err->code) {
+ case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
+ case GST_RESOURCE_ERROR_OPEN_WRITE:
+ _mmcam_dbg_err("audio device [open failed]");
+ hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
+ /* post error to application */
+ hcamcorder->error_occurs = TRUE;
+ msg.id = MM_MESSAGE_CAMCORDER_ERROR;
+ msg.param.code = hcamcorder->error_code;
+ _mmcam_dbg_err(" error : sc->error_occurs %d", hcamcorder->error_occurs);
+ g_error_free(err);
+ _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ gst_message_unref(message);
+ message = NULL;
+ return GST_BUS_DROP;
+ default:
+ break;
+ }
+ }
+
+ g_error_free(err);
+
+ }
+
+ return GST_BUS_PASS;
+}
+
+
int _mmcamcorder_create_pipeline(MMHandleType handle, int type)
{
int ret = MM_ERROR_NONE;
#endif /* _MMCAMCORDER_SKIP_GST_FLOW_ERROR */
/* post error to application */
- sc->error_occurs = TRUE;
+ hcamcorder->error_occurs = TRUE;
msg.id = MM_MESSAGE_CAMCORDER_ERROR;
_mmcamcroder_send_message(handle, &msg);
{
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_CAMERA,
- MM_CAM_CAMERA_FPS,
- MM_CAMCORDER_ATTR_NONE,
- "FPS",
- MM_CAMCONVERT_TYPE_INT_ARRAY,
- NULL,
- },
- { /* 5 */
- CONFIGURE_TYPE_CTRL,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
MM_CAM_CAMERA_FORMAT,
MM_CAMCORDER_ATTR_NONE,
"PictureFormat",
MM_CAMCONVERT_TYPE_INT_RANGE,
NULL,
},
- { /* 10 */
+ {
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_EFFECT,
MM_CAM_FILTER_CONTRAST,
MM_CAMCONVERT_TYPE_INT_RANGE,
NULL,
},
- {
+ {/* 10 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_EFFECT,
MM_CAM_FILTER_SATURATION,
MM_CAMCONVERT_TYPE_INT_ARRAY,
&_mmcamcorder_enum_conv_whitebalance,
},
- { /* 15 */
+ {
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_EFFECT,
MM_CAM_FILTER_COLOR_TONE,
MM_CAMCONVERT_TYPE_INT_RANGE,
NULL,
},
- { /* 20 */
+ {
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
MM_CAM_CAMERA_OPTICAL_ZOOM,
MM_CAMCONVERT_TYPE_INT_RANGE,
NULL,
},
- {
+ {/* 20 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
MM_CAM_CAMERA_FOCUS_MODE,
MM_CAMCONVERT_TYPE_INT_ARRAY,
&_mmcamcorder_enum_conv_ahs,
},
- { /* 30 */
+ {
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_CAPTURE,
MM_CAM_CAPTURE_FORMAT,
MM_CAMCONVERT_TYPE_INT_ARRAY,
NULL,
},
- {
+ {/* 30 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_CAPTURE,
MM_CAM_IMAGE_ENCODER_QUALITY,
MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY,
NULL,
},
- { /* 40 */
+ {
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
MM_CAM_CAMERA_VIDEO_STABILIZATION,
MM_CAMCONVERT_TYPE_INT_ARRAY,
&_mmcamcorder_enum_conv_video_stabilization,
},
- {
+ {/* 40 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_CAMERA,
MM_CAM_VIDEO_WIDTH,
return mslval;
}
+int _mmcamcorder_get_fps_array_by_resolution(MMHandleType handle, int width, int height, MMCamAttrsInfo* fps_info)
+{
+ MMCamAttrsInfo *infoW = NULL;
+ MMCamAttrsInfo *infoH = NULL;
+ int i = 0;
+ char nameFps[5] = {0,};
+ bool valid_check = false;
+
+ type_int_array *fps_array;
+
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+
+ //_mmcam_dbg_log("prev resolution w:%d, h:%d", width, height);
+
+ infoW = (MMCamAttrsInfo*)calloc(1, sizeof(MMCamAttrsInfo));
+ infoH = (MMCamAttrsInfo*)calloc(1, sizeof(MMCamAttrsInfo));
+
+ 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) {
+ valid_check = true;
+ sprintf(nameFps, "FPS%d", i);
+ _mmcam_dbg_log("nameFps : %s!!!", nameFps);
+ break;
+ }
+ }
+
+ if(infoW)
+ free(infoW);
+ if(infoH)
+ free(infoH);
+
+ if(!valid_check) {
+ _mmcam_dbg_err("FAILED : Can't find the valid resolution from attribute.");
+ return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
+ }
+
+ if (!_mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl, CONFIGURE_CATEGORY_CTRL_CAMERA, nameFps, &fps_array)) {
+ _mmcam_dbg_err("FAILED : Can't find the valid FPS array.");
+ return MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+ }
+
+ fps_info->int_array.count = fps_array->count;
+ fps_info->int_array.array = fps_array->value;
+ fps_info->int_array.def = fps_array->default_value;
+
+ return MM_ERROR_NONE;
+}
+
//convert sensor value to MSL value
int _mmcamcorder_convert_sensor_to_msl(MMHandleType handle, int attr_idx, int sensval)
{
if (valid_count > 0) {
*valid_array = (int*)malloc(sizeof(int) * valid_count);
- valid_count = 0;
- for (i = 0; i < original_count; i++) {
- if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE) {
- (*valid_array)[valid_count++] = i;
- //_mmcam_dbg_log( "valid_array[%d] = %d", valid_count-1, (*valid_array)[valid_count-1] );
-
- if (original_array[i] == *valid_default &&
- new_default == _MMCAMCORDER_SENSOR_ENUM_NONE) {
- new_default = i;
- //_mmcam_dbg_log( "converted MSL default[%d]", new_default );
+ if (*valid_array) {
+ valid_count = 0;
+ for (i = 0; i < original_count; i++) {
+ if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE) {
+ (*valid_array)[valid_count++] = i;
+ /*_mmcam_dbg_log( "valid_array[%d] = %d", valid_count-1, (*valid_array)[valid_count-1] );*/
+
+ if (original_array[i] == *valid_default &&
+ new_default == _MMCAMCORDER_SENSOR_ENUM_NONE) {
+ new_default = i;
+ /*_mmcam_dbg_log( "converted MSL default[%d]", new_default );*/
+ }
}
}
}
+ else {
+ valid_count = 0;
+ }
}
if (new_default != _MMCAMCORDER_SENSOR_ENUM_NONE) {
/* "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);
+ ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, idefault);
+ }
}
if (iarray && iarray != tarray->value )
/*=======================================================================================
| INCLUDE FILES |
=======================================================================================*/
+#include <stdlib.h>
#include <sys/time.h>
#include <sys/times.h>
#include <gst/video/cameracontrol.h>
/* sound status changed callback */
static void __sound_status_changed_cb(keynode_t* node, void *data);
-static void __volume_level_changed_cb(void* user_data);
/*=======================================================================================
| FUNCTION DEFINITIONS |
return ret;
}
- _mmcamcorder_remove_all_handlers(handle, _MMCAMCORDER_HANDLER_STILLSHOT);
+ _mmcamcorder_remove_all_handlers(handle, _MMCAMCORDER_HANDLER_STILLSHOT | _MMCAMCORDER_HANDLER_VIDEOREC);
GstPad *reqpad = NULL;
_mmcamcorder_remove_all_handlers(handle, _MMCAMCORDER_HANDLER_CATEGORY_ALL);
gst_object_unref(sc->element[_MMCAMCORDER_MAIN_PIPE].gst);
+
/* NULL initialization will be done in _mmcamcorder_element_release_noti */
}
}
info = sc->info_image;
+ if (info->capturing) {
+ _mmcam_dbg_err("already capturing");
+ return MM_ERROR_CAMCORDER_DEVICE_BUSY;
+ }
+
_mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
CONFIGURE_CATEGORY_MAIN_CAPTURE,
"UseCaptureMode",
_mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
- if (info->capturing) {
- ret = MM_ERROR_CAMCORDER_DEVICE_BUSY;
- goto cmd_error;
- }
-
/* get current state */
mm_camcorder_get_state(handle, ¤t_state);
err_name = NULL;
}
+ ret = MM_ERROR_NONE;
+
/* check capture count */
if (info->count < 1) {
_mmcam_dbg_err("capture count[%d] is invalid", info->count);
ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
- goto cmd_error;
+ goto cmd_done;
} else if (info->count == 1) {
info->type = _MMCamcorder_SINGLE_SHOT;
} else {
}
_mmcam_dbg_log("preview(%dx%d,fmt:%d), capture(%dx%d,fmt:%d), count(%d), hdr mode(%d), interval (%d)",
- width, height, info->preview_format,
- info->width, info->height, cap_format,
+ width, height, info->preview_format, info->width, info->height, cap_format,
info->count, info->hdr_capture_mode, info->interval);
/* check state */
info->hdr_capture_mode != MM_CAMCORDER_HDR_OFF) {
_mmcam_dbg_err("does not support multi/HDR capture while recording");
ret = MM_ERROR_CAMCORDER_INVALID_STATE;
- goto cmd_error;
+ goto cmd_done;
}
/* check capture size if ZSL is not supported*/
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
_mmcam_dbg_err("Can't cast Video source into camera control.");
- return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
+ ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
+ goto cmd_done;
}
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
_mmcam_dbg_err("could not capture in this target while recording");
ret = MM_ERROR_CAMCORDER_INVALID_STATE;
- goto cmd_error;
+ goto cmd_done;
}
if (UseCaptureMode) {
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("failed to set state PAUSED %x", ret);
- return ret;
+ goto cmd_done;
}
if (UseCaptureMode) {
ret = _mmcamcorder_set_videosrc_caps(handle, sc->fourcc, set_width, set_height, fps, rotation);
if (!ret) {
_mmcam_dbg_err("_mmcamcorder_set_videosrc_caps failed");
- return MM_ERROR_CAMCORDER_INTERNAL;
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ goto cmd_done;
}
info->resolution_change = TRUE;
/* make pipeline state as PLAYING */
ret = _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("failed to set state PAUSED %x", ret);
- return ret;
+ _mmcam_dbg_err("failed to set state PLAYING %x", ret);
+ goto cmd_done;
}
_mmcam_dbg_log("Change to target resolution(%d, %d)", set_width, set_height);
ret = _mmcamcorder_create_stillshot_pipeline((MMHandleType)hcamcorder);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("failed to create encodesinkbin %x", ret);
- return ret;
+ goto cmd_done;
}
ret = mm_camcorder_get_attributes(handle, &err_name,
ret = _mmcamcorder_gst_set_state(handle, sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst, GST_STATE_PLAYING);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("failed to set state PLAYING %x", ret);
- return ret;
+ goto cmd_done;
}
}
info->played_capture_sound = FALSE;
}
- return ret;
+cmd_done:
+ if (ret != MM_ERROR_NONE) {
+ info->capturing = FALSE;
+ }
-cmd_error:
- info->capturing = FALSE;
return ret;
}
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
+
if (ret != MM_ERROR_NONE) {
goto cmd_error;
}
_mmcam_dbg_log("sound status %d", info->sound_status);
- /* get volume level */
- mm_sound_volume_get_value(VOLUME_TYPE_SYSTEM, &info->volume_level);
-
- _mmcam_dbg_log("volume level %d", info->volume_level);
-
/* register changed_cb */
vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, __sound_status_changed_cb, hcamcorder);
- mm_sound_volume_add_callback(VOLUME_TYPE_SYSTEM, __volume_level_changed_cb, hcamcorder);
}
}
/* get camera control */
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (control) {
+ /* convert MSL to sensor value */
+ set_strobe = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_MODE, MM_CAMCORDER_STROBE_MODE_OFF);
- /* convert MSL to sensor value */
- set_strobe = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_MODE, MM_CAMCORDER_STROBE_MODE_OFF);
-
- /* set strobe OFF */
- gst_camera_control_set_strobe(control, GST_CAMERA_CONTROL_STROBE_MODE, set_strobe);
+ /* set strobe OFF */
+ gst_camera_control_set_strobe(control, GST_CAMERA_CONTROL_STROBE_MODE, set_strobe);
- _mmcam_dbg_log("set strobe OFF done - value: %d", set_strobe);
+ _mmcam_dbg_log("set strobe OFF done - value: %d", set_strobe);
+ } else {
+ _mmcam_dbg_warn("cast CAMERA_CONTROL failed");
+ }
}
pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
void __mmcamcorder_get_capture_data_from_buffer(MMCamcorderCaptureDataType *capture_data, int pixtype, GstSample *sample)
{
GstCaps *caps = NULL;
- GstMapInfo mapinfo = GST_MAP_INFO_INIT;
+ GstMapInfo mapinfo;
const GstStructure *structure;
mmf_return_if_fail(capture_data && sample);
goto GET_FAILED;
}
+ memset(&mapinfo, 0x0, sizeof(GstMapInfo));
+
gst_buffer_map(gst_sample_get_buffer(sample), &mapinfo, GST_MAP_READ);
capture_data->data = mapinfo.data;
capture_data->format = pixtype;
MMCamcorderCaptureDataType thumb = {0,};
MMCamcorderCaptureDataType scrnail = {0,};
MMCamcorderCaptureDataType encode_src = {0,};
- GstMapInfo mapinfo1 = GST_MAP_INFO_INIT;
- GstMapInfo mapinfo2 = GST_MAP_INFO_INIT;
- GstMapInfo mapinfo3 = GST_MAP_INFO_INIT;
+ GstMapInfo mapinfo1;
+ GstMapInfo mapinfo2;
+ GstMapInfo mapinfo3;
mmf_attrs_t *attrs = NULL;
mmf_attribute_t *item_screennail = NULL;
info = sc->info_image;
+ memset(&mapinfo1, 0x0, sizeof(GstMapInfo));
+ memset(&mapinfo2, 0x0, sizeof(GstMapInfo));
+ memset(&mapinfo3, 0x0, sizeof(GstMapInfo));
+
/* get current state */
current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
if (thumb_raw_data) {
ret = _mmcamcorder_encode_jpeg(thumb_raw_data, thumb_width, thumb_height,
encode_src.format, thumb_length, THUMBNAIL_JPEG_QUALITY,
- (void **)&internal_thumb_data, &internal_thumb_length, JPEG_ENCODER_SOFTWARE);
+ (void **)&internal_thumb_data, &internal_thumb_length);
if (ret) {
_mmcam_dbg_log("encode THUMBNAIL done - data %p, length %d",
internal_thumb_data, internal_thumb_length);
ret = _mmcamcorder_encode_jpeg(mapinfo1.data, dest.width, dest.height,
pixtype_main, dest.length, capture_quality,
- (void **)&internal_main_data, &internal_main_length, JPEG_ENCODER_HARDWARE);
+ (void **)&internal_main_data, &internal_main_length);
if (!ret) {
_mmcam_dbg_err("_mmcamcorder_encode_jpeg failed");
ed = exif_data_new_from_data(imagedata, imgln);
//ed = mm_exif_get_exif_from_info(hcamcorder->exif_info);
- if (ed == NULL || ed->ifd == NULL) {
- _mmcam_dbg_err("get exif data error!!(%p, %p)", ed, (ed ? ed->ifd : NULL));
+ if (ed == NULL) {
+ _mmcam_dbg_err("get exif data error!!");
return MM_ERROR_INVALID_HANDLE;
}
return;
}
-
-
-static void __volume_level_changed_cb(void *data)
-{
- mmf_camcorder_t *hcamcorder = (mmf_camcorder_t *)data;
- _MMCamcorderImageInfo *info = NULL;
-
- mmf_return_if_fail(hcamcorder && hcamcorder->sub_context && hcamcorder->sub_context->info_image);
-
- _mmcam_dbg_log("START");
-
- info = hcamcorder->sub_context->info_image;
-
- mm_sound_volume_get_value(VOLUME_TYPE_SYSTEM, &info->volume_level);
-
- _mmcam_dbg_log("DONE : volume level %d", info->volume_level);
-
- return;
-}
=======================================================================================*/
#include <stdio.h>
#include <stdarg.h>
+#include <stdlib.h>
#include <sys/vfs.h> /* struct statfs */
+#include <sys/time.h> /* gettimeofday */
#include <sys/stat.h>
#include <gst/video/video-info.h>
+#include <gio/gio.h>
#include "mm_camcorder_internal.h"
#include "mm_camcorder_util.h"
#include "mm_camcorder_sound.h"
#include <mm_util_imgp.h>
+#include <mm_util_jpeg.h>
/*-----------------------------------------------------------------------
| GLOBAL VARIABLE DEFINITIONS for internal |
static inline gboolean write_to_32(FILE *f, guint val);
static inline gboolean write_to_16(FILE *f, guint val);
static inline gboolean write_to_24(FILE *f, guint val);
+#ifdef _USE_YUV_TO_RGB888_
+static gboolean _mmcamcorder_convert_YUV_to_RGB888(unsigned char *src, int src_fmt, guint width, guint height, unsigned char **dst, unsigned int *dst_len);
+#endif /* _USE_YUV_TO_RGB888_ */
+static gboolean _mmcamcorder_convert_YUYV_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len);
+static gboolean _mmcamcorder_convert_UYVY_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len);
+static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len);
+
/*===========================================================================================
| |
| GLOBAL FUNCTION DEFINITIONS: |
---------------------------------------------------------------------------*/
+static int __gdbus_method_call_sync(const char* bus_name, const char* object, const char* iface,
+ const char* method, GVariant* args, GVariant** result, bool is_sync)
+{
+ int ret = MM_ERROR_NONE;
+ GError *err = NULL;
+ GVariant* dbus_reply = NULL;
+ GDBusConnection *conn = NULL;
+
+ if (!object || !iface || !method) {
+ _mmcam_dbg_err("Invalid Argument");
+ if (!object)
+ _mmcam_dbg_err("object null");
+ if (!iface)
+ _mmcam_dbg_err("iface null");
+ if (!method)
+ _mmcam_dbg_err("method null");
+ return MM_ERROR_INVALID_ARGUMENT;
+ }
+
+ conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
+ if (conn == NULL) {
+ _mmcam_dbg_err("get connection failed");
+ return MM_ERROR_CAMCORDER_INTERNAL;
+ }
+
+ _mmcam_dbg_log("Dbus call with obj : '%s' iface : '%s' method : '%s'", object, iface, method);
+
+ if (is_sync) {
+ if (dbus_reply = g_dbus_connection_call_sync(conn, bus_name, object, iface, \
+ method, args,\
+ NULL, G_DBUS_CALL_FLAGS_NONE, G_DBUS_REPLY_TIMEOUT, NULL, &err )) {
+ _mmcam_dbg_log("Method Call '%s.%s' Success", iface, method);
+ *result = dbus_reply;
+ } else {
+ _mmcam_dbg_err("dbus method call sync reply failed");
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ }
+ } else {
+ g_dbus_connection_call(conn, bus_name, object, iface, \
+ method, args, \
+ NULL, G_DBUS_CALL_FLAGS_NONE, G_DBUS_REPLY_TIMEOUT, \
+ NULL, NULL, NULL);
+ }
+ g_object_unref(conn);
+ return ret;
+}
+
gint32 _mmcamcorder_double_to_fix(gdouble d_number)
{
return (gint32) (d_number * 65536.0);
// find top level tag only, do not use this function for finding sub level tags
gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc, gboolean do_rewind)
{
+ size_t read_item = 0;
+ guchar buf[8];
+
+ if (do_rewind) {
+ rewind(f);
+ }
+
+ while ((read_item = fread(&buf, sizeof(guchar), 8, f)) > 0) {
+ unsigned long long buf_size = 0;
+ unsigned int buf_fourcc = 0;
+
+ if (read_item < 8) {
+ _mmcam_dbg_err("fread failed : %d", read_item);
+ break;
+ }
+
+ buf_fourcc = MMCAM_FOURCC(buf[4], buf[5], buf[6], buf[7]);
+
+ if (tag_fourcc == buf_fourcc) {
+ _mmcam_dbg_log("find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
+ return TRUE;
+ } else {
+ _mmcam_dbg_log("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc));
+
+ buf_size = (unsigned long long)_mmcamcorder_get_container_size(buf);
+ buf_size = buf_size - 8; /* include tag */
+
+ do {
+ if (buf_size > _MMCAMCORDER_MAX_INT) {
+ _mmcam_dbg_log("seek %d", _MMCAMCORDER_MAX_INT);
+ if (fseek(f, _MMCAMCORDER_MAX_INT, SEEK_CUR) != 0) {
+ _mmcam_dbg_err("fseek() fail");
+ return FALSE;
+ }
+
+ buf_size -= _MMCAMCORDER_MAX_INT;
+ } else {
+ _mmcam_dbg_log("seek %d", buf_size);
+ if (fseek(f, buf_size, SEEK_CUR) != 0) {
+ _mmcam_dbg_err("fseek() fail");
+ return FALSE;
+ }
+ break;
+ }
+ } while (TRUE);
+ }
+ }
+
+ _mmcam_dbg_log("cannot find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
+
+ return FALSE;
+}
+
+gboolean _mmcamcorder_find_fourcc(FILE *f, guint32 tag_fourcc, gboolean do_rewind)
+{
+ size_t read_item = 0;
guchar buf[8];
if (do_rewind) {
rewind(f);
}
- while (fread(&buf, sizeof(guchar), 8, f)>0) {
+ while ((read_item = fread(&buf, sizeof(guchar), 8, f)) > 0) {
unsigned long long buf_size = 0;
- unsigned int buf_fourcc = MMCAM_FOURCC(buf[4], buf[5], buf[6], buf[7]);
+ unsigned int buf_fourcc = 0;
+
+ if (read_item < 8) {
+ _mmcam_dbg_err("fread failed : %d", read_item);
+ break;
+ }
+
+ buf_fourcc = MMCAM_FOURCC(buf[4], buf[5], buf[6], buf[7]);
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)){
+ return TRUE;
+ }
+ else{
+ continue;
+ }
} else {
_mmcam_dbg_log("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc));
if (!write_to_32(f, curr_pos -prev_pos))
return FALSE;
-
+
if(fseek(f, curr_pos, SEEK_SET) != 0)
{
_mmcam_dbg_err("fseek() fail");
return FALSE;
}
-
+
return TRUE;
}
return TRUE;
}
-void _mmcamcorder_write_Latitude(FILE *f,int degreex10000)
-{
- bool isNegative = (degreex10000 < 0);
- char sign = isNegative? '-': '+';
-
- // Handle the whole part
- char str[9];
- int wholePart = 0;
- int fractionalPart = 0;
+void _mmcamcorder_write_Latitude(FILE *f,int value) {
+ char s_latitude[9];
+ int l_decimal = 0;
+ int l_below_decimal = 0;
- wholePart = degreex10000 / 10000;
- if (wholePart == 0) {
- snprintf(str, 5, "%c%.2d.", sign, wholePart);
+ l_decimal = value / 10000;
+ if (value < 0) {
+ if( l_decimal == 0) {
+ snprintf(s_latitude, 5, "-%.2d.", l_decimal);
+ } else {
+ snprintf(s_latitude, 5, "%.2d.", l_decimal);
+ }
} else {
- snprintf(str, 5, "%+.2d.", wholePart);
+ snprintf(s_latitude, 5, "+%.2d.", l_decimal);
}
- // Handle the fractional part
- fractionalPart = degreex10000 - (wholePart * 10000);
- if (fractionalPart < 0) {
- fractionalPart = -fractionalPart;
+ l_below_decimal = value - (l_decimal * 10000);
+ if (l_below_decimal < 0) {
+ l_below_decimal = -l_below_decimal;
}
- snprintf(&str[4], 5, "%.4d", fractionalPart);
+ snprintf(&s_latitude[4], 5, "%.4d", l_below_decimal);
- // Do not write the null terminator
- write_tag(f, str);
+ write_tag(f, s_latitude);
+}
- return;
+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) {
+ snprintf(s_longitude, 6, "-%.3d.", l_decimal);
+ } 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) {
+ l_below_decimal = -l_below_decimal;
+ }
+ snprintf(&s_longitude[5], 5, "%.4d", l_below_decimal);
+
+ write_tag(f, s_longitude);
}
+#define D_GEOGRAPH "\xA9xyz"
+// 0x0012 -> latitude(8) + longitude(9) + seperator(1) = 18
+// 0x15c7 -> encode in english
+#define D_INFO_GEOGRAPH 0x001215c7
+
+gboolean _mmcamcorder_write_geodata(FILE *f,_MMCamcorderLocationInfo info) {
-gboolean _mmcamcorder_write_udta(FILE *f, _MMCamcorderLocationInfo info)
-{
gint64 current_pos, pos;
_mmcam_dbg_log("");
if(!write_to_32(f, 0)) //size
return FALSE;
-
- if(!write_tag(f, "udta")) // type
+ // tag -> .xyz
+ if(!write_tag(f, D_GEOGRAPH)) // type
return FALSE;
- if(! _mmcamcorder_write_loci(f, info))
+ if(!write_to_32(f, D_INFO_GEOGRAPH))
return FALSE;
+ _mmcamcorder_write_Latitude(f,info.latitude);
+ _mmcamcorder_write_Longitude(f,info.longitude);
+
+ FPUTC_CHECK(0x2F, f);
+
if((current_pos = ftell(f))<0)
{
_mmcam_dbg_err("ftell() returns negative value");
}
+gboolean _mmcamcorder_write_udta(FILE *f, int gps_enable, _MMCamcorderLocationInfo info, _MMCamcorderLocationInfo geotag)
+{
+ gint64 current_pos, pos;
+
+ _mmcam_dbg_log("gps enable : %d", gps_enable);
+ if (gps_enable == FALSE) {
+ _mmcam_dbg_log("no need to write udta");
+ return TRUE;
+ }
+
+ if ((pos = ftell(f))<0) {
+ _mmcam_dbg_err("ftell() returns negative value");
+ return FALSE;
+ }
+
+ /* size */
+ if (!write_to_32(f, 0)) {
+ _mmcam_dbg_err("failed to write size");
+ return FALSE;
+ }
+
+ /* type */
+ if (!write_tag(f, "udta")) {
+ _mmcam_dbg_err("failed to write type udta");
+ return FALSE;
+ }
+
+ if (gps_enable) {
+ if (!_mmcamcorder_write_loci(f, info)) {
+ _mmcam_dbg_err("failed to write loci");
+ return FALSE;
+ }
+
+ if (!_mmcamcorder_write_geodata(f,geotag)) {
+ _mmcam_dbg_err("failed to write geodata");
+ return FALSE;
+ }
+ }
+
+ if ((current_pos = ftell(f))<0) {
+ _mmcam_dbg_err("ftell() returns negative value");
+ return FALSE;
+ }
+
+ if (!_mmcamcorder_update_size(f, pos, current_pos)) {
+ _mmcam_dbg_err("failed to update size");
+ return FALSE;
+ }
+
+ _mmcam_dbg_log("done");
+
+ return TRUE;
+}
+
+
guint64 _mmcamcorder_get_container_size(const guchar *size)
{
guint64 result = 0;
}
if (-1 == statfs(path, &fs)) {
- _mmcam_dbg_log("Getting free space is failed.(%s)", path);
+ _mmcam_dbg_log("statfs failed.(%s)", path);
return -1;
}
return 0;
}
+int _mmcamcorder_get_freespace_except_system(guint64 *free_space)
+{
+ double total_space=0;
+ double avail_space=0;
+
+ int ret = MM_ERROR_NONE;
+ GVariant *params = NULL, *result = NULL;
+ const char *param_type = "(xx)";
+
+ if ((ret = __gdbus_method_call_sync("org.tizen.system.deviced",
+ "/Org/Tizen/System/DeviceD/Storage",
+ "org.tizen.system.deviced.storage",
+ "getstorage",
+ params,
+ &result,
+ TRUE)) != MM_ERROR_NONE) {
+ _mmcam_dbg_err("Dbus Call on Client Error");
+ return ret;
+ }
+
+ if (result) {
+ g_variant_get(result, param_type, &total_space, &avail_space);
+ *free_space = (guint64)avail_space;
+ _mmcam_dbg_log("free space [%" G_GUINT64_FORMAT "] ", *free_space);
+ } else {
+ _mmcam_dbg_err("replied result is null");
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ }
+ return ret;
+}
+
+int _mmcamcorder_get_device_flash_brightness(int *brightness)
+{
+ int get_value = 0;
+ int ret = MM_ERROR_NONE;
+ GVariant *params = NULL, *result = NULL;
+ const char *param_type = "(i)";
+
+ if ((ret = __gdbus_method_call_sync("org.tizen.system.deviced",
+ "/Org/Tizen/System/DeviceD/Led",
+ "org.tizen.system.deviced.Led",
+ "GetBrightnessForCamera",
+ params,
+ &result,
+ TRUE)) != MM_ERROR_NONE) {
+ _mmcam_dbg_err("Dbus Call on Client Error");
+ return ret;
+ }
+
+ if (result) {
+ g_variant_get(result, param_type, &get_value);
+ *brightness = get_value;
+ _mmcam_dbg_log("flash brightness : %d", *brightness);
+ } else {
+ _mmcam_dbg_err("replied result is null");
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ }
+
+ return ret;
+}
int _mmcamcorder_get_file_size(const char *filename, guint64 *size)
{
}
-gboolean
-_mmcamcroder_msg_callback(void *data)
+gboolean _mmcamcroder_msg_callback(void *data)
{
_MMCamcorderMsgItem *item = (_MMCamcorderMsgItem*)data;
mmf_camcorder_t *hcamcorder = NULL;
hcamcorder = MMF_CAMCORDER(item->handle);
if (hcamcorder == NULL) {
- _mmcam_dbg_warn("msg id:%x, item:%p, handle is NULL", item->id, item);
+ _mmcam_dbg_warn("msg id:0x%x, item:%p, handle is NULL", item->id, item);
goto MSG_CALLBACK_DONE;
}
-
/*_mmcam_dbg_log("msg id:%x, msg_cb:%p, msg_data:%p, item:%p", item->id, hcamcorder->msg_cb, hcamcorder->msg_data, item);*/
_MMCAMCORDER_LOCK((MMHandleType)hcamcorder);
_MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder);
+ _MMCAMCORDER_SIGNAL(hcamcorder);
+
MSG_CALLBACK_DONE:
/* release allocated memory */
if (item->id == MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO) {
}
-gboolean
-_mmcamcroder_send_message(MMHandleType handle, _MMCamcorderMsgItem *data)
+gboolean _mmcamcroder_send_message(MMHandleType handle, _MMCamcorderMsgItem *data)
{
mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderMsgItem *item = NULL;
}
item = g_malloc(sizeof(_MMCamcorderMsgItem));
- memcpy(item, data, sizeof(_MMCamcorderMsgItem));
- item->handle = handle;
- pthread_mutex_init(&(item->lock), NULL);
+ if (item) {
+ memcpy(item, data, sizeof(_MMCamcorderMsgItem));
+ item->handle = handle;
+ pthread_mutex_init(&(item->lock), NULL);
- _MMCAMCORDER_LOCK(handle);
- hcamcorder->msg_data = g_list_append(hcamcorder->msg_data, item);
-// _mmcam_dbg_log("item[%p]", item);
+ _MMCAMCORDER_LOCK(handle);
+ hcamcorder->msg_data = g_list_append(hcamcorder->msg_data, item);
+// _mmcam_dbg_log("item[%p]", item);
- /* Use DEFAULT priority */
- g_idle_add_full(G_PRIORITY_DEFAULT, _mmcamcroder_msg_callback, item, NULL);
+ /* Use DEFAULT priority */
+ g_idle_add_full(G_PRIORITY_DEFAULT, _mmcamcroder_msg_callback, item, NULL);
- _MMCAMCORDER_UNLOCK(handle);
+ _MMCAMCORDER_UNLOCK(handle);
+ } else {
+ _mmcam_dbg_err("item[id:0x%x] malloc failed : %d", data->id, sizeof(_MMCamcorderMsgItem));
+ }
return TRUE;
}
-void
-_mmcamcroder_remove_message_all(MMHandleType handle)
+void _mmcamcroder_remove_message_all(MMHandleType handle)
{
mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderMsgItem *item = NULL;
gboolean ret = TRUE;
GList *list = NULL;
+ struct timespec timeout;
+ struct timeval tv;
+ struct timeval tv_to_add;
+ struct timeval tv_result;
mmf_return_if_fail(hcamcorder);
if (!hcamcorder->msg_data) {
_mmcam_dbg_log("No message data is remained.");
} else {
+ tv_to_add.tv_sec = 0;
+ tv_to_add.tv_usec = 1000 * 100; /* 100 ms */
+
list = hcamcorder->msg_data;
while (list) {
_mmcam_dbg_err("Fail to remove message. The item is NULL");
} else {
if (pthread_mutex_trylock(&(item->lock))) {
- ret = g_idle_remove_by_data (item);
- _mmcam_dbg_log("Remove item[%p]. ret[%d]", item, ret);
+ ret = g_idle_remove_by_data(item);
- hcamcorder->msg_data = g_list_remove(hcamcorder->msg_data, item);
+ _mmcam_dbg_log("remove msg item[%p], ret[%d]", item, ret);
+
+ if (ret == FALSE) {
+ item->handle = 0;
+ _mmcam_dbg_warn("failed to remove msg cb for item %p, it will be called later with NULL handle", item);
+ }
- if (ret ) {
- /* release allocated memory */
- if (item->id == MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO) {
- MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)item->param.data;
- if (cam_fd_info) {
- SAFE_FREE(cam_fd_info->face_info);
- free(cam_fd_info);
- cam_fd_info = NULL;
- }
-
- item->param.data = NULL;
- item->param.size = 0;
+ /* release allocated memory */
+ if (item->id == MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO) {
+ MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)item->param.data;
+ if (cam_fd_info) {
+ SAFE_FREE(cam_fd_info->face_info);
+ free(cam_fd_info);
+ cam_fd_info = NULL;
}
- pthread_mutex_unlock(&(item->lock));
+ item->param.data = NULL;
+ item->param.size = 0;
+ }
+
+ hcamcorder->msg_data = g_list_remove(hcamcorder->msg_data, item);
+
+ pthread_mutex_unlock(&(item->lock));
+
+ if (ret == TRUE) {
pthread_mutex_destroy(&(item->lock));
- SAFE_FREE(item);
- } else {
- item->handle = 0;
- _mmcam_dbg_warn("Fail to remove item[%p]", item);
- pthread_mutex_unlock(&item->lock);
+ free(item);
+ item = NULL;
+
+ _mmcam_dbg_log("remove msg done");
}
} else {
_mmcam_dbg_warn("item lock failed. it's being called...");
+
+ gettimeofday(&tv, NULL);
+ timeradd(&tv, &tv_to_add, &tv_result);
+ timeout.tv_sec = tv_result.tv_sec;
+ timeout.tv_nsec = tv_result.tv_usec * 1000;
+
+ if (_MMCAMCORDER_TIMED_WAIT(handle, timeout)) {
+ _mmcam_dbg_warn("signal received");
+ } else {
+ _mmcam_dbg_warn("timeout");
+ }
}
}
}
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);
if (!strcmp (media_type, "image/jpeg") ) {
_mmcam_dbg_log("It is jpeg.");
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") &&
+ 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;
_mmcam_dbg_log("It is H264");
type = MM_PIXEL_FORMAT_ENCODED_H264;
} else {
- _mmcam_dbg_err("Not supported format");
+ _mmcam_dbg_err("Not supported format [%s]",media_type);
type = MM_PIXEL_FORMAT_INVALID;
}
{
unsigned int fourcc = 0;
- _mmcam_dbg_log("pixtype(%d)", pixtype);
+ /*_mmcam_dbg_log("pixtype(%d)", pixtype);*/
switch (pixtype) {
case MM_PIXEL_FORMAT_NV12:
int _mmcamcorder_get_pixtype(unsigned int fourcc)
{
int pixtype = MM_PIXEL_FORMAT_INVALID;
+ /*
char *pfourcc = (char*)&fourcc;
- _mmcam_dbg_log("fourcc(%c%c%c%c)", pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]);
+
+ _mmcam_dbg_log("fourcc(%c%c%c%c)",
+ pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]);
+ */
switch (fourcc) {
case GST_MAKE_FOURCC ('S', 'N', '1', '2'):
gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsigned int src_height,
int src_format, unsigned int src_length, unsigned int jpeg_quality,
- void **result_data, unsigned int *result_length, int enc_type)
+ void **result_data, unsigned int *result_length)
{
int ret = 0;
- int i = 0;
+ gboolean ret_conv = TRUE;
guint32 src_fourcc = 0;
- gboolean do_encode = FALSE;
- jpegenc_parameter enc_param;
- jpegenc_info enc_info;
-
- _mmcam_dbg_log("START - enc_type [%d]", enc_type);
+ int jpeg_format = 0;
+ unsigned char *converted_src = NULL;
+ unsigned int converted_src_size = 0;
mmf_return_val_if_fail(src_data && result_data && result_length, FALSE);
- CLEAR(enc_param);
- CLEAR(enc_info);
-
- camsrcjpegenc_get_info(&enc_info);
-
src_fourcc = _mmcamcorder_get_fourcc(src_format, 0, FALSE);
- camsrcjpegenc_get_src_fmt(src_fourcc, &(enc_param.src_fmt));
-
- if (enc_param.src_fmt == COLOR_FORMAT_NOT_SUPPORT) {
- _mmcam_dbg_err("Not Supported FOURCC(format:%d)", src_format);
- return FALSE;
- }
- /* check H/W encoder */
- if (enc_info.hw_support && enc_type == JPEG_ENCODER_HARDWARE) {
- _mmcam_dbg_log("check H/W encoder supported format list");
- /* Check supported format */
- for (i = 0 ; i < enc_info.hw_enc.input_fmt_num ; i++) {
- if (enc_param.src_fmt == enc_info.hw_enc.input_fmt_list[i]) {
- do_encode = TRUE;
- break;
- }
- }
+ 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);
+ jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
+ break;
+ case MM_PIXEL_FORMAT_NV16:
+ jpeg_format = MM_UTIL_JPEG_FMT_NV16;
+ converted_src = src_data;
+ break;
+ case MM_PIXEL_FORMAT_NV21:
+ jpeg_format = MM_UTIL_JPEG_FMT_NV21;
+ converted_src = src_data;
+ 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);
+ 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);
+ jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
+ break;
+ case MM_PIXEL_FORMAT_I420:
+ jpeg_format = MM_UTIL_JPEG_FMT_YUV420;
+ converted_src = src_data;
+ break;
+ case MM_PIXEL_FORMAT_RGB888:
+ jpeg_format = MM_UTIL_JPEG_FMT_RGB888;
+ converted_src = src_data;
+ break;
+ case MM_PIXEL_FORMAT_RGBA:
+ jpeg_format = MM_UTIL_JPEG_FMT_RGBA8888;
+ converted_src = src_data;
+ break;
+ case MM_PIXEL_FORMAT_ARGB:
+ jpeg_format = MM_UTIL_JPEG_FMT_ARGB8888;
+ converted_src = src_data;
+ break;
+ case MM_PIXEL_FORMAT_422P:
+ jpeg_format = MM_UTIL_JPEG_FMT_YUV422; // not supported
+ return FALSE;
+ case MM_PIXEL_FORMAT_NV12T:
+ case MM_PIXEL_FORMAT_YV12:
+ case MM_PIXEL_FORMAT_RGB565:
+ case MM_PIXEL_FORMAT_ENCODED:
+ case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY:
+ default:
+ return FALSE;
- if (do_encode) {
- enc_type = JPEG_ENCODER_HARDWARE;
- }
}
- /* check S/W encoder */
- if (!do_encode && enc_info.sw_support) {
- _mmcam_dbg_log("check S/W encoder supported format list");
- /* Check supported format */
- for (i = 0 ; i < enc_info.sw_enc.input_fmt_num ; i++) {
- if (enc_param.src_fmt == enc_info.sw_enc.input_fmt_list[i]) {
- do_encode = TRUE;
- break;
- }
- }
-
- if (do_encode) {
- enc_type = JPEG_ENCODER_SOFTWARE;
+ if (ret_conv == FALSE) {
+ if (converted_src &&
+ converted_src != src_data) {
+ free(converted_src);
+ converted_src = NULL;
}
+ _mmcam_dbg_err("color convert error source format[%d], jpeg format[%d]", src_format, jpeg_format);
+ return FALSE;
}
- if (do_encode) {
- enc_param.src_data = src_data;
- enc_param.width = src_width;
- enc_param.height = src_height;
- enc_param.src_len = src_length;
- enc_param.jpeg_mode = JPEG_MODE_BASELINE;
- enc_param.jpeg_quality = jpeg_quality;
+ ret = mm_util_jpeg_encode_to_memory(result_data, (int *)result_length,
+ converted_src, src_width, src_height,
+ jpeg_format, jpeg_quality);
- _mmcam_dbg_log("%ux%u, size %u, quality %u, type %d",
- src_width, src_height, src_length,
- jpeg_quality, enc_type);
-
- ret = camsrcjpegenc_encode(&enc_info, enc_type, &enc_param );
- if (ret == CAMSRC_JPEGENC_ERROR_NONE) {
- *result_data = enc_param.result_data;
- *result_length = enc_param.result_len;
-
- _mmcam_dbg_log("JPEG encode length(%d)", *result_length);
-
- return TRUE;
- } else {
- _mmcam_dbg_err("camsrcjpegenc_encode failed(%x)", ret);
- return FALSE;
- }
+ if (converted_src && (converted_src != src_data)) {
+ free(converted_src);
+ converted_src = NULL;
}
- _mmcam_dbg_err("No encoder supports %d format", src_format);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("No encoder supports %d format, error code %x", src_format, ret);
+ return FALSE;
+ }
- return FALSE;
+ return TRUE;
}
return NULL;
}
+
+#ifdef _USE_YUV_TO_RGB888_
+static gboolean
+_mmcamcorder_convert_YUV_to_RGB888(unsigned char *src, int src_fmt, guint width, guint height, unsigned char **dst, unsigned int *dst_len)
+{
+ int ret = 0;
+ int src_cs = MM_UTIL_IMG_FMT_UYVY;
+ int dst_cs = MM_UTIL_IMG_FMT_RGB888;
+ unsigned int dst_size = 0;
+
+ 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)
+ {
+ _mmcam_dbg_log("Convert UYVY to RGB888\n");
+ src_cs = MM_UTIL_IMG_FMT_UYVY;
+ }
+ else if (src_fmt == COLOR_FORMAT_NV12)
+ {
+ _mmcam_dbg_log("Convert NV12 to RGB888\n");
+ src_cs = MM_UTIL_IMG_FMT_NV12;
+ }
+ else
+ {
+ _mmcam_dbg_err("NOT supported format [%d]\n", src_fmt);
+ return FALSE;
+ }
+
+ ret = mm_util_get_image_size(dst_cs, width, height, &dst_size);
+ if (ret != 0) {
+ _mmcam_dbg_err("mm_util_get_image_size failed [%x]\n", ret);
+ return FALSE;
+ }
+
+ *dst = malloc(dst_size);
+ 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)
+ {
+ _mmcam_dbg_log("Convert [dst_size:%d] OK.\n", dst_size);
+ return TRUE;
+ }
+ else
+ {
+ free(*dst);
+ *dst = NULL;
+
+ _mmcam_dbg_err("Convert [size:%d] FAILED.\n", dst_size);
+ return FALSE;
+ }
+}
+#endif /* _USE_YUV_TO_RGB888_ */
+
+
+static gboolean _mmcamcorder_convert_YUYV_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len)
+{
+ unsigned int i = 0;
+ int j = 0;
+ int src_offset = 0;
+ int dst_y_offset = 0;
+ int dst_u_offset = 0;
+ int dst_v_offset = 0;
+ int loop_length = 0;
+ unsigned int dst_size = 0;
+ unsigned char *dst_data = NULL;
+
+ if (!src || !dst || !dst_len) {
+ _mmcam_dbg_err("NULL pointer %p, %p, %p", src, dst, dst_len);
+ return FALSE;
+ }
+
+ dst_size = (width * height * 3) >> 1;
+
+ _mmcam_dbg_log("YUVY -> I420 : %dx%d, dst size %d", width, height, dst_size);
+
+ dst_data = (unsigned char *)malloc(dst_size);
+ if (!dst_data) {
+ _mmcam_dbg_err("failed to alloc dst_data. size %d", dst_size);
+ return FALSE;
+ }
+
+ loop_length = width << 1;
+ dst_u_offset = width * height;
+ dst_v_offset = dst_u_offset + (dst_u_offset >> 2);
+
+ _mmcam_dbg_log("offset y %d, u %d, v %d", dst_y_offset, dst_u_offset, dst_v_offset);
+
+ for (i = 0 ; i < height ; i++) {
+ for (j = 0 ; j < loop_length ; j += 2) {
+ dst_data[dst_y_offset++] = src[src_offset++]; /*Y*/
+
+ if (i % 2 == 0) {
+ if (j % 4 == 0) {
+ dst_data[dst_u_offset++] = src[src_offset++]; /*U*/
+ } 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);
+
+ return TRUE;
+}
+
+
+static gboolean _mmcamcorder_convert_UYVY_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len)
+{
+ unsigned int i = 0;
+ int j = 0;
+ int src_offset = 0;
+ int dst_y_offset = 0;
+ int dst_u_offset = 0;
+ int dst_v_offset = 0;
+ int loop_length = 0;
+ unsigned int dst_size = 0;
+ unsigned char *dst_data = NULL;
+
+ if (!src || !dst || !dst_len) {
+ _mmcam_dbg_err("NULL pointer %p, %p, %p", src, dst, dst_len);
+ return FALSE;
+ }
+
+ dst_size = (width * height * 3) >> 1;
+
+ _mmcam_dbg_log("UYVY -> I420 : %dx%d, dst size %d", width, height, dst_size);
+
+ dst_data = (unsigned char *)malloc(dst_size);
+ if (!dst_data) {
+ _mmcam_dbg_err("failed to alloc dst_data. size %d", dst_size);
+ return FALSE;
+ }
+
+ loop_length = width << 1;
+ dst_u_offset = width * height;
+ dst_v_offset = dst_u_offset + (dst_u_offset >> 2);
+
+ _mmcam_dbg_log("offset y %d, u %d, v %d", dst_y_offset, dst_u_offset, dst_v_offset);
+
+ for (i = 0 ; i < height ; i++) {
+ for (j = 0 ; j < loop_length ; j += 2) {
+ if (i % 2 == 0) {
+ if (j % 4 == 0) {
+ dst_data[dst_u_offset++] = src[src_offset++]; /*U*/
+ } else {
+ dst_data[dst_v_offset++] = src[src_offset++]; /*V*/
+ }
+ } else {
+ src_offset++;
+ }
+
+ dst_data[dst_y_offset++] = src[src_offset++]; /*Y*/
+ }
+ }
+
+ *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);
+
+ return TRUE;
+}
+
+
+static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len)
+{
+ int i = 0;
+ int src_offset = 0;
+ int dst_y_offset = 0;
+ int dst_u_offset = 0;
+ int dst_v_offset = 0;
+ int loop_length = 0;
+ unsigned int dst_size = 0;
+ unsigned char *dst_data = NULL;
+
+ if (!src || !dst || !dst_len) {
+ _mmcam_dbg_err("NULL pointer %p, %p, %p", src, dst, dst_len);
+ return FALSE;
+ }
+
+ dst_size = (width * height * 3) >> 1;
+
+ _mmcam_dbg_log("NV12 -> I420 : %dx%d, dst size %d", width, height, dst_size);
+
+ dst_data = (unsigned char *)malloc(dst_size);
+ if (!dst_data) {
+ _mmcam_dbg_err("failed to alloc dst_data. size %d", dst_size);
+ return FALSE;
+ }
+
+ loop_length = width << 1;
+ dst_u_offset = width * height;
+ dst_v_offset = dst_u_offset + (dst_u_offset >> 2);
+
+ _mmcam_dbg_log("offset y %d, u %d, v %d", dst_y_offset, dst_u_offset, dst_v_offset);
+
+ /* memcpy Y */
+ memcpy(dst_data, src, dst_u_offset);
+
+ loop_length = dst_u_offset >> 1;
+ src_offset = dst_u_offset;
+
+ /* set U and V */
+ for (i = 0 ; i < loop_length ; i++) {
+ if (i % 2 == 0) {
+ dst_data[dst_u_offset++] = src[src_offset++];
+ } 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);
+
+ return TRUE;
+}
+
static GstPadProbeReturn __mmcamcorder_audioque_dataprobe(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
static GstPadProbeReturn __mmcamcorder_video_dataprobe_audio_disable(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
static GstPadProbeReturn __mmcamcorder_audio_dataprobe_audio_mute(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
-static gboolean __mmcamcorder_add_locationinfo(MMHandleType handle, int fileformat);
-static gboolean __mmcamcorder_add_locationinfo_mp4(MMHandleType handle);
+static gboolean __mmcamcorder_add_metadata(MMHandleType handle, int fileformat);
+static gboolean __mmcamcorder_add_metadata_mp4(MMHandleType handle);
static GstPadProbeReturn __mmcamcorder_eventprobe_monitor(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
/*=======================================================================================
sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst) {
GstFlowReturn ret = 0;
GstClock *pipe_clock = NULL;
- GstPad *capsfilter_pad = NULL;
if(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst) {
if(sc->info_video->is_firstframe) {
GST_BUFFER_PTS(buffer) = GST_BUFFER_PTS (buffer) - sc->info_video->base_video_ts;
- capsfilter_pad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_FILT].gst, "src");
-// gst_buffer_set_caps(buffer, gst_pad_get_current_caps(capsfilter_pad));
- gst_object_unref(capsfilter_pad);
- capsfilter_pad = NULL;
-
ret = gst_app_src_push_buffer((GstAppSrc *)sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst, buffer);
if (ret != GST_FLOW_OK &&
ret != GST_FLOW_FLUSHING) {
int ret_free_space = 0;
char *dir_name = NULL;
guint64 free_space = 0;
+ guint64 free_space_exceptsystem = 0;
int file_system_type = 0;
/* Recording */
dir_name = g_path_get_dirname(temp_filename);
if (dir_name) {
ret_free_space = _mmcamcorder_get_freespace(dir_name, &free_space);
+ if(_mmcamcorder_check_file_path(dir_name)) {
+ if (_mmcamcorder_get_freespace_except_system(&free_space_exceptsystem) == MM_ERROR_NONE) {
+ hcamcorder->system_memory = free_space - free_space_exceptsystem;
+ free_space = free_space - hcamcorder->system_memory;
+ } else {
+ hcamcorder->system_memory = 0;
+ }
+ }
- _mmcam_dbg_warn("current space - %s [%" G_GUINT64_FORMAT "]", dir_name, free_space);
+ _mmcam_dbg_warn("current space - %s [%" G_GUINT64_FORMAT "], system [%" G_GUINT64_FORMAT "]",
+ dir_name, free_space, hcamcorder->system_memory);
if (_mmcamcorder_get_file_system_type(dir_name, &file_system_type) == 0) {
/* MSDOS_SUPER_MAGIC : 0x4d44 */
/* start video stream */
if (info->record_dual_stream) {
- GstCameraControl *control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
- if (control) {
+ CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (CameraControl) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "stop-video", TRUE);
#ifdef LATEST_CAMERA_CONTROL
_mmcam_dbg_log("GST_CAMERA_CONTROL_RECORD_COMMAND_START");
- gst_camera_control_set_record_command(control, GST_CAMERA_CONTROL_RECORD_COMMAND_START);
+ gst_camera_control_set_record_command(CameraControl, GST_CAMERA_CONTROL_RECORD_COMMAND_START);
#endif /* LATEST_CAMERA_CONTROL */
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "stop-video", FALSE);
} else {
info->filesize = 0;
sc->ferror_send = FALSE;
sc->ferror_count = 0;
- sc->error_occurs = FALSE;
+ hcamcorder->error_occurs = FALSE;
sc->bget_eos = FALSE;
ret = _mmcamcorder_gst_set_state(handle, sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst, GST_STATE_PLAYING);
if (ret != MM_ERROR_NONE) {
/* stop video stream */
if (info->record_dual_stream) {
- GstCameraControl *control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
- if (control) {
+ CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (CameraControl) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "stop-video", TRUE);
#ifdef LATEST_CAMERA_CONTROL
_mmcam_dbg_log("GST_CAMERA_CONTROL_RECORD_COMMAND_STOP");
- gst_camera_control_set_record_command(control, GST_CAMERA_CONTROL_RECORD_COMMAND_STOP);
+ gst_camera_control_set_record_command(CameraControl, GST_CAMERA_CONTROL_RECORD_COMMAND_STOP);
#endif /* LATEST_CAMERA_CONTROL */
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "stop-video", FALSE);
} else {
/* stop video stream */
if (info->record_dual_stream) {
- GstCameraControl *control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
- if (control) {
+ CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (CameraControl) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "stop-video", TRUE);
#ifdef LATEST_CAMERA_CONTROL
_mmcam_dbg_log("GST_CAMERA_CONTROL_RECORD_COMMAND_STOP");
- gst_camera_control_set_record_command(control, GST_CAMERA_CONTROL_RECORD_COMMAND_STOP);
+ gst_camera_control_set_record_command(CameraControl, GST_CAMERA_CONTROL_RECORD_COMMAND_STOP);
#endif /* LATEST_CAMERA_CONTROL */
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "stop-video", FALSE);
} else {
/* reset restart_preview for inset window layout */
info->restart_preview = FALSE;
- ret = _mmcamcorder_set_camera_resolution(handle, info->preview_width, info->preview_height);
- if (ret != MM_ERROR_NONE) {
+ if (!_mmcamcorder_set_camera_resolution(handle, info->preview_width, info->preview_height)) {
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
goto _ERR_CAMCORDER_VIDEO_COMMAND;
}
sc->display_interval = 0;
sc->previous_slot_time = 0;
+ /* init system memory size */
+ hcamcorder->system_memory = 0;
+
/* Wait EOS */
_mmcam_dbg_log("Start to wait EOS");
ret =_mmcamcorder_get_eos_message(handle);
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
mm_camcorder_get_attributes(handle, NULL,
- MMCAM_TAG_ENABLE, &enabletag,
+ MMCAM_RECORDER_TAG_ENABLE, &enabletag,
NULL);
ret = _mmcamcorder_remove_recorder_pipeline((MMHandleType)hcamcorder);
}
if (enabletag && !(sc->ferror_send)) {
- ret = __mmcamcorder_add_locationinfo((MMHandleType)hcamcorder, info->fileformat);
+ ret = __mmcamcorder_add_metadata((MMHandleType)hcamcorder, info->fileformat);
if (ret) {
_mmcam_dbg_log("Writing location information SUCCEEDED !!");
} else {
sc->pause_time = 0;
sc->isMaxsizePausing = FALSE; /*In async function, this variable should set in callback function. */
sc->isMaxtimePausing = FALSE;
- sc->error_occurs = FALSE;
+ hcamcorder->error_occurs = FALSE;
info->video_frame_count = 0;
info->audio_frame_count = 0;
filename = videoinfo->filename;
ret = _mmcamcorder_get_freespace(filename, &free_space);
+ if(_mmcamcorder_check_file_path(filename) && hcamcorder->system_memory) {
+ free_space = free_space - hcamcorder->system_memory;
+ }
+
/*_mmcam_dbg_log("check free space for recording");*/
switch (ret) {
int err = MM_ERROR_UNKNOWN;
char *err_name = NULL;
GstBuffer *buffer = GST_PAD_PROBE_INFO_BUFFER(info);
- GstMapInfo mapinfo = GST_MAP_INFO_INIT;
+ GstMapInfo mapinfo;
mmf_return_val_if_fail(buffer, GST_PAD_PROBE_DROP);
mmf_return_val_if_fail(hcamcorder, GST_PAD_PROBE_DROP);
SAFE_FREE(err_name);
return err;
}
+
+ memset(&mapinfo, 0x0, sizeof(GstMapInfo));
+
gst_buffer_map(buffer, &mapinfo, GST_MAP_READWRITE);
/* Set audio stream NULL */
}
-static gboolean __mmcamcorder_add_locationinfo(MMHandleType handle, int fileformat)
+static gboolean __mmcamcorder_add_metadata(MMHandleType handle, int fileformat)
{
gboolean bret = FALSE;
switch (fileformat) {
case MM_FILE_FORMAT_3GP:
case MM_FILE_FORMAT_MP4:
- bret = __mmcamcorder_add_locationinfo_mp4(handle);
+ bret = __mmcamcorder_add_metadata_mp4(handle);
break;
default:
_mmcam_dbg_warn("Unsupported fileformat to insert location info (%d)", fileformat);
}
-static gboolean __mmcamcorder_add_locationinfo_mp4(MMHandleType handle)
+static gboolean __mmcamcorder_add_metadata_mp4(MMHandleType handle)
{
FILE *f = NULL;
guchar buf[4];
int gps_enable = 0;
char *err_name = NULL;
char err_msg[MAX_ERROR_MESSAGE_LEN] = {'\0',};
- _MMCamcorderLocationInfo location_info = {0,};
+ _MMCamcorderLocationInfo location_info = {0,0,0};
+ _MMCamcorderLocationInfo geo_info = {0,0,0};
_MMCamcorderVideoInfo *info = NULL;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
location_info.longitude = _mmcamcorder_double_to_fix(longitude);
location_info.latitude = _mmcamcorder_double_to_fix(latitude);
location_info.altitude = _mmcamcorder_double_to_fix(altitude);
-
+ geo_info.longitude = longitude *10000;
+ geo_info.latitude = latitude *10000;
+ geo_info.altitude = altitude *10000;
/* find udta container.
if, there are udta container, write loci box after that
else, make udta container and write loci box. */
- if (_mmcamcorder_find_tag(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");
if (gps_enable) {
if (!_mmcamcorder_write_loci(f, location_info)) {
+ _mmcam_dbg_err("failed to write loci");
+ goto fail;
+ }
+
+ if (!_mmcamcorder_write_geodata(f, geo_info)) {
+ _mmcam_dbg_err("failed to write geodata");
goto fail;
}
}
goto fail;
}
- if (!_mmcamcorder_write_udta(f, location_info)) {
+ if (!_mmcamcorder_write_udta(f, gps_enable, location_info, geo_info)) {
+ _mmcam_dbg_err("failed to write udta");
goto fail;
}
}
}
/* add orientation info */
- fseek(f, internal_pos, SEEK_SET);
+ if (fseek(f, internal_pos, SEEK_SET) < 0) {
+ _mmcam_dbg_err("fseek failed : errno %d", errno);
+ goto fail;
+ }
+
if (!_mmcamcorder_find_tag(f, MMCAM_FOURCC('t','r','a','k'), FALSE)) {
_mmcam_dbg_err("failed to find [trak] tag");
goto fail;
"ROI mode",
};
+const char *capture_sound[] = {
+ "Default",
+ "Extra 01",
+ "Extra 02",
+};
+
const char *rotate_mode[] = {
"0",
"90",
void *dst = NULL;
nret = _mmcamcorder_encode_jpeg(main->data, main->width, main->height, main->format,
- main->length, 90, &dst, &dst_size, 0);
+ main->length, 90, &dst, &dst_size);
if (nret) {
_file_write(m_filename, dst, dst_size);
} else {
err = mm_camcorder_get_attribute_info(hcamcorder->camcorder, attr_name, &info);
if (err != MM_ERROR_NONE) {
- err_msg_t("camcordertest_get_attr_valid_intarray : Error(%x)!!", err);
+ err_msg_t("camcordertest_get_attr_valid_intrange : Error(%x)!!", err);
return FALSE;
} else {
if (info.type == MM_CAM_ATTRS_TYPE_INT) {
}
}
- err_msg_t("camcordertest_get_attr_valid_intarray : Type mismatched!!");
+ err_msg_t("camcordertest_get_attr_valid_intrange : Type mismatched!!");
return FALSE;
}
//success
}
- debug_msg_t("camcordertest_get_attr_valid_intarray(!hcamcorder->camcorde)");
+ debug_msg_t("camcordertest_get_attr_valid_intrange(!hcamcorder->camcorde)");
}
- debug_msg_t("camcordertest_get_attr_valid_intarray(!hcamcorder)");
+ debug_msg_t("camcordertest_get_attr_valid_intrange(!hcamcorder)");
return FALSE;
}
g_print("*Recording start!\n");
video_stream_cb_cnt = 0;
audio_stream_cb_cnt = 0;
+ hcamcorder->elapsed_time = 0;
g_timer_reset(timer);
err = mm_camcorder_record(hcamcorder->camcorder);
switch(buf) {
case '1' : // Start Recording
g_print("*Recording start!\n");
+ hcamcorder->elapsed_time = 0;
g_timer_reset(timer);
err = mm_camcorder_record(hcamcorder->camcorder);
case 'r' : // Setting > Rotate camera input when recording
g_print("*Rotate camera input\n");
- camcordertest_get_attr_valid_intrange(MMCAM_CAMERA_ROTATION, &min, &max);
+ camcordertest_get_attr_valid_intarray(MMCAM_CAMERA_ROTATION, &array, &count);
- if(min >= max) {
+ if(count <= 0) {
g_print("Not supported !! \n");
} else {
flush_stdin();
- for (i = min ; i <= max ; i++) {
- g_print("\t %d. %s\n", i, camera_rotation[i]);
+ for ( i = 0; i < count; i++) {
+ g_print("\t %d. %s\n", array[i], camera_rotation[array[i]]);
}
err = scanf("%d",&idx);
CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
MMCAM_DISPLAY_SURFACE, MM_DISPLAY_SURFACE_X,
MMCAM_DISPLAY_GEOMETRY_METHOD, MM_DISPLAY_METHOD_LETTER_BOX,
MMCAM_CAPTURE_COUNT, IMAGE_CAPTURE_COUNT_STILL,
+ MMCAM_TAG_GPS_ENABLE, TRUE,
"tag-gps-time-stamp", 72815.5436243543,
"tag-gps-date-stamp", "2010:09:20", 10,
"tag-gps-processing-method", "GPS NETWORK HYBRID ARE ALL FINE.", 32,
g_print("\t Enter the media type:\n\t");
err = scanf("%c", &media_type);
+ if (err == EOF) {
+ g_print("\t!!!read input error!!!\n");
+ continue;
+ }
switch (media_type) {
case '1':
projects / platform / core / multimedia / libmm-camcorder.git / commitdiff