X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_attribute.c;h=fb85d7bd0486433f4c1198e56c5da61283f9e1a6;hb=633f96af86163942d6f4237f0ab2b5204b9e1930;hp=b7dd25a392123f501eee3e8b094f954fd83685e9;hpb=c8f57d6b6b2d7fc65adeedb5acd6eae45d28537f;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git diff --git a/src/mm_camcorder_attribute.c b/src/mm_camcorder_attribute.c index b7dd25a..fb85d7b 100644 --- a/src/mm_camcorder_attribute.c +++ b/src/mm_camcorder_attribute.c @@ -29,15 +29,15 @@ #include #include #include -#ifdef HAVE_WAYLAND -#include -#endif /*----------------------------------------------------------------------- | MACRO DEFINITIONS: | -----------------------------------------------------------------------*/ #define MMCAMCORDER_DEFAULT_CAMERA_WIDTH 640 #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 | @@ -46,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. */ @@ -82,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; @@ -96,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.*/ @@ -135,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 */ @@ -153,9 +152,9 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_AUDIO_DEVICE_MIC}, - MM_ATTRS_VALID_TYPE_INT_RANGE, - {.int_min = 0}, - {.int_max = (MM_AUDIO_DEVICE_NUM-1)}, + MM_ATTRS_VALID_TYPE_INT_ARRAY, + {NULL}, + {0}, NULL, }, { @@ -218,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}, @@ -246,7 +245,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {ARRAY_SIZE(depth)}, NULL, }, - //10 + /* 10 */ { MM_CAM_AUDIO_CHANNEL, "audio-channel", @@ -263,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}, @@ -357,7 +356,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {.int_max = -1}, _mmcamcorder_commit_filter, }, - //20 + /* 20 */ { MM_CAM_FILTER_SHARPNESS, "filter-sharpness", @@ -378,17 +377,17 @@ _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_INT}, + {.double_max = _MMCAMCORDER_MAX_DOUBLE}, _mmcamcorder_commit_camera_recording_motion_rate, }, { @@ -397,9 +396,9 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)30}, - MM_ATTRS_VALID_TYPE_INT_ARRAY, - {0}, + MM_ATTRS_VALID_TYPE_INT_RANGE, {0}, + {1024}, _mmcamcorder_commit_camera_fps, }, { @@ -468,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", @@ -555,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, @@ -577,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", @@ -589,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, @@ -673,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}, @@ -690,13 +689,13 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {0}, NULL, }, - // 50 + /* 50 */ { MM_CAM_DISPLAY_SURFACE, "display-surface", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, - {(void*)MM_DISPLAY_SURFACE_X}, + {(void*)MM_DISPLAY_SURFACE_OVERLAY}, MM_ATTRS_VALID_TYPE_INT_ARRAY, {0}, {0}, @@ -731,7 +730,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, - {.int_min = 0}, + {.int_min = 1}, {.int_max = _MMCAMCORDER_MAX_INT}, _mmcamcorder_commit_display_rect, }, @@ -742,7 +741,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, - {.int_min = 0}, + {.int_min = 1}, {.int_max = _MMCAMCORDER_MAX_INT}, _mmcamcorder_commit_display_rect, }, @@ -801,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, @@ -839,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}, @@ -854,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, @@ -865,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, @@ -876,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, @@ -898,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, @@ -1022,7 +1022,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {.int_max = -1}, _mmcamcorder_commit_detect, }, - //80 + /* 80 */ { MM_CAM_DETECT_STATUS, "detect-status", @@ -1094,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}, @@ -1131,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, @@ -1183,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}, @@ -1244,7 +1244,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {0}, _mmcamcorder_commit_display_mode, }, - //100 + /* 100 */ { MM_CAM_AUDIO_DISABLE, "audio-disable", @@ -1283,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}, @@ -1294,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}, @@ -1355,7 +1355,62 @@ _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", + MMF_VALUE_TYPE_INT, + MM_ATTRS_FLAG_RW, + {(void*)0}, + MM_ATTRS_VALID_TYPE_INT_RANGE, + {.int_min = 0}, + {.int_max = -1}, + _mmcamcorder_commit_camera_pan, + }, + { + MM_CAM_CAMERA_PAN_ELEC, + "camera-pan-elec", + MMF_VALUE_TYPE_INT, + MM_ATTRS_FLAG_RW, + {(void*)0}, + MM_ATTRS_VALID_TYPE_INT_RANGE, + {.int_min = 0}, + {.int_max = -1}, + _mmcamcorder_commit_camera_pan, + }, + { + MM_CAM_CAMERA_TILT_MECHA, + "camera-tilt-mecha", + MMF_VALUE_TYPE_INT, + MM_ATTRS_FLAG_RW, + {(void*)0}, + MM_ATTRS_VALID_TYPE_INT_RANGE, + {.int_min = 0}, + {.int_max = -1}, + _mmcamcorder_commit_camera_tilt, + }, + { + MM_CAM_CAMERA_TILT_ELEC, + "camera-tilt-elec", + MMF_VALUE_TYPE_INT, + MM_ATTRS_FLAG_RW, + {(void*)0}, + MM_ATTRS_VALID_TYPE_INT_RANGE, + {.int_min = 0}, + {.int_max = -1}, + _mmcamcorder_commit_camera_tilt, + }, + { + MM_CAM_CAMERA_PTZ_TYPE, + "camera-ptz-type", + MMF_VALUE_TYPE_INT, + MM_ATTRS_FLAG_RW, + {(void*)0}, + MM_ATTRS_VALID_TYPE_INT_ARRAY, + {0}, + {0}, + _mmcamcorder_commit_camera_ptz_type, + }, { MM_CAM_VIDEO_WIDTH, "video-width", @@ -1410,6 +1465,150 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {.int_min = FALSE}, {.int_max = TRUE}, NULL, + }, + /* 120 */ + { + MM_CAM_ENCODED_PREVIEW_BITRATE, + "encoded-preview-bitrate", + MMF_VALUE_TYPE_INT, + MM_ATTRS_FLAG_RW, + {(void*)MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_BITRATE}, + MM_ATTRS_VALID_TYPE_INT_RANGE, + {.int_min = 0}, + {.int_max = _MMCAMCORDER_MAX_INT}, + _mmcamcorder_commit_encoded_preview_bitrate, + }, + { + MM_CAM_ENCODED_PREVIEW_GOP_INTERVAL, + "encoded-preview-gop-interval", + MMF_VALUE_TYPE_INT, + MM_ATTRS_FLAG_RW, + {(void*)MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_GOP_INTERVAL}, + MM_ATTRS_VALID_TYPE_INT_RANGE, + {.int_min = 0}, + {.int_max = _MMCAMCORDER_MAX_INT}, + _mmcamcorder_commit_encoded_preview_gop_interval, + }, + { + MM_CAM_RECORDER_TAG_ENABLE, + "recorder-tag-enable", + 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_DISPLAY_SOCKET_PATH, + "display-socket-path", + MMF_VALUE_TYPE_STRING, + MM_ATTRS_FLAG_RW, + {NULL}, + MM_ATTRS_VALID_TYPE_NONE, + {0}, + {0}, + NULL, + }, + { + MM_CAM_PID_FOR_SOUND_FOCUS, + "pid-for-sound-focus", + MMF_VALUE_TYPE_INT, + MM_ATTRS_FLAG_RW, + {(void*)0}, + MM_ATTRS_VALID_TYPE_INT_RANGE, + {.int_min = 0}, + {.int_max = _MMCAMCORDER_MAX_INT}, + _mmcamcorder_commit_pid_for_sound_focus, + }, + { + MM_CAM_ROOT_DIRECTORY, + "root-directory", + MMF_VALUE_TYPE_STRING, + MM_ATTRS_FLAG_RW, + {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, + {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_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*)FALSE}, + MM_ATTRS_VALID_TYPE_INT_RANGE, + {.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, } }; @@ -1436,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; @@ -1453,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; } } @@ -1538,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); @@ -1556,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) { @@ -1601,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; } } @@ -1652,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; @@ -1664,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; } @@ -1761,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); @@ -1796,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; @@ -1817,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; @@ -1853,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; @@ -1864,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) { @@ -1889,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); @@ -1905,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; @@ -1943,40 +2166,71 @@ 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) { - MMCamAttrsInfo fps_info; - int resolution_width = 0; - int resolution_height = 0; - int i; - int ret; - - _mmcam_dbg_log("FPS(%d)", value->value.i_val); + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + int current_state = MM_CAMCORDER_STATE_NONE; - ret = mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_WIDTH, &resolution_width, - MMCAM_CAMERA_HEIGHT, &resolution_height, - NULL); + mmf_return_val_if_fail(hcamcorder && value, FALSE); - if(ret != MM_ERROR_NONE) { - _mmcam_dbg_err("FAILED : coult not get resolution values."); + 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; } - ret = mm_camcorder_get_fps_list_by_resolution(handle, resolution_width, resolution_height, &fps_info); + return TRUE; +} - if(ret != MM_ERROR_NONE) { - _mmcam_dbg_err("FAILED : coult not get FPS values by resolution."); - return FALSE; - } - for(i=0; ivalue.i_val == fps_info.int_array.array[i]) { - 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 = 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); + + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("FAILED : coult not get resolution values."); + return FALSE; + } + + ret = mm_camcorder_get_fps_list_by_resolution(handle, resolution_width, resolution_height, &fps_info); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("FAILED : coult not get FPS values by resolution."); + return FALSE; + } + + for (i = 0 ; i < fps_info.int_array.count ; i++) { + if (value->value.i_val == fps_info.int_array.array[i]) + return TRUE; } _mmcam_dbg_err("FAILED : %d is not supported FPS", value->value.i_val); + return FALSE; } @@ -1984,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; @@ -2026,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); @@ -2056,13 +2308,20 @@ 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 (!pthread_mutex_trylock(&(hcamcorder->restart_preview_lock))) { + if (hcamcorder->resolution_changed == FALSE) { + _mmcam_dbg_log("no need to restart preview"); + return TRUE; + } + + hcamcorder->resolution_changed = FALSE; + + if (g_mutex_trylock(&hcamcorder->restart_preview_lock)) { _mmcam_dbg_log("restart preview"); MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE); @@ -2070,6 +2329,13 @@ bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const m _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY); + /* check decoder recreation */ + if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) { + _mmcam_dbg_err("_mmcamcorder_recreate_decoder_for_encoded_preview failed"); + g_mutex_unlock(&hcamcorder->restart_preview_lock); + return FALSE; + } + /* get preview format */ sc->info_image->preview_format = preview_format; sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format); @@ -2081,7 +2347,7 @@ bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const m _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING); /* unlock */ - pthread_mutex_unlock(&(hcamcorder->restart_preview_lock)); + g_mutex_unlock(&hcamcorder->restart_preview_lock); } else { _mmcam_dbg_err("currently locked for preview restart"); return FALSE; @@ -2109,21 +2375,21 @@ 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); _mmcam_dbg_log("Height(%d)", value->value.i_val); - current_state = _mmcamcorder_get_state( handle); + current_state = _mmcamcorder_get_state(handle); if (current_state > MM_CAMCORDER_STATE_PREPARE) { _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } else { int width = 0; @@ -2133,17 +2399,24 @@ 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; if (current_state == MM_CAMCORDER_STATE_PREPARE) { - if (!pthread_mutex_trylock(&(hcamcorder->restart_preview_lock))) { + if (hcamcorder->resolution_changed == FALSE) { + _mmcam_dbg_log("no need to restart preview"); + return TRUE; + } + + hcamcorder->resolution_changed = FALSE; + + if (g_mutex_trylock(&hcamcorder->restart_preview_lock)) { _mmcam_dbg_log("restart preview"); _mmcam_dbg_log("set empty buffers"); @@ -2153,6 +2426,13 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY); + /* check decoder recreation */ + if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) { + _mmcam_dbg_err("_mmcamcorder_recreate_decoder_for_encoded_preview failed"); + g_mutex_unlock(&hcamcorder->restart_preview_lock); + return FALSE; + } + /* get preview format */ sc->info_image->preview_format = preview_format; sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format); @@ -2165,7 +2445,7 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING); /* unlock */ - pthread_mutex_unlock(&(hcamcorder->restart_preview_lock)); + g_mutex_unlock(&hcamcorder->restart_preview_lock); } else { _mmcam_dbg_err("currently locked for preview restart"); return FALSE; @@ -2187,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); @@ -2221,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; @@ -2239,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; @@ -2260,10 +2545,206 @@ bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const m } -bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value) +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; + + GstCameraControl *CameraControl = NULL; + GstCameraControlChannel *CameraControlChannel = NULL; + 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); + + _mmcam_dbg_log("ptz type : %d", value->value.i_val); + + current_state = _mmcamcorder_get_state(handle); + if (current_state < MM_CAMCORDER_STATE_PREPARE || + current_state == MM_CAMCORDER_STATE_CAPTURING) { + _mmcam_dbg_err("invalid state[%d]", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; + } + + if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) { + if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) { + _mmcam_dbg_log("Can't cast Video source into camera control."); + return FALSE; + } + + CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + if (CameraControl == NULL) { + _mmcam_dbg_err("cast CAMERA_CONTROL failed"); + return FALSE; + } + + controls = gst_camera_control_list_channels(CameraControl); + if (controls == NULL) { + _mmcam_dbg_err("gst_camera_control_list_channels failed"); + return FALSE; + } + + for (item = controls ; item && item->data ; item = item->next) { + CameraControlChannel = item->data; + _mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label); + if (!strcmp(CameraControlChannel->label, "ptz")) { + if (gst_camera_control_set_value(CameraControl, CameraControlChannel, value->value.i_val)) { + _mmcam_dbg_warn("set ptz type %d done", value->value.i_val); + return TRUE; + } else { + _mmcam_dbg_err("failed to set ptz type %d", value->value.i_val); + return FALSE; + } + } + } + + _mmcam_dbg_warn("failed to find tilt control channel"); + } + + return FALSE; +} + + +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; + + GstCameraControl *CameraControl = NULL; + GstCameraControlChannel *CameraControlChannel = NULL; + 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); + + _mmcam_dbg_log("pan : %d", value->value.i_val); + + current_state = _mmcamcorder_get_state(handle); + if (current_state < MM_CAMCORDER_STATE_PREPARE || + current_state == MM_CAMCORDER_STATE_CAPTURING) { + _mmcam_dbg_err("invalid state[%d]", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; + } + + if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) { + if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) { + _mmcam_dbg_log("Can't cast Video source into camera control."); + return FALSE; + } + + CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + if (CameraControl == NULL) { + _mmcam_dbg_err("cast CAMERA_CONTROL failed"); + return FALSE; + } + + controls = gst_camera_control_list_channels(CameraControl); + if (controls == NULL) { + _mmcam_dbg_err("gst_camera_control_list_channels failed"); + return FALSE; + } + + for (item = controls ; item && item->data ; item = item->next) { + CameraControlChannel = item->data; + _mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label); + if (!strcmp(CameraControlChannel->label, "pan")) { + if (gst_camera_control_set_value(CameraControl, CameraControlChannel, value->value.i_val)) { + _mmcam_dbg_warn("set pan %d done", value->value.i_val); + return TRUE; + } else { + _mmcam_dbg_err("failed to set pan %d", value->value.i_val); + return FALSE; + } + } + } + + _mmcam_dbg_warn("failed to find pan control channel"); + } + + return FALSE; +} + + +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; + + GstCameraControl *CameraControl = NULL; + GstCameraControlChannel *CameraControlChannel = NULL; + 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); + + _mmcam_dbg_log("tilt : %d", value->value.i_val); + + current_state = _mmcamcorder_get_state(handle); + if (current_state < MM_CAMCORDER_STATE_PREPARE || + current_state == MM_CAMCORDER_STATE_CAPTURING) { + _mmcam_dbg_err("invalid state[%d]", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; + } + + if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) { + if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) { + _mmcam_dbg_log("Can't cast Video source into camera control."); + return FALSE; + } + + CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + if (CameraControl == NULL) { + _mmcam_dbg_err("cast CAMERA_CONTROL failed"); + return FALSE; + } + + controls = gst_camera_control_list_channels(CameraControl); + if (controls == NULL) { + _mmcam_dbg_err("gst_camera_control_list_channels failed"); + return FALSE; + } + + for (item = controls ; item && item->data ; item = item->next) { + CameraControlChannel = item->data; + _mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label); + if (!strcmp(CameraControlChannel->label, "tilt")) { + if (gst_camera_control_set_value(CameraControl, CameraControlChannel, value->value.i_val)) { + _mmcam_dbg_warn("set tilt %d done", value->value.i_val); + return TRUE; + } else { + _mmcam_dbg_err("failed to set tilt %d", value->value.i_val); + return FALSE; + } + } + } + + _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) { 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; @@ -2271,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); @@ -2290,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) { @@ -2301,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; @@ -2338,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; @@ -2350,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; @@ -2369,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) { @@ -2377,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 { @@ -2408,11 +2902,14 @@ bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx return FALSE; } -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 }, get_area = { 0, 0, 0, 0 }; + GstCameraControlRectType set_area = { 0, 0, 0, 0 }; + GstCameraControlRectType get_area = { 0, 0, 0, 0 }; int current_state = MM_CAMCORDER_STATE_NONE; int ret = FALSE; @@ -2420,7 +2917,11 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx gboolean do_set = FALSE; - MMCamAttrsInfo info_y, info_w, info_h; + MMCamAttrsInfo info_y; + MMCamAttrsInfo info_w; + MMCamAttrsInfo info_h; + + mmf_return_val_if_fail(hcamcorder && value, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); if (!sc) @@ -2428,146 +2929,171 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx _mmcam_dbg_log("(%d)", attr_idx); - current_state = _mmcamcorder_get_state( handle); - - if( current_state < MM_CAMCORDER_STATE_PREPARE ) - { + current_state = _mmcamcorder_get_state(handle); + if (current_state < MM_CAMCORDER_STATE_PREPARE) { _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state); 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); - if( ret != MM_ERROR_NONE ) - { - _mmcam_dbg_warn( "Failed to get FOCUS MODE.[%x]", ret ); + MMCAM_CAMERA_FOCUS_MODE, &focus_mode, + NULL); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_warn("Failed to get FOCUS MODE.[%x]", ret); return FALSE; } - if ((focus_mode != MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO ) && (focus_mode != MM_CAMCORDER_FOCUS_MODE_CONTINUOUS)) - { - _mmcam_dbg_warn( "Focus mode is NOT TOUCH AUTO or CONTINUOUS(current[%d]). return FALSE", focus_mode ); + if ((focus_mode != MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO) && (focus_mode != MM_CAMCORDER_FOCUS_MODE_CONTINUOUS)) { + _mmcam_dbg_warn("Focus mode is NOT TOUCH AUTO or CONTINUOUS(current[%d]). return FALSE", focus_mode); return FALSE; } - if( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst ) - { - if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) - { + if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) { + if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) { _mmcam_dbg_log("Can't cast Video source into camera control."); return TRUE; } - switch( attr_idx ) - { - case MM_CAM_CAMERA_AF_TOUCH_X: - mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_Y, &info_y); - mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_WIDTH, &info_w); - mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h); - 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); - do_set = TRUE; - } - else - { - _mmcam_dbg_log( "Just store AF area[x:%d]", value->value.i_val ); - return TRUE; - } - break; - case MM_CAM_CAMERA_AF_TOUCH_Y: - mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_WIDTH, &info_w); - mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h); - 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); - do_set = TRUE; - } - else - { - _mmcam_dbg_log( "Just store AF area[y:%d]", value->value.i_val ); - return TRUE; - } - break; - case MM_CAM_CAMERA_AF_TOUCH_WIDTH: - mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h); - 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); - do_set = TRUE; - } - else - { - _mmcam_dbg_log( "Just store AF area[width:%d]", value->value.i_val ); - return TRUE; - } - break; - case MM_CAM_CAMERA_AF_TOUCH_HEIGHT: - set_area.height = value->value.i_val; + memset(&info_y, 0x0, sizeof(MMCamAttrsInfo)); + memset(&info_w, 0x0, sizeof(MMCamAttrsInfo)); + memset(&info_h, 0x0, sizeof(MMCamAttrsInfo)); + + switch (attr_idx) { + case MM_CAM_CAMERA_AF_TOUCH_X: + mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_Y, &info_y); + mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_WIDTH, &info_w); + mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h); + 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); + do_set = TRUE; + } else { + _mmcam_dbg_log("Just store AF area[x:%d]", value->value.i_val); + return TRUE; + } + break; + case MM_CAM_CAMERA_AF_TOUCH_Y: + mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_WIDTH, &info_w); + mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h); + 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); + do_set = TRUE; + } else { + _mmcam_dbg_log("Just store AF area[y:%d]", value->value.i_val); + return TRUE; + } + break; + case MM_CAM_CAMERA_AF_TOUCH_WIDTH: + mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h); + 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_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_HEIGHT, &set_area.height, + NULL); do_set = TRUE; - break; - default: - break; + } else { + _mmcam_dbg_log("Just store AF area[width:%d]", value->value.i_val); + return TRUE; + } + break; + 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); + do_set = TRUE; + break; + default: + break; } - if( do_set ) - { - control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + if (do_set) { + _MMCamcorderVideoInfo *info = sc->info_video; + + if (info == NULL) { + _mmcam_dbg_err("video info is NULL"); + return FALSE; + } + + control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); if (control == NULL) { _mmcam_dbg_err("cast CAMERA_CONTROL failed"); return FALSE; } - ret = gst_camera_control_get_auto_focus_area( control, &get_area ); - if( !ret ) - { - _mmcam_dbg_warn( "Failed to get AF area" ); + /* convert area */ + if (current_state >= MM_CAMCORDER_STATE_RECORDING && info->support_dual_stream == FALSE && + (info->preview_width != info->video_width || info->preview_height != info->video_height)) { + float ratio_width = 0.0; + float ratio_height = 0.0; + + if (info->preview_width != 0 && info->preview_height != 0) { + ratio_width = (float)info->video_width / (float)info->preview_width; + ratio_height = (float)info->video_height / (float)info->preview_height; + + _mmcam_dbg_log("original area %d,%d,%dx%d, resolution ratio : width %f, height %f", + 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) + set_area.width = 1; + + 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); + } else { + _mmcam_dbg_warn("invalid preview size %dx%d, skip AF area converting", + info->preview_width, info->preview_height); + } + } + + ret = gst_camera_control_get_auto_focus_area(control, &get_area); + if (!ret) { + _mmcam_dbg_warn("Failed to get AF area"); return FALSE; } - if( get_area.x == set_area.x && get_area.y == set_area.y ) - // width and height are not supported now. - // get_area.width == set_area.width && get_area.height == set_area.height - { - _mmcam_dbg_log( "No need to set AF area[x,y:%d,%d]", get_area.x, get_area.y ); + /* 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); 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 ); + 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); 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 ); + } 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); } } - } - else - { + } else { _mmcam_dbg_log("pointer of video src is null"); } @@ -2575,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; @@ -2598,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; @@ -2623,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) { @@ -2643,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; @@ -2651,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"); @@ -2664,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)) { @@ -2682,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; } @@ -2714,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"); @@ -2737,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)) { @@ -2750,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; } @@ -2757,9 +3300,51 @@ bool _mmcamcorder_commit_camera_anti_handshake(MMHandleType handle, int attr_idx } +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; + + 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; + } + + 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) { @@ -2767,6 +3352,7 @@ bool _mmcamcorder_commit_camera_video_stabilization(MMHandleType handle, int att 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; } @@ -2777,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); @@ -2784,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); @@ -2798,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) { @@ -2811,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); @@ -2829,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); @@ -2845,33 +3435,31 @@ bool _mmcamcorder_commit_target_filename(MMHandleType handle, int attr_idx, cons return FALSE; } - if (sc->info_video) { - if (sc->info_video->filename) { - free(sc->info_video->filename); - sc->info_video->filename = NULL; - } - sc->info_video->filename = 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(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); + + 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) +bool _mmcamcorder_commit_filter(MMHandleType handle, int attr_idx, const mmf_value_t *value) { GstColorBalance *balance = NULL; GstColorBalanceChannel *Colorchannel = NULL; @@ -2887,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) @@ -2907,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; } @@ -2964,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);*/ @@ -2989,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; } @@ -3007,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); @@ -3029,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) { @@ -3052,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"); @@ -3081,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; @@ -3099,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"); @@ -3120,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) { @@ -3141,35 +3744,22 @@ bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const if (p_handle) { /* get videosink name */ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name); + if (videosink_name == NULL) { + _mmcam_dbg_err("Please check videosink element in configuration file"); + return FALSE; + } + _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(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; - GstContext *context = NULL; - - context = gst_wayland_display_handle_context_new((struct wl_display *)wl_info->display); - if (context) { - gst_element_set_context(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), context); - } else { - _mmcam_dbg_warn("gst_wayland_display_handle_context_new failed"); - } - - gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), (guintptr)wl_info->surface); - 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 */ + MMCAMCORDER_G_OBJECT_SET_POINTER(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "evas-object", p_handle); + } else if (!strcmp(videosink_name, "tizenwlsink")) { + _mmcam_dbg_log("wayland global surface id : %d", *(int *)(p_handle)); + gst_video_overlay_set_wl_window_wl_surface_id(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), (guintptr)*(int *)(p_handle)); } else { _mmcam_dbg_warn("Commit : Nothing to commit with this element[%s]", videosink_name); return FALSE; @@ -3191,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) { @@ -3209,16 +3799,21 @@ bool _mmcamcorder_commit_display_mode(MMHandleType handle, int attr_idx, const m sc = MMF_CAMCORDER_SUBCONTEXT(handle); _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name); + if (videosink_name == NULL) { + _mmcam_dbg_err("Please check videosink element in configuration file"); + return FALSE; + } + _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name); - if (!strcmp(videosink_name, "xvimagesink")) { + 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; } @@ -3228,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) { @@ -3243,7 +3838,7 @@ bool _mmcamcorder_commit_display_rotation(MMHandleType handle, int attr_idx, con return TRUE; } - return _mmcamcorder_set_display_rotation(handle, value->value.i_val); + return _mmcamcorder_set_display_rotation(handle, value->value.i_val, _MMCAMCORDER_VIDEOSINK_SINK); } @@ -3253,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) { @@ -3268,7 +3863,7 @@ bool _mmcamcorder_commit_display_flip(MMHandleType handle, int attr_idx, const m return TRUE; } - return _mmcamcorder_set_display_flip(handle, value->value.i_val); + return _mmcamcorder_set_display_flip(handle, value->value.i_val, _MMCAMCORDER_VIDEOSINK_SINK); } @@ -3280,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) { @@ -3299,19 +3894,24 @@ bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, cons /* Get videosink name */ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name); - if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "evasimagesink") || - !strcmp(videosink_name, "evaspixmapsink")) { + if (videosink_name == NULL) { + _mmcam_dbg_err("Please check videosink element in configuration file"); + return FALSE; + } + + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") || + !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) { 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; @@ -3320,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) { @@ -3339,15 +3939,20 @@ bool _mmcamcorder_commit_display_geometry_method (MMHandleType handle, int attr_ /* Get videosink name */ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name); - if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "evasimagesink") || - !strcmp(videosink_name, "evaspixmapsink")) { + if (videosink_name == NULL) { + _mmcam_dbg_err("Please check videosink element in configuration file"); + return FALSE; + } + + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") || + !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) { method = value->value.i_val; - MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-geometry-method", method); - return TRUE; + MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-geometry-method", method); } 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; } @@ -3355,12 +3960,13 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m { int current_state = MM_CAMCORDER_STATE_NONE; int method = 0; + int ret = MM_ERROR_NONE; const char *videosink_name = NULL; 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) { @@ -3379,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; @@ -3388,7 +3994,12 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m /* Get videosink name */ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name); - if (!strcmp(videosink_name, "xvimagesink") || + if (videosink_name == NULL) { + _mmcam_dbg_err("Please check videosink element in configuration file"); + return FALSE; + } + + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") || !strcmp(videosink_name, "evaspixmapsink")) { int rect_x = 0; int rect_y = 0; @@ -3398,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); @@ -3440,21 +4051,29 @@ 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); - 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); + _mmcam_dbg_log("RECT(x,y,w,h) = (%d,%d,%d,%d)", rect_x, rect_y, rect_width, rect_height); + + if (!strcmp(videosink_name, "tizenwlsink")) { + ret = gst_video_overlay_set_render_rectangle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), + rect_x, rect_y, rect_width, rect_height); + if (!ret) { + _mmcam_dbg_err("FAILED : could not set render rectangle."); + return FALSE; + } + } 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); + } } - - 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; } @@ -3468,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) { @@ -3487,8 +4106,13 @@ bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const /* Get videosink name */ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name); + if (videosink_name == NULL) { + _mmcam_dbg_err("Please check videosink element in configuration file"); + return FALSE; + } + zoom = value->value.i_val; - if (!strcmp(videosink_name, "xvimagesink")) { + 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)); @@ -3508,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) { @@ -3532,6 +4156,11 @@ bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_i /* Get videosink name */ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name); + if (videosink_name == NULL) { + _mmcam_dbg_err("Please check videosink element in configuration file"); + return FALSE; + } + if (!strcmp(videosink_name, "evaspixmapsink")) { MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "origin-size", !do_scaling); _mmcam_dbg_log("Set origin-size to %d", !(value->value.i_val)); @@ -3543,19 +4172,15 @@ 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; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); int strobe_type, mslVal, newVal, cur_value; int current_state = MM_CAMCORDER_STATE_NONE; - int set_flash_state = -1; - if (hcamcorder == NULL) { - _mmcam_dbg_err("NULL handle"); - return FALSE; - } + mmf_return_val_if_fail(hcamcorder && value, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); if (!sc) @@ -3570,7 +4195,7 @@ bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_va int flash_brightness = 0; /* get current flash brightness */ - if (_mmcamcorder_get_device_flash_brightness(&flash_brightness) != MM_ERROR_NONE) { + if (_mmcamcorder_get_device_flash_brightness(hcamcorder->gdbus_conn, &flash_brightness) != MM_ERROR_NONE) { _mmcam_dbg_err("_mmcamcorder_get_device_flash_brightness failed"); hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION; return FALSE; @@ -3585,14 +4210,7 @@ bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_va _mmcam_dbg_err("other module already turned on flash. avoid to set flash mode here."); return FALSE; } else { - /* flash is OFF state, this case will set flash state key */ - if (mslVal == MM_CAMCORDER_STROBE_MODE_OFF) { - set_flash_state = VCONFKEY_CAMERA_FLASH_STATE_OFF; - } else { - set_flash_state = VCONFKEY_CAMERA_FLASH_STATE_ON; - } - - _mmcam_dbg_log("keep going, and will set flash state key %d", set_flash_state); + _mmcam_dbg_log("keep going"); } } @@ -3600,16 +4218,9 @@ bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_va current_state = _mmcamcorder_get_state(handle); if (current_state < MM_CAMCORDER_STATE_READY) { _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state); - - if (set_flash_state != -1) { - _mmcam_dbg_log("set VCONFKEY_CAMERA_FLASH_STATE : %d", set_flash_state); - vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, set_flash_state); - vconf_set_int(VCONFKEY_CAMERA_PID, (int)getpid()); - } - return TRUE; } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) { - _mmcam_dbg_warn("invalid state[capturing]"); + _mmcam_dbg_err("Can not set while CAPTURING"); hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } @@ -3668,12 +4279,6 @@ bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_va } } - if (bret == TRUE && set_flash_state != -1) { - _mmcam_dbg_log("set VCONFKEY_CAMERA_FLASH_STATE : %d", set_flash_state); - vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, set_flash_state); - vconf_set_int(VCONFKEY_CAMERA_PID, (int)getpid()); - } - return bret; } @@ -3682,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); @@ -3694,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."); @@ -3712,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);*/ @@ -3731,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; } @@ -3739,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); @@ -3755,6 +4358,12 @@ bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, c _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY); + /* check decoder recreation */ + if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) { + _mmcam_dbg_err("_mmcamcorder_recreate_decoder_for_encoded_preview failed"); + return FALSE; + } + MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE); MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE); } @@ -3764,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; @@ -3787,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; @@ -3852,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; } } @@ -3870,16 +4474,270 @@ bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const mmf_val } -static bool -__mmcamcorder_attrs_is_supported(MMHandleType handle, int idx) +bool _mmcamcorder_commit_encoded_preview_bitrate(MMHandleType handle, int attr_idx, const mmf_value_t *value) +{ + int current_state = MM_CAMCORDER_STATE_NONE; + int preview_format = MM_PIXEL_FORMAT_NV12; + + mmf_return_val_if_fail(handle && value, FALSE); + + _mmcam_dbg_log("Commit : encoded preview bitrate - %d", value->value.i_val); + + /* check preview format */ + mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FORMAT, &preview_format, NULL); + if (preview_format != MM_PIXEL_FORMAT_ENCODED_H264) { + _mmcam_dbg_err("current preview format[%d] is not encoded format", preview_format); + return FALSE; + } + + /* check state */ + current_state = _mmcamcorder_get_state(handle); + if (current_state < MM_CAMCORDER_STATE_READY) { + _mmcam_dbg_log("will be applied when preview starts"); + return TRUE; + } + + return _mmcamcorder_set_encoded_preview_bitrate(handle, value->value.i_val); +} + + +bool _mmcamcorder_commit_encoded_preview_gop_interval(MMHandleType handle, int attr_idx, const mmf_value_t *value) +{ + int current_state = MM_CAMCORDER_STATE_NONE; + int preview_format = MM_PIXEL_FORMAT_NV12; + + mmf_return_val_if_fail(handle && value, FALSE); + + _mmcam_dbg_log("Commit : encoded preview I-frame interval - %d", value->value.i_val); + + /* check preview format */ + mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FORMAT, &preview_format, NULL); + if (preview_format != MM_PIXEL_FORMAT_ENCODED_H264) { + _mmcam_dbg_err("current preview format[%d] is not encoded format", preview_format); + return FALSE; + } + + /* check state */ + current_state = _mmcamcorder_get_state(handle); + if (current_state < MM_CAMCORDER_STATE_READY) { + _mmcam_dbg_log("will be applied when preview starts"); + return TRUE; + } + + return _mmcamcorder_set_encoded_preview_gop_interval(handle, value->value.i_val); +} + + +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); + + mmf_return_val_if_fail(hcamcorder && value, FALSE); + + /* state check */ + 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_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; + } + + 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 { + /* 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 { + hcamcorder->session_type = 0; + hcamcorder->session_flags = 0; + hcamcorder->sound_focus_register = TRUE; + + _mmcam_dbg_warn("read session info failed. sound focus watch cb will be set."); + + 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; + } + } + + return TRUE; +} + + +bool _mmcamcorder_commit_sound_stream_info(MMHandleType handle, int attr_idx, const mmf_value_t *value) +{ + int stream_index = 0; + char *stream_type = NULL; + _MMCamcorderSubContext *sc = 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_warn("audiosrc element is not initialized, it will be set later"); + return TRUE; + } + + _mmcam_dbg_warn("Commit : sound stream info - type %s, index %d", stream_type, stream_index); + + return _mmcamcorder_set_sound_stream_info(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, stream_type, stream_index); +} + + +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; + } + + 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); + + 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) { 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; } @@ -3887,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) { @@ -3948,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."); @@ -3982,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); @@ -3997,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])); @@ -4010,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; @@ -4027,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); } } @@ -4060,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); @@ -4083,17 +4969,17 @@ static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width, } -static int -__mmcamcorder_check_valid_pair( MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args ) +static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args) { #define INIT_VALUE -1 #define CHECK_COUNT 3 - mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle); + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); MMHandleType attrs = 0; int ret = MM_ERROR_NONE; - int i = 0, j = 0; + int i = 0; + int j = 0; const char *name = NULL; const char *check_pair_name[CHECK_COUNT][3] = { {MMCAM_CAMERA_WIDTH, MMCAM_CAMERA_HEIGHT, "MMCAM_CAMERA_WIDTH and HEIGHT"}, @@ -4109,15 +4995,14 @@ __mmcamcorder_check_valid_pair( MMHandleType handle, char **err_attr_name, const 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); @@ -4131,21 +5016,18 @@ __mmcamcorder_check_valid_pair( MMHandleType handle, char **err_attr_name, const /* 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: @@ -4160,13 +5042,11 @@ __mmcamcorder_check_valid_pair( MMHandleType handle, char **err_attr_name, const break; } } - if (matched) { + if (matched) break; - } } - if (matched == FALSE) { + if (matched == FALSE) va_arg((var_args), int); - } break; } case MM_ATTRS_TYPE_DOUBLE: @@ -4183,9 +5063,9 @@ __mmcamcorder_check_valid_pair( MMHandleType handle, char **err_attr_name, const 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; } @@ -4214,14 +5094,14 @@ __mmcamcorder_check_valid_pair( MMHandleType handle, char **err_attr_name, const 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; } @@ -4229,8 +5109,8 @@ __mmcamcorder_check_valid_pair( MMHandleType handle, char **err_attr_name, const 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 { @@ -4243,6 +5123,25 @@ __mmcamcorder_check_valid_pair( MMHandleType handle, char **err_attr_name, const return MM_ERROR_CAMCORDER_INVALID_ARGUMENT; } + if (!strcmp(check_pair_name[i][0], MMCAM_CAMERA_WIDTH)) { + int current_width = 0; + int current_height = 0; + + mm_camcorder_get_attributes(handle, 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]) { + hcamcorder->resolution_changed = TRUE; + } else { + hcamcorder->resolution_changed = FALSE; + } + + _mmcam_dbg_log("resolution changed : %d", hcamcorder->resolution_changed); + } + if (err_name) { free(err_name); err_name = NULL; @@ -4274,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);