Name: libmm-camcorder
Summary: Camera and recorder library
-Version: 0.10.134
+Version: 0.10.135
Release: 0
Group: Multimedia/Libraries
License: Apache-2.0
$(DLOG_LIBS) \
$(STORAGE_LIBS)
-libmmfcamcorder_la_CFLAGS += -DMMF_LOG_OWNER=0x010 -D_FILE_OFFSET_BITS=64
+libmmfcamcorder_la_CFLAGS += -D_FILE_OFFSET_BITS=64
libmmfcamcorder_la_CFLAGS += -fdata-sections -ffunction-sections -Wl,--gc-sections
libmmfcamcorder_la_LDFLAGS = -Wl,--gc-sections
libmmfcamcorder_la_LIBADD += $(SYSTEMINFO_LIBS)
| MACRO DEFINITIONS |
========================================================================================*/
#define SAFE_FREE(x) \
+do { \
if (x) {\
free(x); \
x = NULL; \
- }
+ } \
+} while (0)
#define SAFE_G_FREE(x) \
+do { \
if (x) {\
g_free(x); \
x = NULL; \
- }
+ } \
+} while (0)
#define CONFIGURE_MAIN_FILE "mmfw_camcorder.ini"
_mmcam_dbg_log("Adding buffer probe on [%s:%s] - [ID : %lu], [Category : %x] ", \
GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); \
} \
-} while (0);
+} while (0)
#define MMCAMCORDER_ADD_EVENT_PROBE(x_pad, x_category, x_callback, x_hcamcorder) \
do { \
_mmcam_dbg_log("Adding event probe on [%s:%s] - [ID : %lu], [Category : %x] ", \
GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); \
} \
-} while (0);
+} while (0)
#define MMCAMCORDER_SIGNAL_CONNECT(x_object, x_category, x_signal, x_callback, x_hcamcorder) \
do { \
_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);
+} while (0)
#define MMCAMCORDER_G_OBJECT_GET(obj, name, value) \
do { \
} else { \
_mmcam_dbg_err("Null object"); \
} \
-} while (0);
+} while (0)
#define MMCAMCORDER_G_OBJECT_SET(obj, name, value) \
do { \
} else { \
_mmcam_dbg_err("Null object"); \
} \
-} while (0);
+} while (0)
#define MMCAMCORDER_G_OBJECT_SET_POINTER(obj, name, value) \
do { \
} else { \
_mmcam_dbg_err("Null object"); \
} \
-} while (0);
+} while (0)
#define MMCAM_FOURCC(a, b, c, d) (guint32)((a)|(b)<<8|(c)<<16|(d)<<24)
#define MMCAM_FOURCC_ARGS(fourcc) \
((gchar)(((fourcc)>>24)&0xff))
#define MMCAM_SEND_MESSAGE(handle, msg_id, msg_code) \
-{\
+do {\
_MMCamcorderMsgItem msg;\
msg.id = msg_id;\
msg.param.code = msg_code;\
_mmcam_dbg_log("msg id : %x, code : %x", msg_id, msg_code);\
_mmcamcorder_send_message((MMHandleType)handle, &msg);\
-}
+} while (0)
/*=======================================================================================
va_list var_args;
int ret = MM_ERROR_NONE;
- return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
+ mmf_return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
va_start(var_args, attribute_name);
ret = _mmcamcorder_get_attributes(camcorder, err_attr_name, attribute_name, var_args);
va_list var_args;
int ret = MM_ERROR_NONE;
- return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
+ mmf_return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
va_start(var_args, attribute_name);
ret = _mmcamcorder_set_attributes(camcorder, err_attr_name, attribute_name, var_args);
}
}
- if (item == NULL) {
- _mmcam_dbg_warn("failed to find tilt control channel");
- }
+ _mmcam_dbg_warn("failed to find tilt control channel");
}
return FALSE;
}
}
- if (item == NULL) {
- _mmcam_dbg_warn("failed to find pan control channel");
- }
+ _mmcam_dbg_warn("failed to find pan control channel");
}
return FALSE;
}
}
- if (item == NULL) {
- _mmcam_dbg_warn("failed to find tilt control channel");
- }
+ _mmcam_dbg_warn("failed to find tilt control channel");
}
return FALSE;
if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_AUDIO_COMMAND;
- if (info->bMuxing) {
+ if (info->bMuxing)
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
- } else {
+ else
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", FALSE);
- }
_mmcamcorder_gst_set_state(handle, sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, GST_STATE_NULL);
_mmcamcorder_send_message(handle, &msg);
- if (info->bMuxing) {
+ if (info->bMuxing)
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
- } else {
+ else
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", FALSE);
- }
_mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_NULL);
_mmcam_dbg_warn("Free Space : [%" G_GUINT64_FORMAT "], file size : [%" G_GUINT64_FORMAT "]",
free_space, audioinfo->filesize);
- if (audioinfo->bMuxing) {
+ if (audioinfo->bMuxing)
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
- } else {
+ else
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", TRUE);
- }
sc->isMaxsizePausing = TRUE;
msg.id = MM_MESSAGE_CAMCORDER_NO_FREE_SPACE;
audioinfo->max_size, audioinfo->filesize, trailer_size);
/* just same as pause status. After blocking two queue, this function will not call again. */
- if (audioinfo->bMuxing) {
+ if (audioinfo->bMuxing)
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
- } else {
+ else
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", TRUE);
- }
msg.id = MM_MESSAGE_CAMCORDER_RECORDING_STATUS;
msg.param.recording_status.elapsed = (unsigned long long)rec_pipe_time;
_mmcam_dbg_warn("Current time : [%" G_GUINT64_FORMAT "], Maximum time : [%" G_GUINT64_FORMAT "]", \
rec_pipe_time, audioinfo->max_time);
- if (audioinfo->bMuxing) {
+ if (audioinfo->bMuxing)
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
- } else {
+ else
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", TRUE);
- }
sc->isMaxtimePausing = TRUE;
msg.id = MM_MESSAGE_CAMCORDER_TIME_LIMIT;
size_t BUFFER_LENGTH_STRING = 256;
const char* delimiters = " |=,\t\n";
+ int i = 0;
int ret = MM_ERROR_NONE;
int category = 0;
int count_main_category = 0;
read_main = 0;
- /* Comment */
if (*buffer_token[0] == ';') {
+ /* Comment */
/*_mmcam_dbg_log( "Comment - Nothing to do" );*/
- }
- /* Main Category */
- else if (*buffer_token[0] == '[') {
+ } else if (*buffer_token[0] == '[') {
+ /* Main Category */
category_name = get_new_string(buffer_token[0]);
if (category_name == NULL) {
_mmcam_dbg_err("strdup failed for [%s]", buffer_token[0]);
/* Details */
if (type == CONFIGURE_TYPE_MAIN) {
- if (!strcmp("[General]", category_name)) {
+ if (!strcmp("[General]", category_name))
category = CONFIGURE_CATEGORY_MAIN_GENERAL;
- } else if (!strcmp("[VideoInput]", category_name)) {
+ else if (!strcmp("[VideoInput]", category_name))
category = CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT;
- } else if (!strcmp("[AudioInput]", category_name)) {
+ else if (!strcmp("[AudioInput]", category_name))
category = CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT;
- } else if (!strcmp("[VideoOutput]", category_name)) {
+ else if (!strcmp("[VideoOutput]", category_name))
category = CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT;
- } else if (!strcmp("[Capture]", category_name)) {
+ else if (!strcmp("[Capture]", category_name))
category = CONFIGURE_CATEGORY_MAIN_CAPTURE;
- } else if (!strcmp("[Record]", category_name)) {
+ else if (!strcmp("[Record]", category_name))
category = CONFIGURE_CATEGORY_MAIN_RECORD;
- } else if (!strcmp("[VideoEncoder]", category_name)) {
+ else if (!strcmp("[VideoEncoder]", category_name))
category = CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER;
- } else if (!strcmp("[AudioEncoder]", category_name)) {
+ else if (!strcmp("[AudioEncoder]", category_name))
category = CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER;
- } else if (!strcmp("[ImageEncoder]", category_name)) {
+ else if (!strcmp("[ImageEncoder]", category_name))
category = CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER;
- } else if (!strcmp("[Mux]", category_name)) {
+ else if (!strcmp("[Mux]", category_name))
category = CONFIGURE_CATEGORY_MAIN_MUX;
- }
} else {
- if (!strcmp("[Camera]", category_name)) {
+ if (!strcmp("[Camera]", category_name))
category = CONFIGURE_CATEGORY_CTRL_CAMERA;
- } else if (!strcmp("[Strobe]", category_name)) {
+ else if (!strcmp("[Strobe]", category_name))
category = CONFIGURE_CATEGORY_CTRL_STROBE;
- } else if (!strcmp("[Effect]", category_name)) {
+ else if (!strcmp("[Effect]", category_name))
category = CONFIGURE_CATEGORY_CTRL_EFFECT;
- } else if (!strcmp("[Photograph]", category_name)) {
+ else if (!strcmp("[Photograph]", category_name))
category = CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH;
- } else if (!strcmp("[Capture]", category_name)) {
+ else if (!strcmp("[Capture]", category_name))
category = CONFIGURE_CATEGORY_CTRL_CAPTURE;
- } else if (!strcmp("[Detect]", category_name)) {
+ else if (!strcmp("[Detect]", category_name))
category = CONFIGURE_CATEGORY_CTRL_DETECT;
- }
}
if (category != -1) {
}
/* Free memory */
- {
- int i;
-
- for (i = 0 ; i < count_details ; i++) {
- SAFE_G_FREE(buffer_details[i]);
- }
- }
+ for (i = 0 ; i < count_details ; i++)
+ SAFE_G_FREE(buffer_details[i]);
}
SAFE_G_FREE(category_name);
SAFE_G_FREE(temp_string_array->name);
if (temp_string_array->value) {
count = temp_string_array->count;
- for (k = 0 ; k < count ; k++) {
+
+ for (k = 0 ; k < count ; k++)
SAFE_G_FREE(temp_string_array->value[k]);
- }
SAFE_G_FREE(temp_string_array->value);
}
return MM_AUDIO_CODEC_INVALID;
}
- if (!strcmp(name, "AMR")) {
+ if (!strcmp(name, "AMR"))
codec_index = MM_AUDIO_CODEC_AMR;
- } else if (!strcmp(name, "G723_1")) {
+ else if (!strcmp(name, "G723_1"))
codec_index = MM_AUDIO_CODEC_G723_1;
- } else if (!strcmp(name, "MP3")) {
+ else if (!strcmp(name, "MP3"))
codec_index = MM_AUDIO_CODEC_MP3;
- } else if (!strcmp(name, "AAC")) {
+ else if (!strcmp(name, "AAC"))
codec_index = MM_AUDIO_CODEC_AAC;
- } else if (!strcmp(name, "MMF")) {
+ else if (!strcmp(name, "MMF"))
codec_index = MM_AUDIO_CODEC_MMF;
- } else if (!strcmp(name, "ADPCM")) {
+ else if (!strcmp(name, "ADPCM"))
codec_index = MM_AUDIO_CODEC_ADPCM;
- } else if (!strcmp(name, "WAVE")) {
+ else if (!strcmp(name, "WAVE"))
codec_index = MM_AUDIO_CODEC_WAVE;
- } else if (!strcmp(name, "MIDI")) {
+ else if (!strcmp(name, "MIDI"))
codec_index = MM_AUDIO_CODEC_MIDI;
- } else if (!strcmp(name, "IMELODY")) {
+ else if (!strcmp(name, "IMELODY"))
codec_index = MM_AUDIO_CODEC_IMELODY;
- } else if (!strcmp(name, "VORBIS")) {
+ else if (!strcmp(name, "VORBIS"))
codec_index = MM_AUDIO_CODEC_VORBIS;
- }
/*_mmcam_dbg_log("audio codec index %d", codec_index);*/
return MM_VIDEO_CODEC_INVALID;
}
- if (!strcmp(name, "H263")) {
+ if (!strcmp(name, "H263"))
codec_index = MM_VIDEO_CODEC_H263;
- } else if (!strcmp(name, "H264")) {
+ else if (!strcmp(name, "H264"))
codec_index = MM_VIDEO_CODEC_H264;
- } else if (!strcmp(name, "H26L")) {
+ else if (!strcmp(name, "H26L"))
codec_index = MM_VIDEO_CODEC_H26L;
- } else if (!strcmp(name, "MPEG4")) {
+ else if (!strcmp(name, "MPEG4"))
codec_index = MM_VIDEO_CODEC_MPEG4;
- } else if (!strcmp(name, "MPEG1")) {
+ else if (!strcmp(name, "MPEG1"))
codec_index = MM_VIDEO_CODEC_MPEG1;
- } else if (!strcmp(name, "THEORA")) {
+ else if (!strcmp(name, "THEORA"))
codec_index = MM_VIDEO_CODEC_THEORA;
- }
/*_mmcam_dbg_log("video codec index %d", codec_index);*/
return MM_IMAGE_CODEC_INVALID;
}
- if (!strcmp(name, "JPEG")) {
+ if (!strcmp(name, "JPEG"))
codec_index = MM_IMAGE_CODEC_JPEG;
- } else if (!strcmp(name, "PNG")) {
+ else if (!strcmp(name, "PNG"))
codec_index = MM_IMAGE_CODEC_PNG;
- } else if (!strcmp(name, "BMP")) {
+ else if (!strcmp(name, "BMP"))
codec_index = MM_IMAGE_CODEC_BMP;
- } else if (!strcmp(name, "WBMP")) {
+ else if (!strcmp(name, "WBMP"))
codec_index = MM_IMAGE_CODEC_WBMP;
- } else if (!strcmp(name, "TIFF")) {
+ else if (!strcmp(name, "TIFF"))
codec_index = MM_IMAGE_CODEC_TIFF;
- } else if (!strcmp(name, "PCX")) {
+ else if (!strcmp(name, "PCX"))
codec_index = MM_IMAGE_CODEC_PCX;
- } else if (!strcmp(name, "GIF")) {
+ else if (!strcmp(name, "GIF"))
codec_index = MM_IMAGE_CODEC_GIF;
- } else if (!strcmp(name, "ICO")) {
+ else if (!strcmp(name, "ICO"))
codec_index = MM_IMAGE_CODEC_ICO;
- } else if (!strcmp(name, "RAS")) {
+ else if (!strcmp(name, "RAS"))
codec_index = MM_IMAGE_CODEC_RAS;
- } else if (!strcmp(name, "TGA")) {
+ else if (!strcmp(name, "TGA"))
codec_index = MM_IMAGE_CODEC_TGA;
- } else if (!strcmp(name, "XBM")) {
+ else if (!strcmp(name, "XBM"))
codec_index = MM_IMAGE_CODEC_XBM;
- } else if (!strcmp(name, "XPM")) {
+ else if (!strcmp(name, "XPM"))
codec_index = MM_IMAGE_CODEC_XPM;
- }
_mmcam_dbg_log("image codec index %d", codec_index);
return MM_FILE_FORMAT_INVALID;
}
- if (!strcmp(name, "3GP")) {
+ if (!strcmp(name, "3GP"))
mux_index = MM_FILE_FORMAT_3GP;
- } else if (!strcmp(name, "AMR")) {
+ else if (!strcmp(name, "AMR"))
mux_index = MM_FILE_FORMAT_AMR;
- } else if (!strcmp(name, "MP4")) {
+ else if (!strcmp(name, "MP4"))
mux_index = MM_FILE_FORMAT_MP4;
- } else if (!strcmp(name, "AAC")) {
+ else if (!strcmp(name, "AAC"))
mux_index = MM_FILE_FORMAT_AAC;
- } else if (!strcmp(name, "MP3")) {
+ else if (!strcmp(name, "MP3"))
mux_index = MM_FILE_FORMAT_MP3;
- } else if (!strcmp(name, "OGG")) {
+ else if (!strcmp(name, "OGG"))
mux_index = MM_FILE_FORMAT_OGG;
- } else if (!strcmp(name, "WAV")) {
+ else if (!strcmp(name, "WAV"))
mux_index = MM_FILE_FORMAT_WAV;
- } else if (!strcmp(name, "AVI")) {
+ else if (!strcmp(name, "AVI"))
mux_index = MM_FILE_FORMAT_AVI;
- } else if (!strcmp(name, "WMA")) {
+ else if (!strcmp(name, "WMA"))
mux_index = MM_FILE_FORMAT_WMA;
- } else if (!strcmp(name, "WMV")) {
+ else if (!strcmp(name, "WMV"))
mux_index = MM_FILE_FORMAT_WMV;
- } else if (!strcmp(name, "MID")) {
+ else if (!strcmp(name, "MID"))
mux_index = MM_FILE_FORMAT_MID;
- } else if (!strcmp(name, "MMF")) {
+ else if (!strcmp(name, "MMF"))
mux_index = MM_FILE_FORMAT_MMF;
- } else if (!strcmp(name, "MATROSKA")) {
+ else if (!strcmp(name, "MATROSKA"))
mux_index = MM_FILE_FORMAT_MATROSKA;
- } else if (!strcmp(name, "M2TS")) {
+ else if (!strcmp(name, "M2TS"))
mux_index = MM_FILE_FORMAT_M2TS;
- }
/*_mmcam_dbg_log("mux index %d", mux_index);*/
}
}
- if (item == NULL) {
- _mmcam_dbg_warn("failed to find \"bitrate\" control channel");
- }
+ _mmcam_dbg_warn("failed to find \"bitrate\" control channel");
}
return FALSE;
/* get model name */
sys_info_ret = system_info_get_platform_string("http://tizen.org/system/model_name", &hcamcorder->model_name);
- if (hcamcorder->model_name) {
- _mmcam_dbg_log("model name [%s], sys_info_ret 0x%x", hcamcorder->model_name, sys_info_ret);
- } else {
- _mmcam_dbg_warn("failed get model name, sys_info_ret 0x%x", sys_info_ret);
- }
+
+ _mmcam_dbg_warn("model name [%s], ret 0x%x",
+ hcamcorder->model_name ? hcamcorder->model_name : "NULL", sys_info_ret);
/* get software version */
sys_info_ret = system_info_get_platform_string("http://tizen.org/system/build.string", &hcamcorder->software_version);
- if (hcamcorder->software_version) {
- _mmcam_dbg_log("software version [%s], sys_info_ret 0x%d", hcamcorder->software_version, sys_info_ret);
- } else {
- _mmcam_dbg_warn("failed get software version, sys_info_ret 0x%x", sys_info_ret);
- }
+
+ _mmcam_dbg_warn("software version [%s], ret 0x%x",
+ hcamcorder->software_version ? hcamcorder->software_version : "NULL", sys_info_ret);
#ifdef _MMCAMCORDER_MURPHY_SUPPORT
if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
/* create resource set */
ret = _mmcamcorder_resource_create_resource_set(&hcamcorder->resource_manager);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
- }
hcamcorder->resource_manager.acquire_count = 0;
_ERR_CAMCORDER_CMD:
#ifdef _MMCAMCORDER_MURPHY_SUPPORT
/* release hw resources */
- if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) {
- int ret_resource = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
- if (ret_resource == MM_ERROR_RESOURCE_INVALID_STATE) {
- _mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource");
- } else if (ret_resource != MM_ERROR_NONE) {
- _mmcam_dbg_err("failed to release resource, ret_resource(0x%x)", ret_resource);
- }
- }
+ if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE)
+ _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
#ifdef _MMCAMCORDER_RM_SUPPORT
if (hcamcorder->rm_handle) {
{
_mmcam_dbg_warn("Stop preview.");
- while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
+ while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE))
_mmcam_dbg_warn("Can't stop preview.(%x)", result);
- }
break;
}
{
_mmcam_dbg_warn("unrealize");
- if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE) {
+ if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE)
_mmcam_dbg_warn("Can't unrealize.(%x)", result);
- }
break;
}
gchar *msg_src_element = NULL;
_MMCamcorderSubContext *sc = NULL;
- return_val_if_fail(hcamcorder, FALSE);
- return_val_if_fail(error, FALSE);
+ mmf_return_val_if_fail(hcamcorder, FALSE);
+ mmf_return_val_if_fail(error, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc, FALSE);
static gint __mmcamcorder_gst_handle_library_error(MMHandleType handle, int code, GstMessage *message)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
_mmcam_dbg_log("");
gchar *debug = NULL;
GError *err = NULL;
- return_val_if_fail(hcamcorder, FALSE);
- return_val_if_fail(error, FALSE);
+ mmf_return_val_if_fail(hcamcorder, FALSE);
+ mmf_return_val_if_fail(error, FALSE);
_mmcam_dbg_log("");
mmf_return_val_if_fail((MMHandleType)hcamcorder, RM_CB_RESULT_OK);
current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
- if (current_state <= MM_CAMCORDER_STATE_NONE || current_state >= MM_CAMCORDER_STATE_NUM) {
- _mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state);
- }
+
+ _mmcam_dbg_warn("current state %d (handle %p)", current_state, hcamcorder);
_MMCAMCORDER_LOCK_ASM(hcamcorder);
if (hcamcorder->caminfo_convert[i].type == CONFIGURE_TYPE_CTRL) {
switch (hcamcorder->caminfo_convert[i].category) {
case CONFIGURE_CATEGORY_CTRL_STROBE:
- if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "StrobeMode")) {
+ if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "StrobeMode"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]);
- }
break;
case CONFIGURE_CATEGORY_CTRL_EFFECT:
- if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WhiteBalance")) {
+ if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WhiteBalance"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]);
- } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ColorTone")) {
+ else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ColorTone"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]);
- } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WDR")) {
+ else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WDR"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_WDR]);
- } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "Flip")) {
+ else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "Flip"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]);
- } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "Rotation")) {
+ else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "Rotation"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]);
- }
break;
case CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH:
- if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "FocusMode")) {
+ if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "FocusMode"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]);
- } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AFType")) {
+ else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AFType"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]);
- } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AEType")) {
+ else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AEType"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]);
- } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ISO")) {
+ else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ISO"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ISO]);
- } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ProgramMode")) {
+ else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ProgramMode"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]);
- } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AntiHandshake")) {
+ else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AntiHandshake"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]);
- } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "VideoStabilization")) {
+ else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "VideoStabilization"))
hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]);
- }
break;
default:
break;
for (i = 0; i < MM_CAMCORDER_RESOURCE_MAX; i++) {
res = mrp_res_get_resource_by_name(rs, mm_camcorder_resource_str[i]);
- if (res == NULL) {
- _mmcam_dbg_warn(" -- %s not present in resource set", mm_camcorder_resource_str[i]);
+ if (res) {
+ _mmcam_dbg_warn(" -- resource name [%s] -> [%s]",
+ res->name, __mmcamcorder_resource_state_to_str(res->state));
} else {
- _mmcam_dbg_warn(" -- resource name [%s] -> [%s]", res->name, __mmcamcorder_resource_state_to_str(res->state));
+ _mmcam_dbg_warn(" -- %s not present in resource set", mm_camcorder_resource_str[i]);
}
}
| GLOBAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
#define EXIF_SET_ERR(return_type, tag_id) \
+do { \
_mmcam_dbg_err("error=%x,tag=%x", return_type, tag_id); \
if (return_type == (int)MM_ERROR_CAMCORDER_LOW_MEMORY) { \
goto exit; \
- }
+ } \
+} while (0)
/*---------------------------------------------------------------------------------------
| LOCAL VARIABLE DEFINITIONS for internal |
if (attr) {
if (_mmcamcorder_check_supported_attribute(handle, MM_CAM_CAMERA_FOCUS_MODE)) {
mmf_attribute_set_modified(&(attr->items[MM_CAM_CAMERA_FOCUS_MODE]));
- if (mmf_attrs_commit((MMHandleType)attr) == -1) {
- _mmcam_dbg_err("set focus mode error");
- } else {
- _mmcam_dbg_log("set focus mode success");
- }
+ mmf_attrs_commit((MMHandleType)attr);
} else {
_mmcam_dbg_log("focus mode is not supported");
}
/* Set strobe mode - strobe mode can not be set to driver while captuing */
if (attr) {
mmf_attribute_set_modified(&(attr->items[MM_CAM_STROBE_MODE]));
- if (mmf_attrs_commit((MMHandleType) attr) == -1) {
+ if (mmf_attrs_commit((MMHandleType) attr) == -1)
_mmcam_dbg_warn("Failed to set strobe mode");
- }
}
while (current_framecount >= sc->kpi.video_framecount &&
}
_mmcam_dbg_log("Wait Frame Done. count before[%d],after[%d], try_count[%d]",
- current_framecount, sc->kpi.video_framecount, try_count);
+ current_framecount, sc->kpi.video_framecount, try_count);
} else {
ret = _mmcamcorder_remove_stillshot_pipeline(handle);
if (ret != MM_ERROR_NONE)
_mmcam_dbg_log("");
if (!original || original->data == NULL || original->length == 0) {
- if (!original) {
- _mmcam_dbg_log("original is null");
+ if (original) {
+ _mmcam_dbg_err("data=%p, length=%d",
+ original->data, original->length);
} else {
- _mmcam_dbg_log("data=%p, length=%d", original->data, original->length);
+ _mmcam_dbg_err("original is null");
}
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
if (send_captured_message) {
if (info->hdr_capture_mode != MM_CAMCORDER_HDR_ON_AND_ORIGINAL) {
/* Send CAPTURED message and count - capture success */
- if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
+ if (current_state >= MM_CAMCORDER_STATE_RECORDING)
MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_VIDEO_SNAPSHOT_CAPTURED, count);
- } else {
+ else
MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_CAPTURED, count);
- }
} else if (info->hdr_capture_mode == MM_CAMCORDER_HDR_ON_AND_ORIGINAL && count == 2) {
/* send captured message only once in HDR and Original Capture mode */
MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_CAPTURED, 1);
if (hcamcorder->software_version) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_SOFTWARE, EXIF_FORMAT_ASCII,
strlen(hcamcorder->software_version)+1, (const char *)hcamcorder->software_version);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("set software_version[%s] failed", hcamcorder->software_version);
- } else {
- _mmcam_dbg_log("set software_version[%s] done", hcamcorder->software_version);
- }
+
+ _mmcam_dbg_log("set software_version[%s] ret[0x%x]",
+ hcamcorder->software_version, ret);
} else {
_mmcam_dbg_err("model_name is NULL");
}
if (hcamcorder->model_name) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_MODEL, EXIF_FORMAT_ASCII,
strlen(hcamcorder->model_name)+1, (const char *)hcamcorder->model_name);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("set model name[%s] failed", hcamcorder->model_name);
- } else {
- _mmcam_dbg_log("set model name[%s] done", hcamcorder->model_name);
- }
+
+ _mmcam_dbg_err("set model name[%s] ret[0x%x]",
+ hcamcorder->model_name, ret);
} else {
_mmcam_dbg_err("model_name is NULL");
}
if (latitude < 0) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE_REF,
EXIF_FORMAT_ASCII, 2, "S");
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_LATITUDE_REF);
- }
latitude = -latitude;
} else if (latitude > 0) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE_REF,
EXIF_FORMAT_ASCII, 2, "N");
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_LATITUDE_REF);
- }
}
deg = (unsigned int)(latitude);
if (longitude < 0) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE_REF,
EXIF_FORMAT_ASCII, 2, "W");
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_LONGITUDE_REF);
- }
longitude = -longitude;
} else if (longitude > 0) {
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE_REF,
EXIF_FORMAT_ASCII, 2, "E");
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_LONGITUDE_REF);
- }
}
deg = (unsigned int)(longitude);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_GPS, EXIF_TAG_GPS_PROCESSING_METHOD,
EXIF_FORMAT_UNDEFINED, processing_method_len, (const char *)processing_method);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GPS_PROCESSING_METHOD);
- }
}
}
} else {
__mmcamcorder_update_exif_orientation(handle, ed);
__mmcamcorder_update_exif_gps(handle, ed);
ret = mm_exif_set_exif_to_info(hcamcorder->exif_info, ed);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
_mmcam_dbg_err("mm_exif_set_exif_to_info err!! [%x]", ret);
- }
exif_data_unref(ed);
ed = NULL;
exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_LENGTH,
EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_IMAGE_LENGTH);
- }
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_Y_DIMENSION,
EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_PIXEL_Y_DIMENSION);
- }
_mmcam_dbg_log("height[%d]", value);
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.colorspace);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_COLOR_SPACE,
EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_COLOR_SPACE);
- }
}
/*10. EXIF_TAG_COMPONENTS_CONFIGURATION */
_mmcam_dbg_log("EXIF_TAG_COMPONENTS_CONFIGURATION [%4x] ", config);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_COMPONENTS_CONFIGURATION,
EXIF_FORMAT_UNDEFINED, 4, (const char *)&config);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_COMPONENTS_CONFIGURATION);
- }
}
/*11. EXIF_TAG_COMPRESSED_BITS_PER_PIXEL */
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_TIME,
EXIF_FORMAT_RATIONAL, 1, (const char *)b);
free(b);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_TIME);
- }
} else {
_mmcam_dbg_warn("malloc failed.");
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FNUMBER,
EXIF_FORMAT_RATIONAL, 1, (const char *)b);
free(b);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_FNUMBER);
- }
} else {
_mmcam_dbg_warn("malloc failed.");
}
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.iso);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS,
EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_ISO_SPEED_RATINGS);
- }
}
/*18. EXIF_TAG_SHUTTER_SPEED_VALUE*/
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SHUTTER_SPEED_VALUE,
EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
free(b);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_SHUTTER_SPEED_VALUE);
- }
} else {
_mmcam_dbg_warn("malloc failed.");
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_APERTURE_VALUE,
EXIF_FORMAT_RATIONAL, 1, (const char *)b);
free(b);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_APERTURE_VALUE);
- }
} else {
_mmcam_dbg_warn("malloc failed.");
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_BRIGHTNESS_VALUE,
EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
free(b);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_BRIGHTNESS_VALUE);
- }
} else {
_mmcam_dbg_warn("malloc failed.");
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_BIAS_VALUE,
EXIF_FORMAT_SRATIONAL, 1, (const char *)b);
free(b);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_EXPOSURE_BIAS_VALUE);
- }
} else {
_mmcam_dbg_warn("malloc failed.");
}
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_MAX_APERTURE_VALUE,
EXIF_FORMAT_RATIONAL, 1, b);
free(b);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_MAX_APERTURE_VALUE);
- }
} else {
_mmcam_dbg_warn("failed to alloc for MAX aperture value");
}
_mmcam_dbg_log("EXIF_TAG_METERING_MODE [%d]", avsys_exif_info.metering_mode);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_METERING_MODE,
EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_METERING_MODE);
- }
}
/*25. EXIF_TAG_LIGHT_SOURCE*/
_mmcam_dbg_log("EXIF_TAG_FLASH [%d]", avsys_exif_info.flash);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FLASH,
EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_FLASH);
- }
}
/*27. EXIF_TAG_FOCAL_LENGTH*/
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH,
EXIF_FORMAT_RATIONAL, 1, (const char *)b);
free(b);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_FOCAL_LENGTH);
- }
} else {
_mmcam_dbg_warn("malloc failed.");
}
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SENSING_METHOD,
EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_SENSING_METHOD);
- }
/*29. EXIF_TAG_FILE_SOURCE*/
/*
exif_set_long(&elong[cntl], exif_data_get_byte_order(ed),value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FILE_SOURCE,
EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_FILE_SOURCE);
- }
*/
/*30. EXIF_TAG_SCENE_TYPE*/
exif_set_long(&elong[cntl], exif_data_get_byte_order(ed),value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SCENE_TYPE,
EXIF_FORMAT_UNDEFINED, 4, (const char *)&elong[cntl++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_SCENE_TYPE);
- }
*/
/*31. EXIF_TAG_EXPOSURE_MODE*/
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), set_value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_WHITE_BALANCE,
EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_WHITE_BALANCE);
- }
} else {
_mmcam_dbg_warn("failed to get white balance [%x]", ret);
}
exif_set_long(&elong[cntl], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_DIGITAL_ZOOM_RATIO,
EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_DIGITAL_ZOOM_RATIO);
- }
} else {
_mmcam_dbg_warn("failed to get digital zoom [%x]", ret);
}
exif_set_short(&eshort[cnts], exif_data_get_byte_order(ed),value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM,
EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM);
- }
*/
/*35. EXIF_TAG_SCENE_CAPTURE_TYPE*/
if (ret == MM_ERROR_NONE) {
_mmcam_dbg_log("Scene mode(program mode) [%d]", value);
- if (value == MM_CAMCORDER_SCENE_MODE_NORMAL) {
+ switch (value) {
+ case MM_CAMCORDER_SCENE_MODE_NORMAL:
scene_capture_type = 0; /* standard */
- } else if (value == MM_CAMCORDER_SCENE_MODE_PORTRAIT) {
+ break;
+ case MM_CAMCORDER_SCENE_MODE_PORTRAIT:
scene_capture_type = 2; /* portrait */
- } else if (value == MM_CAMCORDER_SCENE_MODE_LANDSCAPE) {
+ break;
+ case MM_CAMCORDER_SCENE_MODE_LANDSCAPE:
scene_capture_type = 1; /* landscape */
- } else if (value == MM_CAMCORDER_SCENE_MODE_NIGHT_SCENE) {
+ break;
+ case MM_CAMCORDER_SCENE_MODE_NIGHT_SCENE:
scene_capture_type = 3; /* night scene */
- } else {
+ break;
+ default:
scene_capture_type = 4; /* Others */
+ break;
}
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), scene_capture_type);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SCENE_CAPTURE_TYPE,
EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_SCENE_CAPTURE_TYPE);
- }
} else {
_mmcam_dbg_warn("failed to get scene mode [%x]", ret);
}
exif_set_long(&elong[cntl], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_GAIN_CONTROL,
EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_GAIN_CONTROL);
- }
*/
_mmcam_dbg_log("CONTRAST currentt [%d], default [%d]", value, irange->default_value);
- if (value == irange->default_value) {
+ if (value == irange->default_value)
level = MM_VALUE_NORMAL;
- } else if (value < irange->default_value) {
+ else if (value < irange->default_value)
level = MM_VALUE_LOW;
- } else {
+ else
level = MM_VALUE_HARD;
- }
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), level);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_CONTRAST,
EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_CONTRAST);
- }
} else {
_mmcam_dbg_warn("failed to get range of contrast");
}
_mmcam_dbg_log("SATURATION current [%d], default [%d]", value, irange->default_value);
- if (value == irange->default_value) {
+ if (value == irange->default_value)
level = MM_VALUE_NORMAL;
- } else if (value < irange->default_value) {
+ else if (value < irange->default_value)
level = MM_VALUE_LOW;
- } else {
+ else
level = MM_VALUE_HARD;
- }
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), level);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SATURATION,
EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_SATURATION);
- }
} else {
_mmcam_dbg_warn("failed to get range of saturation");
}
_mmcam_dbg_log("SHARPNESS current [%d], default [%d]", value, irange->default_value);
- if (value == irange->default_value) {
+ if (value == irange->default_value)
level = MM_VALUE_NORMAL;
- } else if (value < irange->default_value) {
+ else if (value < irange->default_value)
level = MM_VALUE_LOW;
- } else {
+ else
level = MM_VALUE_HARD;
- }
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), level);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SHARPNESS,
EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_SHARPNESS);
- }
} else {
_mmcam_dbg_warn("failed to get range of sharpness");
}
exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_SUBJECT_DISTANCE_RANGE,
EXIF_FORMAT_SHORT, 1, (const char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
EXIF_SET_ERR(ret, EXIF_TAG_SUBJECT_DISTANCE_RANGE);
- }
/* GPS information */
__mmcamcorder_update_exif_gps(handle, ed);
/* remove item from msg data */
if (hcamcorder->msg_data) {
+ /*_mmcam_dbg_log("remove item %p", item);*/
hcamcorder->msg_data = g_list_remove(hcamcorder->msg_data, item);
} else {
_mmcam_dbg_warn("msg_data is NULL but item[%p] will be removed", item);
if (hcamcorder->capture_in_recording) {
gint64 end_time = g_get_monotonic_time() + (200 * G_TIME_SPAN_MILLISECOND);
- if (_MMCAMCORDER_CMD_WAIT_UNTIL(handle, end_time)) {
- _mmcam_dbg_warn("signal received");
- } else {
+ if (!_MMCAMCORDER_CMD_WAIT_UNTIL(handle, end_time))
_mmcam_dbg_warn("timeout");
- }
} else {
usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
}
if (enabletag && !(sc->ferror_send)) {
ret = __mmcamcorder_add_metadata((MMHandleType)hcamcorder, info->fileformat);
- if (ret) {
- _mmcam_dbg_log("Writing location information SUCCEEDED !!");
- } else {
- _mmcam_dbg_err("Writing location information FAILED !!");
- }
+ _mmcam_dbg_log("Writing location information [%s] !!", ret ? "SUCCEEDED" : "FAILED");
}
/* Check file size */
}
/* get trailer size */
- if (videoinfo->fileformat == MM_FILE_FORMAT_3GP || videoinfo->fileformat == MM_FILE_FORMAT_MP4) {
+ if (videoinfo->fileformat == MM_FILE_FORMAT_3GP || videoinfo->fileformat == MM_FILE_FORMAT_MP4)
MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst, "expected-trailer-size", &trailer_size);
- } else {
+ else
trailer_size = 0;
- }
/* check max size of recorded file */
max_size = videoinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE;
}
/* get trailer size */
- if (videoinfo->fileformat == MM_FILE_FORMAT_3GP || videoinfo->fileformat == MM_FILE_FORMAT_MP4) {
+ if (videoinfo->fileformat == MM_FILE_FORMAT_3GP || videoinfo->fileformat == MM_FILE_FORMAT_MP4)
MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst, "expected-trailer-size", &trailer_size);
- } else {
+ else
trailer_size = 0;
- }
/* check free space */
ret = _mmcamcorder_get_freespace(hcamcorder->storage_info.type, &free_space);
}
/* get queued buffer size */
- if (sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst) {
+ if (sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst)
MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst, "current-level-bytes", &aq_size);
- }
- if (sc->encode_element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst) {
+ if (sc->encode_element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst)
MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst, "current-level-bytes", &vq_size);
- }
queued_buffer = aq_size + vq_size;
rec_pipe_time = GST_TIME_AS_MSECONDS(b_time);
- if (videoinfo->fileformat == MM_FILE_FORMAT_3GP || videoinfo->fileformat == MM_FILE_FORMAT_MP4) {
+ if (videoinfo->fileformat == MM_FILE_FORMAT_3GP || videoinfo->fileformat == MM_FILE_FORMAT_MP4)
MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst, "expected-trailer-size", &trailer_size);
- } else {
+ else
trailer_size = 0;
- }
/* check max time */
if (videoinfo->max_time > 0 && rec_pipe_time > videoinfo->max_time) {
rec_pipe_time = GST_TIME_AS_MSECONDS(GST_BUFFER_PTS(buffer));
- if (videoinfo->fileformat == MM_FILE_FORMAT_3GP || videoinfo->fileformat == MM_FILE_FORMAT_MP4) {
+ if (videoinfo->fileformat == MM_FILE_FORMAT_3GP || videoinfo->fileformat == MM_FILE_FORMAT_MP4)
MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst, "expected-trailer-size", &trailer_size);
- } else {
+ else
trailer_size = 0;
- }
/* calculate remained time can be recorded */
if (videoinfo->max_time > 0 && videoinfo->max_time < (remained_time + rec_pipe_time)) {
projects / platform / core / multimedia / libmm-camcorder.git / commitdiff