MM_CAM_RECOMMEND_DISPLAY_ROTATION,
MM_CAM_SUPPORT_ZSL_CAPTURE,
MM_CAM_SUPPORT_ZERO_COPY_FORMAT,
- MM_CAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB
+ MM_CAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB,
+ MM_CAM_PLATFORM_PRIVILEGE_CAMERA,
+ MM_CAM_LOG_LEVEL
};
/*-----------------------------------------------------------------------
MMHandleType
_mmcamcorder_alloc_attribute(MMHandleType handle)
{
- _mmcam_dbg_log("");
+ MMCAM_LOG_INFO("");
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
MMHandleType attrs = NULL;
};
if (hcamcorder == NULL) {
- _mmcam_dbg_err("handle is NULL");
+ MMCAM_LOG_ERROR("handle is NULL");
return 0;
}
/* Create attribute constructor */
- _mmcam_dbg_log("start");
+ MMCAM_LOG_INFO("start");
/* alloc 'MMAttrsConstructInfo' */
attr_count = MM_CAM_ATTRIBUTE_NUM;
attrs_const_info = malloc(attr_count * sizeof(MMAttrsConstructInfo));
if (!attrs_const_info) {
- _mmcam_dbg_err("Fail to alloc constructor.");
+ MMCAM_LOG_ERROR("Fail to alloc constructor.");
return 0;
}
/* alloc default attribute info */
hcamcorder->cam_attrs_const_info = (mm_cam_attr_construct_info *)malloc(sizeof(mm_cam_attr_construct_info) * attr_count);
if (hcamcorder->cam_attrs_const_info == NULL) {
- _mmcam_dbg_err("failed to alloc default attribute info");
+ MMCAM_LOG_ERROR("failed to alloc default attribute info");
free(attrs_const_info);
attrs_const_info = NULL;
return 0;
{0},
{0},
NULL,
+ },
+ {
+ MM_CAM_PLATFORM_PRIVILEGE_CAMERA,
+ "platform-privilege-camera",
+ MM_ATTRS_TYPE_STRING,
+ MM_ATTRS_FLAG_RW,
+ {NULL},
+ MM_ATTRS_VALID_TYPE_NONE,
+ {0},
+ {0},
+ NULL,
+ },
+ {
+ MM_CAM_LOG_LEVEL,
+ "log-level",
+ MM_ATTRS_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)MM_CAMCORDER_LOG_LEVEL_INFO},
+ MM_ATTRS_VALID_TYPE_INT_RANGE,
+ {.int_min = MM_CAMCORDER_LOG_LEVEL_CRITICAL},
+ {.int_max = MM_CAMCORDER_LOG_LEVEL_VERBOSE},
+ NULL,
}
};
for (idx = 0 ; idx < attr_count ; idx++) {
/* attribute order check. This should be same. */
if (idx != hcamcorder->cam_attrs_const_info[idx].attrid) {
- _mmcam_dbg_err("Please check attributes order. Is the idx same with enum val?");
+ MMCAM_LOG_ERROR("Please check attributes order. Is the idx same with enum val?");
free(attrs_const_info);
attrs_const_info = NULL;
free(hcamcorder->cam_attrs_const_info);
}
/* Camcorder Attributes */
- _mmcam_dbg_log("Create Camcorder Attributes[%p, %d]", attrs_const_info, attr_count);
+ MMCAM_LOG_INFO("Create Camcorder Attributes[%p, %d]", attrs_const_info, attr_count);
ret = mm_attrs_new(attrs_const_info,
attr_count,
attrs_const_info = NULL;
if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("Fail to alloc attribute handle");
+ MMCAM_LOG_ERROR("Fail to alloc attribute handle");
free(hcamcorder->cam_attrs_const_info);
hcamcorder->cam_attrs_const_info = NULL;
return 0;
for (idx = 0; idx < attr_count; idx++) {
mm_cam_attr_construct_info *attr_info = &hcamcorder->cam_attrs_const_info[idx];
-/*
- _mmcam_dbg_log("Valid type [%s:%d, %d, %d]",
- attr_info->name, attr_info->validity_type,
- attr_info->validity_value1, attr_info->validity_value2);
-*/
mm_attrs_set_valid_type(attrs, idx, attr_info->validity_type);
switch (attr_info->validity_type) {
break;
case MM_ATTRS_VALID_TYPE_INVALID:
default:
- _mmcam_dbg_err("Valid type error.");
+ MMCAM_LOG_ERROR("Valid type error.");
break;
}
}
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
if (hcamcorder == NULL) {
- _mmcam_dbg_err("handle is NULL");
+ MMCAM_LOG_ERROR("handle is NULL");
return;
}
- _mmcam_dbg_log("");
+ MMCAM_LOG_INFO("");
if (attrs) {
mm_attrs_free(attrs);
- _mmcam_dbg_log("released attribute");
+ MMCAM_LOG_INFO("released attribute");
}
if (hcamcorder->cam_attrs_const_info) {
free(hcamcorder->cam_attrs_const_info);
hcamcorder->cam_attrs_const_info = NULL;
- _mmcam_dbg_log("released attribute info");
+ MMCAM_LOG_INFO("released attribute info");
}
return;
mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
if (!_MMCAMCORDER_TRYLOCK_CMD(handle)) {
- _mmcam_dbg_err("Another command is running.");
+ MMCAM_LOG_ERROR("Another command is running.");
return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
}
if (attrs) {
ret = __mmcamcorder_check_valid_pair(handle, &tmp_err_attr_name, attribute_name, var_args);
} else {
- _mmcam_dbg_err("handle %p, attrs is NULL, attr name [%s]", handle, attribute_name);
+ MMCAM_LOG_ERROR("handle %p, attrs is NULL, attr name [%s]", handle, attribute_name);
ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
}
if (ret == MM_ERROR_COMMON_OUT_OF_RANGE) {
if (mm_attrs_get_index(attrs, tmp_err_attr_name, &err_index) == MM_ERROR_NONE &&
_mmcamcorder_check_supported_attribute(handle, err_index)) {
- _mmcam_dbg_err("[%s] is supported, but value is invalid",
+ MMCAM_LOG_ERROR("[%s] is supported, but value is invalid",
tmp_err_attr_name ? tmp_err_attr_name : "NULL");
ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
}
if (hcamcorder->error_code != MM_ERROR_NONE) {
- _mmcam_dbg_err("error_code is set. ret 0x%x -> modified 0x%x", ret, hcamcorder->error_code);
+ MMCAM_LOG_ERROR("error_code is set. ret 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);
+ MMCAM_LOG_ERROR("failed error code 0x%x - handle %p", ret, (mmf_camcorder_t *)handle);
}
if (tmp_err_attr_name) {
if (!err_attr_name) {
- _mmcam_dbg_err("set attribute[%s] error, but err name is NULL", tmp_err_attr_name);
+ MMCAM_LOG_ERROR("set attribute[%s] error, but err name is NULL", tmp_err_attr_name);
free(tmp_err_attr_name);
tmp_err_attr_name = NULL;
} else {
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
if (hcamcorder == NULL) {
- _mmcam_dbg_err("handle is NULL");
+ MMCAM_LOG_ERROR("handle is NULL");
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
if (hcamcorder == NULL) {
- _mmcam_dbg_err("handle is NULL");
+ MMCAM_LOG_ERROR("handle is NULL");
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
- _mmcam_dbg_log("START");
+ MMCAM_LOG_INFO("START");
/* Audio encoder info */
allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_1.int_array);
if (allocated_memory) {
- free(allocated_memory);
+ g_free(allocated_memory);
hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_1.int_array = NULL;
hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_2.count = 0;
}
/* Video encoder info */
allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_1.int_array);
if (allocated_memory) {
- free(allocated_memory);
+ g_free(allocated_memory);
hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_1.int_array = NULL;
hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_2.count = 0;
}
/* Image encoder info */
allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_1.int_array);
if (allocated_memory) {
- free(allocated_memory);
+ g_free(allocated_memory);
hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_1.int_array = NULL;
hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_2.count = 0;
}
/* File format info */
allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_1.int_array);
if (allocated_memory) {
- free(allocated_memory);
+ g_free(allocated_memory);
hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_1.int_array = NULL;
hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_2.count = 0;
}
- _mmcam_dbg_log("DONE");
+ MMCAM_LOG_INFO("DONE");
return MM_ERROR_NONE;
}
attr = MMF_CAMCORDER_ATTRS(handle);
mmf_return_val_if_fail(attr, FALSE);
- /*_mmcam_dbg_log("(%d)", attr_idx);*/
+ /*MMCAM_LOG_INFO("(%d)", attr_idx);*/
current_state = _mmcamcorder_get_state(handle);
if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
return TRUE;
} else {
- _mmcam_dbg_log("Capture resolution can't be set.(state=%d)", current_state);
+ MMCAM_LOG_INFO("Capture resolution can't be set.(state=%d)", current_state);
return FALSE;
}
}
return __mmcamcorder_set_capture_resolution(handle, capture_width, capture_height);
} else {
- _mmcam_dbg_log("Capture resolution can't be set.(state=%d)", current_state);
+ MMCAM_LOG_INFO("Capture resolution can't be set.(state=%d)", current_state);
return FALSE;
}
info = sc->info_image;
if (!info) {
- _mmcam_dbg_err("info image is NULL");
+ MMCAM_LOG_ERROR("info image is NULL");
return FALSE;
}
if (ivalue && current_state == MM_CAMCORDER_STATE_CAPTURING) {
if (info->capture_send_count > 0) {
info->capturing = FALSE;
- _mmcam_dbg_warn("capturing -> FALSE and skip capture callback since now");
+ MMCAM_LOG_WARNING("capturing -> FALSE and skip capture callback since now");
}
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_warn("Can't cast Video source into camera control.");
+ MMCAM_LOG_WARNING("Can't cast Video source into camera control.");
return TRUE;
}
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);
+ MMCAM_LOG_WARNING("Commit Break continuous shot : Set command OK. current state[%d]", current_state);
} else {
- _mmcam_dbg_warn("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_WARNING("cast CAMERA_CONTROL failed");
}
} else {
- _mmcam_dbg_warn("Commit Break continuous shot : No effect. value[%d],current state[%d]", ivalue, current_state);
+ MMCAM_LOG_WARNING("Commit Break continuous shot : No effect. value[%d],current state[%d]", ivalue, current_state);
}
return TRUE;
current_state = _mmcamcorder_get_state(handle);
mm_camcorder_get_attributes(handle, NULL, MMCAM_MODE, &mode, NULL);
- _mmcam_dbg_log("current state %d, mode %d, set count %d",
+ MMCAM_LOG_INFO("current state %d, mode %d, set count %d",
current_state, mode, value->value.i_val);
if (mode != MM_CAMCORDER_MODE_AUDIO &&
current_state != MM_CAMCORDER_STATE_CAPTURING) {
return TRUE;
} else {
- _mmcam_dbg_err("Invalid mode[%d] or state[%d]", mode, current_state);
+ MMCAM_LOG_ERROR("Invalid mode[%d] or state[%d]", mode, current_state);
return FALSE;
}
}
mmf_return_val_if_fail(hcamcorder && value, FALSE);
- _mmcam_dbg_log("shutter sound policy: %d", hcamcorder->shutter_sound_policy);
+ MMCAM_LOG_INFO("shutter sound policy: %d", hcamcorder->shutter_sound_policy);
/* return error when disable shutter sound if policy is TRUE */
if (!value->value.i_val &&
hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON) {
- _mmcam_dbg_err("not permitted DISABLE SHUTTER SOUND");
+ MMCAM_LOG_ERROR("not permitted DISABLE SHUTTER SOUND");
return FALSE;
} else {
- _mmcam_dbg_log("set value [%d] success", value->value.i_val);
+ MMCAM_LOG_INFO("set value [%d] success", value->value.i_val);
return TRUE;
}
}
}
}
- _mmcam_dbg_log("Commit : volume(%f)", mslNewVal);
+ MMCAM_LOG_INFO("Commit : volume(%f)", mslNewVal);
bret = TRUE;
} else {
- _mmcam_dbg_log("Commit : nothing to commit. status(%d)", current_state);
+ MMCAM_LOG_INFO("Commit : nothing to commit. status(%d)", current_state);
bret = TRUE;
}
current_state = _mmcamcorder_get_state(handle);
if (current_state > MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_err("invalid state %d", current_state);
+ MMCAM_LOG_ERROR("invalid state %d", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
current_state = _mmcamcorder_get_state(handle);
if (current_state > MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_err("invalid state %d", current_state);
+ MMCAM_LOG_ERROR("invalid state %d", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
if (attr_idx == MM_CAM_CAMERA_FPS_AUTO)
return TRUE;
- _mmcam_dbg_log("FPS(%d)", value->value.i_val);
+ MMCAM_LOG_INFO("FPS(%d)", value->value.i_val);
ret = mm_camcorder_get_attributes(handle, NULL,
MMCAM_CAMERA_WIDTH, &resolution_width,
NULL);
if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("FAILED : coult not get resolution values.");
+ MMCAM_LOG_ERROR("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.");
+ MMCAM_LOG_ERROR("FAILED : coult not get FPS values by resolution.");
return FALSE;
}
return TRUE;
}
- _mmcam_dbg_err("FAILED : %d is not supported FPS", value->value.i_val);
+ MMCAM_LOG_ERROR("FAILED : %d is not supported FPS", value->value.i_val);
return FALSE;
}
current_state = _mmcamcorder_get_state(handle);
if (current_state > MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_warn("invalid state %d", current_state);
+ MMCAM_LOG_WARNING("invalid state %d", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
else
sc->is_modified_rate = FALSE;
- _mmcam_dbg_log("Set slow motion rate %lf", value->value.d_val);
+ MMCAM_LOG_INFO("Set slow motion rate %lf", value->value.d_val);
return TRUE;
} else {
- _mmcam_dbg_warn("Failed to set recording motion rate %lf", value->value.d_val);
+ MMCAM_LOG_WARNING("Failed to set recording motion rate %lf", value->value.d_val);
return FALSE;
}
}
attr = MMF_CAMCORDER_ATTRS(handle);
mmf_return_val_if_fail(attr, FALSE);
- _mmcam_dbg_log("Width(%d)", value->value.i_val);
+ MMCAM_LOG_INFO("Width(%d)", value->value.i_val);
current_state = _mmcamcorder_get_state(handle);
if (current_state > MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state);
+ MMCAM_LOG_INFO("Resolution can't be changed.(state=%d)", current_state);
return FALSE;
} else {
int flags = MM_ATTRS_FLAG_NONE;
if (current_state == MM_CAMCORDER_STATE_PREPARE) {
if (hcamcorder->resolution_changed == FALSE) {
- _mmcam_dbg_log("no need to restart preview");
+ MMCAM_LOG_INFO("no need to restart preview");
return TRUE;
}
hcamcorder->resolution_changed = FALSE;
if (g_mutex_trylock(&hcamcorder->restart_preview_lock)) {
- _mmcam_dbg_log("restart preview");
+ MMCAM_LOG_INFO("restart preview");
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
- _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
+ if (!_mmcamcorder_is_encoded_preview_pixel_format(preview_format))
+ _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
/* check decoder recreation */
if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) {
- _mmcam_dbg_err("_mmcamcorder_recreate_decoder_for_encoded_preview failed");
+ MMCAM_LOG_ERROR("_mmcamcorder_recreate_decoder_for_encoded_preview failed");
g_mutex_unlock(&hcamcorder->restart_preview_lock);
return FALSE;
}
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
- _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
+ if (!_mmcamcorder_is_encoded_preview_pixel_format(preview_format))
+ _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
/* unlock */
g_mutex_unlock(&hcamcorder->restart_preview_lock);
} else {
- _mmcam_dbg_err("currently locked for preview restart");
+ MMCAM_LOG_ERROR("currently locked for preview restart");
return FALSE;
}
} else {
attr = MMF_CAMCORDER_ATTRS(hcamcorder);
mmf_return_val_if_fail(attr, FALSE);
- _mmcam_dbg_log("Height(%d)", value->value.i_val);
+ MMCAM_LOG_INFO("Height(%d)", value->value.i_val);
current_state = _mmcamcorder_get_state(handle);
if (current_state > MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state);
+ MMCAM_LOG_INFO("Resolution can't be changed.(state=%d)", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
} else {
if (current_state == MM_CAMCORDER_STATE_PREPARE) {
if (hcamcorder->resolution_changed == FALSE) {
- _mmcam_dbg_log("no need to restart preview");
+ MMCAM_LOG_INFO("no need to restart preview");
return TRUE;
}
hcamcorder->resolution_changed = FALSE;
if (g_mutex_trylock(&hcamcorder->restart_preview_lock)) {
- _mmcam_dbg_log("restart preview");
+ MMCAM_LOG_INFO("restart preview");
- _mmcam_dbg_log("set empty buffers");
+ MMCAM_LOG_INFO("set empty buffers");
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
- _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
+ if (!_mmcamcorder_is_encoded_preview_pixel_format(preview_format))
+ _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
/* check decoder recreation */
if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) {
- _mmcam_dbg_err("_mmcamcorder_recreate_decoder_for_encoded_preview failed");
+ MMCAM_LOG_ERROR("_mmcamcorder_recreate_decoder_for_encoded_preview failed");
g_mutex_unlock(&hcamcorder->restart_preview_lock);
return FALSE;
}
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
- _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
+ if (!_mmcamcorder_is_encoded_preview_pixel_format(preview_format))
+ _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
/* unlock */
g_mutex_unlock(&hcamcorder->restart_preview_lock);
} else {
- _mmcam_dbg_err("currently locked for preview restart");
+ MMCAM_LOG_ERROR("currently locked for preview restart");
return FALSE;
}
} else {
current_state = _mmcamcorder_get_state(handle);
if (current_state > MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_err("Video Resolution can't be changed.(state=%d)", current_state);
+ MMCAM_LOG_ERROR("Video Resolution can't be changed.(state=%d)", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
} else {
- _mmcam_dbg_warn("Video Resolution %d [attr_idx %d] ",
+ MMCAM_LOG_WARNING("Video Resolution %d [attr_idx %d] ",
value->value.i_val, attr_idx);
return TRUE;
}
zoom_level = value->value.i_val;
- _mmcam_dbg_log("(%d)", attr_idx);
+ MMCAM_LOG_INFO("(%d)", attr_idx);
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("will be applied when preview starts");
+ MMCAM_LOG_INFO("will be applied when preview starts");
return TRUE;
} else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("Can not set while CAPTURING");
+ MMCAM_LOG_ERROR("Can not set while CAPTURING");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
int ret = FALSE;
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_log("Can't cast Video source into camera control.");
+ MMCAM_LOG_INFO("Can't cast Video source into camera control.");
return TRUE;
}
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
- _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_ERROR("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);
+ MMCAM_LOG_INFO("Succeed in operating Zoom[%d].", zoom_level);
return TRUE;
} else {
- _mmcam_dbg_warn("Failed to operate Zoom. Type[%d],Level[%d]", zoom_type, zoom_level);
+ MMCAM_LOG_WARNING("Failed to operate Zoom. Type[%d],Level[%d]", zoom_type, zoom_level);
}
} else {
- _mmcam_dbg_log("pointer of video src is null");
+ MMCAM_LOG_INFO("pointer of video src is null");
}
return FALSE;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc, TRUE);
- _mmcam_dbg_log("ptz type : %d", value->value.i_val);
+ MMCAM_LOG_INFO("ptz type : %d", value->value.i_val);
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_PREPARE ||
current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("invalid state[%d]", current_state);
+ MMCAM_LOG_ERROR("invalid state[%d]", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_log("Can't cast Video source into camera control.");
+ MMCAM_LOG_INFO("Can't cast Video source into camera control.");
return FALSE;
}
CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (CameraControl == NULL) {
- _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_ERROR("cast CAMERA_CONTROL failed");
return FALSE;
}
controls = gst_camera_control_list_channels(CameraControl);
if (controls == NULL) {
- _mmcam_dbg_err("gst_camera_control_list_channels failed");
+ MMCAM_LOG_ERROR("gst_camera_control_list_channels failed");
return FALSE;
}
for (item = controls ; item && item->data ; item = item->next) {
CameraControlChannel = item->data;
- _mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label);
- if (!strcmp(CameraControlChannel->label, "ptz")) {
+ MMCAM_LOG_INFO("CameraControlChannel->label %s", CameraControlChannel->label);
+ if (!strcmp(CameraControlChannel->label, "ptz_type")) {
if (gst_camera_control_set_value(CameraControl, CameraControlChannel, value->value.i_val)) {
- _mmcam_dbg_warn("set ptz type %d done", value->value.i_val);
+ MMCAM_LOG_WARNING("set ptz type %d done", value->value.i_val);
return TRUE;
} else {
- _mmcam_dbg_err("failed to set ptz type %d", value->value.i_val);
+ MMCAM_LOG_ERROR("failed to set ptz type %d", value->value.i_val);
return FALSE;
}
}
}
- _mmcam_dbg_warn("failed to find tilt control channel");
+ MMCAM_LOG_WARNING("failed to find ptz type control channel");
}
return FALSE;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc, TRUE);
- _mmcam_dbg_log("pan : %d", value->value.i_val);
+ MMCAM_LOG_INFO("pan : %d", value->value.i_val);
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_PREPARE ||
current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("invalid state[%d]", current_state);
+ MMCAM_LOG_ERROR("invalid state[%d]", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_log("Can't cast Video source into camera control.");
+ MMCAM_LOG_INFO("Can't cast Video source into camera control.");
return FALSE;
}
CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (CameraControl == NULL) {
- _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_ERROR("cast CAMERA_CONTROL failed");
return FALSE;
}
controls = gst_camera_control_list_channels(CameraControl);
if (controls == NULL) {
- _mmcam_dbg_err("gst_camera_control_list_channels failed");
+ MMCAM_LOG_ERROR("gst_camera_control_list_channels failed");
return FALSE;
}
for (item = controls ; item && item->data ; item = item->next) {
CameraControlChannel = item->data;
- _mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label);
+ MMCAM_LOG_INFO("CameraControlChannel->label %s", CameraControlChannel->label);
if (!strcmp(CameraControlChannel->label, "pan")) {
if (gst_camera_control_set_value(CameraControl, CameraControlChannel, value->value.i_val)) {
- _mmcam_dbg_warn("set pan %d done", value->value.i_val);
+ MMCAM_LOG_WARNING("set pan %d done", value->value.i_val);
return TRUE;
} else {
- _mmcam_dbg_err("failed to set pan %d", value->value.i_val);
+ MMCAM_LOG_ERROR("failed to set pan %d", value->value.i_val);
return FALSE;
}
}
}
- _mmcam_dbg_warn("failed to find pan control channel");
+ MMCAM_LOG_WARNING("failed to find pan control channel");
}
return FALSE;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc, TRUE);
- _mmcam_dbg_log("tilt : %d", value->value.i_val);
+ MMCAM_LOG_INFO("tilt : %d", value->value.i_val);
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_PREPARE ||
current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("invalid state[%d]", current_state);
+ MMCAM_LOG_ERROR("invalid state[%d]", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_log("Can't cast Video source into camera control.");
+ MMCAM_LOG_INFO("Can't cast Video source into camera control.");
return FALSE;
}
CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (CameraControl == NULL) {
- _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_ERROR("cast CAMERA_CONTROL failed");
return FALSE;
}
controls = gst_camera_control_list_channels(CameraControl);
if (controls == NULL) {
- _mmcam_dbg_err("gst_camera_control_list_channels failed");
+ MMCAM_LOG_ERROR("gst_camera_control_list_channels failed");
return FALSE;
}
for (item = controls ; item && item->data ; item = item->next) {
CameraControlChannel = item->data;
- _mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label);
+ MMCAM_LOG_INFO("CameraControlChannel->label %s", CameraControlChannel->label);
if (!strcmp(CameraControlChannel->label, "tilt")) {
if (gst_camera_control_set_value(CameraControl, CameraControlChannel, value->value.i_val)) {
- _mmcam_dbg_warn("set tilt %d done", value->value.i_val);
+ MMCAM_LOG_WARNING("set tilt %d done", value->value.i_val);
return TRUE;
} else {
- _mmcam_dbg_err("failed to set tilt %d", value->value.i_val);
+ MMCAM_LOG_ERROR("failed to set tilt %d", value->value.i_val);
return FALSE;
}
}
}
- _mmcam_dbg_warn("failed to find tilt control channel");
+ MMCAM_LOG_WARNING("failed to find tilt control channel");
}
return FALSE;
if (!sc)
return TRUE;
- _mmcam_dbg_log("Focus mode(%d)", value->value.i_val);
+ MMCAM_LOG_INFO("Focus mode(%d)", value->value.i_val);
/* check whether set or not */
if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
- _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ MMCAM_LOG_INFO("skip set value %d", value->value.i_val);
return TRUE;
}
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_NULL) {
- _mmcam_dbg_log("Focus mode will be changed later.(state=%d)", current_state);
+ MMCAM_LOG_INFO("Focus mode will be changed later.(state=%d)", current_state);
return TRUE;
} else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("Can not set while CAPTURING");
+ MMCAM_LOG_ERROR("Can not set while CAPTURING");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
MMCamAttrsInfo info;
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_log("Can't cast Video source into camera control.");
+ MMCAM_LOG_INFO("Can't cast Video source into camera control.");
return TRUE;
}
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
- _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_ERROR("cast CAMERA_CONTROL failed");
return FALSE;
}
if (gst_camera_control_get_focus(control, &cur_focus_mode, &cur_focus_range)) {
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);
+ MMCAM_LOG_INFO("Succeed in setting AF mode[%d]", mslVal);
return TRUE;
} else {
- _mmcam_dbg_warn("Failed to set AF mode[%d]", mslVal);
+ MMCAM_LOG_WARNING("Failed to set AF mode[%d]", mslVal);
}
} else {
- _mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal);
+ MMCAM_LOG_INFO("No need to set AF mode. Current[%d]", mslVal);
return TRUE;
}
} else {
- _mmcam_dbg_warn("Failed to get AF mode, so do not set new AF mode[%d]", mslVal);
+ MMCAM_LOG_WARNING("Failed to get AF mode, so do not set new AF mode[%d]", mslVal);
}
}
} else {
- _mmcam_dbg_log("pointer of video src is null");
+ MMCAM_LOG_INFO("pointer of video src is null");
}
return TRUE;
if (!sc)
return TRUE;
- _mmcam_dbg_log("(%d)", attr_idx);
+ MMCAM_LOG_INFO("(%d)", attr_idx);
/* check whether set or not */
if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
- _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ MMCAM_LOG_INFO("skip set value %d", value->value.i_val);
return TRUE;
}
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
+ MMCAM_LOG_INFO("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
} else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("Can not set while CAPTURING");
+ MMCAM_LOG_ERROR("Can not set while CAPTURING");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_log("Can't cast Video source into camera control.");
+ MMCAM_LOG_INFO("Can't cast Video source into camera control.");
return TRUE;
}
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
- _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_ERROR("cast CAMERA_CONTROL failed");
return FALSE;
}
if (gst_camera_control_get_focus(control, &cur_focus_mode, &cur_focus_range)) {
if ((newVal != cur_focus_range) || (converted_mode != cur_focus_mode)) {
if (gst_camera_control_set_focus(control, converted_mode, newVal)) {
- /*_mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal);*/
+ /*MMCAM_LOG_INFO("Succeed in setting AF mode[%d]", mslVal);*/
return TRUE;
} else {
- _mmcam_dbg_warn("Failed to set AF mode[%d]", mslVal);
+ MMCAM_LOG_WARNING("Failed to set AF mode[%d]", mslVal);
}
} else {
- /*_mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal);*/
+ /*MMCAM_LOG_INFO("No need to set AF mode. Current[%d]", mslVal);*/
return TRUE;
}
} else {
- _mmcam_dbg_warn("Failed to get AF mode, so do not set new AF mode[%d]", mslVal);
+ MMCAM_LOG_WARNING("Failed to get AF mode, so do not set new AF mode[%d]", mslVal);
}
} else {
- _mmcam_dbg_log("pointer of video src is null");
+ MMCAM_LOG_INFO("pointer of video src is null");
}
return FALSE;
if (!sc)
return TRUE;
- _mmcam_dbg_log("(%d)", attr_idx);
+ MMCAM_LOG_INFO("(%d)", attr_idx);
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
+ MMCAM_LOG_INFO("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
} else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("Can not set while CAPTURING");
+ MMCAM_LOG_ERROR("Can not set while CAPTURING");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
NULL);
if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_warn("Failed to get FOCUS MODE.[%x]", ret);
+ MMCAM_LOG_WARNING("Failed to get FOCUS MODE.[%x]", ret);
return FALSE;
}
if ((focus_mode != MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO) && (focus_mode != MM_CAMCORDER_FOCUS_MODE_CONTINUOUS)) {
- _mmcam_dbg_warn("Focus mode is NOT TOUCH AUTO or CONTINUOUS(current[%d]). return FALSE", focus_mode);
+ MMCAM_LOG_WARNING("Focus mode is NOT TOUCH AUTO or CONTINUOUS(current[%d]). return FALSE", focus_mode);
return FALSE;
}
if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_log("Can't cast Video source into camera control.");
+ MMCAM_LOG_INFO("Can't cast Video source into camera control.");
return TRUE;
}
NULL);
do_set = TRUE;
} else {
- _mmcam_dbg_log("Just store AF area[x:%d]", value->value.i_val);
+ MMCAM_LOG_INFO("Just store AF area[x:%d]", value->value.i_val);
return TRUE;
}
break;
NULL);
do_set = TRUE;
} else {
- _mmcam_dbg_log("Just store AF area[y:%d]", value->value.i_val);
+ MMCAM_LOG_INFO("Just store AF area[y:%d]", value->value.i_val);
return TRUE;
}
break;
NULL);
do_set = TRUE;
} else {
- _mmcam_dbg_log("Just store AF area[width:%d]", value->value.i_val);
+ MMCAM_LOG_INFO("Just store AF area[width:%d]", value->value.i_val);
return TRUE;
}
break;
_MMCamcorderVideoInfo *info = sc->info_video;
if (info == NULL) {
- _mmcam_dbg_err("video info is NULL");
+ MMCAM_LOG_ERROR("video info is NULL");
return FALSE;
}
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
- _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_ERROR("cast CAMERA_CONTROL failed");
return FALSE;
}
ratio_width = (float)info->video_width / (float)info->preview_width;
ratio_height = (float)info->video_height / (float)info->preview_height;
- _mmcam_dbg_log("original area %d,%d,%dx%d, resolution ratio : width %f, height %f",
+ MMCAM_LOG_INFO("original area %d,%d,%dx%d, resolution ratio : width %f, height %f",
set_area.x, set_area.y, set_area.width, set_area.height, ratio_width, ratio_height);
set_area.x = (int)((float)set_area.x * ratio_width);
if (set_area.height <= 0)
set_area.height = 1;
- _mmcam_dbg_log("converted area %d,%d,%dx%d",
+ MMCAM_LOG_INFO("converted area %d,%d,%dx%d",
set_area.x, set_area.y, set_area.width, set_area.height);
} else {
- _mmcam_dbg_warn("invalid preview size %dx%d, skip AF area converting",
+ MMCAM_LOG_WARNING("invalid preview size %dx%d, skip AF area converting",
info->preview_width, info->preview_height);
}
}
ret = gst_camera_control_get_auto_focus_area(control, &get_area);
if (!ret) {
- _mmcam_dbg_warn("Failed to get AF area");
+ MMCAM_LOG_WARNING("Failed to get AF area");
return FALSE;
}
/* width and height are not supported now */
if (get_area.x == set_area.x && get_area.y == set_area.y) {
- _mmcam_dbg_log("No need to set AF area[x,y:%d,%d]",
+ MMCAM_LOG_INFO("No need to set AF area[x,y:%d,%d]",
get_area.x, get_area.y);
return TRUE;
}
ret = gst_camera_control_set_auto_focus_area(control, set_area);
if (ret) {
- _mmcam_dbg_log("Succeed to set AF area[%d,%d,%dx%d]",
+ MMCAM_LOG_INFO("Succeed to set AF area[%d,%d,%dx%d]",
set_area.x, set_area.y, set_area.width, set_area.height);
return TRUE;
} else {
- _mmcam_dbg_warn("Failed to set AF area[%d,%d,%dx%d]",
+ MMCAM_LOG_WARNING("Failed to set AF area[%d,%d,%dx%d]",
set_area.x, set_area.y, set_area.width, set_area.height);
}
}
} else {
- _mmcam_dbg_log("pointer of video src is null");
+ MMCAM_LOG_INFO("pointer of video src is null");
}
return FALSE;
/* check whether set or not */
if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
- _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ MMCAM_LOG_INFO("skip set value %d", value->value.i_val);
return TRUE;
}
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("will be applied when preview starts");
+ MMCAM_LOG_INFO("will be applied when preview starts");
return TRUE;
} else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("Can not set while CAPTURING");
+ MMCAM_LOG_ERROR("Can not set while CAPTURING");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
if (check_scene_mode) {
mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
if (scene_mode != MM_CAMCORDER_SCENE_MODE_NORMAL) {
- _mmcam_dbg_warn("can not set [%d] when scene mode is NOT normal.", attr_idx);
+ MMCAM_LOG_WARNING("can not set [%d] when scene mode is NOT normal.", attr_idx);
return FALSE;
}
}
int ret = 0;
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_log("Can't cast Video source into camera control.");
+ MMCAM_LOG_INFO("Can't cast Video source into camera control.");
return TRUE;
}
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
- _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_ERROR("cast CAMERA_CONTROL failed");
return FALSE;
}
ret = gst_camera_control_set_exposure(control, exposure_type, newVal1, newVal2);
if (ret) {
- _mmcam_dbg_log("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2);
+ MMCAM_LOG_INFO("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2);
return TRUE;
} else {
- _mmcam_dbg_warn("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2);
+ MMCAM_LOG_WARNING("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2);
}
} else {
- _mmcam_dbg_log("pointer of video src is null");
+ MMCAM_LOG_INFO("pointer of video src is null");
}
return FALSE;
/* check whether set or not */
if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
- _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ MMCAM_LOG_INFO("skip set value %d", value->value.i_val);
return TRUE;
}
/* check current state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("will be applied when preview starts");
+ MMCAM_LOG_INFO("will be applied when preview starts");
return TRUE;
} else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("Can not set while CAPTURING");
+ MMCAM_LOG_ERROR("Can not set while CAPTURING");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_log("Can't cast Video source into camera control.");
+ MMCAM_LOG_INFO("Can't cast Video source into camera control.");
return TRUE;
}
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
- _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_ERROR("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)) {
- _mmcam_dbg_log("Success - set wdr[%d]", mslVal);
+ MMCAM_LOG_INFO("Success - set wdr[%d]", mslVal);
return TRUE;
} else {
- _mmcam_dbg_warn("Failed to set WDR. NewVal[%d],CurVal[%d]", newVal, cur_value);
+ MMCAM_LOG_WARNING("Failed to set WDR. NewVal[%d],CurVal[%d]", newVal, cur_value);
}
} else {
- _mmcam_dbg_log("No need to set new WDR. Current[%d]", mslVal);
+ MMCAM_LOG_INFO("No need to set new WDR. Current[%d]", mslVal);
return TRUE;
}
} else {
- _mmcam_dbg_warn("Failed to get WDR.");
+ MMCAM_LOG_WARNING("Failed to get WDR.");
}
} else {
- _mmcam_dbg_log("pointer of video src is null");
+ MMCAM_LOG_INFO("pointer of video src is null");
}
return FALSE;
/* check whether set or not */
if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
- _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ MMCAM_LOG_INFO("skip set value %d", value->value.i_val);
return TRUE;
}
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);
+ MMCAM_LOG_INFO("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
} else if (current_state > MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_err("Invaild state (state %d)", current_state);
+ MMCAM_LOG_ERROR("Invalid state (state %d)", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
if (!sc || !sc->encode_element) {
- _mmcam_dbg_log("will be applied later - idx %d, bitrate %d", attr_idx, bitrate);
+ MMCAM_LOG_INFO("will be applied later - idx %d, bitrate %d", attr_idx, bitrate);
return TRUE;
}
current_state = _mmcamcorder_get_state(handle);
if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
- _mmcam_dbg_err("Can not set while RECORDING - attr idx %d", attr_idx);
+ MMCAM_LOG_ERROR("Can not set while RECORDING - attr idx %d", attr_idx);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
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);
+ MMCAM_LOG_INFO("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
} else if (current_state > MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_err("Invaild state (state %d)", current_state);
+ MMCAM_LOG_ERROR("Invalid state (state %d)", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
mmf_return_val_if_fail(hcamcorder && value, FALSE);
- _mmcam_dbg_log("rotate(%d)", value->value.i_val);
+ MMCAM_LOG_INFO("rotate(%d)", value->value.i_val);
current_state = _mmcamcorder_get_state(handle);
if (current_state > MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_err("camera rotation setting failed.(state=%d)", current_state);
+ MMCAM_LOG_ERROR("camera rotation setting failed.(state=%d)", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
} else {
/* check type */
if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
- _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ MMCAM_LOG_ERROR("invalid mode %d", hcamcorder->type);
return FALSE;
}
/* check current state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("NOT initialized. this will be applied later");
+ MMCAM_LOG_INFO("NOT initialized. this will be applied later");
return TRUE;
} else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("Can not set while CAPTURING");
+ MMCAM_LOG_ERROR("Can not set while CAPTURING");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- _mmcam_dbg_log("Image encoder quality(%d)", value->value.i_val);
+ MMCAM_LOG_INFO("Image encoder quality(%d)", value->value.i_val);
if (current_state == MM_CAMCORDER_STATE_PREPARE) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-jpg-quality", value->value.i_val);
return TRUE;
} else {
- _mmcam_dbg_err("invalid state %d", current_state);
+ MMCAM_LOG_ERROR("invalid state %d", current_state);
return FALSE;
}
}
/* get string */
if (!value->value.s_val) {
- _mmcam_dbg_err("NULL filename");
+ MMCAM_LOG_ERROR("NULL filename");
return FALSE;
}
- _mmcam_dbg_log("set filename [%s]", value->value.s_val);
+ MMCAM_LOG_INFO("set filename [%s]", value->value.s_val);
return TRUE;
}
current_state = _mmcamcorder_get_state(handle);
if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
- _mmcam_dbg_err("Can not set while RECORDING");
+ MMCAM_LOG_ERROR("Can not set while RECORDING");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
}
+static int __color_channel_item_compare_func(gconstpointer data, gconstpointer user_data)
+{
+ GstColorBalanceChannel *Colorchannel = (GstColorBalanceChannel *)data;
+ MMCAM_LOG_VERBOSE("check[%s], input[%s]", Colorchannel->label, (char *)user_data);
+ return strcmp(Colorchannel->label, user_data);
+}
+
bool _mmcamcorder_commit_filter(MMHandleType handle, int attr_idx, const MMAttrsValue *value)
{
GstColorBalance *balance = NULL;
GstColorBalanceChannel *Colorchannel = NULL;
- const GList *controls = NULL;
- const GList *item = NULL;
+ GList *controls = NULL;
+ GList *item = NULL;
int newVal = 0;
- int mslNewVal = 0;
+ int mslVal = 0;
int current_state = MM_CAMCORDER_STATE_NONE;
const char *control_label = NULL;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
gboolean check_scene_mode = FALSE;
+ int wb_temp_table[] = {
+ [MM_CAMCORDER_WHITE_BALANCE_DAYLIGHT] = 5200,
+ [MM_CAMCORDER_WHITE_BALANCE_CLOUDY] = 6000,
+ [MM_CAMCORDER_WHITE_BALANCE_FLUORESCENT] = 4000,
+ [MM_CAMCORDER_WHITE_BALANCE_INCANDESCENT] = 3200,
+ [MM_CAMCORDER_WHITE_BALANCE_SHADE] = 7000,
+ [MM_CAMCORDER_WHITE_BALANCE_FLASH] = 6000
+ };
+
mmf_return_val_if_fail(hcamcorder && value, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
/* check whether set or not */
if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
- _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ MMCAM_LOG_INFO("skip set value %d", value->value.i_val);
return TRUE;
}
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("will be applied when preview starts");
+ MMCAM_LOG_INFO("will be applied when preview starts");
return TRUE;
} else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("Can not set while CAPTURING");
+ MMCAM_LOG_ERROR("Can not set while CAPTURING");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
if (value->type != MM_ATTRS_TYPE_INT) {
- _mmcam_dbg_warn("Mismatched value type (%d)", value->type);
+ MMCAM_LOG_WARNING("Mismatched value type (%d)", value->type);
return FALSE;
- } else {
- mslNewVal = value->value.i_val;
}
+ mslVal = value->value.i_val;
+
switch (attr_idx) {
case MM_CAM_FILTER_BRIGHTNESS:
control_label = "brightness";
check_scene_mode = TRUE;
break;
-
case MM_CAM_FILTER_CONTRAST:
control_label = "contrast";
break;
-
case MM_CAM_FILTER_WB:
control_label = "white balance";
check_scene_mode = TRUE;
break;
-
case MM_CAM_FILTER_COLOR_TONE:
control_label = "color tone";
break;
-
case MM_CAM_FILTER_SATURATION:
control_label = "saturation";
check_scene_mode = TRUE;
break;
-
case MM_CAM_FILTER_HUE:
control_label = "hue";
break;
-
case MM_CAM_FILTER_SHARPNESS:
control_label = "sharpness";
check_scene_mode = TRUE;
break;
default:
- _mmcam_dbg_err("unknown attribute index %d", attr_idx);
+ MMCAM_LOG_ERROR("unknown attribute index %d", attr_idx);
return FALSE;
}
if (check_scene_mode) {
mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
if (scene_mode != MM_CAMCORDER_SCENE_MODE_NORMAL) {
- _mmcam_dbg_warn("can not set %s when scene mode is NOT normal.", control_label);
+ MMCAM_LOG_WARNING("can not set %s when scene mode is NOT normal.", control_label);
return FALSE;
}
}
- newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslNewVal);
+ newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal);
if (newVal == _MMCAMCORDER_SENSOR_ENUM_NONE)
return FALSE;
- /*_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.");
+ MMCAM_LOG_INFO("Can't cast Video source into color balance.");
return TRUE;
}
balance = GST_COLOR_BALANCE(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (balance == NULL) {
- _mmcam_dbg_err("cast COLOR_BALANCE failed");
+ MMCAM_LOG_ERROR("cast COLOR_BALANCE failed");
return FALSE;
}
- controls = gst_color_balance_list_channels(balance);
+ controls = (GList *)gst_color_balance_list_channels(balance);
if (controls == NULL) {
- _mmcam_dbg_log("There is no list of colorbalance controls");
+ MMCAM_LOG_INFO("There is no list of colorbalance controls");
return FALSE;
}
- for (item = controls ; item && item->data ; item = item->next) {
+_CHECK_AGAIN:
+ MMCAM_LOG_DEBUG("attr[%d] label[%s]: MSL[%d] -> Sensor[%d]",
+ attr_idx, control_label, mslVal, newVal);
+
+ item = g_list_find_custom(controls, control_label, __color_channel_item_compare_func);
+ if (item) {
Colorchannel = item->data;
- /*_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label);*/
+ gst_color_balance_set_value(balance, Colorchannel, newVal);
+ MMCAM_LOG_INFO("Set complete - %s[msl:%d,real:%d]", Colorchannel->label, mslVal, newVal);
+ return TRUE;
+ }
- if (!strcmp(Colorchannel->label, control_label)) {
- gst_color_balance_set_value(balance, Colorchannel, newVal);
- _mmcam_dbg_log("Set complete - %s[msl:%d,real:%d]", Colorchannel->label, mslNewVal, newVal);
- break;
+ if (attr_idx == MM_CAM_FILTER_WB && !strcmp(control_label, "white balance")) {
+ if (mslVal == MM_CAMCORDER_WHITE_BALANCE_AUTOMATIC) {
+ newVal = 1;
+ control_label = "white_balance_temperature_auto";
+ goto _CHECK_AGAIN;
+ } else {
+ newVal = wb_temp_table[mslVal];
+ control_label = "white_balance_temperature";
+ goto _CHECK_AGAIN;
}
}
- if (item == NULL) {
- _mmcam_dbg_err("failed to find color channel item");
- return FALSE;
- }
+ MMCAM_LOG_ERROR("failed to find color channel item");
- return TRUE;
+ return FALSE;
}
/* check whether set or not */
if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
- _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ MMCAM_LOG_INFO("skip set value %d", value->value.i_val);
return TRUE;
}
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);
+ MMCAM_LOG_INFO("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
} else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("Can not set while CAPTURING");
+ MMCAM_LOG_ERROR("Can not set while CAPTURING");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
int ret = 0;
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_log("Can't cast Video source into camera control.");
+ MMCAM_LOG_INFO("Can't cast Video source into camera control.");
return TRUE;
}
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
- _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_ERROR("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);
+ MMCAM_LOG_INFO("Succeed in setting program mode[%d].", mslVal);
if (mslVal == MM_CAMCORDER_SCENE_MODE_NORMAL) {
unsigned int i = 0;
return TRUE;
} else {
- _mmcam_dbg_log("Failed to set program mode[%d].", mslVal);
+ MMCAM_LOG_INFO("Failed to set program mode[%d].", mslVal);
}
} else {
- _mmcam_dbg_warn("pointer of video src is null");
+ MMCAM_LOG_WARNING("pointer of video src is null");
}
return FALSE;
{
mmf_return_val_if_fail(handle && value, FALSE);
- _mmcam_dbg_warn("Filter Flip(%d)", value->value.i_val);
+ MMCAM_LOG_WARNING("Filter Flip(%d)", value->value.i_val);
return TRUE;
}
{
mmf_return_val_if_fail(handle && value, FALSE);
- _mmcam_dbg_log("Commit : Do nothing. this attr will be removed soon.");
+ MMCAM_LOG_INFO("Commit : Do nothing. this attr will be removed soon.");
return TRUE;
}
current_state = _mmcamcorder_get_state(handle);
if (current_state > MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_warn("Can NOT Disable AUDIO. invalid state %d", current_state);
+ MMCAM_LOG_WARNING("Can NOT Disable AUDIO. invalid state %d", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
} else {
- _mmcam_dbg_log("Disable AUDIO when Recording");
+ MMCAM_LOG_INFO("Disable AUDIO when Recording");
return TRUE;
}
}
{
int current_state = MM_CAMCORDER_STATE_NONE;
const char *videosink_name = NULL;
- void *p_handle = NULL;
+ void *dp_handle = NULL;
+ MMCamWindowInfo *window_info = NULL;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
/* check type */
if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
- _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ MMCAM_LOG_ERROR("invalid mode %d", hcamcorder->type);
return FALSE;
}
/* check current state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("NOT initialized. this will be applied later");
+ MMCAM_LOG_INFO("NOT initialized. this will be applied later");
return TRUE;
}
+ dp_handle = value->value.p_val;
+ if (!dp_handle) {
+ MMCAM_LOG_WARNING("Display handle is NULL");
+ return FALSE;
+ }
+
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- p_handle = value->value.p_val;
- if (p_handle) {
- /* get videosink name */
- _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
- if (videosink_name == NULL) {
- _mmcam_dbg_err("Please check videosink element in configuration file");
- return FALSE;
- }
+ /* get videosink name */
+ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
+ if (!videosink_name) {
+ MMCAM_LOG_ERROR("Please check videosink element in configuration file");
+ return FALSE;
+ }
- _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
-
- if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "ximagesink")) {
- _mmcam_dbg_log("Commit : Set XID[%x]", *(int *)(p_handle));
- gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), *(int *)(p_handle));
- } else if (!strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "evaspixmapsink")) {
- _mmcam_dbg_log("Commit : Set evas object [%p]", p_handle);
- MMCAMCORDER_G_OBJECT_SET_POINTER(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "evas-object", p_handle);
- } else if (!strcmp(videosink_name, "tizenwlsink")) {
- _mmcam_dbg_log("wayland global surface id : %d", *(int *)(p_handle));
- gst_video_overlay_set_wl_window_wl_surface_id(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), (guintptr)*(int *)(p_handle));
- } else {
- _mmcam_dbg_warn("Commit : Nothing to commit with this element[%s]", videosink_name);
- return FALSE;
- }
+ MMCAM_LOG_INFO("Commit : videosinkname[%s]", videosink_name);
+
+ if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "ximagesink")) {
+ MMCAM_LOG_INFO("Commit : Set XID[%x]", *(int *)(dp_handle));
+ gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), *(int *)(dp_handle));
+ } else if (!strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "evaspixmapsink")) {
+ MMCAM_LOG_INFO("Commit : Set evas object [%p]", dp_handle);
+ MMCAMCORDER_G_OBJECT_SET_POINTER(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "evas-object", dp_handle);
+ } else if (!strcmp(videosink_name, "tizenwlsink")) {
+ window_info = (MMCamWindowInfo *)dp_handle;
+ MMCAM_LOG_INFO("wayland global surface id : %d", window_info->surface_id);
+ gst_video_overlay_set_wl_window_wl_surface_id(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), (guintptr)window_info->surface_id);
+ } else if (!strcmp(videosink_name, "directvideosink")) {
+ window_info = (MMCamWindowInfo *)dp_handle;
+ MMCAM_LOG_INFO("wayland global surface id : %d, x,y,w,h (%d,%d,%d,%d)",
+ window_info->surface_id,
+ window_info->rect.x,
+ window_info->rect.y,
+ window_info->rect.width,
+ window_info->rect.height);
+ gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), (guintptr)window_info->surface_id);
+ gst_video_overlay_set_render_rectangle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst),
+ window_info->rect.x,
+ window_info->rect.y,
+ window_info->rect.width,
+ window_info->rect.height);
} else {
- _mmcam_dbg_warn("Display handle is NULL");
+ MMCAM_LOG_WARNING("Commit : Nothing to commit with this element[%s]", videosink_name);
return FALSE;
}
/* check type */
if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
- _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ MMCAM_LOG_ERROR("invalid mode %d", hcamcorder->type);
return FALSE;
}
/* check current state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("NOT initialized. this will be applied later");
+ MMCAM_LOG_INFO("NOT initialized. this will be applied later");
return TRUE;
}
_mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
if (videosink_name == NULL) {
- _mmcam_dbg_err("Please check videosink element in configuration file");
+ MMCAM_LOG_ERROR("Please check videosink element in configuration file");
return FALSE;
}
- _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
+ MMCAM_LOG_INFO("Commit : videosinkname[%s]", videosink_name);
if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink")) {
- _mmcam_dbg_log("Commit : display mode [%d]", value->value.i_val);
+ MMCAM_LOG_INFO("Commit : display mode [%d]", value->value.i_val);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-mode", value->value.i_val);
} else {
- _mmcam_dbg_warn("[%s] does not support display mode, but no error", videosink_name);
+ MMCAM_LOG_WARNING("[%s] does not support display mode, but no error", videosink_name);
}
return TRUE;
/* check type */
if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
- _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ MMCAM_LOG_ERROR("invalid mode %d", hcamcorder->type);
return FALSE;
}
/* check current state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("NOT initialized. this will be applied later [rotate:%d]", value->value.i_val);
+ MMCAM_LOG_INFO("NOT initialized. this will be applied later [rotate:%d]", value->value.i_val);
return TRUE;
}
/* check type */
if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
- _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ MMCAM_LOG_ERROR("invalid mode %d", hcamcorder->type);
return FALSE;
}
/* check current state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("NOT initialized. this will be applied later [flip:%d]", value->value.i_val);
+ MMCAM_LOG_INFO("NOT initialized. this will be applied later [flip:%d]", value->value.i_val);
return TRUE;
}
/* check type */
if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
- _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ MMCAM_LOG_ERROR("invalid mode %d", hcamcorder->type);
return FALSE;
}
/* check current state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("NOT initialized. this will be applied later");
+ MMCAM_LOG_INFO("NOT initialized. this will be applied later");
return TRUE;
}
/* Get videosink name */
_mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
if (videosink_name == NULL) {
- _mmcam_dbg_err("Please check videosink element in configuration file");
+ MMCAM_LOG_ERROR("Please check videosink element in configuration file");
return FALSE;
}
if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") ||
- !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) {
+ !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink") ||
+ !strcmp(videosink_name, "directvideosink")) {
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);
+ MMCAM_LOG_INFO("Set visible [%d] done.", value->value.i_val);
} else {
- _mmcam_dbg_warn("[%s] does not support VISIBLE, but no error", videosink_name);
+ MMCAM_LOG_WARNING("[%s] does not support VISIBLE, but no error", videosink_name);
}
return TRUE;
/* check type */
if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
- _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ MMCAM_LOG_ERROR("invalid mode %d", hcamcorder->type);
return FALSE;
}
/* check current state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("NOT initialized. this will be applied later");
+ MMCAM_LOG_INFO("NOT initialized. this will be applied later");
return TRUE;
}
/* Get videosink name */
_mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
if (videosink_name == NULL) {
- _mmcam_dbg_err("Please check videosink element in configuration file");
+ MMCAM_LOG_ERROR("Please check videosink element in configuration file");
return FALSE;
}
if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") ||
- !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) {
+ !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink") ||
+ !strcmp(videosink_name, "directvideosink")) {
method = value->value.i_val;
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-geometry-method", method);
} else {
- _mmcam_dbg_warn("[%s] does not support geometry method, but no error", videosink_name);
+ MMCAM_LOG_WARNING("[%s] does not support geometry method, but no error", videosink_name);
}
return TRUE;
/* check type */
if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
- _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ MMCAM_LOG_ERROR("invalid mode %d", hcamcorder->type);
return FALSE;
}
/* check current state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("NOT initialized. this will be applied later");
+ MMCAM_LOG_INFO("NOT initialized. this will be applied later");
return TRUE;
}
/* Get videosink name */
_mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
if (videosink_name == NULL) {
- _mmcam_dbg_err("Please check videosink element in configuration file");
+ MMCAM_LOG_ERROR("Please check videosink element in configuration file");
return FALSE;
}
if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") ||
- !strcmp(videosink_name, "evaspixmapsink")) {
+ !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "directvideosink")) {
int rect_x = 0;
int rect_y = 0;
int rect_width = 0;
rect_height = value->value.i_val;
break;
default:
- _mmcam_dbg_err("Wrong attr_idx!");
+ MMCAM_LOG_ERROR("Wrong attr_idx!");
return FALSE;
}
if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
- _mmcam_dbg_log("RECT(x,y,w,h) = (%d,%d,%d,%d)", rect_x, rect_y, rect_width, rect_height);
+ MMCAM_LOG_INFO("RECT(x,y,w,h) = (%d,%d,%d,%d)", rect_x, rect_y, rect_width, rect_height);
if (!strcmp(videosink_name, "tizenwlsink")) {
ret = gst_video_overlay_set_display_roi_area(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst),
rect_x, rect_y, rect_width, rect_height);
if (!ret) {
- _mmcam_dbg_err("FAILED : could not set display roi area.");
+ MMCAM_LOG_ERROR("FAILED : could not set display roi area.");
return FALSE;
}
} else {
}
}
} else {
- _mmcam_dbg_warn("[%s] does not support display rect, but no error", videosink_name);
+ MMCAM_LOG_WARNING("[%s] does not support display rect, but no error", videosink_name);
}
return TRUE;
/* check type */
if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
- _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ MMCAM_LOG_ERROR("invalid mode %d", hcamcorder->type);
return FALSE;
}
/* check current state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("NOT initialized. this will be applied later");
+ MMCAM_LOG_INFO("NOT initialized. this will be applied later");
return TRUE;
}
/* Get videosink name */
_mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
if (videosink_name == NULL) {
- _mmcam_dbg_err("Please check videosink element in configuration file");
+ MMCAM_LOG_ERROR("Please check videosink element in configuration file");
return FALSE;
}
vs_element = sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst;
MMCAMCORDER_G_OBJECT_SET(vs_element, "zoom", (float)(zoom + 1));
- _mmcam_dbg_log("Set display zoom to %d", zoom + 1);
+ MMCAM_LOG_INFO("Set display zoom to %d", zoom + 1);
return TRUE;
} else {
- _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
+ MMCAM_LOG_WARNING("videosink[%s] does not support scale", videosink_name);
return FALSE;
}
}
/* check type */
if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
- _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ MMCAM_LOG_ERROR("invalid mode %d", hcamcorder->type);
return FALSE;
}
/* check current state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("NOT initialized. this will be applied later");
+ MMCAM_LOG_INFO("NOT initialized. this will be applied later");
return TRUE;
}
/* Get videosink name */
_mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
if (videosink_name == NULL) {
- _mmcam_dbg_err("Please check videosink element in configuration file");
+ MMCAM_LOG_ERROR("Please check videosink element in configuration file");
return FALSE;
}
if (!strcmp(videosink_name, "evaspixmapsink")) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "origin-size", !do_scaling);
- _mmcam_dbg_log("Set origin-size to %d", !(value->value.i_val));
+ MMCAM_LOG_INFO("Set origin-size to %d", !(value->value.i_val));
return TRUE;
} else {
- _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
+ MMCAM_LOG_WARNING("videosink[%s] does not support scale", videosink_name);
return FALSE;
}
}
if (!sc)
return TRUE;
- /*_mmcam_dbg_log( "Commit : strobe attribute(%d)", attr_idx );*/
+ /*MMCAM_LOG_INFO( "Commit : strobe attribute(%d)", attr_idx );*/
mslVal = value->value.i_val;
/* get current flash brightness */
if (_mmcamcorder_get_device_flash_brightness(hcamcorder->gdbus_conn, &flash_brightness) != MM_ERROR_NONE) {
- _mmcam_dbg_err("_mmcamcorder_get_device_flash_brightness failed");
+ MMCAM_LOG_ERROR("_mmcamcorder_get_device_flash_brightness failed");
hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
return FALSE;
}
- _mmcam_dbg_log("flash brightness %d", flash_brightness);
+ MMCAM_LOG_INFO("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.");
+ MMCAM_LOG_ERROR("other module already turned on flash. avoid to set flash mode here.");
return FALSE;
} else {
- _mmcam_dbg_log("keep going");
+ MMCAM_LOG_INFO("keep going");
}
}
/* 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);
+ MMCAM_LOG_INFO("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
} else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("Can not set while CAPTURING");
+ MMCAM_LOG_ERROR("Can not set while CAPTURING");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
case MM_CAM_STROBE_MODE:
/* check whether set or not */
if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
- _mmcam_dbg_log("skip set value %d", mslVal);
+ MMCAM_LOG_INFO("skip set value %d", mslVal);
return TRUE;
}
newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_MODE, mslVal);
break;
default:
- _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
+ MMCAM_LOG_ERROR("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
return FALSE;
}
GstCameraControl *control = NULL;
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_err("Can't cast Video source into camera control.");
+ MMCAM_LOG_ERROR("Can't cast Video source into camera control.");
bret = FALSE;
} else {
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
- _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_ERROR("cast CAMERA_CONTROL failed");
return FALSE;
}
if (gst_camera_control_get_strobe(control, strobe_type, &cur_value)) {
if (newVal != cur_value) {
if (gst_camera_control_set_strobe(control, strobe_type, newVal)) {
- _mmcam_dbg_log("Succeed in setting strobe. Type[%d],value[%d]", strobe_type, mslVal);
+ MMCAM_LOG_INFO("Succeed in setting strobe. Type[%d],value[%d]", strobe_type, mslVal);
bret = TRUE;
} else {
- _mmcam_dbg_warn("Set strobe failed. Type[%d],value[%d]", strobe_type, mslVal);
+ MMCAM_LOG_WARNING("Set strobe failed. Type[%d],value[%d]", strobe_type, mslVal);
bret = FALSE;
}
} else {
- _mmcam_dbg_log("No need to set strobe. Type[%d],value[%d]", strobe_type, mslVal);
+ MMCAM_LOG_INFO("No need to set strobe. Type[%d],value[%d]", strobe_type, mslVal);
bret = TRUE;
}
} else {
- _mmcam_dbg_warn("Failed to get strobe. Type[%d]", strobe_type);
+ MMCAM_LOG_WARNING("Failed to get strobe. Type[%d]", strobe_type);
bret = FALSE;
}
}
mmf_return_val_if_fail(hcamcorder && value, FALSE);
- _mmcam_dbg_log("Commit : flip %d", value->value.i_val);
+ MMCAM_LOG_INFO("Commit : flip %d", value->value.i_val);
/* state check */
current_state = _mmcamcorder_get_state(handle);
if (current_state > MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_err("Can not set camera FLIP horizontal at state %d", current_state);
+ MMCAM_LOG_ERROR("Can not set camera FLIP horizontal at state %d", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
} else if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("Pipeline is not created yet. This will be set when create pipeline.");
+ MMCAM_LOG_INFO("Pipeline is not created yet. This will be set when create pipeline.");
return TRUE;
}
ret = _mmcamcorder_set_videosrc_flip(handle, value->value.i_val);
- _mmcam_dbg_log("ret %d", ret);
+ MMCAM_LOG_INFO("ret %d", ret);
return ret;
}
mmf_return_val_if_fail(hcamcorder && value, FALSE);
- /*_mmcam_dbg_log("Commit : HDR Capture %d", value->value.i_val);*/
+ /*MMCAM_LOG_INFO("Commit : HDR Capture %d", value->value.i_val);*/
/* check whether set or not */
if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
- _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ MMCAM_LOG_INFO("skip set value %d", value->value.i_val);
return TRUE;
}
/* state check */
current_state = _mmcamcorder_get_state(handle);
if (current_state > MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_err("can NOT set HDR capture at state %d", current_state);
+ MMCAM_LOG_ERROR("can NOT set HDR capture at state %d", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
NULL);
if (set_hdr_mode == current_value) {
- _mmcam_dbg_log("same HDR value : %d, do nothing", set_hdr_mode);
+ MMCAM_LOG_INFO("same HDR value : %d, do nothing", set_hdr_mode);
return TRUE;
}
/* check decoder recreation */
if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) {
- _mmcam_dbg_err("_mmcamcorder_recreate_decoder_for_encoded_preview failed");
+ MMCAM_LOG_ERROR("_mmcamcorder_recreate_decoder_for_encoded_preview failed");
return FALSE;
}
set_hdr_mode = value->value.i_val;
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hdr-capture", set_hdr_mode);
sc->info_image->hdr_capture_mode = set_hdr_mode;
- _mmcam_dbg_log("set HDR mode : %d", set_hdr_mode);
+ MMCAM_LOG_INFO("set HDR mode : %d", set_hdr_mode);
if (current_state == MM_CAMCORDER_STATE_PREPARE)
_mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
} else {
- _mmcam_dbg_err("sc is NULL. can not set HDR capture");
+ MMCAM_LOG_ERROR("sc is NULL. can not set HDR capture");
return FALSE;
}
}
if (!sc)
return TRUE;
- /*_mmcam_dbg_log("Commit : detect attribute(%d)", attr_idx);*/
+ /*MMCAM_LOG_INFO("Commit : detect attribute(%d)", attr_idx);*/
/* state check */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("will be applied when preview starts");
+ MMCAM_LOG_INFO("will be applied when preview starts");
return TRUE;
}
case MM_CAM_DETECT_MODE:
/* check whether set or not */
if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
- _mmcam_dbg_log("skip set value %d", set_value);
+ MMCAM_LOG_INFO("skip set value %d", set_value);
return TRUE;
}
detect_type = GST_CAMERA_CONTROL_FACE_DETECT_STATUS;
break;
default:
- _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
+ MMCAM_LOG_ERROR("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
return FALSE;
}
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_err("Can't cast Video source into camera control.");
+ MMCAM_LOG_ERROR("Can't cast Video source into camera control.");
bret = FALSE;
} else {
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
if (control == NULL) {
- _mmcam_dbg_err("cast CAMERA_CONTROL failed");
+ MMCAM_LOG_ERROR("cast CAMERA_CONTROL failed");
return FALSE;
}
if (gst_camera_control_get_detect(control, detect_type, ¤t_value)) {
if (current_value == set_value) {
- _mmcam_dbg_log("No need to set detect(same). Type[%d],value[%d]", detect_type, set_value);
+ MMCAM_LOG_INFO("No need to set detect(same). Type[%d],value[%d]", detect_type, set_value);
bret = TRUE;
} else {
if (!gst_camera_control_set_detect(control, detect_type, set_value)) {
- _mmcam_dbg_warn("Set detect failed. Type[%d],value[%d]",
+ MMCAM_LOG_WARNING("Set detect failed. Type[%d],value[%d]",
detect_type, set_value);
bret = FALSE;
} else {
- _mmcam_dbg_log("Set detect success. Type[%d],value[%d]",
+ MMCAM_LOG_INFO("Set detect success. Type[%d],value[%d]",
detect_type, set_value);
bret = TRUE;
}
}
} else {
- _mmcam_dbg_warn("Get detect failed. Type[%d]", detect_type);
+ MMCAM_LOG_WARNING("Get detect failed. Type[%d]", detect_type);
bret = FALSE;
}
}
mmf_return_val_if_fail(handle && value, FALSE);
- _mmcam_dbg_log("Commit : encoded preview bitrate - %d", value->value.i_val);
+ MMCAM_LOG_INFO("Commit : encoded preview bitrate - %d", value->value.i_val);
/* check preview format */
mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FORMAT, &preview_format, NULL);
if (preview_format != MM_PIXEL_FORMAT_ENCODED_H264) {
- _mmcam_dbg_err("current preview format[%d] is not encoded format", preview_format);
+ MMCAM_LOG_ERROR("current preview format[%d] is not encoded format", preview_format);
return FALSE;
}
/* check state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("will be applied when preview starts");
+ MMCAM_LOG_INFO("will be applied when preview starts");
return TRUE;
}
mmf_return_val_if_fail(handle && value, FALSE);
- _mmcam_dbg_log("Commit : encoded preview I-frame interval - %d", value->value.i_val);
+ MMCAM_LOG_INFO("Commit : encoded preview I-frame interval - %d", value->value.i_val);
/* check preview format */
mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FORMAT, &preview_format, NULL);
if (preview_format != MM_PIXEL_FORMAT_ENCODED_H264) {
- _mmcam_dbg_err("current preview format[%d] is not encoded format", preview_format);
+ MMCAM_LOG_ERROR("current preview format[%d] is not encoded format", preview_format);
return FALSE;
}
/* check state */
current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
- _mmcam_dbg_log("will be applied when preview starts");
+ MMCAM_LOG_INFO("will be applied when preview starts");
return TRUE;
}
stream_type = value->value.s_val;
if (!stream_type) {
- _mmcam_dbg_err("NULL string");
+ MMCAM_LOG_ERROR("NULL string");
return FALSE;
}
MMCAM_SOUND_STREAM_INDEX, &stream_index,
NULL);
if (stream_index < 0) {
- _mmcam_dbg_err("invalid stream index %d", stream_index);
+ MMCAM_LOG_ERROR("invalid stream index %d", stream_index);
return FALSE;
}
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
if (!sc || !sc->encode_element ||
!sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst) {
- _mmcam_dbg_warn("audiosrc element is not initialized, it will be set later");
+ MMCAM_LOG_WARNING("audiosrc element is not initialized, it will be set later");
return TRUE;
}
- _mmcam_dbg_warn("Commit : sound stream info - type %s, index %d", stream_type, stream_index);
+ MMCAM_LOG_WARNING("Commit : sound stream info - type %s, index %d", stream_type, stream_index);
return _mmcamcorder_set_sound_stream_info(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, stream_type, stream_index);
}
current_state = _mmcamcorder_get_state(handle);
if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- _mmcam_dbg_err("Can not set while CAPTURING");
+ MMCAM_LOG_ERROR("Can not set while CAPTURING");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
current_state = _mmcamcorder_get_state(handle);
if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
- _mmcam_dbg_err("Can not set replay gain enable [state : %d]", current_state);
+ MMCAM_LOG_ERROR("Can not set replay gain enable [state : %d]", current_state);
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
return FALSE;
}
NULL);
if (audio_disable) {
- _mmcam_dbg_err("audio is disabled");
+ MMCAM_LOG_ERROR("audio is disabled");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_CONDITION;
return FALSE;
}
- _mmcam_dbg_log("set replay gain enable : %d", value->value.i_val);
+ MMCAM_LOG_INFO("set replay gain enable : %d", value->value.i_val);
} else if (attr_idx == MM_CAM_AUDIO_REPLAY_GAIN_REFERENCE_LEVEL) {
/* Replay gain reference level */
int replay_gain_enable = FALSE;
NULL);
if (replay_gain_enable == FALSE) {
- _mmcam_dbg_err("replay gain is disabled");
+ MMCAM_LOG_ERROR("replay gain is disabled");
hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_CONDITION;
return FALSE;
}
- _mmcam_dbg_log("set reference level for replay gain : %lf dB", value->value.d_val);
+ MMCAM_LOG_INFO("set reference level for replay gain : %lf dB", value->value.d_val);
} else {
- _mmcam_dbg_err("unknown attribute id %d", attr_idx);
+ MMCAM_LOG_ERROR("unknown attribute id %d", attr_idx);
return FALSE;
}
mmf_return_val_if_fail(hcamcorder, FALSE);
- _mmcam_dbg_log("commit some attributes again");
+ MMCAM_LOG_INFO("commit some attributes again");
attrs = MMF_CAMCORDER_ATTRS(handle);
if (attrs == NULL) {
- _mmcam_dbg_err("Get attribute handle failed.");
+ MMCAM_LOG_ERROR("Get attribute handle failed.");
return FALSE;
}
else
ret = TRUE;
- _mmcam_dbg_log("Done.");
+ MMCAM_LOG_INFO("Done.");
return ret;
}
unsigned int i = 0;
int ret = TRUE;
int attr_idxs[] = {
- MM_CAM_STROBE_MODE
+ MM_CAM_STROBE_MODE,
+ MM_CAM_CAMERA_PTZ_TYPE,
+ MM_CAM_CAMERA_PAN_MECHA,
+ MM_CAM_CAMERA_PAN_ELEC,
+ MM_CAM_CAMERA_TILT_MECHA,
+ MM_CAM_CAMERA_TILT_ELEC
};
mmf_return_val_if_fail(hcamcorder, FALSE);
- _mmcam_dbg_log("commit some attribute again[2]");
+ MMCAM_LOG_INFO("commit some attribute again[2]");
attrs = MMF_CAMCORDER_ATTRS(handle);
if (attrs == NULL) {
- _mmcam_dbg_err("Get attribute handle failed.");
+ MMCAM_LOG_ERROR("Get attribute handle failed.");
return FALSE;
}
else
ret = TRUE;
- _mmcam_dbg_log("Done.");
+ MMCAM_LOG_INFO("Done.");
return ret;
}
attrs = MMF_CAMCORDER_ATTRS(handle);
mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- _mmcam_dbg_log("");
+ MMCAM_LOG_INFO("");
table_size = ARRAY_SIZE(readonly_attributes);
- _mmcam_dbg_log("%d", table_size);
+ MMCAM_LOG_INFO("%d", table_size);
for (i = 0; i < table_size; i++) {
int sCategory = readonly_attributes[i];
attrs = MMF_CAMCORDER_ATTRS(handle);
mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- _mmcam_dbg_log("");
+ MMCAM_LOG_INFO("");
/* add gst_param */
_mmcamcorder_conf_get_value_string_array(hcamcorder->conf_main,
cnt_str = disabled_attr->count;
for (i = 0; i < cnt_str; i++) {
int idx = 0;
- _mmcam_dbg_log("[%d]%s", i, disabled_attr->value[i]);
+ MMCAM_LOG_INFO("[%d]%s", i, disabled_attr->value[i]);
nerror = mm_attrs_get_index(attrs, disabled_attr->value[i], &idx);
if (nerror == MM_ERROR_NONE)
mm_attrs_set_disabled(attrs, idx);
else
- _mmcam_dbg_warn("No ATTR named %s[%d]", disabled_attr->value[i], i);
+ MMCAM_LOG_WARNING("No ATTR named %s[%d]", disabled_attr->value[i], i);
}
}
if (sc->element && sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
- _mmcam_dbg_log("set capture width and height [%dx%d] to camera plugin", width, height);
+ MMCAM_LOG_INFO("set capture width and height [%dx%d] to camera plugin", width, height);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-width", width);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-height", height);
} else {
- _mmcam_dbg_warn("invalid state[%d]", current_state);
+ MMCAM_LOG_WARNING("invalid state[%d]", current_state);
return FALSE;
}
} else {
- _mmcam_dbg_log("element is not created yet");
+ MMCAM_LOG_INFO("element is not created yet");
}
return TRUE;
};
if (hcamcorder == NULL || attribute_name == NULL) {
- _mmcam_dbg_warn("handle[%p] or attribute_name[%p] is NULL.",
+ MMCAM_LOG_WARNING("handle[%p] or attribute_name[%p] is NULL.",
hcamcorder, attribute_name);
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
if (err_attr_name)
*err_attr_name = NULL;
- /*_mmcam_dbg_log( "ENTER" );*/
+ /*MMCAM_LOG_INFO( "ENTER" );*/
attrs = MMF_CAMCORDER_ATTRS(handle);
int idx = -1;
MMAttrsType attr_type = MM_ATTRS_TYPE_INVALID;
- /*_mmcam_dbg_log("NAME : %s", name);*/
+ /*MMCAM_LOG_INFO("NAME : %s", name);*/
/* attribute name check */
if ((ret = mm_attrs_get_index(attrs, name, &idx)) != MM_ERROR_NONE) {
for (j = 0 ; j < 2 ; j++) {
if (!strcmp(name, check_pair_name[i][j])) {
check_pair_value[i][j] = va_arg((var_args), int);
- _mmcam_dbg_log("%s : %d", check_pair_name[i][j], check_pair_value[i][j]);
+ MMCAM_LOG_INFO("%s : %d", check_pair_name[i][j], check_pair_value[i][j]);
matched = TRUE;
break;
}
break;
case MM_ATTRS_TYPE_INVALID:
default:
- _mmcam_dbg_err("Not supported attribute type(%d, name:%s)", attr_type, name);
+ MMCAM_LOG_ERROR("Not supported attribute type(%d, name:%s)", attr_type, name);
if (err_attr_name)
*err_attr_name = strdup(name);
if (attr_info_0.int_array.array[j] == check_pair_value[i][0] &&
attr_info_1.int_array.array[j] == check_pair_value[i][1]) {
/*
- _mmcam_dbg_log("Valid Pair[%s,%s] existed %dx%d[index:%d]",
+ MMCAM_LOG_INFO("Valid Pair[%s,%s] existed %dx%d[index:%d]",
check_pair_name[i][0], check_pair_name[i][1],
check_pair_value[i][0], check_pair_value[i][1], i);
*/
}
if (check_result == FALSE) {
- _mmcam_dbg_err("INVALID pair[%s,%s] %dx%d",
+ MMCAM_LOG_ERROR("INVALID pair[%s,%s] %dx%d",
check_pair_name[i][0], check_pair_name[i][1],
check_pair_value[i][0], check_pair_value[i][1]);
if (err_attr_name) {
hcamcorder->resolution_changed = FALSE;
}
- _mmcam_dbg_log("resolution changed : %d", hcamcorder->resolution_changed);
+ MMCAM_LOG_INFO("resolution changed : %d", hcamcorder->resolution_changed);
}
if (err_name) {
}
}
- /*_mmcam_dbg_log("DONE");*/
+ /*MMCAM_LOG_INFO("DONE");*/
return MM_ERROR_NONE;
}
MMAttrsInfo info;
if ((void *)handle == NULL) {
- _mmcam_dbg_warn("handle %p is NULL", handle);
+ MMCAM_LOG_WARNING("handle %p is NULL", handle);
return FALSE;
}
switch (info.validity_type) {
case MM_ATTRS_VALID_TYPE_INT_ARRAY:
/*
- _mmcam_dbg_log("int array count %d", info.int_array.count);
+ MMCAM_LOG_INFO("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);
+ MMCAM_LOG_INFO("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_LOG_INFO("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);
+ MMCAM_LOG_INFO("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;
break;
default:
- _mmcam_dbg_warn("invalid type %d", info.validity_type);
+ MMCAM_LOG_WARNING("invalid type %d", info.validity_type);
return FALSE;
}