X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_attribute.c;h=fb85d7bd0486433f4c1198e56c5da61283f9e1a6;hb=633f96af86163942d6f4237f0ab2b5204b9e1930;hp=4a10fb8db1dc0ec400e21f6da3b18c0bc1f9b71c;hpb=d1c3989b620b90f0cf2ee7b3df883d49e5208f15;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git diff --git a/src/mm_camcorder_attribute.c b/src/mm_camcorder_attribute.c index 4a10fb8..fb85d7b 100644 --- a/src/mm_camcorder_attribute.c +++ b/src/mm_camcorder_attribute.c @@ -29,9 +29,6 @@ #include #include #include -#ifdef HAVE_WAYLAND -#include -#endif /*----------------------------------------------------------------------- | MACRO DEFINITIONS: | @@ -40,6 +37,7 @@ #define MMCAMCORDER_DEFAULT_CAMERA_HEIGHT 480 #define MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_BITRATE (1024*1024*10) #define MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_GOP_INTERVAL 1000 +#define MMCAMCORDER_DEFAULT_REPLAY_GAIN_REFERENCE_LEVEL 89.0 /*--------------------------------------------------------------------------------------- | GLOBAL VARIABLE DEFINITIONS for internal | @@ -48,7 +46,7 @@ /*----------------------------------------------------------------------- | LOCAL VARIABLE DEFINITIONS for internal | -----------------------------------------------------------------------*/ -/* Readonly attributes list. +/* Readonly attributes list. * If you want to make some attributes read only, write down here. * It will make them read only after composing whole attributes. */ @@ -84,9 +82,9 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_ | GLOBAL FUNCTION DEFINITIONS: | -----------------------------------------------------------------------*/ MMHandleType -_mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) +_mmcamcorder_alloc_attribute(MMHandleType handle, MMCamPreset *info) { - _mmcam_dbg_log( "" ); + _mmcam_dbg_log(""); mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); MMHandleType attrs = 0; @@ -98,8 +96,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) static int flip_list[] = { MM_FLIP_NONE }; static int rotation_list[] = { MM_VIDEO_INPUT_ROTATION_NONE }; static int visible_values[] = { 0, 1 }; /*0: off, 1:on*/ - static int tag_orientation_values[] = - { + static int tag_orientation_values[] = { 1, /*The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side.*/ 2, /*the 0th row is at the visual top of the image, and the 0th column is the visual right-hand side.*/ 3, /*the 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side.*/ @@ -137,7 +134,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) /* basic attributes' info */ mm_cam_attr_construct_info temp_info[] = { - //0 + /* 0 */ { MM_CAM_MODE, /* ID */ "mode", /* Name */ @@ -220,7 +217,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) "camera-device-name", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -248,7 +245,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {ARRAY_SIZE(depth)}, NULL, }, - //10 + /* 10 */ { MM_CAM_AUDIO_CHANNEL, "audio-channel", @@ -265,7 +262,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) "audio-volume", MMF_VALUE_TYPE_DOUBLE, MM_ATTRS_FLAG_RW, - {(void*)1}, + {.value_double = 1.0}, MM_ATTRS_VALID_TYPE_DOUBLE_RANGE, {.double_min = 0.0}, {.double_max = 10.0}, @@ -359,7 +356,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {.int_max = -1}, _mmcamcorder_commit_filter, }, - //20 + /* 20 */ { MM_CAM_FILTER_SHARPNESS, "filter-sharpness", @@ -380,14 +377,14 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_VALID_TYPE_INT_ARRAY, {0}, {0}, - NULL, + _mmcamcorder_commit_camera_format, }, { MM_CAM_CAMERA_RECORDING_MOTION_RATE, "camera-recording-motion-rate", MMF_VALUE_TYPE_DOUBLE, MM_ATTRS_FLAG_RW, - {(void*)1}, + {.value_double = 1.0}, MM_ATTRS_VALID_TYPE_DOUBLE_RANGE, {.double_min = 0.0}, {.double_max = _MMCAMCORDER_MAX_DOUBLE}, @@ -470,7 +467,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {0}, _mmcamcorder_commit_camera_af_scan_range, }, - //30 + /* 30 */ { MM_CAM_CAMERA_EXPOSURE_MODE, "camera-exposure-mode", @@ -557,7 +554,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_VALID_TYPE_INT_RANGE, {.int_min = 0}, {.int_max = 1}, - NULL, + _mmcamcorder_commit_camera_fps, }, { MM_CAM_CAMERA_DELAY_ATTR_SETTING, @@ -579,9 +576,9 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_VALID_TYPE_INT_RANGE, {.int_min = 0}, {.int_max = _MMCAMCORDER_MAX_INT}, - NULL, + _mmcamcorder_commit_encoder_bitrate, }, - // 40 + /* 40 */ { MM_CAM_VIDEO_ENCODER_BITRATE, "video-encoder-bitrate", @@ -591,7 +588,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_VALID_TYPE_INT_RANGE, {.int_min = 0}, {.int_max = _MMCAMCORDER_MAX_INT}, - NULL, + _mmcamcorder_commit_encoder_bitrate, }, { MM_CAM_IMAGE_ENCODER_QUALITY, @@ -675,7 +672,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) "display-handle", MMF_VALUE_TYPE_DATA, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -692,7 +689,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {0}, NULL, }, - // 50 + /* 50 */ { MM_CAM_DISPLAY_SURFACE, "display-surface", @@ -803,7 +800,8 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {.int_max = MM_DISPLAY_ROTATION_270}, _mmcamcorder_commit_display_rotation, }, - { // 60 + /* 60 */ + { MM_CAM_DISPLAY_VISIBLE, "display-visible", MMF_VALUE_TYPE_INT, @@ -841,7 +839,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) "target-filename", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -856,7 +854,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_VALID_TYPE_INT_RANGE, {.int_min = 0}, {.int_max = _MMCAMCORDER_MAX_INT}, - NULL, + _mmcamcorder_commit_recording_max_limit, }, { MM_CAM_TARGET_TIME_LIMIT, @@ -867,7 +865,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_VALID_TYPE_INT_RANGE, {.int_min = 0}, {.int_max = _MMCAMCORDER_MAX_INT}, - NULL, + _mmcamcorder_commit_recording_max_limit, }, { MM_CAM_TAG_ENABLE, @@ -878,18 +876,18 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_VALID_TYPE_INT_RANGE, {.int_min = 0}, {.int_max = 1}, - NULL, + _mmcamcorder_commit_tag, }, { MM_CAM_TAG_IMAGE_DESCRIPTION, "tag-image-description", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, - NULL, + _mmcamcorder_commit_tag, }, { MM_CAM_TAG_ORIENTATION, @@ -900,52 +898,52 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_VALID_TYPE_INT_ARRAY, {tag_orientation_values}, {ARRAY_SIZE(tag_orientation_values)}, - NULL, + _mmcamcorder_commit_tag, }, { MM_CAM_TAG_SOFTWARE, "tag-software", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, - NULL, + _mmcamcorder_commit_tag, }, - //70 + /* 70 */ { MM_CAM_TAG_LATITUDE, "tag-latitude", MMF_VALUE_TYPE_DOUBLE, MM_ATTRS_FLAG_RW, - {(void*)0}, + {.value_double = 0.0}, MM_ATTRS_VALID_TYPE_DOUBLE_RANGE, {.double_min = -360.0}, {.double_max = 360.0}, - NULL, + _mmcamcorder_commit_tag, }, { MM_CAM_TAG_LONGITUDE, "tag-longitude", MMF_VALUE_TYPE_DOUBLE, MM_ATTRS_FLAG_RW, - {(void*)0}, + {.value_double = 0.0}, MM_ATTRS_VALID_TYPE_DOUBLE_RANGE, {.double_min = -360.0}, {.double_max = 360.0}, - NULL, + _mmcamcorder_commit_tag, }, { MM_CAM_TAG_ALTITUDE, "tag-altitude", MMF_VALUE_TYPE_DOUBLE, MM_ATTRS_FLAG_RW, - {(void*)0}, + {.value_double = 0.0}, MM_ATTRS_VALID_TYPE_DOUBLE_RANGE, {.double_min = -999999.0}, {.double_max = 999999.0}, - NULL, + _mmcamcorder_commit_tag, }, { MM_CAM_STROBE_CONTROL, @@ -1024,7 +1022,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {.int_max = -1}, _mmcamcorder_commit_detect, }, - //80 + /* 80 */ { MM_CAM_DETECT_STATUS, "detect-status", @@ -1096,7 +1094,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) "camera-focal-length", MMF_VALUE_TYPE_DOUBLE, MM_ATTRS_FLAG_RW, - {(void*)0}, + {.value_double = 0.0}, MM_ATTRS_VALID_TYPE_DOUBLE_RANGE, {.double_min = 0.0}, {.double_max = 1000.0}, @@ -1133,41 +1131,41 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_VALID_TYPE_INT_RANGE, {.int_min = 0}, {.int_max = 1}, - NULL, + _mmcamcorder_commit_tag, }, - // 90 + /* 90 */ { MM_CAM_TAG_GPS_TIME_STAMP, "tag-gps-time-stamp", MMF_VALUE_TYPE_DOUBLE, MM_ATTRS_FLAG_RW, - {(void*)0}, + {.value_double = 0.0}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, - NULL, + _mmcamcorder_commit_tag, }, { MM_CAM_TAG_GPS_DATE_STAMP, "tag-gps-date-stamp", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, - NULL, + _mmcamcorder_commit_tag, }, { MM_CAM_TAG_GPS_PROCESSING_METHOD, "tag-gps-processing-method", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, - NULL, + _mmcamcorder_commit_tag, }, { MM_CAM_CAMERA_ROTATION, @@ -1185,7 +1183,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) "captured-screennail", MMF_VALUE_TYPE_DATA, MM_ATTRS_FLAG_READABLE, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -1246,7 +1244,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {0}, _mmcamcorder_commit_display_mode, }, - //100 + /* 100 */ { MM_CAM_AUDIO_DISABLE, "audio-disable", @@ -1285,7 +1283,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) "captured-exif-raw-data", MMF_VALUE_TYPE_DATA, MM_ATTRS_FLAG_READABLE, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -1296,7 +1294,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) "display-evas-surface-sink", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_READABLE, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -1357,7 +1355,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {.int_max = MM_CAMCORDER_TAG_VIDEO_ORT_270}, NULL, }, - //110 + /* 110 */ { MM_CAM_CAMERA_PAN_MECHA, "camera-pan-mecha", @@ -1468,6 +1466,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {.int_max = TRUE}, NULL, }, + /* 120 */ { MM_CAM_ENCODED_PREVIEW_BITRATE, "encoded-preview-bitrate", @@ -1490,7 +1489,6 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {.int_max = _MMCAMCORDER_MAX_INT}, _mmcamcorder_commit_encoded_preview_gop_interval, }, - //120 { MM_CAM_RECORDER_TAG_ENABLE, "recorder-tag-enable", @@ -1507,7 +1505,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) "display-socket-path", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -1529,33 +1527,88 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) "root-directory", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, NULL, }, { + MM_CAM_SOUND_STREAM_INDEX, + "sound-stream-index", + MMF_VALUE_TYPE_INT, + MM_ATTRS_FLAG_RW, + {(void*)-1}, + MM_ATTRS_VALID_TYPE_INT_RANGE, + {.int_min = -1}, + {.int_max = _MMCAMCORDER_MAX_INT}, + NULL, + }, + { MM_CAM_SOUND_STREAM_TYPE, "sound-stream-type", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, + _mmcamcorder_commit_sound_stream_info, + }, + { + MM_CAM_DISPLAY_REUSE_HINT, + "display-reuse-hint", + MMF_VALUE_TYPE_INT, + MM_ATTRS_FLAG_RW, + {(void*)FALSE}, + MM_ATTRS_VALID_TYPE_INT_RANGE, + {.int_min = FALSE}, + {.int_max = TRUE}, NULL, }, { - MM_CAM_SOUND_STREAM_INDEX, - "sound-stream-index", + MM_CAM_DISPLAY_REUSE_ELEMENT, + "display-reuse-element", + MMF_VALUE_TYPE_DATA, + MM_ATTRS_FLAG_RW, + {NULL}, + MM_ATTRS_VALID_TYPE_NONE, + {0}, + {0}, + NULL, + }, + { + MM_CAM_GDBUS_CONNECTION, + "gdbus-connection", + MMF_VALUE_TYPE_DATA, + MM_ATTRS_FLAG_RW, + {NULL}, + MM_ATTRS_VALID_TYPE_NONE, + {0}, + {0}, + NULL, + }, + { + MM_CAM_AUDIO_REPLAY_GAIN_ENABLE, + "audio-replay-gain-enable", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, - {(void*)-1}, + {(void*)FALSE}, MM_ATTRS_VALID_TYPE_INT_RANGE, - {.int_min = -1}, - {.int_max = _MMCAMCORDER_MAX_INT}, - _mmcamcorder_commit_sound_stream_info, + {.int_min = 0}, + {.int_max = 1}, + _mmcamcorder_commit_audio_replay_gain, + }, + { + MM_CAM_AUDIO_REPLAY_GAIN_REFERENCE_LEVEL, + "audio-replay-gain-reference-level", + MMF_VALUE_TYPE_DOUBLE, + MM_ATTRS_FLAG_RW, + {.value_double = MMCAMCORDER_DEFAULT_REPLAY_GAIN_REFERENCE_LEVEL}, + MM_ATTRS_VALID_TYPE_DOUBLE_RANGE, + {.double_min = 0.0}, + {.double_max = 150.0}, + _mmcamcorder_commit_audio_replay_gain, } }; @@ -1582,10 +1635,10 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) _mmcam_dbg_log("Create Camcorder Attributes[%p, %d]", attrs_const_info, attr_count); attrs = mmf_attrs_new_from_data("Camcorder_Attributes", - attrs_const_info, - attr_count, - _mmcamcorder_commit_camcorder_attrs, - (void *)handle); + attrs_const_info, + attr_count, + _mmcamcorder_commit_camcorder_attrs, + (void *)handle); free(attrs_const_info); attrs_const_info = NULL; @@ -1599,50 +1652,53 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) __mmcamcorder_set_conf_to_valid_info(handle); - for (idx = 0; idx < attr_count; idx++) - { -/* _mmcam_dbg_log("Valid type [%s:%d, %d, %d]", cam_attrs_const_info[idx].name, cam_attrs_const_info[idx].validity_type - , cam_attrs_const_info[idx].validity_value1, cam_attrs_const_info[idx].validity_value2); -*/ - mmf_attrs_set_valid_type (attrs, idx, hcamcorder->cam_attrs_const_info[idx].validity_type); + for (idx = 0; idx < attr_count; idx++) { + mm_cam_attr_construct_info *attr_info = &hcamcorder->cam_attrs_const_info[idx]; - switch (hcamcorder->cam_attrs_const_info[idx].validity_type) - { - case MM_ATTRS_VALID_TYPE_INT_ARRAY: - if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array && - hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) { - mmf_attrs_set_valid_array(attrs, idx, - (const int *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array), - hcamcorder->cam_attrs_const_info[idx].validity_value_2.count, - hcamcorder->cam_attrs_const_info[idx].default_value.value_int); - } +/* + _mmcam_dbg_log("Valid type [%s:%d, %d, %d]", + attr_info->name, attr_info->validity_type, + attr_info->validity_value1, attr_info->validity_value2); +*/ + mmf_attrs_set_valid_type(attrs, idx, attr_info->validity_type); + + switch (attr_info->validity_type) { + case MM_ATTRS_VALID_TYPE_INT_ARRAY: + if (attr_info->validity_value_1.int_array && + attr_info->validity_value_2.count > 0) { + mmf_attrs_set_valid_array(attrs, idx, + (const int *)(attr_info->validity_value_1.int_array), + attr_info->validity_value_2.count, + attr_info->default_value.value_int); + } break; - case MM_ATTRS_VALID_TYPE_INT_RANGE: - mmf_attrs_set_valid_range(attrs, idx, - hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_min, - hcamcorder->cam_attrs_const_info[idx].validity_value_2.int_max, - hcamcorder->cam_attrs_const_info[idx].default_value.value_int); + case MM_ATTRS_VALID_TYPE_INT_RANGE: + mmf_attrs_set_valid_range(attrs, idx, + attr_info->validity_value_1.int_min, + attr_info->validity_value_2.int_max, + attr_info->default_value.value_int); break; - case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY: - if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array && - hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) { - mmf_attrs_set_valid_double_array(attrs, idx, - (const double *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array), - hcamcorder->cam_attrs_const_info[idx].validity_value_2.count, - hcamcorder->cam_attrs_const_info[idx].default_value.value_double); - } + case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY: + if (attr_info->validity_value_1.double_array && + attr_info->validity_value_2.count > 0) { + mmf_attrs_set_valid_double_array(attrs, idx, + (const double *)(attr_info->validity_value_1.double_array), + attr_info->validity_value_2.count, + attr_info->default_value.value_double); + } break; - case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE: - mmf_attrs_set_valid_double_range(attrs, idx, - hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_min, - hcamcorder->cam_attrs_const_info[idx].validity_value_2.double_max, - hcamcorder->cam_attrs_const_info[idx].default_value.value_double); + case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE: + mmf_attrs_set_valid_double_range(attrs, idx, + attr_info->validity_value_1.double_min, + attr_info->validity_value_2.double_max, + attr_info->default_value.value_double); + ((mmf_attrs_t *)attrs)->items[idx].value.value.d_val = attr_info->default_value.value_double; break; - case MM_ATTRS_VALID_TYPE_NONE: + case MM_ATTRS_VALID_TYPE_NONE: break; - case MM_ATTRS_VALID_TYPE_INVALID: - default: - _mmcam_dbg_err("Valid type error."); + case MM_ATTRS_VALID_TYPE_INVALID: + default: + _mmcam_dbg_err("Valid type error."); break; } } @@ -1684,11 +1740,11 @@ _mmcamcorder_get_attributes(MMHandleType handle, char **err_attr_name, const ch MMHandleType attrs = 0; int ret = MM_ERROR_NONE; - mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT ); -// mmf_return_val_if_fail( err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT ); + mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); + /*mmf_return_val_if_fail(err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);*/ attrs = MMF_CAMCORDER_ATTRS(handle); - mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED ); + mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED); ret = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, var_args); @@ -1702,28 +1758,35 @@ _mmcamcorder_set_attributes(MMHandleType handle, char **err_attr_name, const cha MMHandleType attrs = 0; int ret = MM_ERROR_NONE; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + va_list var_args_copy; - mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT ); -// mmf_return_val_if_fail( err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT ); + mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); + /*mmf_return_val_if_fail(err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);*/ if (!_MMCAMCORDER_TRYLOCK_CMD(handle)) { _mmcam_dbg_err("Another command is running."); return MM_ERROR_CAMCORDER_CMD_IS_RUNNING; } + /* copy var_args to keep original var_args */ + va_copy(var_args_copy, var_args); + attrs = MMF_CAMCORDER_ATTRS(handle); if (attrs) { - ret = __mmcamcorder_check_valid_pair( handle, err_attr_name, attribute_name, var_args ); + ret = __mmcamcorder_check_valid_pair(handle, err_attr_name, attribute_name, var_args); } else { - _mmcam_dbg_err("handle 0x%x, attrs is NULL, attr name [%s]", handle, attribute_name); + _mmcam_dbg_err("handle %p, attrs is NULL, attr name [%s]", handle, attribute_name); ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED; } if (ret == MM_ERROR_NONE) { hcamcorder->error_code = MM_ERROR_NONE; - ret = mm_attrs_set_valist(attrs, err_attr_name, attribute_name, var_args); + /* In 64bit environment, unexpected result is returned if var_args is used again. */ + ret = mm_attrs_set_valist(attrs, err_attr_name, attribute_name, var_args_copy); } + va_end(var_args_copy); + _MMCAMCORDER_UNLOCK_CMD(handle); if (ret != MM_ERROR_NONE) { @@ -1747,48 +1810,46 @@ _mmcamcorder_get_attribute_info(MMHandleType handle, const char *attr_name, MMCa MMAttrsInfo attrinfo; int ret = MM_ERROR_NONE; - mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT ); - mmf_return_val_if_fail( attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT ); - mmf_return_val_if_fail( info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT ); + mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); + mmf_return_val_if_fail(attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); + mmf_return_val_if_fail(info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); attrs = MMF_CAMCORDER_ATTRS(handle); - mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); + mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); ret = mm_attrs_get_info_by_name(attrs, attr_name, (MMAttrsInfo*)&attrinfo); - if (ret == MM_ERROR_NONE) - { + if (ret == MM_ERROR_NONE) { memset(info, 0x00, sizeof(MMCamAttrsInfo)); info->type = attrinfo.type; info->flag = attrinfo.flag; - info->validity_type= attrinfo.validity_type; + info->validity_type = attrinfo.validity_type; - switch(attrinfo.validity_type) - { - case MM_ATTRS_VALID_TYPE_INT_ARRAY: - info->int_array.array = attrinfo.int_array.array; - info->int_array.count = attrinfo.int_array.count; - info->int_array.def = attrinfo.int_array.dval; + switch (attrinfo.validity_type) { + case MM_ATTRS_VALID_TYPE_INT_ARRAY: + info->int_array.array = attrinfo.int_array.array; + info->int_array.count = attrinfo.int_array.count; + info->int_array.def = attrinfo.int_array.dval; break; - case MM_ATTRS_VALID_TYPE_INT_RANGE: - info->int_range.min = attrinfo.int_range.min; - info->int_range.max = attrinfo.int_range.max; - info->int_range.def = attrinfo.int_range.dval; + case MM_ATTRS_VALID_TYPE_INT_RANGE: + info->int_range.min = attrinfo.int_range.min; + info->int_range.max = attrinfo.int_range.max; + info->int_range.def = attrinfo.int_range.dval; break; - case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY: - info->double_array.array = attrinfo.double_array.array; - info->double_array.count = attrinfo.double_array.count; - info->double_array.def = attrinfo.double_array.dval; + case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY: + info->double_array.array = attrinfo.double_array.array; + info->double_array.count = attrinfo.double_array.count; + info->double_array.def = attrinfo.double_array.dval; break; - case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE: - info->double_range.min = attrinfo.double_range.min; - info->double_range.max = attrinfo.double_range.max; - info->double_range.def = attrinfo.double_range.dval; + case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE: + info->double_range.min = attrinfo.double_range.min; + info->double_range.max = attrinfo.double_range.max; + info->double_range.def = attrinfo.double_range.dval; break; - case MM_ATTRS_VALID_TYPE_NONE: + case MM_ATTRS_VALID_TYPE_NONE: break; - case MM_ATTRS_VALID_TYPE_INVALID: - default: + case MM_ATTRS_VALID_TYPE_INVALID: + default: break; } } @@ -1798,7 +1859,7 @@ _mmcamcorder_get_attribute_info(MMHandleType handle, const char *attr_name, MMCa bool -_mmcamcorder_commit_camcorder_attrs (int attr_idx, const char *attr_name, const mmf_value_t *value, void *commit_param) +_mmcamcorder_commit_camcorder_attrs(int attr_idx, const char *attr_name, const mmf_value_t *value, void *commit_param) { bool bret = FALSE; mmf_camcorder_t *hcamcorder = NULL; @@ -1810,11 +1871,10 @@ _mmcamcorder_commit_camcorder_attrs (int attr_idx, const char *attr_name, const hcamcorder = MMF_CAMCORDER(commit_param); - if (hcamcorder->cam_attrs_const_info[attr_idx].attr_commit) { + if (hcamcorder->cam_attrs_const_info[attr_idx].attr_commit) bret = hcamcorder->cam_attrs_const_info[attr_idx].attr_commit((MMHandleType)commit_param, attr_idx, value); - } else { + else bret = TRUE; - } return bret; } @@ -1907,11 +1967,13 @@ int __mmcamcorder_release_conf_valid_info(MMHandleType handle) } -bool _mmcamcorder_commit_capture_width (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_capture_width(MMHandleType handle, int attr_idx, const mmf_value_t *value) { MMHandleType attr = 0; int current_state = MM_CAMCORDER_STATE_NONE; + mmf_return_val_if_fail(handle && value, FALSE); + attr = MMF_CAMCORDER_ATTRS(handle); mmf_return_val_if_fail(attr, FALSE); @@ -1942,7 +2004,7 @@ bool _mmcamcorder_commit_capture_width (MMHandleType handle, int attr_idx, const } -bool _mmcamcorder_commit_capture_height (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_capture_height(MMHandleType handle, int attr_idx, const mmf_value_t *value) { int current_state = MM_CAMCORDER_STATE_NONE; @@ -1963,29 +2025,44 @@ bool _mmcamcorder_commit_capture_height (MMHandleType handle, int attr_idx, cons } -bool _mmcamcorder_commit_capture_break_cont_shot (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_capture_break_cont_shot(MMHandleType handle, int attr_idx, const mmf_value_t *value) { - int current_state = _mmcamcorder_get_state( handle); - int ivalue = value->value.i_val; - - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + int current_state = 0; + int ivalue = 0; + const char *videosrc_name = NULL; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - GstCameraControl *control = NULL; - type_element *VideosrcElement = NULL; + _MMCamcorderImageInfo *info = NULL; + GstCameraControl *control = NULL; + type_element *VideosrcElement = NULL; - const char *videosrc_name = NULL; + mmf_return_val_if_fail(handle && value, FALSE); + + current_state = _mmcamcorder_get_state(handle); + ivalue = value->value.i_val; _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, - "VideosrcElement", - &VideosrcElement ); + CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, + "VideosrcElement", + &VideosrcElement); _mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name); sc = MMF_CAMCORDER_SUBCONTEXT(handle); if (!sc) return TRUE; + info = sc->info_image; + if (!info) { + _mmcam_dbg_err("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"); + } + if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) { _mmcam_dbg_warn("Can't cast Video source into camera control."); return TRUE; @@ -1999,7 +2076,7 @@ bool _mmcamcorder_commit_capture_break_cont_shot (MMHandleType handle, int attr_ _mmcam_dbg_warn("cast CAMERA_CONTROL failed"); } } else { - _mmcam_dbg_warn( "Commit Break continuous shot : No effect. value[%d],current state[%d]", ivalue, current_state ); + _mmcam_dbg_warn("Commit Break continuous shot : No effect. value[%d],current state[%d]", ivalue, current_state); } return TRUE; @@ -2010,16 +2087,15 @@ bool _mmcamcorder_commit_capture_count(MMHandleType handle, int attr_idx, const { int mode = MM_CAMCORDER_MODE_VIDEO_CAPTURE; int current_state = MM_CAMCORDER_STATE_NONE; - mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - mmf_return_val_if_fail(hcamcorder, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); 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", - current_state, mode, value->value.i_val); + current_state, mode, value->value.i_val); if (mode != MM_CAMCORDER_MODE_AUDIO && current_state != MM_CAMCORDER_STATE_CAPTURING) { @@ -2035,7 +2111,7 @@ bool _mmcamcorder_commit_capture_sound_enable(MMHandleType handle, int attr_idx, { mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - mmf_return_val_if_fail(hcamcorder, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); _mmcam_dbg_log("shutter sound policy: %d", hcamcorder->shutter_sound_policy); @@ -2051,20 +2127,21 @@ bool _mmcamcorder_commit_capture_sound_enable(MMHandleType handle, int attr_idx, } -bool _mmcamcorder_commit_audio_volume (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_audio_volume(MMHandleType handle, int attr_idx, const mmf_value_t *value) { int current_state = MM_CAMCORDER_STATE_NONE; _MMCamcorderSubContext *sc = NULL; bool bret = FALSE; + mmf_return_val_if_fail(handle && value, FALSE); + sc = MMF_CAMCORDER_SUBCONTEXT(handle); - if (!sc) { + if (!sc) return TRUE; - } - current_state = _mmcamcorder_get_state( handle); + current_state = _mmcamcorder_get_state(handle); - if ((current_state == MM_CAMCORDER_STATE_RECORDING)||(current_state == MM_CAMCORDER_STATE_PAUSED)) { + if ((current_state == MM_CAMCORDER_STATE_RECORDING) || (current_state == MM_CAMCORDER_STATE_PAUSED)) { double mslNewVal = 0; mslNewVal = value->value.d_val; @@ -2089,22 +2166,54 @@ bool _mmcamcorder_commit_audio_volume (MMHandleType handle, int attr_idx, const } -bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_format(MMHandleType handle, int attr_idx, const mmf_value_t *value) +{ + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + int current_state = MM_CAMCORDER_STATE_NONE; + + mmf_return_val_if_fail(hcamcorder && value, FALSE); + + current_state = _mmcamcorder_get_state(handle); + if (current_state > MM_CAMCORDER_STATE_READY) { + _mmcam_dbg_err("invalid state %d", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; + } + + return TRUE; +} + + +bool _mmcamcorder_commit_camera_fps(MMHandleType handle, int attr_idx, const mmf_value_t *value) { + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); MMCamAttrsInfo fps_info; int resolution_width = 0; int resolution_height = 0; - int i; - int ret; + int i = 0; + int ret = 0; + int current_state = MM_CAMCORDER_STATE_NONE; + + mmf_return_val_if_fail(hcamcorder && value, FALSE); + + current_state = _mmcamcorder_get_state(handle); + if (current_state > MM_CAMCORDER_STATE_PREPARE) { + _mmcam_dbg_err("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); ret = mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_WIDTH, &resolution_width, - MMCAM_CAMERA_HEIGHT, &resolution_height, - NULL); + MMCAM_CAMERA_WIDTH, &resolution_width, + MMCAM_CAMERA_HEIGHT, &resolution_height, + NULL); - if(ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) { _mmcam_dbg_err("FAILED : coult not get resolution values."); return FALSE; } @@ -2116,12 +2225,12 @@ bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mm } for (i = 0 ; i < fps_info.int_array.count ; i++) { - if(value->value.i_val == fps_info.int_array.array[i]) { + if (value->value.i_val == fps_info.int_array.array[i]) return TRUE; - } } _mmcam_dbg_err("FAILED : %d is not supported FPS", value->value.i_val); + return FALSE; } @@ -2129,30 +2238,29 @@ bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mm bool _mmcamcorder_commit_camera_recording_motion_rate(MMHandleType handle, int attr_idx, const mmf_value_t *value) { int current_state = MM_CAMCORDER_STATE_NONE; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - mmf_return_val_if_fail(handle, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); current_state = _mmcamcorder_get_state(handle); - if (current_state > MM_CAMCORDER_STATE_PREPARE) { _mmcam_dbg_warn("invalid state %d", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } /* Verify recording motion rate */ if (value->value.d_val > 0.0) { sc = MMF_CAMCORDER_SUBCONTEXT(handle); - if (!sc) { + if (!sc) return TRUE; - } /* set is_slow flag */ - if (value->value.d_val != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) { + if (value->value.d_val != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) sc->is_modified_rate = TRUE; - } else { + else sc->is_modified_rate = FALSE; - } _mmcam_dbg_log("Set slow motion rate %lf", value->value.d_val); return TRUE; @@ -2171,12 +2279,11 @@ bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const m mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - mmf_return_val_if_fail(hcamcorder, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); - if (!sc) { + if (!sc) return TRUE; - } attr = MMF_CAMCORDER_ATTRS(handle); mmf_return_val_if_fail(attr, FALSE); @@ -2201,10 +2308,10 @@ bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const m int codec_type = MM_IMAGE_CODEC_JPEG; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_HEIGHT, &height, - MMCAM_CAMERA_FORMAT, &preview_format, - MMCAM_IMAGE_ENCODER, &codec_type, - NULL); + MMCAM_CAMERA_HEIGHT, &height, + MMCAM_CAMERA_FORMAT, &preview_format, + MMCAM_IMAGE_ENCODER, &codec_type, + NULL); if (current_state == MM_CAMCORDER_STATE_PREPARE) { if (hcamcorder->resolution_changed == FALSE) { @@ -2268,12 +2375,11 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - mmf_return_val_if_fail(hcamcorder, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); - if (!sc) { + if (!sc) return TRUE; - } attr = MMF_CAMCORDER_ATTRS(hcamcorder); mmf_return_val_if_fail(attr, FALSE); @@ -2283,6 +2389,7 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const if (current_state > MM_CAMCORDER_STATE_PREPARE) { _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } else { int width = 0; @@ -2292,11 +2399,11 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const int video_stabilization = 0; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_WIDTH, &width, - MMCAM_CAMERA_FORMAT, &preview_format, - MMCAM_IMAGE_ENCODER, &codec_type, - MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization, - NULL); + MMCAM_CAMERA_WIDTH, &width, + MMCAM_CAMERA_FORMAT, &preview_format, + MMCAM_IMAGE_ENCODER, &codec_type, + MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization, + NULL); sc->info_video->preview_width = width; sc->info_video->preview_height = height; @@ -2360,32 +2467,37 @@ bool _mmcamcorder_commit_video_size(MMHandleType handle, int attr_idx, const mmf int current_state = MM_CAMCORDER_STATE_NONE; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - mmf_return_val_if_fail(hcamcorder, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); 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); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } else { _mmcam_dbg_warn("Video Resolution %d [attr_idx %d] ", - value->value.i_val, attr_idx); + value->value.i_val, attr_idx); return TRUE; } } -bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_zoom(MMHandleType handle, int attr_idx, const mmf_value_t *value) { + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; int current_state = MM_CAMCORDER_STATE_NONE; GstCameraControl *control = NULL; - int zoom_level = value->value.i_val; - int zoom_type; + int zoom_level = 0; + int zoom_type = 0; + + mmf_return_val_if_fail(hcamcorder && value, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); - if (!sc) { + if (!sc) return TRUE; - } + + zoom_level = value->value.i_val; _mmcam_dbg_log("(%d)", attr_idx); @@ -2394,15 +2506,15 @@ bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const m _mmcam_dbg_log("will be applied when preview starts"); return TRUE; } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) { - _mmcam_dbg_warn("Can not set while CAPTURING"); + _mmcam_dbg_err("Can not set while CAPTURING"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } - if (attr_idx == MM_CAM_CAMERA_OPTICAL_ZOOM) { + if (attr_idx == MM_CAM_CAMERA_OPTICAL_ZOOM) zoom_type = GST_CAMERA_CONTROL_OPTICAL_ZOOM; - } else { + else zoom_type = GST_CAMERA_CONTROL_DIGITAL_ZOOM; - } if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) { int ret = FALSE; @@ -2412,7 +2524,7 @@ bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const m return TRUE; } - control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); if (control == NULL) { _mmcam_dbg_err("cast CAMERA_CONTROL failed"); return FALSE; @@ -2435,6 +2547,7 @@ bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const m bool _mmcamcorder_commit_camera_ptz_type(MMHandleType handle, int attr_idx, const mmf_value_t *value) { + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; int current_state = MM_CAMCORDER_STATE_NONE; @@ -2443,6 +2556,8 @@ bool _mmcamcorder_commit_camera_ptz_type(MMHandleType handle, int attr_idx, cons const GList *controls = NULL; const GList *item = NULL; + mmf_return_val_if_fail(hcamcorder && value, FALSE); + sc = MMF_CAMCORDER_SUBCONTEXT(handle); mmf_return_val_if_fail(sc, TRUE); @@ -2452,6 +2567,7 @@ bool _mmcamcorder_commit_camera_ptz_type(MMHandleType handle, int attr_idx, cons if (current_state < MM_CAMCORDER_STATE_PREPARE || current_state == MM_CAMCORDER_STATE_CAPTURING) { _mmcam_dbg_err("invalid state[%d]", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } @@ -2487,9 +2603,7 @@ bool _mmcamcorder_commit_camera_ptz_type(MMHandleType handle, int attr_idx, cons } } - if (item == NULL) { - _mmcam_dbg_warn("failed to find tilt control channel"); - } + _mmcam_dbg_warn("failed to find tilt control channel"); } return FALSE; @@ -2498,6 +2612,7 @@ bool _mmcamcorder_commit_camera_ptz_type(MMHandleType handle, int attr_idx, cons bool _mmcamcorder_commit_camera_pan(MMHandleType handle, int attr_idx, const mmf_value_t *value) { + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; int current_state = MM_CAMCORDER_STATE_NONE; @@ -2506,6 +2621,8 @@ bool _mmcamcorder_commit_camera_pan(MMHandleType handle, int attr_idx, const mmf const GList *controls = NULL; const GList *item = NULL; + mmf_return_val_if_fail(hcamcorder && value, FALSE); + sc = MMF_CAMCORDER_SUBCONTEXT(handle); mmf_return_val_if_fail(sc, TRUE); @@ -2515,6 +2632,7 @@ bool _mmcamcorder_commit_camera_pan(MMHandleType handle, int attr_idx, const mmf if (current_state < MM_CAMCORDER_STATE_PREPARE || current_state == MM_CAMCORDER_STATE_CAPTURING) { _mmcam_dbg_err("invalid state[%d]", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } @@ -2550,9 +2668,7 @@ bool _mmcamcorder_commit_camera_pan(MMHandleType handle, int attr_idx, const mmf } } - if (item == NULL) { - _mmcam_dbg_warn("failed to find pan control channel"); - } + _mmcam_dbg_warn("failed to find pan control channel"); } return FALSE; @@ -2561,6 +2677,7 @@ bool _mmcamcorder_commit_camera_pan(MMHandleType handle, int attr_idx, const mmf bool _mmcamcorder_commit_camera_tilt(MMHandleType handle, int attr_idx, const mmf_value_t *value) { + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; int current_state = MM_CAMCORDER_STATE_NONE; @@ -2569,6 +2686,8 @@ bool _mmcamcorder_commit_camera_tilt(MMHandleType handle, int attr_idx, const mm const GList *controls = NULL; const GList *item = NULL; + mmf_return_val_if_fail(hcamcorder && value, FALSE); + sc = MMF_CAMCORDER_SUBCONTEXT(handle); mmf_return_val_if_fail(sc, TRUE); @@ -2578,6 +2697,7 @@ bool _mmcamcorder_commit_camera_tilt(MMHandleType handle, int attr_idx, const mm if (current_state < MM_CAMCORDER_STATE_PREPARE || current_state == MM_CAMCORDER_STATE_CAPTURING) { _mmcam_dbg_err("invalid state[%d]", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } @@ -2613,19 +2733,18 @@ bool _mmcamcorder_commit_camera_tilt(MMHandleType handle, int attr_idx, const mm } } - if (item == NULL) { - _mmcam_dbg_warn("failed to find tilt control channel"); - } + _mmcam_dbg_warn("failed to find tilt control channel"); } return FALSE; } -bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_focus_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value) { MMHandleType attr = 0; int current_state = MM_CAMCORDER_STATE_NONE; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; GstCameraControl *control = NULL; int mslVal; @@ -2633,6 +2752,8 @@ bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, c int cur_focus_mode = 0; int cur_focus_range = 0; + mmf_return_val_if_fail(hcamcorder && value, FALSE); + attr = MMF_CAMCORDER_ATTRS(handle); mmf_return_val_if_fail(attr, FALSE); @@ -2652,6 +2773,10 @@ bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, c if (current_state < MM_CAMCORDER_STATE_NULL) { _mmcam_dbg_log("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"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; } if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) { @@ -2663,14 +2788,14 @@ bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, c return TRUE; } - control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); if (control == NULL) { _mmcam_dbg_err("cast CAMERA_CONTROL failed"); return FALSE; } mslVal = value->value.i_val; - set_focus_mode = _mmcamcorder_convert_msl_to_sensor( handle, attr_idx, mslVal ); + set_focus_mode = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal); mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_SCAN_RANGE, &info); flags = info.flag; @@ -2700,8 +2825,9 @@ bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, c } -bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_af_scan_range(MMHandleType handle, int attr_idx, const mmf_value_t *value) { + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; GstCameraControl *control = NULL; int current_state = MM_CAMCORDER_STATE_NONE; @@ -2712,6 +2838,8 @@ bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx int msl_mode = MM_CAMCORDER_FOCUS_MODE_NONE; int converted_mode = 0; + mmf_return_val_if_fail(hcamcorder && value, FALSE); + sc = MMF_CAMCORDER_SUBCONTEXT(handle); if (!sc) return TRUE; @@ -2731,6 +2859,10 @@ bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx if (current_state < MM_CAMCORDER_STATE_PREPARE) { _mmcam_dbg_log("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"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; } if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) { @@ -2739,25 +2871,25 @@ bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx return TRUE; } - control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); if (control == NULL) { _mmcam_dbg_err("cast CAMERA_CONTROL failed"); return FALSE; } mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FOCUS_MODE, &msl_mode, NULL); - converted_mode = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_CAMERA_FOCUS_MODE, msl_mode ); + converted_mode = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_FOCUS_MODE, msl_mode); if (gst_camera_control_get_focus(control, &cur_focus_mode, &cur_focus_range)) { if ((newVal != cur_focus_range) || (converted_mode != cur_focus_mode)) { if (gst_camera_control_set_focus(control, converted_mode, newVal)) { - //_mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal); + /*_mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal);*/ return TRUE; } else { _mmcam_dbg_warn("Failed to set AF mode[%d]", mslVal); } } else { - //_mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal); + /*_mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal);*/ return TRUE; } } else { @@ -2771,8 +2903,9 @@ bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx } -bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_af_touch_area(MMHandleType handle, int attr_idx, const mmf_value_t *value) { + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; GstCameraControl *control = NULL; GstCameraControlRectType set_area = { 0, 0, 0, 0 }; @@ -2788,10 +2921,11 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx MMCamAttrsInfo info_w; MMCamAttrsInfo info_h; + mmf_return_val_if_fail(hcamcorder && value, FALSE); + sc = MMF_CAMCORDER_SUBCONTEXT(handle); - if (!sc) { + if (!sc) return TRUE; - } _mmcam_dbg_log("(%d)", attr_idx); @@ -2799,11 +2933,15 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx if (current_state < MM_CAMCORDER_STATE_PREPARE) { _mmcam_dbg_log("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"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; } ret = mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_FOCUS_MODE, &focus_mode, - NULL); + MMCAM_CAMERA_FOCUS_MODE, &focus_mode, + NULL); if (ret != MM_ERROR_NONE) { _mmcam_dbg_warn("Failed to get FOCUS MODE.[%x]", ret); return FALSE; @@ -2832,10 +2970,10 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx if (!((info_y.flag|info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED)) { set_area.x = value->value.i_val; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y, - MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width, - MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height, - NULL); + MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y, + MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width, + MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height, + NULL); do_set = TRUE; } else { _mmcam_dbg_log("Just store AF area[x:%d]", value->value.i_val); @@ -2848,13 +2986,13 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx if (!((info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED)) { set_area.y = value->value.i_val; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_AF_TOUCH_X, &set_area.x, - MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width, - MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height, - NULL); + MMCAM_CAMERA_AF_TOUCH_X, &set_area.x, + MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width, + MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height, + NULL); do_set = TRUE; } else { - _mmcam_dbg_log( "Just store AF area[y:%d]", value->value.i_val ); + _mmcam_dbg_log("Just store AF area[y:%d]", value->value.i_val); return TRUE; } break; @@ -2863,10 +3001,10 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx if (!(info_h.flag & MM_ATTRS_FLAG_MODIFIED)) { set_area.width = value->value.i_val; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_AF_TOUCH_X, &set_area.x, - MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y, - MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height, - NULL); + MMCAM_CAMERA_AF_TOUCH_X, &set_area.x, + MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y, + MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height, + NULL); do_set = TRUE; } else { _mmcam_dbg_log("Just store AF area[width:%d]", value->value.i_val); @@ -2876,10 +3014,10 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx case MM_CAM_CAMERA_AF_TOUCH_HEIGHT: set_area.height = value->value.i_val; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_AF_TOUCH_X, &set_area.x, - MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y, - MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width, - NULL); + MMCAM_CAMERA_AF_TOUCH_X, &set_area.x, + MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y, + MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width, + NULL); do_set = TRUE; break; default: @@ -2894,7 +3032,7 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx return FALSE; } - control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); if (control == NULL) { _mmcam_dbg_err("cast CAMERA_CONTROL failed"); return FALSE; @@ -2911,49 +3049,48 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx ratio_height = (float)info->video_height / (float)info->preview_height; _mmcam_dbg_log("original area %d,%d,%dx%d, resolution ratio : width %f, height %f", - set_area.x, set_area.y, set_area.width, set_area.height, ratio_width, ratio_height); + set_area.x, set_area.y, set_area.width, set_area.height, ratio_width, ratio_height); set_area.x = (int)((float)set_area.x * ratio_width); set_area.y = (int)((float)set_area.y * ratio_height); set_area.width = (int)((float)set_area.width * ratio_width); set_area.height = (int)((float)set_area.height * ratio_height); - if (set_area.width <= 0) { + if (set_area.width <= 0) set_area.width = 1; - } - if (set_area.height <= 0) { + + if (set_area.height <= 0) set_area.height = 1; - } _mmcam_dbg_log("converted area %d,%d,%dx%d", - set_area.x, set_area.y, set_area.width, set_area.height); + set_area.x, set_area.y, set_area.width, set_area.height); } else { _mmcam_dbg_warn("invalid preview size %dx%d, skip AF area converting", - info->preview_width, info->preview_height); + info->preview_width, info->preview_height); } } ret = gst_camera_control_get_auto_focus_area(control, &get_area); if (!ret) { - _mmcam_dbg_warn( "Failed to get AF area" ); + _mmcam_dbg_warn("Failed to get AF area"); return FALSE; } /* width and height are not supported now */ if (get_area.x == set_area.x && get_area.y == set_area.y) { _mmcam_dbg_log("No need to set AF area[x,y:%d,%d]", - get_area.x, get_area.y); + get_area.x, get_area.y); return TRUE; } ret = gst_camera_control_set_auto_focus_area(control, set_area); if (ret) { _mmcam_dbg_log("Succeed to set AF area[%d,%d,%dx%d]", - set_area.x, set_area.y, set_area.width, set_area.height); + set_area.x, set_area.y, set_area.width, set_area.height); return TRUE; } else { _mmcam_dbg_warn("Failed to set AF area[%d,%d,%dx%d]", - set_area.x, set_area.y, set_area.width, set_area.height); + set_area.x, set_area.y, set_area.width, set_area.height); } } } else { @@ -2964,19 +3101,24 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx } -bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_capture_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value) { GstCameraControl *control = NULL; - int ivalue = value->value.i_val; - int mslVal1 = 0, mslVal2 = 0; - int newVal1 = 0, newVal2 = 0; + int ivalue = 0; + int mslVal1 = 0; + int mslVal2 = 0; + int newVal1 = 0; + int newVal2 = 0; int exposure_type = 0; int current_state = MM_CAMCORDER_STATE_NONE; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL; gboolean check_scene_mode = FALSE; + mmf_return_val_if_fail(hcamcorder && value, FALSE); + sc = MMF_CAMCORDER_SUBCONTEXT(handle); if (!sc) return TRUE; @@ -2987,19 +3129,26 @@ bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx, return TRUE; } - current_state = _mmcamcorder_get_state( handle); + current_state = _mmcamcorder_get_state(handle); if (current_state < MM_CAMCORDER_STATE_READY) { + _mmcam_dbg_log("will be applied when preview starts"); return TRUE; + } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) { + _mmcam_dbg_err("Can not set while CAPTURING"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; } + ivalue = value->value.i_val; + if (attr_idx == MM_CAM_CAMERA_F_NUMBER) { exposure_type = GST_CAMERA_CONTROL_F_NUMBER; - mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue ); - mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue ); + mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR(ivalue); + mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR(ivalue); } else if (attr_idx == MM_CAM_CAMERA_SHUTTER_SPEED) { exposure_type = GST_CAMERA_CONTROL_SHUTTER_SPEED; - mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue ); - mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue ); + mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR(ivalue); + mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR(ivalue); } else if (attr_idx == MM_CAM_CAMERA_ISO) { exposure_type = GST_CAMERA_CONTROL_ISO; mslVal1 = ivalue; @@ -3012,8 +3161,8 @@ bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx, check_scene_mode = TRUE; } else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_VALUE) { exposure_type = GST_CAMERA_CONTROL_EXPOSURE_VALUE; - mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue ); - mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue ); + mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR(ivalue); + mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR(ivalue); } if (check_scene_mode) { @@ -3032,7 +3181,7 @@ bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx, return TRUE; } - control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); if (control == NULL) { _mmcam_dbg_err("cast CAMERA_CONTROL failed"); return FALSE; @@ -3040,10 +3189,10 @@ bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx, ret = gst_camera_control_set_exposure(control, exposure_type, newVal1, newVal2); if (ret) { - _mmcam_dbg_log("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 ); + _mmcam_dbg_log("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2); return TRUE; } else { - _mmcam_dbg_warn("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 ); + _mmcam_dbg_warn("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2); } } else { _mmcam_dbg_log("pointer of video src is null"); @@ -3053,16 +3202,17 @@ bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx, } -bool _mmcamcorder_commit_camera_wdr (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_wdr(MMHandleType handle, int attr_idx, const mmf_value_t *value) { GstCameraControl *control = NULL; int mslVal = 0; int newVal = 0; int cur_value = 0; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; int current_state = MM_CAMCORDER_STATE_NONE; - mmf_return_val_if_fail(handle && value, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); /* check whether set or not */ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) { @@ -3071,17 +3221,17 @@ bool _mmcamcorder_commit_camera_wdr (MMHandleType handle, int attr_idx, const mm } sc = MMF_CAMCORDER_SUBCONTEXT(handle); - if (!sc) { + if (!sc) return TRUE; - } /* check current state */ - current_state = _mmcamcorder_get_state( handle); + current_state = _mmcamcorder_get_state(handle); if (current_state < MM_CAMCORDER_STATE_READY) { _mmcam_dbg_log("will be applied when preview starts"); return TRUE; } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) { - _mmcam_dbg_warn("Can not set while CAPTURING"); + _mmcam_dbg_err("Can not set while CAPTURING"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } @@ -3103,17 +3253,17 @@ bool _mmcamcorder_commit_camera_wdr (MMHandleType handle, int attr_idx, const mm if (gst_camera_control_get_wdr(control, &cur_value)) { if (newVal != cur_value) { if (gst_camera_control_set_wdr(control, newVal)) { - _mmcam_dbg_log( "Success - set wdr[%d]", mslVal ); + _mmcam_dbg_log("Success - set wdr[%d]", mslVal); return TRUE; } else { _mmcam_dbg_warn("Failed to set WDR. NewVal[%d],CurVal[%d]", newVal, cur_value); } } else { - _mmcam_dbg_log( "No need to set new WDR. Current[%d]", mslVal ); + _mmcam_dbg_log("No need to set new WDR. Current[%d]", mslVal); return TRUE; } } else { - _mmcam_dbg_warn( "Failed to get WDR." ); + _mmcam_dbg_warn("Failed to get WDR."); } } else { _mmcam_dbg_log("pointer of video src is null"); @@ -3126,6 +3276,9 @@ bool _mmcamcorder_commit_camera_wdr (MMHandleType handle, int attr_idx, const mm bool _mmcamcorder_commit_camera_anti_handshake(MMHandleType handle, int attr_idx, const mmf_value_t *value) { int current_state = MM_CAMCORDER_STATE_NONE; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + + mmf_return_val_if_fail(hcamcorder && value, FALSE); /* check whether set or not */ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) { @@ -3139,6 +3292,7 @@ bool _mmcamcorder_commit_camera_anti_handshake(MMHandleType handle, int attr_idx return TRUE; } else if (current_state > MM_CAMCORDER_STATE_PREPARE) { _mmcam_dbg_err("Invaild state (state %d)", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } @@ -3146,16 +3300,59 @@ bool _mmcamcorder_commit_camera_anti_handshake(MMHandleType handle, int attr_idx } -bool _mmcamcorder_commit_camera_video_stabilization(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_encoder_bitrate(MMHandleType handle, int attr_idx, const mmf_value_t *value) { + int audio_enc = 0; + int bitrate = 0; int current_state = MM_CAMCORDER_STATE_NONE; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + _MMCamcorderSubContext *sc = NULL; - 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); + mmf_return_val_if_fail(hcamcorder && value, FALSE); + + bitrate = value->value.i_val; + + sc = MMF_CAMCORDER_SUBCONTEXT(handle); + if (!sc || !sc->encode_element) { + _mmcam_dbg_log("will be applied later - idx %d, bitrate %d", attr_idx, bitrate); return TRUE; - } else if (current_state > MM_CAMCORDER_STATE_PREPARE) { + } + + 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); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; + } + + if (attr_idx == MM_CAM_AUDIO_ENCODER_BITRATE) { + mm_camcorder_get_attributes(handle, NULL, MMCAM_AUDIO_ENCODER, &audio_enc, NULL); + + _mmcamcorder_set_encoder_bitrate(MM_CAMCORDER_ENCODER_TYPE_AUDIO, audio_enc, + bitrate, sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst); + } else { + _mmcamcorder_set_encoder_bitrate(MM_CAMCORDER_ENCODER_TYPE_VIDEO, 0, + bitrate, sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst); + } + + return TRUE; +} + + +bool _mmcamcorder_commit_camera_video_stabilization(MMHandleType handle, int attr_idx, const mmf_value_t *value) +{ + int current_state = MM_CAMCORDER_STATE_NONE; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + + mmf_return_val_if_fail(hcamcorder && value, 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); + return TRUE; + } else if (current_state > MM_CAMCORDER_STATE_PREPARE) { _mmcam_dbg_err("Invaild state (state %d)", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } @@ -3166,6 +3363,9 @@ bool _mmcamcorder_commit_camera_video_stabilization(MMHandleType handle, int att bool _mmcamcorder_commit_camera_rotate(MMHandleType handle, int attr_idx, const mmf_value_t *value) { int current_state = MM_CAMCORDER_STATE_NONE; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + + mmf_return_val_if_fail(hcamcorder && value, FALSE); _mmcam_dbg_log("rotate(%d)", value->value.i_val); @@ -3173,6 +3373,7 @@ bool _mmcamcorder_commit_camera_rotate(MMHandleType handle, int attr_idx, const if (current_state > MM_CAMCORDER_STATE_READY) { _mmcam_dbg_err("camera rotation setting failed.(state=%d)", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } else { return _mmcamcorder_set_videosrc_rotation(handle, value->value.i_val); @@ -3187,7 +3388,7 @@ bool _mmcamcorder_commit_image_encoder_quality(MMHandleType handle, int attr_idx mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - mmf_return_val_if_fail(handle, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); /* check type */ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) { @@ -3200,6 +3401,10 @@ bool _mmcamcorder_commit_image_encoder_quality(MMHandleType handle, int attr_idx if (current_state < MM_CAMCORDER_STATE_READY) { _mmcam_dbg_log("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"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; } sc = MMF_CAMCORDER_SUBCONTEXT(handle); @@ -3218,14 +3423,10 @@ bool _mmcamcorder_commit_image_encoder_quality(MMHandleType handle, int attr_idx bool _mmcamcorder_commit_target_filename(MMHandleType handle, int attr_idx, const mmf_value_t *value) { - _MMCamcorderSubContext *sc = NULL; - const char * filename = NULL; int size = 0; + const char *filename = NULL; - sc = MMF_CAMCORDER_SUBCONTEXT(handle); - if (!sc) { - return TRUE; - } + mmf_return_val_if_fail(handle && value, FALSE); /* get string */ filename = mmf_value_get_string(value, &size); @@ -3234,30 +3435,31 @@ bool _mmcamcorder_commit_target_filename(MMHandleType handle, int attr_idx, cons return FALSE; } - if (sc->info_video) { - SAFE_G_FREE(sc->info_video->filename); - sc->info_video->filename = g_strdup(filename); - if (sc->info_video->filename == NULL) { - _mmcam_dbg_err("failed to strdup filename [%s]", filename); - return FALSE; - } - } - - if (sc->encode_element && sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst) { - _mmcam_dbg_log("new file location set.[%s] filesink %p", filename, sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst); - MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", filename); - _mmcam_dbg_log("new file location set.(%s)", filename); - } else { - _mmcam_dbg_log("element is not created yet. [%s] will be set later...", filename); - } + _mmcam_dbg_log("set filename [%s]", filename); return TRUE; } +bool _mmcamcorder_commit_recording_max_limit(MMHandleType handle, int attr_idx, const mmf_value_t *value) +{ + int current_state = MM_CAMCORDER_STATE_NONE; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + mmf_return_val_if_fail(hcamcorder && value, FALSE); -bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_value_t *value) + current_state = _mmcamcorder_get_state(handle); + if (current_state >= MM_CAMCORDER_STATE_RECORDING) { + _mmcam_dbg_err("Can not set while RECORDING"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; + } + + return TRUE; +} + + +bool _mmcamcorder_commit_filter(MMHandleType handle, int attr_idx, const mmf_value_t *value) { GstColorBalance *balance = NULL; GstColorBalanceChannel *Colorchannel = NULL; @@ -3273,10 +3475,7 @@ bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_va int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL; gboolean check_scene_mode = FALSE; - if (hcamcorder == NULL) { - _mmcam_dbg_log("handle is NULL"); - return FALSE; - } + mmf_return_val_if_fail(hcamcorder && value, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); if (!sc) @@ -3293,7 +3492,8 @@ bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_va _mmcam_dbg_log("will be applied when preview starts"); return TRUE; } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) { - _mmcam_dbg_warn("Can not set while CAPTURING"); + _mmcam_dbg_err("Can not set while CAPTURING"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } @@ -3350,9 +3550,8 @@ bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_va } newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslNewVal); - if (newVal == _MMCAMCORDER_SENSOR_ENUM_NONE) { + if (newVal == _MMCAMCORDER_SENSOR_ENUM_NONE) return FALSE; - } /*_mmcam_dbg_log("label(%s): MSL(%d)->Sensor(%d)", control_label, mslNewVal, newVal);*/ @@ -3375,10 +3574,10 @@ bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_va for (item = controls ; item && item->data ; item = item->next) { Colorchannel = item->data; - //_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label); + /*_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label);*/ if (!strcmp(Colorchannel->label, control_label)) { - gst_color_balance_set_value (balance, Colorchannel, newVal); + gst_color_balance_set_value(balance, Colorchannel, newVal); _mmcam_dbg_log("Set complete - %s[msl:%d,real:%d]", Colorchannel->label, mslNewVal, newVal); break; } @@ -3393,18 +3592,24 @@ bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_va } -bool _mmcamcorder_commit_filter_scene_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_filter_scene_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value) { + int mslVal = 0; + int newVal = 0; + int current_state = MM_CAMCORDER_STATE_NONE; GstCameraControl *control = NULL; - int mslVal = value->value.i_val; - int newVal = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_FILTER_SCENE_MODE, mslVal ); + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - int current_state = MM_CAMCORDER_STATE_NONE; + + mmf_return_val_if_fail(hcamcorder && value, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); if (!sc) return TRUE; + mslVal = value->value.i_val; + newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_FILTER_SCENE_MODE, mslVal); + /* check whether set or not */ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) { _mmcam_dbg_log("skip set value %d", value->value.i_val); @@ -3415,6 +3620,10 @@ bool _mmcamcorder_commit_filter_scene_mode (MMHandleType handle, int attr_idx, c if (current_state < MM_CAMCORDER_STATE_READY) { _mmcam_dbg_log("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"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; } if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) { @@ -3438,26 +3647,25 @@ bool _mmcamcorder_commit_filter_scene_mode (MMHandleType handle, int attr_idx, c if (mslVal == MM_CAMCORDER_SCENE_MODE_NORMAL) { unsigned int i = 0; int attr_idxs[] = { - MM_CAM_CAMERA_ISO - , MM_CAM_FILTER_BRIGHTNESS - , MM_CAM_FILTER_WB - , MM_CAM_FILTER_SATURATION - , MM_CAM_FILTER_SHARPNESS - , MM_CAM_FILTER_COLOR_TONE - , MM_CAM_CAMERA_EXPOSURE_MODE + MM_CAM_CAMERA_ISO, + MM_CAM_FILTER_BRIGHTNESS, + MM_CAM_FILTER_WB, + MM_CAM_FILTER_SATURATION, + MM_CAM_FILTER_SHARPNESS, + MM_CAM_FILTER_COLOR_TONE, + MM_CAM_CAMERA_EXPOSURE_MODE }; mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle); for (i = 0 ; i < ARRAY_SIZE(attr_idxs) ; i++) { - if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs[i])) { + if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs[i])) mmf_attribute_set_modified(&(attr->items[attr_idxs[i]])); - } } } return TRUE; } else { - _mmcam_dbg_log( "Failed to set program mode[%d].", mslVal ); + _mmcam_dbg_log("Failed to set program mode[%d].", mslVal); } } else { _mmcam_dbg_warn("pointer of video src is null"); @@ -3467,15 +3675,20 @@ bool _mmcamcorder_commit_filter_scene_mode (MMHandleType handle, int attr_idx, c } -bool _mmcamcorder_commit_filter_flip (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_filter_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value) { + mmf_return_val_if_fail(handle && value, FALSE); + _mmcam_dbg_warn("Filter Flip(%d)", value->value.i_val); + return TRUE; } -bool _mmcamcorder_commit_audio_input_route (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_audio_input_route(MMHandleType handle, int attr_idx, const mmf_value_t *value) { + mmf_return_val_if_fail(handle && value, FALSE); + _mmcam_dbg_log("Commit : Do nothing. this attr will be removed soon."); return TRUE; @@ -3485,10 +3698,14 @@ bool _mmcamcorder_commit_audio_input_route (MMHandleType handle, int attr_idx, c bool _mmcamcorder_commit_audio_disable(MMHandleType handle, int attr_idx, const mmf_value_t *value) { int current_state = MM_CAMCORDER_STATE_NONE; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + + mmf_return_val_if_fail(hcamcorder && value, FALSE); 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); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } else { _mmcam_dbg_log("Disable AUDIO when Recording"); @@ -3506,7 +3723,7 @@ bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - mmf_return_val_if_fail(handle, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); /* check type */ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) { @@ -3534,24 +3751,15 @@ bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const _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")) { + 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); -#ifdef HAVE_WAYLAND - } else if (!strcmp(videosink_name, "waylandsink")) { - MMCamWaylandInfo *wl_info = (MMCamWaylandInfo *)p_handle; - - _mmcam_dbg_log("wayland global surface id : %d", wl_info->global_surface_id); - - gst_video_overlay_set_wl_window_wl_surface_id(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), (guintptr)wl_info->global_surface_id); - gst_video_overlay_set_render_rectangle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), - wl_info->window_x, wl_info->window_y, wl_info->window_width, wl_info->window_height); -#endif /* HAVE_WAYLAND */ + } 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; @@ -3573,7 +3781,7 @@ bool _mmcamcorder_commit_display_mode(MMHandleType handle, int attr_idx, const m mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - mmf_return_val_if_fail(handle, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); /* check type */ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) { @@ -3598,14 +3806,14 @@ bool _mmcamcorder_commit_display_mode(MMHandleType handle, int attr_idx, const m _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name); - if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink")) { + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink")) { _mmcam_dbg_log("Commit : display mode [%d]", value->value.i_val); MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-mode", value->value.i_val); - return TRUE; } else { - _mmcam_dbg_warn("Commit : This element [%s] does not support display mode", videosink_name); - return FALSE; + _mmcam_dbg_warn("[%s] does not support display mode, but no error", videosink_name); } + + return TRUE; } @@ -3615,7 +3823,7 @@ bool _mmcamcorder_commit_display_rotation(MMHandleType handle, int attr_idx, con mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - mmf_return_val_if_fail(handle, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); /* check type */ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) { @@ -3640,7 +3848,7 @@ bool _mmcamcorder_commit_display_flip(MMHandleType handle, int attr_idx, const m mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - mmf_return_val_if_fail(handle, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); /* check type */ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) { @@ -3667,7 +3875,7 @@ bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, cons mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - mmf_return_val_if_fail(handle, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); /* check type */ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) { @@ -3691,19 +3899,19 @@ bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, cons return FALSE; } - if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink") || - !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) { + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") || + !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) { MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "visible", value->value.i_val); _mmcam_dbg_log("Set visible [%d] done.", value->value.i_val); - return TRUE; } else { - _mmcam_dbg_warn("videosink[%s] does not support VISIBLE.", videosink_name); - return FALSE; + _mmcam_dbg_warn("[%s] does not support VISIBLE, but no error", videosink_name); } + + return TRUE; } -bool _mmcamcorder_commit_display_geometry_method (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_display_geometry_method(MMHandleType handle, int attr_idx, const mmf_value_t *value) { int method = 0; int current_state = MM_CAMCORDER_STATE_NONE; @@ -3712,7 +3920,7 @@ bool _mmcamcorder_commit_display_geometry_method (MMHandleType handle, int attr_ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - mmf_return_val_if_fail(handle, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); /* check type */ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) { @@ -3736,15 +3944,15 @@ bool _mmcamcorder_commit_display_geometry_method (MMHandleType handle, int attr_ return FALSE; } - if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink") || + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") || !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) { method = value->value.i_val; MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-geometry-method", method); - return TRUE; } else { - _mmcam_dbg_warn("videosink[%s] does not support geometry method.", videosink_name); - return FALSE; + _mmcam_dbg_warn("[%s] does not support geometry method, but no error", videosink_name); } + + return TRUE; } @@ -3758,7 +3966,7 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - mmf_return_val_if_fail(handle, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); /* check type */ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) { @@ -3777,8 +3985,8 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m /* check current method */ mm_camcorder_get_attributes(handle, NULL, - MMCAM_DISPLAY_GEOMETRY_METHOD, &method, - NULL); + MMCAM_DISPLAY_GEOMETRY_METHOD, &method, + NULL); if (method != MM_DISPLAY_METHOD_CUSTOM_ROI) { _mmcam_dbg_log("current method[%d] is not supported rect", method); return FALSE; @@ -3791,7 +3999,7 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m return FALSE; } - if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink") || + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") || !strcmp(videosink_name, "evaspixmapsink")) { int rect_x = 0; int rect_y = 0; @@ -3801,11 +4009,11 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m MMCamAttrsInfo info; mm_camcorder_get_attributes(handle, NULL, - MMCAM_DISPLAY_RECT_X, &rect_x, - MMCAM_DISPLAY_RECT_Y, &rect_y, - MMCAM_DISPLAY_RECT_WIDTH, &rect_width, - MMCAM_DISPLAY_RECT_HEIGHT, &rect_height, - NULL); + MMCAM_DISPLAY_RECT_X, &rect_x, + MMCAM_DISPLAY_RECT_Y, &rect_y, + MMCAM_DISPLAY_RECT_WIDTH, &rect_width, + MMCAM_DISPLAY_RECT_HEIGHT, &rect_height, + NULL); switch (attr_idx) { case MM_CAM_DISPLAY_RECT_X: mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_Y, &info); @@ -3845,7 +4053,7 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m 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); - if (!strcmp(videosink_name, "waylandsink")) { + if (!strcmp(videosink_name, "tizenwlsink")) { ret = gst_video_overlay_set_render_rectangle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), rect_x, rect_y, rect_width, rect_height); if (!ret) { @@ -3854,19 +4062,18 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m } } else { g_object_set(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, - "dst-roi-x", rect_x, - "dst-roi-y", rect_y, - "dst-roi-w", rect_width, - "dst-roi-h", rect_height, - NULL); + "dst-roi-x", rect_x, + "dst-roi-y", rect_y, + "dst-roi-w", rect_width, + "dst-roi-h", rect_height, + NULL); } } - - return TRUE; } else { - _mmcam_dbg_warn("videosink[%s] does not support display rect.", videosink_name); - return FALSE; + _mmcam_dbg_warn("[%s] does not support display rect, but no error", videosink_name); } + + return TRUE; } @@ -3880,7 +4087,7 @@ bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - mmf_return_val_if_fail(handle, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); /* check type */ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) { @@ -3905,7 +4112,7 @@ bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const } zoom = value->value.i_val; - if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink")) { + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink")) { vs_element = sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst; MMCAMCORDER_G_OBJECT_SET(vs_element, "zoom", (float)(zoom + 1)); @@ -3925,10 +4132,10 @@ bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_i int do_scaling = 0; const char *videosink_name = NULL; - mmf_camcorder_t *hcamcorder= MMF_CAMCORDER( handle); + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - mmf_return_val_if_fail(handle, FALSE); + mmf_return_val_if_fail(handle && value, FALSE); /* check type */ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) { @@ -3965,7 +4172,7 @@ bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_i } -bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_strobe(MMHandleType handle, int attr_idx, const mmf_value_t *value) { bool bret = FALSE; _MMCamcorderSubContext *sc = NULL; @@ -3973,10 +4180,7 @@ bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_va int strobe_type, mslVal, newVal, cur_value; int current_state = MM_CAMCORDER_STATE_NONE; - if (hcamcorder == NULL) { - _mmcam_dbg_err("NULL handle"); - return FALSE; - } + mmf_return_val_if_fail(hcamcorder && value, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); if (!sc) @@ -4016,7 +4220,7 @@ bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_va _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state); return TRUE; } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) { - _mmcam_dbg_warn("invalid state[capturing]"); + _mmcam_dbg_err("Can not set while CAPTURING"); hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } @@ -4083,11 +4287,9 @@ bool _mmcamcorder_commit_camera_flip(MMHandleType handle, int attr_idx, const mm { int ret = 0; int current_state = MM_CAMCORDER_STATE_NONE; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - if ((void *)handle == NULL) { - _mmcam_dbg_warn("handle is NULL"); - return FALSE; - } + mmf_return_val_if_fail(hcamcorder && value, FALSE); _mmcam_dbg_log("Commit : flip %d", value->value.i_val); @@ -4095,6 +4297,7 @@ bool _mmcamcorder_commit_camera_flip(MMHandleType handle, int attr_idx, const mm 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); + 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."); @@ -4113,12 +4316,10 @@ bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, c { int set_hdr_mode = MM_CAMCORDER_HDR_OFF; int current_state = MM_CAMCORDER_STATE_NONE; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - if ((void *)handle == NULL) { - _mmcam_dbg_warn("handle is NULL"); - return FALSE; - } + mmf_return_val_if_fail(hcamcorder && value, FALSE); /*_mmcam_dbg_log("Commit : HDR Capture %d", value->value.i_val);*/ @@ -4132,6 +4333,7 @@ bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, c 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); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } @@ -4140,8 +4342,8 @@ bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, c set_hdr_mode = value->value.i_val; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_HDR_CAPTURE, ¤t_value, - NULL); + MMCAM_CAMERA_HDR_CAPTURE, ¤t_value, + NULL); if (set_hdr_mode == current_value) { _mmcam_dbg_log("same HDR value : %d, do nothing", set_hdr_mode); @@ -4171,9 +4373,8 @@ bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, c sc->info_image->hdr_capture_mode = set_hdr_mode; _mmcam_dbg_log("set HDR mode : %d", set_hdr_mode); - if (current_state == MM_CAMCORDER_STATE_PREPARE) { + if (current_state == MM_CAMCORDER_STATE_PREPARE) _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING); - } } else { _mmcam_dbg_err("sc is NULL. can not set HDR capture"); return FALSE; @@ -4194,20 +4395,16 @@ bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const mmf_val int current_state = MM_CAMCORDER_STATE_NONE; GstCameraControl *control = NULL; - if ((void *)handle == NULL) { - _mmcam_dbg_warn("handle is NULL"); - return FALSE; - } + mmf_return_val_if_fail(handle && value, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); - if (!sc) { + if (!sc) return TRUE; - } /*_mmcam_dbg_log("Commit : detect attribute(%d)", attr_idx);*/ /* state check */ - current_state = _mmcamcorder_get_state( handle); + current_state = _mmcamcorder_get_state(handle); if (current_state < MM_CAMCORDER_STATE_READY) { _mmcam_dbg_log("will be applied when preview starts"); return TRUE; @@ -4259,11 +4456,11 @@ bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const mmf_val } else { if (!gst_camera_control_set_detect(control, detect_type, set_value)) { _mmcam_dbg_warn("Set detect failed. Type[%d],value[%d]", - detect_type, set_value); + detect_type, set_value); bret = FALSE; } else { _mmcam_dbg_log("Set detect success. Type[%d],value[%d]", - detect_type, set_value); + detect_type, set_value); bret = TRUE; } } @@ -4282,10 +4479,7 @@ bool _mmcamcorder_commit_encoded_preview_bitrate(MMHandleType handle, int attr_i int current_state = MM_CAMCORDER_STATE_NONE; int preview_format = MM_PIXEL_FORMAT_NV12; - if ((void *)handle == NULL) { - _mmcam_dbg_warn("handle is NULL"); - return FALSE; - } + mmf_return_val_if_fail(handle && value, FALSE); _mmcam_dbg_log("Commit : encoded preview bitrate - %d", value->value.i_val); @@ -4312,10 +4506,7 @@ bool _mmcamcorder_commit_encoded_preview_gop_interval(MMHandleType handle, int a int current_state = MM_CAMCORDER_STATE_NONE; int preview_format = MM_PIXEL_FORMAT_NV12; - if ((void *)handle == NULL) { - _mmcam_dbg_warn("handle is NULL"); - return FALSE; - } + mmf_return_val_if_fail(handle && value, FALSE); _mmcam_dbg_log("Commit : encoded preview I-frame interval - %d", value->value.i_val); @@ -4340,60 +4531,91 @@ bool _mmcamcorder_commit_encoded_preview_gop_interval(MMHandleType handle, int a bool _mmcamcorder_commit_pid_for_sound_focus(MMHandleType handle, int attr_idx, const mmf_value_t *value) { int new_pid = 0; + int ret = 0; int current_state = MM_CAMCORDER_STATE_NONE; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - if (hcamcorder == NULL) { - _mmcam_dbg_warn("handle is NULL"); - return FALSE; - } + mmf_return_val_if_fail(hcamcorder && value, FALSE); /* state check */ - current_state = _mmcamcorder_get_state( handle); + current_state = _mmcamcorder_get_state(handle); if (current_state > MM_CAMCORDER_STATE_NULL) { _mmcam_dbg_log("invalid state %d", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } new_pid = value->value.i_val; - _mmcam_dbg_log("Commit : pid %d, current sound_focus_register %d, sound_focus_id %d", - new_pid, hcamcorder->sound_focus_register, hcamcorder->sound_focus_id); + _mmcam_dbg_warn("Commit : pid %d, current focus id %d, subscribe id %u", + new_pid, hcamcorder->sound_focus_id, hcamcorder->sound_focus_subscribe_id); + + /* unregister sound focus and unsubscribe sound signal before set new one */ + if (hcamcorder->sound_focus_id > 0) { + mm_sound_unregister_focus(hcamcorder->sound_focus_id); + _mmcam_dbg_log("unregister sound focus done"); + hcamcorder->sound_focus_id = 0; + } - /* unregister sound focus before set new one */ - if (hcamcorder->sound_focus_register && hcamcorder->sound_focus_id > 0) { - if (MM_ERROR_NONE != mm_sound_unregister_focus(hcamcorder->sound_focus_id)) { - _mmcam_dbg_err("mm_sound_unregister_focus[id %d] failed", hcamcorder->sound_focus_id); + if (hcamcorder->sound_focus_subscribe_id > 0) { + mm_sound_unsubscribe_signal(hcamcorder->sound_focus_subscribe_id); + _mmcam_dbg_log("unsubscribe sound signal done"); + hcamcorder->sound_focus_subscribe_id = 0; + } + + ret = _mm_session_util_read_information(new_pid, &hcamcorder->session_type, &hcamcorder->session_flags); + if (ret == MM_ERROR_NONE) { + if (hcamcorder->session_type == MM_SESSION_TYPE_REPLACED_BY_STREAM) { + hcamcorder->sound_focus_register = FALSE; + _mmcam_dbg_warn("no need to use sound focus internally"); } else { - _mmcam_dbg_log("mm_sound_unregister_focus[id %d] done", hcamcorder->sound_focus_id); + /* check my session type : allow only media & call series here */ + if ((hcamcorder->session_type != MM_SESSION_TYPE_MEDIA) && + (hcamcorder->session_type != MM_SESSION_TYPE_MEDIA_RECORD) && + (hcamcorder->session_type != MM_SESSION_TYPE_CALL) && + (hcamcorder->session_type != MM_SESSION_TYPE_VIDEOCALL) && + (hcamcorder->session_type != MM_SESSION_TYPE_VOIP)) { + _mmcam_dbg_err("Blocked by session policy, my session_type[%s]", hcamcorder->session_type); + hcamcorder->error_code = MM_ERROR_POLICY_BLOCKED; + return FALSE; + } + + ret = mm_sound_focus_get_id(&hcamcorder->sound_focus_id); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("mm_sound_focus_get_id failed"); + hcamcorder->error_code = MM_ERROR_POLICY_BLOCKED; + return FALSE; + } + + ret = mm_sound_register_focus_for_session(hcamcorder->sound_focus_id, + new_pid, "media", _mmcamcorder_sound_focus_cb, hcamcorder); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("mm_sound_register_focus_for_session failed 0x%x", ret); + hcamcorder->sound_focus_id = 0; + hcamcorder->error_code = MM_ERROR_POLICY_BLOCKED; + return FALSE; + } + + hcamcorder->sound_focus_register = TRUE; + + _mmcam_dbg_log("mm_sound_register_focus_for_session done - id %d, session type %d, flags 0x%x", + hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags); } } else { - _mmcam_dbg_log("no need to unregister sound focus"); - } + hcamcorder->session_type = 0; + hcamcorder->session_flags = 0; + hcamcorder->sound_focus_register = TRUE; - /* register sound focus */ - if (hcamcorder->sound_focus_register) { - hcamcorder->sound_focus_id = 0; - if (MM_ERROR_NONE != mm_sound_focus_get_id(&hcamcorder->sound_focus_id)) { - _mmcam_dbg_err("mm_sound_focus_get_uniq failed"); - hcamcorder->error_code = MM_ERROR_POLICY_BLOCKED; - return FALSE; - } + _mmcam_dbg_warn("read session info failed. sound focus watch cb will be set."); - if (MM_ERROR_NONE != mm_sound_register_focus_for_session(hcamcorder->sound_focus_id, - new_pid, - "media", - _mmcamcorder_sound_focus_cb, - hcamcorder)) { - _mmcam_dbg_err("mm_sound_register_focus failed"); + ret = mm_sound_subscribe_signal_for_daemon(MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS, + new_pid, &hcamcorder->sound_focus_subscribe_id, + (mm_sound_signal_callback)_mmcamcorder_sound_signal_callback, (void*)hcamcorder); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("subscribe sound signal failed [0x%x]", ret); hcamcorder->error_code = MM_ERROR_POLICY_BLOCKED; return FALSE; } - - _mmcam_dbg_log("mm_sound_register_focus done - id %d, session type %d, flags 0x%x", - hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags); - } else { - _mmcam_dbg_log("no need to register sound focus"); } return TRUE; @@ -4402,47 +4624,120 @@ bool _mmcamcorder_commit_pid_for_sound_focus(MMHandleType handle, int attr_idx, bool _mmcamcorder_commit_sound_stream_info(MMHandleType handle, int attr_idx, const mmf_value_t *value) { + int stream_index = 0; char *stream_type = NULL; - int stream_type_len = 0; _MMCamcorderSubContext *sc = NULL; - if ((void *)handle == NULL) { - _mmcam_dbg_warn("handle is NULL"); + mmf_return_val_if_fail(handle && value, FALSE); + + stream_type = value->value.s_val; + if (!stream_type) { + _mmcam_dbg_err("NULL string"); return FALSE; } + mm_camcorder_get_attributes(handle, NULL, + MMCAM_SOUND_STREAM_INDEX, &stream_index, + NULL); + if (stream_index < 0) { + _mmcam_dbg_err("invalid stream index %d", stream_index); + return FALSE; + } + + /* unset watch callback if existed */ + _mmcamcorder_sound_signal_callback(MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS, 1, (void *)handle); + sc = MMF_CAMCORDER_SUBCONTEXT(handle); if (!sc || !sc->encode_element || !sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst) { - _mmcam_dbg_log("audiosrc element is not initialized, it will be set later"); + _mmcam_dbg_warn("audiosrc element is not initialized, it will be set later"); return TRUE; } - mm_camcorder_get_attributes(handle, NULL, - MMCAM_SOUND_STREAM_TYPE, &stream_type, &stream_type_len, - NULL); + _mmcam_dbg_warn("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); +} + - if (stream_type == NULL) { - _mmcam_dbg_err("stream type is not set"); +bool _mmcamcorder_commit_tag(MMHandleType handle, int attr_idx, const mmf_value_t *value) +{ + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + int current_state = MM_CAMCORDER_STATE_NONE; + + mmf_return_val_if_fail(hcamcorder && value, FALSE); + + current_state = _mmcamcorder_get_state(handle); + if (current_state == MM_CAMCORDER_STATE_CAPTURING) { + _mmcam_dbg_err("Can not set while CAPTURING"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } - _mmcam_dbg_log("Commit : sound stream info - type %s", stream_type); + return TRUE; +} + +bool _mmcamcorder_commit_audio_replay_gain(MMHandleType handle, int attr_idx, const mmf_value_t *value) +{ + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + + mmf_return_val_if_fail(hcamcorder && value, FALSE); + + if (attr_idx == MM_CAM_AUDIO_REPLAY_GAIN_ENABLE) { + /* Replay gain enable */ + int current_state = MM_CAMCORDER_STATE_NONE; + int audio_disable = 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); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; + } + + mm_camcorder_get_attributes(handle, NULL, + MMCAM_AUDIO_DISABLE, &audio_disable, + NULL); + + if (audio_disable) { + _mmcam_dbg_err("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); + } else if (attr_idx == MM_CAM_AUDIO_REPLAY_GAIN_REFERENCE_LEVEL) { + /* Replay gain reference level */ + int replay_gain_enable = FALSE; + + mm_camcorder_get_attributes(handle, NULL, + MMCAM_AUDIO_REPLAY_GAIN_ENABLE, &replay_gain_enable, + NULL); - return _mmcamcorder_set_sound_stream_info(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, stream_type, value->value.i_val); + if (replay_gain_enable == FALSE) { + _mmcam_dbg_err("replay gain is disabled"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_CONDITION; + return FALSE; + } + + _mmcam_dbg_log("set reference level for replay gain : %ld dB", value->value.d_val); + } else { + _mmcam_dbg_err("unknown attribute id %d", attr_idx); + return FALSE; + } + + return TRUE; } -static bool -__mmcamcorder_attrs_is_supported(MMHandleType handle, int idx) +static bool __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx) { mmf_attrs_t *attr = (mmf_attrs_t*)handle; int flag; if (mm_attrs_get_flags(handle, idx, &flag) == MM_ERROR_NONE) { - if (flag == MM_ATTRS_FLAG_NONE) { + if (flag == MM_ATTRS_FLAG_NONE) return FALSE; - } } else { return FALSE; } @@ -4450,55 +4745,51 @@ __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx) if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_RANGE) { int min, max; mm_attrs_get_valid_range((MMHandleType)attr, idx, &min, &max); - if (max < min) { + if (max < min) return FALSE; - } } else if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_ARRAY) { int count; int *array; mm_attrs_get_valid_array((MMHandleType)attr, idx, &count, &array); - if (count == 0) { + if (count == 0) return FALSE; - } } return TRUE; } -bool -_mmcamcorder_set_attribute_to_camsensor(MMHandleType handle) +bool _mmcamcorder_set_attribute_to_camsensor(MMHandleType handle) { - mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle); + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); mmf_attrs_t *attr = NULL; int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL; - unsigned int i = 0 ; + unsigned int i = 0; int ret = TRUE; int attr_idxs_default[] = { - MM_CAM_CAMERA_DIGITAL_ZOOM - , MM_CAM_CAMERA_OPTICAL_ZOOM - , MM_CAM_CAMERA_WDR - , MM_CAM_FILTER_CONTRAST - , MM_CAM_FILTER_HUE - , MM_CAM_STROBE_MODE - , MM_CAM_DETECT_MODE + MM_CAM_CAMERA_DIGITAL_ZOOM, + MM_CAM_CAMERA_OPTICAL_ZOOM, + MM_CAM_CAMERA_WDR, + MM_CAM_FILTER_CONTRAST, + MM_CAM_FILTER_HUE, + MM_CAM_DETECT_MODE }; int attr_idxs_extra[] = { - MM_CAM_CAMERA_ISO - , MM_CAM_FILTER_BRIGHTNESS - , MM_CAM_FILTER_WB - , MM_CAM_FILTER_SATURATION - , MM_CAM_FILTER_SHARPNESS - , MM_CAM_FILTER_COLOR_TONE - , MM_CAM_CAMERA_EXPOSURE_MODE + MM_CAM_CAMERA_ISO, + MM_CAM_FILTER_BRIGHTNESS, + MM_CAM_FILTER_WB, + MM_CAM_FILTER_SATURATION, + MM_CAM_FILTER_SHARPNESS, + MM_CAM_FILTER_COLOR_TONE, + MM_CAM_CAMERA_EXPOSURE_MODE }; mmf_return_val_if_fail(hcamcorder, FALSE); - _mmcam_dbg_log("Set all attribute again."); + _mmcam_dbg_log("commit some attributes again"); attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle); if (attr == NULL) { @@ -4511,30 +4802,65 @@ _mmcamcorder_set_attribute_to_camsensor(MMHandleType handle) _mmcam_dbg_log("attribute count(%d)", attr->count); for (i = 0 ; i < ARRAY_SIZE(attr_idxs_default) ; i++) { - if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_default[i])) { + if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_default[i])) mmf_attribute_set_modified(&(attr->items[attr_idxs_default[i]])); - } } /* Set extra if scene mode is NORMAL */ if (scene_mode == MM_CAMCORDER_SCENE_MODE_NORMAL) { for (i = 0 ; i < ARRAY_SIZE(attr_idxs_extra) ; i++) { - if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_extra[i])) { + if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_extra[i])) mmf_attribute_set_modified(&(attr->items[attr_idxs_extra[i]])); - } } } else { /* Set scene mode if scene mode is NOT NORMAL */ - if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, MM_CAM_FILTER_SCENE_MODE)) { + if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, MM_CAM_FILTER_SCENE_MODE)) mmf_attribute_set_modified(&(attr->items[MM_CAM_FILTER_SCENE_MODE])); - } } - if (mmf_attrs_commit((MMHandleType)attr) == -1) { + if (mmf_attrs_commit((MMHandleType)attr) == -1) ret = FALSE; - } else { + else ret = TRUE; + } + + _mmcam_dbg_log("Done."); + + return ret; +} + + +bool _mmcamcorder_set_attribute_to_camsensor2(MMHandleType handle) +{ + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + mmf_attrs_t *attr = NULL; + + unsigned int i = 0; + int ret = TRUE; + int attr_idxs[] = { + MM_CAM_STROBE_MODE + }; + + mmf_return_val_if_fail(hcamcorder, FALSE); + + _mmcam_dbg_log("commit some attribute again[2]"); + + attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle); + if (attr == NULL) { + _mmcam_dbg_err("Get attribute handle failed."); + return FALSE; + } else { + _mmcam_dbg_log("attribute count(%d)", attr->count); + + for (i = 0 ; i < ARRAY_SIZE(attr_idxs) ; i++) { + if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs[i])) + mmf_attribute_set_modified(&(attr->items[attr_idxs[i]])); } + + if (mmf_attrs_commit((MMHandleType)attr) == -1) + ret = FALSE; + else + ret = TRUE; } _mmcam_dbg_log("Done."); @@ -4545,11 +4871,11 @@ _mmcamcorder_set_attribute_to_camsensor(MMHandleType handle) int _mmcamcorder_lock_readonly_attributes(MMHandleType handle) { - mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle); + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); int table_size = 0; int i = 0; mmf_attrs_t *attr = NULL; - int nerror = MM_ERROR_NONE ; + int nerror = MM_ERROR_NONE; mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); @@ -4560,8 +4886,7 @@ int _mmcamcorder_lock_readonly_attributes(MMHandleType handle) table_size = ARRAY_SIZE(readonly_attributes); _mmcam_dbg_log("%d", table_size); - for (i = 0; i < table_size; i++) - { + for (i = 0; i < table_size; i++) { int sCategory = readonly_attributes[i]; mmf_attribute_set_readonly(&(attr->items[sCategory])); @@ -4573,8 +4898,7 @@ int _mmcamcorder_lock_readonly_attributes(MMHandleType handle) int _mmcamcorder_set_disabled_attributes(MMHandleType handle) { - mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle); - //int table_size = 0; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); int i = 0; mmf_attrs_t *attr = NULL; type_string_array * disabled_attr = NULL; @@ -4590,20 +4914,20 @@ int _mmcamcorder_set_disabled_attributes(MMHandleType handle) /* add gst_param */ _mmcamcorder_conf_get_value_string_array(hcamcorder->conf_main, - CONFIGURE_CATEGORY_MAIN_GENERAL, - "DisabledAttributes", - &disabled_attr); + CONFIGURE_CATEGORY_MAIN_GENERAL, + "DisabledAttributes", + &disabled_attr); if (disabled_attr != NULL && disabled_attr->value) { cnt_str = disabled_attr->count; for (i = 0; i < cnt_str; i++) { int idx = 0; - _mmcam_dbg_log("[%d]%s", i, disabled_attr->value[i] ); + _mmcam_dbg_log("[%d]%s", i, disabled_attr->value[i]); nerror = mm_attrs_get_index((MMHandleType)attr, disabled_attr->value[i], &idx); - if (nerror == MM_ERROR_NONE) { + + if (nerror == MM_ERROR_NONE) mmf_attribute_set_disabled(&(attr->items[idx])); - } else { - _mmcam_dbg_warn("No ATTR named %s[%d]",disabled_attr->value[i], i); - } + else + _mmcam_dbg_warn("No ATTR named %s[%d]", disabled_attr->value[i], i); } } @@ -4623,9 +4947,8 @@ static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width, mmf_return_val_if_fail(hcamcorder, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); - if (!sc) { + if (!sc) return TRUE; - } current_state = _mmcamcorder_get_state(handle); @@ -4672,15 +4995,14 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n if (hcamcorder == NULL || attribute_name == NULL) { _mmcam_dbg_warn("handle[%p] or attribute_name[%p] is NULL.", - hcamcorder, attribute_name ); + hcamcorder, attribute_name); return MM_ERROR_CAMCORDER_INVALID_ARGUMENT; } - if (err_attr_name) { + if (err_attr_name) *err_attr_name = NULL; - } - //_mmcam_dbg_log( "ENTER" ); + /*_mmcam_dbg_log( "ENTER" );*/ attrs = MMF_CAMCORDER_ATTRS(handle); @@ -4694,21 +5016,18 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n /* attribute name check */ if ((ret = mm_attrs_get_index(attrs, name, &idx)) != MM_ERROR_NONE) { - if (err_attr_name) { + if (err_attr_name) *err_attr_name = strdup(name); - } - if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY) { //to avoid confusing + if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY) return MM_ERROR_COMMON_ATTR_NOT_EXIST; - } else { + else return ret; - } } /* type check */ - if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE) { + if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE) return ret; - } switch (attr_type) { case MM_ATTRS_TYPE_INT: @@ -4723,13 +5042,11 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n break; } } - if (matched) { + if (matched) break; - } } - if (matched == FALSE) { + if (matched == FALSE) va_arg((var_args), int); - } break; } case MM_ATTRS_TYPE_DOUBLE: @@ -4746,9 +5063,9 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n case MM_ATTRS_TYPE_INVALID: default: _mmcam_dbg_err("Not supported attribute type(%d, name:%s)", attr_type, name); - if (err_attr_name) { + if (err_attr_name) *err_attr_name = strdup(name); - } + return MM_ERROR_CAMCORDER_INVALID_ARGUMENT; } @@ -4777,14 +5094,14 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n check_result = FALSE; - for( j = 0 ; j < attr_info_0.int_array.count ; j++ ) { + for (j = 0 ; j < attr_info_0.int_array.count ; j++) { if (attr_info_0.int_array.array[j] == check_pair_value[i][0] && attr_info_1.int_array.array[j] == check_pair_value[i][1]) { /* _mmcam_dbg_log("Valid Pair[%s,%s] existed %dx%d[index:%d]", - check_pair_name[i][0], check_pair_name[i][1], - check_pair_value[i][0], check_pair_value[i][1], i); - */ + check_pair_name[i][0], check_pair_name[i][1], + check_pair_value[i][0], check_pair_value[i][1], i); + */ check_result = TRUE; break; } @@ -4792,8 +5109,8 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n if (check_result == FALSE) { _mmcam_dbg_err("INVALID pair[%s,%s] %dx%d", - check_pair_name[i][0], check_pair_name[i][1], - check_pair_value[i][0], check_pair_value[i][1]); + check_pair_name[i][0], check_pair_name[i][1], + check_pair_value[i][0], check_pair_value[i][1]); if (err_attr_name) { *err_attr_name = err_name; } else { @@ -4811,9 +5128,9 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n int current_height = 0; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_WIDTH, ¤t_width, - MMCAM_CAMERA_HEIGHT, ¤t_height, - NULL); + MMCAM_CAMERA_WIDTH, ¤t_width, + MMCAM_CAMERA_HEIGHT, ¤t_height, + NULL); if (current_width != check_pair_value[i][0] || current_height != check_pair_value[i][1]) { @@ -4856,33 +5173,29 @@ bool _mmcamcorder_check_supported_attribute(MMHandleType handle, int attr_index) /* _mmcam_dbg_log("int array count %d", info.int_array.count); */ - if (info.int_array.count <= 1) { + if (info.int_array.count <= 1) return FALSE; - } break; case MM_ATTRS_VALID_TYPE_INT_RANGE: /* _mmcam_dbg_log("int range min %d, max %d",info.int_range.min, info.int_range.max); */ - if (info.int_range.min >= info.int_range.max) { + if (info.int_range.min >= info.int_range.max) return FALSE; - } break; case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY: /* _mmcam_dbg_log("double array count %d", info.double_array.count); */ - if (info.double_array.count <= 1) { + if (info.double_array.count <= 1) return FALSE; - } break; case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE: /* _mmcam_dbg_log("double range min %lf, max %lf",info.int_range.min, info.int_range.max); */ - if (info.double_range.min >= info.double_range.max) { + if (info.double_range.min >= info.double_range.max) return FALSE; - } break; default: _mmcam_dbg_warn("invalid type %d", info.validity_type);