X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_attribute.c;h=39c3ac46e216cd8a159a9260af4d17ca7285de80;hb=60a19067caf665ae3612c96456dc0ce358e4fa73;hp=e9014f854392de2da05d29723b0c9bcf52abe703;hpb=cb328297838d2658d5ce377d026044bd101ce0e4;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git diff --git a/src/mm_camcorder_attribute.c b/src/mm_camcorder_attribute.c index e9014f8..39c3ac4 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. */ @@ -72,7 +72,6 @@ static int readonly_attributes[] = { static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width, int height); static int __mmcamcorder_set_conf_to_valid_info(MMHandleType handle); static int __mmcamcorder_release_conf_valid_info(MMHandleType handle); -static bool __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx); static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args); /*======================================================================= @@ -82,22 +81,22 @@ 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) { - _mmcam_dbg_log( "" ); + _mmcam_dbg_log(""); mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); - MMHandleType attrs = 0; - mmf_attrs_construct_info_t *attrs_const_info = NULL; + MMHandleType attrs = NULL; + MMAttrsConstructInfo *attrs_const_info; unsigned int attr_count = 0; unsigned int idx; + int ret = MM_ERROR_NONE; static int depth[] = {MM_CAMCORDER_AUDIO_FORMAT_PCM_U8, MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE}; 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.*/ @@ -116,9 +115,9 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) /* Create attribute constructor */ _mmcam_dbg_log("start"); - /* alloc 'mmf_attrs_construct_info_t' */ + /* alloc 'MMAttrsConstructInfo' */ attr_count = MM_CAM_ATTRIBUTE_NUM; - attrs_const_info = malloc(attr_count * sizeof(mmf_attrs_construct_info_t)); + attrs_const_info = malloc(attr_count * sizeof(MMAttrsConstructInfo)); if (!attrs_const_info) { _mmcam_dbg_err("Fail to alloc constructor."); return 0; @@ -135,11 +134,11 @@ _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 */ - MMF_VALUE_TYPE_INT, /* Type */ + MM_ATTRS_TYPE_INT, /* Type */ MM_ATTRS_FLAG_RW, /* Flag */ {(void*)MM_CAMCORDER_MODE_VIDEO_CAPTURE}, /* Default value */ MM_ATTRS_VALID_TYPE_INT_RANGE, /* Validity type */ @@ -150,7 +149,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_AUDIO_DEVICE, "audio-device", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_AUDIO_DEVICE_MIC}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -161,7 +160,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_DEVICE_COUNT, "camera-device-count", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_VIDEO_DEVICE_NUM}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -172,7 +171,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_AUDIO_ENCODER, "audio-encoder", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_AUDIO_CODEC_AMR}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -183,7 +182,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_VIDEO_ENCODER, "video-encoder", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_VIDEO_CODEC_MPEG4}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -194,7 +193,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_IMAGE_ENCODER, "image-encoder", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_IMAGE_CODEC_JPEG}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -205,7 +204,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_FILE_FORMAT, "file-format", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_FILE_FORMAT_MP4}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -216,9 +215,9 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_DEVICE_NAME, "camera-device-name", - MMF_VALUE_TYPE_STRING, + MM_ATTRS_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -227,7 +226,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_AUDIO_SAMPLERATE, "audio-samplerate", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)8000}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -238,7 +237,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_AUDIO_FORMAT, "audio-format", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -246,11 +245,11 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {ARRAY_SIZE(depth)}, NULL, }, - //10 + /* 10 */ { MM_CAM_AUDIO_CHANNEL, "audio-channel", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)2}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -261,9 +260,9 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_AUDIO_VOLUME, "audio-volume", - MMF_VALUE_TYPE_DOUBLE, + MM_ATTRS_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}, @@ -272,7 +271,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_AUDIO_INPUT_ROUTE, "audio-input-route", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_AUDIOROUTE_USE_EXTERNAL_SETTING}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -283,7 +282,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_FILTER_SCENE_MODE, "filter-scene-mode", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -294,7 +293,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_FILTER_BRIGHTNESS, "filter-brightness", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)1}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -305,7 +304,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_FILTER_CONTRAST, "filter-contrast", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -316,7 +315,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_FILTER_WB, "filter-wb", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -327,7 +326,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_FILTER_COLOR_TONE, "filter-color-tone", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -338,7 +337,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_FILTER_SATURATION, "filter-saturation", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -349,7 +348,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_FILTER_HUE, "filter-hue", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -357,11 +356,11 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {.int_max = -1}, _mmcamcorder_commit_filter, }, - //20 + /* 20 */ { MM_CAM_FILTER_SHARPNESS, "filter-sharpness", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -372,29 +371,29 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_FORMAT, "camera-format", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_PIXEL_FORMAT_YUYV}, 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_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, }, { MM_CAM_CAMERA_FPS, "camera-fps", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)30}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -405,7 +404,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_WIDTH, "camera-width", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MMCAMCORDER_DEFAULT_CAMERA_WIDTH}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -416,7 +415,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_HEIGHT, "camera-height", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MMCAMCORDER_DEFAULT_CAMERA_HEIGHT}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -427,7 +426,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_DIGITAL_ZOOM, "camera-digital-zoom", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)10}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -438,7 +437,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_OPTICAL_ZOOM, "camera-optical-zoom", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -449,7 +448,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_FOCUS_MODE, "camera-focus-mode", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_CAMCORDER_FOCUS_MODE_NONE}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -460,7 +459,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_AF_SCAN_RANGE, "camera-af-scan-range", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -468,11 +467,11 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {0}, _mmcamcorder_commit_camera_af_scan_range, }, - //30 + /* 30 */ { MM_CAM_CAMERA_EXPOSURE_MODE, "camera-exposure-mode", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -483,7 +482,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_EXPOSURE_VALUE, "camera-exposure-value", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -494,7 +493,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_F_NUMBER, "camera-f-number", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -505,7 +504,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_SHUTTER_SPEED, "camera-shutter-speed", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -516,7 +515,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_ISO, "camera-iso", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -527,7 +526,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_WDR, "camera-wdr", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -538,7 +537,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_ANTI_HANDSHAKE, "camera-anti-handshake", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -549,18 +548,18 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_FPS_AUTO, "camera-fps-auto", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)FALSE}, MM_ATTRS_VALID_TYPE_INT_RANGE, {.int_min = 0}, {.int_max = 1}, - NULL, + _mmcamcorder_commit_camera_fps, }, { MM_CAM_CAMERA_DELAY_ATTR_SETTING, "camera-delay-attr-setting", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)FALSE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -571,30 +570,30 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_AUDIO_ENCODER_BITRATE, "audio-encoder-bitrate", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, 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", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, {.int_min = 0}, {.int_max = _MMCAMCORDER_MAX_INT}, - NULL, + _mmcamcorder_commit_encoder_bitrate, }, { MM_CAM_IMAGE_ENCODER_QUALITY, "image-encoder-quality", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)95}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -605,7 +604,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAPTURE_FORMAT, "capture-format", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_PIXEL_FORMAT_ENCODED}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -616,7 +615,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAPTURE_WIDTH, "capture-width", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)1600}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -627,7 +626,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAPTURE_HEIGHT, "capture-height", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)1200}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -638,7 +637,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAPTURE_COUNT, "capture-count", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)1}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -649,7 +648,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAPTURE_INTERVAL, "capture-interval", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -660,7 +659,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAPTURE_BREAK_CONTINUOUS_SHOT, "capture-break-cont-shot", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)FALSE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -671,9 +670,9 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_HANDLE, "display-handle", - MMF_VALUE_TYPE_DATA, + MM_ATTRS_TYPE_DATA, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -682,7 +681,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_DEVICE, "display-device", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_DISPLAY_DEVICE_MAINLCD}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -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_TYPE_INT, MM_ATTRS_FLAG_RW, - {(void*)MM_DISPLAY_SURFACE_X}, + {(void*)MM_DISPLAY_SURFACE_OVERLAY}, MM_ATTRS_VALID_TYPE_INT_ARRAY, {0}, {0}, @@ -705,7 +704,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_RECT_X, "display-rect-x", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -716,7 +715,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_RECT_Y, "display-rect-y", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -727,29 +726,29 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_RECT_WIDTH, "display-rect-width", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, 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, }, { MM_CAM_DISPLAY_RECT_HEIGHT, "display-rect-height", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, 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, }, { MM_CAM_DISPLAY_SOURCE_X, "display-src-x", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -760,7 +759,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_SOURCE_Y, "display-src-y", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -771,7 +770,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_SOURCE_WIDTH, "display-src-width", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -782,7 +781,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_SOURCE_HEIGHT, "display-src-height", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -793,7 +792,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_ROTATION, "display-rotation", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_DISPLAY_ROTATION_NONE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -801,10 +800,11 @@ _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, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)1}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -815,7 +815,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_SCALE, "display-scale", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -826,7 +826,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_GEOMETRY_METHOD, "display-geometry-method", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -837,9 +837,9 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_TARGET_FILENAME, "target-filename", - MMF_VALUE_TYPE_STRING, + MM_ATTRS_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -848,107 +848,107 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_TARGET_MAX_SIZE, "target-max-size", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, 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, "target-time-limit", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, {.int_min = 0}, {.int_max = _MMCAMCORDER_MAX_INT}, - NULL, + _mmcamcorder_commit_recording_max_limit, }, { MM_CAM_TAG_ENABLE, "tag-enable", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, 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_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, - NULL, + _mmcamcorder_commit_tag, }, { MM_CAM_TAG_ORIENTATION, "tag-orientation", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)1}, 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_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_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_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_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, "strobe-control", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -959,7 +959,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_STROBE_CAPABILITIES, "strobe-capabilities", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -970,7 +970,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_STROBE_MODE, "strobe-mode", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -981,7 +981,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DETECT_MODE, "detect-mode", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -992,7 +992,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DETECT_NUMBER, "detect-number", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1003,7 +1003,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DETECT_FOCUS_SELECT, "detect-focus-select", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1014,7 +1014,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DETECT_SELECT_NUMBER, "detect-select-number", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1022,11 +1022,11 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {.int_max = -1}, _mmcamcorder_commit_detect, }, - //80 + /* 80 */ { MM_CAM_DETECT_STATUS, "detect-status", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -1037,7 +1037,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAPTURE_ZERO_SYSTEMLAG, "capture-zero-systemlag", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)FALSE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1048,7 +1048,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_AF_TOUCH_X, "camera-af-touch-x", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1059,7 +1059,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_AF_TOUCH_Y, "camera-af-touch-y", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1070,7 +1070,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_AF_TOUCH_WIDTH, "camera-af-touch-width", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1081,7 +1081,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_AF_TOUCH_HEIGHT, "camera-af-touch-height", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1092,9 +1092,9 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_FOCAL_LENGTH, "camera-focal-length", - MMF_VALUE_TYPE_DOUBLE, + MM_ATTRS_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}, @@ -1103,7 +1103,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, "recommend-preview-format-for-capture", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_PIXEL_FORMAT_YUYV}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1114,7 +1114,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, "recommend-preview-format-for-recording", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_PIXEL_FORMAT_NV12}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1125,52 +1125,52 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_TAG_GPS_ENABLE, "tag-gps-enable", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)FALSE}, 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_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_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_TYPE_STRING, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, - NULL, + _mmcamcorder_commit_tag, }, { MM_CAM_CAMERA_ROTATION, "camera-rotation", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_VIDEO_INPUT_ROTATION_NONE}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -1181,9 +1181,9 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAPTURED_SCREENNAIL, "captured-screennail", - MMF_VALUE_TYPE_DATA, - MM_ATTRS_FLAG_READABLE, - {(void*)NULL}, + MM_ATTRS_TYPE_DATA, + MM_ATTRS_FLAG_RW, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -1192,7 +1192,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAPTURE_SOUND_ENABLE, "capture-sound-enable", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)TRUE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1203,7 +1203,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_RECOMMEND_DISPLAY_ROTATION, "recommend-display-rotation", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_DISPLAY_ROTATION_270}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1214,7 +1214,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_FLIP, "camera-flip", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_FLIP_NONE}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -1225,7 +1225,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_HDR_CAPTURE, "camera-hdr-capture", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)FALSE}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -1236,7 +1236,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_MODE, "display-mode", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_DISPLAY_MODE_DEFAULT}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -1244,11 +1244,11 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {0}, _mmcamcorder_commit_display_mode, }, - //100 + /* 100 */ { MM_CAM_AUDIO_DISABLE, "audio-disable", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)FALSE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1259,7 +1259,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_RECOMMEND_CAMERA_WIDTH, "recommend-camera-width", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MMCAMCORDER_DEFAULT_CAMERA_WIDTH}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -1270,7 +1270,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_RECOMMEND_CAMERA_HEIGHT, "recommend-camera-height", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MMCAMCORDER_DEFAULT_CAMERA_HEIGHT}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -1281,9 +1281,9 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAPTURED_EXIF_RAW_DATA, "captured-exif-raw-data", - MMF_VALUE_TYPE_DATA, - MM_ATTRS_FLAG_READABLE, - {(void*)NULL}, + MM_ATTRS_TYPE_DATA, + MM_ATTRS_FLAG_RW, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -1292,9 +1292,9 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_EVAS_SURFACE_SINK, "display-evas-surface-sink", - MMF_VALUE_TYPE_STRING, - MM_ATTRS_FLAG_READABLE, - {(void*)NULL}, + MM_ATTRS_TYPE_STRING, + MM_ATTRS_FLAG_RW, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -1303,7 +1303,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_EVAS_DO_SCALING, "display-evas-do-scaling", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)TRUE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1314,7 +1314,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_FACING_DIRECTION, "camera-facing-direction", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1325,7 +1325,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_DISPLAY_FLIP, "display-flip", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_FLIP_NONE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1336,7 +1336,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_CAMERA_VIDEO_STABILIZATION, "camera-video-stabilization", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_CAMCORDER_VIDEO_STABILIZATION_OFF}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -1347,7 +1347,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_TAG_VIDEO_ORIENTATION, "tag-video-orientation", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)MM_CAMCORDER_TAG_VIDEO_ORT_NONE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1355,11 +1355,66 @@ _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", + MM_ATTRS_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", + MM_ATTRS_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", + MM_ATTRS_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", + MM_ATTRS_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", + MM_ATTRS_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", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -1370,7 +1425,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_VIDEO_HEIGHT, "video-height", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)0}, MM_ATTRS_VALID_TYPE_INT_ARRAY, @@ -1381,7 +1436,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_SUPPORT_ZSL_CAPTURE, "support-zsl-capture", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)FALSE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1392,7 +1447,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_SUPPORT_ZERO_COPY_FORMAT, "support-zero-copy-format", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)FALSE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1403,7 +1458,7 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) { MM_CAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB, "support-media-packet-preview-cb", - MMF_VALUE_TYPE_INT, + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)FALSE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1411,10 +1466,154 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) {.int_max = TRUE}, NULL, }, + /* 120 */ + { + MM_CAM_ENCODED_PREVIEW_BITRATE, + "encoded-preview-bitrate", + MM_ATTRS_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", + MM_ATTRS_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_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", + MM_ATTRS_TYPE_STRING, + MM_ATTRS_FLAG_RW, + {NULL}, + MM_ATTRS_VALID_TYPE_NONE, + {0}, + {0}, + NULL, + }, + { + MM_CAM_CLIENT_PID, + "client-pid", + MM_ATTRS_TYPE_INT, + MM_ATTRS_FLAG_RW, + {(void*)0}, + MM_ATTRS_VALID_TYPE_INT_RANGE, + {.int_min = 0}, + {.int_max = _MMCAMCORDER_MAX_INT}, + NULL, + }, + { + MM_CAM_ROOT_DIRECTORY, + "root-directory", + MM_ATTRS_TYPE_STRING, + MM_ATTRS_FLAG_RW, + {NULL}, + MM_ATTRS_VALID_TYPE_NONE, + {0}, + {0}, + NULL, + }, + { + MM_CAM_SOUND_STREAM_INDEX, + "sound-stream-index", + MM_ATTRS_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", + MM_ATTRS_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", + MM_ATTRS_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", + MM_ATTRS_TYPE_DATA, + MM_ATTRS_FLAG_RW, + {NULL}, + MM_ATTRS_VALID_TYPE_NONE, + {0}, + {0}, + NULL, + }, + { + MM_CAM_GDBUS_CONNECTION, + "gdbus-connection", + MM_ATTRS_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", + MM_ATTRS_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", + MM_ATTRS_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, + }, + { + MM_CAM_SUPPORT_USER_BUFFER, + "support-user-buffer", + MM_ATTRS_TYPE_INT, MM_ATTRS_FLAG_RW, {(void*)FALSE}, MM_ATTRS_VALID_TYPE_INT_RANGE, @@ -1423,11 +1622,11 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) NULL, }, { - MM_CAM_DISPLAY_SHM_SOCKET_PATH, - "display-shm-socket-path", - MMF_VALUE_TYPE_STRING, + MM_CAM_USER_BUFFER_FD, + "user-buffer-fd", + MM_ATTRS_TYPE_DATA, MM_ATTRS_FLAG_RW, - {(void*)NULL}, + {NULL}, MM_ATTRS_VALID_TYPE_NONE, {0}, {0}, @@ -1457,16 +1656,17 @@ _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info ) /* Camcorder Attributes */ _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); + ret = mm_attrs_new(attrs_const_info, + attr_count, + "Camcorder_Attributes", + _mmcamcorder_commit_camcorder_attrs, + (void *)handle, + &attrs); free(attrs_const_info); attrs_const_info = NULL; - if (attrs == 0) { + if (ret != MM_ERROR_NONE) { _mmcam_dbg_err("Fail to alloc attribute handle"); free(hcamcorder->cam_attrs_const_info); hcamcorder->cam_attrs_const_info = NULL; @@ -1475,50 +1675,52 @@ _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); +*/ + mm_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) { + mm_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: + mm_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) { + mm_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: + mm_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); 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; } } @@ -1542,7 +1744,7 @@ _mmcamcorder_dealloc_attribute(MMHandleType handle, MMHandleType attrs) _mmcam_dbg_log(""); if (attrs) { - mmf_attrs_free(attrs); + mm_attrs_free(attrs); _mmcam_dbg_log("released attribute"); } @@ -1551,6 +1753,8 @@ _mmcamcorder_dealloc_attribute(MMHandleType handle, MMHandleType attrs) hcamcorder->cam_attrs_const_info = NULL; _mmcam_dbg_log("released attribute info"); } + + return; } @@ -1560,11 +1764,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); @@ -1577,34 +1781,51 @@ _mmcamcorder_set_attributes(MMHandleType handle, char **err_attr_name, const cha { MMHandleType attrs = 0; int ret = MM_ERROR_NONE; + int err_index = 0; + char *tmp_err_attr_name = NULL; 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); 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, &tmp_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, &tmp_err_attr_name, attribute_name, var_args_copy); } + va_end(var_args_copy); + _MMCAMCORDER_UNLOCK_CMD(handle); if (ret != MM_ERROR_NONE) { + if (ret == MM_ERROR_COMMON_OUT_OF_RANGE) { + if (mm_attrs_get_index(attrs, tmp_err_attr_name, &err_index) == MM_ERROR_NONE && + _mmcamcorder_check_supported_attribute(handle, err_index)) { + _mmcam_dbg_err("[%s] is supported, but value is invalid", + tmp_err_attr_name ? tmp_err_attr_name : "NULL"); + ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT; + } + } + if (hcamcorder->error_code != MM_ERROR_NONE) { - _mmcam_dbg_err("error_code is not NONE. origin 0x%x, modified 0x%x", ret, hcamcorder->error_code); + _mmcam_dbg_err("error_code is set. ret 0x%x -> modified 0x%x", ret, hcamcorder->error_code); ret = hcamcorder->error_code; hcamcorder->error_code = MM_ERROR_NONE; } @@ -1612,6 +1833,16 @@ _mmcamcorder_set_attributes(MMHandleType handle, char **err_attr_name, const cha _mmcam_dbg_err("failed error code 0x%x - handle %p", ret, (mmf_camcorder_t *)handle); } + if (tmp_err_attr_name) { + if (!err_attr_name) { + _mmcam_dbg_err("set attribute[%s] error, but err name is NULL", tmp_err_attr_name); + free(tmp_err_attr_name); + tmp_err_attr_name = NULL; + } else { + *err_attr_name = tmp_err_attr_name; + } + } + return ret; } @@ -1623,48 +1854,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; } } @@ -1674,7 +1903,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 MMAttrsValue *value, void *commit_param) { bool bret = FALSE; mmf_camcorder_t *hcamcorder = NULL; @@ -1686,11 +1915,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; } @@ -1783,11 +2011,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 MMAttrsValue *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); @@ -1818,7 +2048,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 MMAttrsValue *value) { int current_state = MM_CAMCORDER_STATE_NONE; @@ -1839,29 +2069,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 MMAttrsValue *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; @@ -1875,27 +2120,26 @@ 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; } -bool _mmcamcorder_commit_capture_count(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_capture_count(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { 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) { @@ -1907,11 +2151,11 @@ bool _mmcamcorder_commit_capture_count(MMHandleType handle, int attr_idx, const } -bool _mmcamcorder_commit_capture_sound_enable(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_capture_sound_enable(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { 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); @@ -1927,20 +2171,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 MMAttrsValue *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; @@ -1965,22 +2210,54 @@ bool _mmcamcorder_commit_audio_volume (MMHandleType handle, int attr_idx, const } -bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_format(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + int current_state = MM_CAMCORDER_STATE_NONE; + + mmf_return_val_if_fail(hcamcorder && value, FALSE); + + current_state = _mmcamcorder_get_state(handle); + if (current_state > MM_CAMCORDER_STATE_READY) { + _mmcam_dbg_err("invalid state %d", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; + } + + return TRUE; +} + + +bool _mmcamcorder_commit_camera_fps(MMHandleType handle, int attr_idx, const MMAttrsValue *value) +{ + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); MMCamAttrsInfo fps_info; int resolution_width = 0; int resolution_height = 0; - int i; - int ret; + int i = 0; + int ret = 0; + int current_state = MM_CAMCORDER_STATE_NONE; + + mmf_return_val_if_fail(hcamcorder && value, FALSE); + + current_state = _mmcamcorder_get_state(handle); + if (current_state > MM_CAMCORDER_STATE_PREPARE) { + _mmcam_dbg_err("invalid state %d", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; + } + + if (attr_idx == MM_CAM_CAMERA_FPS_AUTO) + return TRUE; _mmcam_dbg_log("FPS(%d)", value->value.i_val); ret = mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_WIDTH, &resolution_width, - MMCAM_CAMERA_HEIGHT, &resolution_height, - NULL); + MMCAM_CAMERA_WIDTH, &resolution_width, + MMCAM_CAMERA_HEIGHT, &resolution_height, + NULL); - if(ret != MM_ERROR_NONE) { + if (ret != MM_ERROR_NONE) { _mmcam_dbg_err("FAILED : coult not get resolution values."); return FALSE; } @@ -1992,43 +2269,42 @@ bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mm } for (i = 0 ; i < fps_info.int_array.count ; i++) { - if(value->value.i_val == fps_info.int_array.array[i]) { + if (value->value.i_val == fps_info.int_array.array[i]) return TRUE; - } } _mmcam_dbg_err("FAILED : %d is not supported FPS", value->value.i_val); + return FALSE; } -bool _mmcamcorder_commit_camera_recording_motion_rate(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_recording_motion_rate(MMHandleType handle, int attr_idx, const MMAttrsValue *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; @@ -2039,7 +2315,7 @@ bool _mmcamcorder_commit_camera_recording_motion_rate(MMHandleType handle, int a } -bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { MMHandleType attr = 0; int current_state = MM_CAMCORDER_STATE_NONE; @@ -2047,12 +2323,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); @@ -2077,10 +2352,10 @@ bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const m int codec_type = MM_IMAGE_CODEC_JPEG; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_HEIGHT, &height, - MMCAM_CAMERA_FORMAT, &preview_format, - MMCAM_IMAGE_ENCODER, &codec_type, - NULL); + MMCAM_CAMERA_HEIGHT, &height, + MMCAM_CAMERA_FORMAT, &preview_format, + MMCAM_IMAGE_ENCODER, &codec_type, + NULL); if (current_state == MM_CAMCORDER_STATE_PREPARE) { if (hcamcorder->resolution_changed == FALSE) { @@ -2090,7 +2365,7 @@ bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const m hcamcorder->resolution_changed = FALSE; - if (!pthread_mutex_trylock(&(hcamcorder->restart_preview_lock))) { + 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); @@ -2098,6 +2373,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); @@ -2109,7 +2391,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; @@ -2129,7 +2411,7 @@ bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const m } -bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { int ret = 0; int current_state = MM_CAMCORDER_STATE_NONE; @@ -2137,12 +2419,11 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - mmf_return_val_if_fail(hcamcorder, FALSE); + mmf_return_val_if_fail(hcamcorder && value, FALSE); sc = MMF_CAMCORDER_SUBCONTEXT(handle); - if (!sc) { + if (!sc) return TRUE; - } attr = MMF_CAMCORDER_ATTRS(hcamcorder); mmf_return_val_if_fail(attr, FALSE); @@ -2152,6 +2433,7 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const if (current_state > MM_CAMCORDER_STATE_PREPARE) { _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; return FALSE; } else { int width = 0; @@ -2161,11 +2443,11 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const int video_stabilization = 0; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_WIDTH, &width, - MMCAM_CAMERA_FORMAT, &preview_format, - MMCAM_IMAGE_ENCODER, &codec_type, - MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization, - NULL); + MMCAM_CAMERA_WIDTH, &width, + MMCAM_CAMERA_FORMAT, &preview_format, + MMCAM_IMAGE_ENCODER, &codec_type, + MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization, + NULL); sc->info_video->preview_width = width; sc->info_video->preview_height = height; @@ -2178,7 +2460,7 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const hcamcorder->resolution_changed = FALSE; - if (!pthread_mutex_trylock(&(hcamcorder->restart_preview_lock))) { + if (g_mutex_trylock(&hcamcorder->restart_preview_lock)) { _mmcam_dbg_log("restart preview"); _mmcam_dbg_log("set empty buffers"); @@ -2188,6 +2470,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); @@ -2200,7 +2489,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; @@ -2217,37 +2506,42 @@ bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const } -bool _mmcamcorder_commit_video_size(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_video_size(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { 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 MMAttrsValue *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); @@ -2256,15 +2550,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; @@ -2274,7 +2568,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; @@ -2295,10 +2589,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 MMAttrsValue *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_type")) { + if (gst_camera_control_set_value(CameraControl, CameraControlChannel, value->value.i_val)) { + _mmcam_dbg_warn("set ptz type %d done", value->value.i_val); + return TRUE; + } else { + _mmcam_dbg_err("failed to set ptz type %d", value->value.i_val); + return FALSE; + } + } + } + + _mmcam_dbg_warn("failed to find ptz type control channel"); + } + + return FALSE; +} + + +bool _mmcamcorder_commit_camera_pan(MMHandleType handle, int attr_idx, const MMAttrsValue *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 MMAttrsValue *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 MMAttrsValue *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; @@ -2306,6 +2796,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); @@ -2325,6 +2817,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) { @@ -2336,14 +2832,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; @@ -2373,8 +2869,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 MMAttrsValue *value) { + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; GstCameraControl *control = NULL; int current_state = MM_CAMCORDER_STATE_NONE; @@ -2385,6 +2882,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; @@ -2404,6 +2903,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) { @@ -2412,25 +2915,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 { @@ -2444,8 +2947,9 @@ bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx } -bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_af_touch_area(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; GstCameraControl *control = NULL; GstCameraControlRectType set_area = { 0, 0, 0, 0 }; @@ -2461,10 +2965,11 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx MMCamAttrsInfo info_w; MMCamAttrsInfo info_h; + mmf_return_val_if_fail(hcamcorder && value, FALSE); + sc = MMF_CAMCORDER_SUBCONTEXT(handle); - if (!sc) { + if (!sc) return TRUE; - } _mmcam_dbg_log("(%d)", attr_idx); @@ -2472,11 +2977,15 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx if (current_state < MM_CAMCORDER_STATE_PREPARE) { _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state); return TRUE; + } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) { + _mmcam_dbg_err("Can not set while CAPTURING"); + hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE; + return FALSE; } ret = mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_FOCUS_MODE, &focus_mode, - NULL); + MMCAM_CAMERA_FOCUS_MODE, &focus_mode, + NULL); if (ret != MM_ERROR_NONE) { _mmcam_dbg_warn("Failed to get FOCUS MODE.[%x]", ret); return FALSE; @@ -2505,10 +3014,10 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx if (!((info_y.flag|info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED)) { set_area.x = value->value.i_val; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y, - MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width, - MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height, - NULL); + MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y, + MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width, + MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height, + NULL); do_set = TRUE; } else { _mmcam_dbg_log("Just store AF area[x:%d]", value->value.i_val); @@ -2521,13 +3030,13 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx if (!((info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED)) { set_area.y = value->value.i_val; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_AF_TOUCH_X, &set_area.x, - MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width, - MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height, - NULL); + MMCAM_CAMERA_AF_TOUCH_X, &set_area.x, + MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width, + MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height, + NULL); do_set = TRUE; } else { - _mmcam_dbg_log( "Just store AF area[y:%d]", value->value.i_val ); + _mmcam_dbg_log("Just store AF area[y:%d]", value->value.i_val); return TRUE; } break; @@ -2536,10 +3045,10 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx if (!(info_h.flag & MM_ATTRS_FLAG_MODIFIED)) { set_area.width = value->value.i_val; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_AF_TOUCH_X, &set_area.x, - MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y, - MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height, - NULL); + MMCAM_CAMERA_AF_TOUCH_X, &set_area.x, + MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y, + MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height, + NULL); do_set = TRUE; } else { _mmcam_dbg_log("Just store AF area[width:%d]", value->value.i_val); @@ -2549,10 +3058,10 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx case MM_CAM_CAMERA_AF_TOUCH_HEIGHT: set_area.height = value->value.i_val; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_AF_TOUCH_X, &set_area.x, - MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y, - MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width, - NULL); + MMCAM_CAMERA_AF_TOUCH_X, &set_area.x, + MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y, + MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width, + NULL); do_set = TRUE; break; default: @@ -2567,7 +3076,7 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx return FALSE; } - control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); if (control == NULL) { _mmcam_dbg_err("cast CAMERA_CONTROL failed"); return FALSE; @@ -2584,49 +3093,48 @@ bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx ratio_height = (float)info->video_height / (float)info->preview_height; _mmcam_dbg_log("original area %d,%d,%dx%d, resolution ratio : width %f, height %f", - set_area.x, set_area.y, set_area.width, set_area.height, ratio_width, ratio_height); + set_area.x, set_area.y, set_area.width, set_area.height, ratio_width, ratio_height); set_area.x = (int)((float)set_area.x * ratio_width); set_area.y = (int)((float)set_area.y * ratio_height); set_area.width = (int)((float)set_area.width * ratio_width); set_area.height = (int)((float)set_area.height * ratio_height); - if (set_area.width <= 0) { + if (set_area.width <= 0) set_area.width = 1; - } - if (set_area.height <= 0) { + + if (set_area.height <= 0) set_area.height = 1; - } _mmcam_dbg_log("converted area %d,%d,%dx%d", - set_area.x, set_area.y, set_area.width, set_area.height); + set_area.x, set_area.y, set_area.width, set_area.height); } else { _mmcam_dbg_warn("invalid preview size %dx%d, skip AF area converting", - info->preview_width, info->preview_height); + info->preview_width, info->preview_height); } } ret = gst_camera_control_get_auto_focus_area(control, &get_area); if (!ret) { - _mmcam_dbg_warn( "Failed to get AF area" ); + _mmcam_dbg_warn("Failed to get AF area"); return FALSE; } /* width and height are not supported now */ if (get_area.x == set_area.x && get_area.y == set_area.y) { _mmcam_dbg_log("No need to set AF area[x,y:%d,%d]", - get_area.x, get_area.y); + get_area.x, get_area.y); return TRUE; } ret = gst_camera_control_set_auto_focus_area(control, set_area); if (ret) { _mmcam_dbg_log("Succeed to set AF area[%d,%d,%dx%d]", - set_area.x, set_area.y, set_area.width, set_area.height); + set_area.x, set_area.y, set_area.width, set_area.height); return TRUE; } else { _mmcam_dbg_warn("Failed to set AF area[%d,%d,%dx%d]", - set_area.x, set_area.y, set_area.width, set_area.height); + set_area.x, set_area.y, set_area.width, set_area.height); } } } else { @@ -2637,19 +3145,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 MMAttrsValue *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; @@ -2660,19 +3173,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; @@ -2685,8 +3205,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) { @@ -2705,7 +3225,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; @@ -2713,10 +3233,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"); @@ -2726,16 +3246,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 MMAttrsValue *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)) { @@ -2744,17 +3265,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; } @@ -2776,17 +3297,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"); @@ -2796,9 +3317,12 @@ 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) +bool _mmcamcorder_commit_camera_anti_handshake(MMHandleType handle, int attr_idx, const MMAttrsValue *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)) { @@ -2812,6 +3336,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; } @@ -2819,9 +3344,51 @@ bool _mmcamcorder_commit_camera_anti_handshake(MMHandleType handle, int attr_idx } -bool _mmcamcorder_commit_camera_video_stabilization(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_encoder_bitrate(MMHandleType handle, int attr_idx, const MMAttrsValue *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 MMAttrsValue *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) { @@ -2829,6 +3396,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; } @@ -2836,9 +3404,12 @@ 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) +bool _mmcamcorder_commit_camera_rotate(MMHandleType handle, int attr_idx, const MMAttrsValue *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); @@ -2846,6 +3417,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); @@ -2853,14 +3425,14 @@ bool _mmcamcorder_commit_camera_rotate(MMHandleType handle, int attr_idx, const } -bool _mmcamcorder_commit_image_encoder_quality(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_image_encoder_quality(MMHandleType handle, int attr_idx, const MMAttrsValue *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); /* check type */ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) { @@ -2873,6 +3445,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); @@ -2889,51 +3465,41 @@ 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) +bool _mmcamcorder_commit_target_filename(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { - _MMCamcorderSubContext *sc = NULL; - const char * filename = NULL; - int size = 0; - - 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); - if (filename == NULL) { + if (!value->value.s_val) { _mmcam_dbg_err("NULL filename"); 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_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", filename); - _mmcam_dbg_log("new file location set.(%s)", filename); - } else { - _mmcam_dbg_log("element is not created yet. [%s] will be set later...", filename); - } + _mmcam_dbg_log("set filename [%s]", value->value.s_val); return TRUE; } +bool _mmcamcorder_commit_recording_max_limit(MMHandleType handle, int attr_idx, const MMAttrsValue *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 MMAttrsValue *value) { GstColorBalance *balance = NULL; GstColorBalanceChannel *Colorchannel = NULL; @@ -2949,10 +3515,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) @@ -2969,7 +3532,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; } @@ -3026,9 +3590,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);*/ @@ -3051,10 +3614,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; } @@ -3069,18 +3632,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 MMAttrsValue *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); @@ -3091,6 +3660,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) { @@ -3114,26 +3687,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); + MMHandleType attrs = MMF_CAMCORDER_ATTRS(handle); 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 (_mmcamcorder_check_supported_attribute(handle, attr_idxs[i])) + mm_attrs_set_modified(attrs, 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"); @@ -3143,28 +3715,37 @@ 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 MMAttrsValue *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 MMAttrsValue *value) { + mmf_return_val_if_fail(handle && value, FALSE); + _mmcam_dbg_log("Commit : Do nothing. this attr will be removed soon."); return TRUE; } -bool _mmcamcorder_commit_audio_disable(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_audio_disable(MMHandleType handle, int attr_idx, const MMAttrsValue *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"); @@ -3173,7 +3754,7 @@ bool _mmcamcorder_commit_audio_disable(MMHandleType handle, int attr_idx, const } -bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { int current_state = MM_CAMCORDER_STATE_NONE; const char *videosink_name = NULL; @@ -3182,7 +3763,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) { @@ -3210,33 +3791,15 @@ bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name); - if (!strcmp(videosink_name, "xvimagesink") || - !strcmp(videosink_name, "ximagesink")) { - _mmcam_dbg_log("Commit : Set XID[%x]", *(int*)(p_handle)); - gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), *(int*)(p_handle)); - } else if (!strcmp(videosink_name, "evasimagesink") || - !strcmp(videosink_name, "evaspixmapsink")) { + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "ximagesink")) { + _mmcam_dbg_log("Commit : Set XID[%x]", *(int *)(p_handle)); + gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), *(int *)(p_handle)); + } else if (!strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "evaspixmapsink")) { _mmcam_dbg_log("Commit : Set evas object [%p]", p_handle); MMCAMCORDER_G_OBJECT_SET_POINTER(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "evas-object", p_handle); -#ifdef HAVE_WAYLAND - } else if (!strcmp(videosink_name, "waylandsink")) { - MMCamWaylandInfo *wl_info = (MMCamWaylandInfo *)p_handle; - GstContext *context = NULL; - - context = gst_wayland_display_handle_context_new((struct wl_display *)wl_info->display); - if (context) { - gst_element_set_context(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 */ + } 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; @@ -3250,7 +3813,7 @@ bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const } -bool _mmcamcorder_commit_display_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_display_mode(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { int current_state = MM_CAMCORDER_STATE_NONE; const char *videosink_name = NULL; @@ -3258,7 +3821,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) { @@ -3283,24 +3846,24 @@ bool _mmcamcorder_commit_display_mode(MMHandleType handle, int attr_idx, const m _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name); - if (!strcmp(videosink_name, "xvimagesink")) { + 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; } -bool _mmcamcorder_commit_display_rotation(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_display_rotation(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { int current_state = MM_CAMCORDER_STATE_NONE; 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) { @@ -3315,17 +3878,17 @@ 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); } -bool _mmcamcorder_commit_display_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_display_flip(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { int current_state = MM_CAMCORDER_STATE_NONE; 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) { @@ -3340,11 +3903,11 @@ 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); } -bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { int current_state = MM_CAMCORDER_STATE_NONE; const char *videosink_name = NULL; @@ -3352,7 +3915,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) { @@ -3376,19 +3939,19 @@ bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, cons return FALSE; } - if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "evasimagesink") || - !strcmp(videosink_name, "evaspixmapsink")) { + 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 MMAttrsValue *value) { int method = 0; int current_state = MM_CAMCORDER_STATE_NONE; @@ -3397,7 +3960,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) { @@ -3421,28 +3984,29 @@ bool _mmcamcorder_commit_display_geometry_method (MMHandleType handle, int attr_ return FALSE; } - if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "evasimagesink") || - !strcmp(videosink_name, "evaspixmapsink")) { + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") || + !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink") || + !strcmp(videosink_name, "directvideosink")) { method = value->value.i_val; - MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-geometry-method", method); - 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; } -bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { 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) { @@ -3459,15 +4023,6 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m sc = MMF_CAMCORDER_SUBCONTEXT(handle); - /* check current method */ - mm_camcorder_get_attributes(handle, 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; - } - /* Get videosink name */ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name); if (videosink_name == NULL) { @@ -3475,8 +4030,8 @@ bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const m return FALSE; } - if (!strcmp(videosink_name, "xvimagesink") || - !strcmp(videosink_name, "evaspixmapsink")) { + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") || + !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "directvideosink")) { int rect_x = 0; int rect_y = 0; int rect_width = 0; @@ -3485,11 +4040,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); @@ -3527,25 +4082,33 @@ 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); - return TRUE; + if (!strcmp(videosink_name, "tizenwlsink")) { + ret = gst_video_overlay_set_display_roi_area(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), + rect_x, rect_y, rect_width, rect_height); + if (!ret) { + _mmcam_dbg_err("FAILED : could not set display roi area."); + 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); + } + } } 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; } -bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { int zoom = 0; int current_state = MM_CAMCORDER_STATE_NONE; @@ -3555,7 +4118,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) { @@ -3580,7 +4143,7 @@ bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const } 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)); @@ -3594,16 +4157,16 @@ bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const } -bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { int current_state = MM_CAMCORDER_STATE_NONE; 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) { @@ -3640,19 +4203,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 MMAttrsValue *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) @@ -3667,7 +4226,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; @@ -3682,14 +4241,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"); } } @@ -3697,16 +4249,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; } @@ -3765,25 +4310,17 @@ 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; } -bool _mmcamcorder_commit_camera_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_flip(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { 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); @@ -3791,6 +4328,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."); @@ -3805,16 +4343,14 @@ bool _mmcamcorder_commit_camera_flip(MMHandleType handle, int attr_idx, const mm } -bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { 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);*/ @@ -3828,6 +4364,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; } @@ -3836,8 +4373,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); @@ -3852,6 +4389,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); } @@ -3861,9 +4404,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; @@ -3874,7 +4416,7 @@ bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, c } -bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const mmf_value_t *value) +bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const MMAttrsValue *value) { bool bret = FALSE; _MMCamcorderSubContext *sc = NULL; @@ -3884,20 +4426,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; @@ -3949,11 +4487,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; } } @@ -3967,110 +4505,269 @@ 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 MMAttrsValue *value) { - mmf_attrs_t *attr = (mmf_attrs_t*)handle; - int flag; + int current_state = MM_CAMCORDER_STATE_NONE; + int preview_format = MM_PIXEL_FORMAT_NV12; - if (mm_attrs_get_flags(handle, idx, &flag) == MM_ERROR_NONE) { - if (flag == MM_ATTRS_FLAG_NONE) { - return FALSE; - } - } else { + 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 MMAttrsValue *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_sound_stream_info(MMHandleType handle, int attr_idx, const MMAttrsValue *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; + } + + 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 MMAttrsValue *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; } - 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) { + return TRUE; +} + +bool _mmcamcorder_commit_audio_replay_gain(MMHandleType handle, int attr_idx, const MMAttrsValue *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; } - } 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) { + + 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 : %lf dB", value->value.d_val); + } else { + _mmcam_dbg_err("unknown attribute id %d", attr_idx); + 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_attrs_t *attr = NULL; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + MMHandleType attrs; 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) { + attrs = MMF_CAMCORDER_ATTRS(handle); + if (attrs == NULL) { _mmcam_dbg_err("Get attribute handle failed."); return FALSE; - } else { - /* Get Scene mode */ - mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL); + } - _mmcam_dbg_log("attribute count(%d)", attr->count); + /* Get Scene mode */ + mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL); - for (i = 0 ; i < ARRAY_SIZE(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]])); - } - } + for (i = 0 ; i < ARRAY_SIZE(attr_idxs_default) ; i++) { + if (_mmcamcorder_check_supported_attribute(handle, attr_idxs_default[i])) + mm_attrs_set_modified(attrs, 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])) { - 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)) { - mmf_attribute_set_modified(&(attr->items[MM_CAM_FILTER_SCENE_MODE])); - } + /* 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_check_supported_attribute(handle, attr_idxs_extra[i])) + mm_attrs_set_modified(attrs, attr_idxs_extra[i]); } + } else { + /* Set scene mode if scene mode is NOT NORMAL */ + if (_mmcamcorder_check_supported_attribute(handle, MM_CAM_FILTER_SCENE_MODE)) + mm_attrs_set_modified(attrs, MM_CAM_FILTER_SCENE_MODE); + } - if (mmf_attrs_commit((MMHandleType)attr) == -1) { - ret = FALSE; - } else { - ret = TRUE; - } + if (mm_attrs_commit_all(attrs) == -1) + ret = FALSE; + else + ret = TRUE; + + _mmcam_dbg_log("Done."); + + return ret; +} + + +bool _mmcamcorder_set_attribute_to_camsensor2(MMHandleType handle) +{ + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + MMHandleType attrs; + unsigned int i = 0; + int ret = TRUE; + int attr_idxs[] = { + MM_CAM_STROBE_MODE, + MM_CAM_CAMERA_PTZ_TYPE, + MM_CAM_CAMERA_PAN_MECHA, + MM_CAM_CAMERA_PAN_ELEC, + MM_CAM_CAMERA_TILT_MECHA, + MM_CAM_CAMERA_TILT_ELEC + }; + + mmf_return_val_if_fail(hcamcorder, FALSE); + + _mmcam_dbg_log("commit some attribute again[2]"); + + attrs = MMF_CAMCORDER_ATTRS(handle); + if (attrs == NULL) { + _mmcam_dbg_err("Get attribute handle failed."); + return FALSE; + } + + for (i = 0 ; i < ARRAY_SIZE(attr_idxs) ; i++) { + if (_mmcamcorder_check_supported_attribute(handle, attr_idxs[i])) + mm_attrs_set_modified(attrs, attr_idxs[i]); } + if (mm_attrs_commit_all(attrs) == -1) + ret = FALSE; + else + ret = TRUE; + _mmcam_dbg_log("Done."); return ret; @@ -4079,26 +4776,25 @@ _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); + MMHandleType attrs; 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); - attr = (mmf_attrs_t*) MMF_CAMCORDER_ATTRS(handle); - mmf_return_val_if_fail(attr, MM_ERROR_CAMCORDER_NOT_INITIALIZED); + attrs = MMF_CAMCORDER_ATTRS(handle); + mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED); _mmcam_dbg_log(""); 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])); + mm_attrs_set_readonly(attrs, sCategory); } return nerror; @@ -4107,37 +4803,36 @@ 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); + MMHandleType attrs; int i = 0; - mmf_attrs_t *attr = NULL; type_string_array * disabled_attr = NULL; int cnt_str = 0; int nerror = MM_ERROR_NONE ; mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); - attr = (mmf_attrs_t*) MMF_CAMCORDER_ATTRS(handle); - mmf_return_val_if_fail(attr, MM_ERROR_CAMCORDER_NOT_INITIALIZED); + attrs = MMF_CAMCORDER_ATTRS(handle); + mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED); _mmcam_dbg_log(""); /* 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] ); - nerror = mm_attrs_get_index((MMHandleType)attr, disabled_attr->value[i], &idx); - 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); - } + _mmcam_dbg_log("[%d]%s", i, disabled_attr->value[i]); + nerror = mm_attrs_get_index(attrs, disabled_attr->value[i], &idx); + + if (nerror == MM_ERROR_NONE) + mm_attrs_set_disabled(attrs, idx); + else + _mmcam_dbg_warn("No ATTR named %s[%d]", disabled_attr->value[i], i); } } @@ -4157,9 +4852,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); @@ -4206,15 +4900,14 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n if (hcamcorder == NULL || attribute_name == NULL) { _mmcam_dbg_warn("handle[%p] or attribute_name[%p] is NULL.", - hcamcorder, attribute_name ); + hcamcorder, attribute_name); return MM_ERROR_CAMCORDER_INVALID_ARGUMENT; } - if (err_attr_name) { + if (err_attr_name) *err_attr_name = NULL; - } - //_mmcam_dbg_log( "ENTER" ); + /*_mmcam_dbg_log( "ENTER" );*/ attrs = MMF_CAMCORDER_ATTRS(handle); @@ -4228,21 +4921,18 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n /* attribute name check */ if ((ret = mm_attrs_get_index(attrs, name, &idx)) != MM_ERROR_NONE) { - if (err_attr_name) { + if (err_attr_name) *err_attr_name = strdup(name); - } - if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY) { //to avoid confusing + if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY) return MM_ERROR_COMMON_ATTR_NOT_EXIST; - } else { + else return ret; - } } /* type check */ - if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE) { + if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE) return ret; - } switch (attr_type) { case MM_ATTRS_TYPE_INT: @@ -4257,13 +4947,11 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n break; } } - if (matched) { + if (matched) break; - } } - if (matched == FALSE) { + if (matched == FALSE) va_arg((var_args), int); - } break; } case MM_ATTRS_TYPE_DOUBLE: @@ -4280,9 +4968,9 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n case MM_ATTRS_TYPE_INVALID: default: _mmcam_dbg_err("Not supported attribute type(%d, name:%s)", attr_type, name); - if (err_attr_name) { + if (err_attr_name) *err_attr_name = strdup(name); - } + return MM_ERROR_CAMCORDER_INVALID_ARGUMENT; } @@ -4311,14 +4999,14 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n check_result = FALSE; - for( j = 0 ; j < attr_info_0.int_array.count ; j++ ) { + for (j = 0 ; j < attr_info_0.int_array.count ; j++) { if (attr_info_0.int_array.array[j] == check_pair_value[i][0] && attr_info_1.int_array.array[j] == check_pair_value[i][1]) { /* _mmcam_dbg_log("Valid Pair[%s,%s] existed %dx%d[index:%d]", - check_pair_name[i][0], check_pair_name[i][1], - check_pair_value[i][0], check_pair_value[i][1], i); - */ + check_pair_name[i][0], check_pair_name[i][1], + check_pair_value[i][0], check_pair_value[i][1], i); + */ check_result = TRUE; break; } @@ -4326,8 +5014,8 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n if (check_result == FALSE) { _mmcam_dbg_err("INVALID pair[%s,%s] %dx%d", - check_pair_name[i][0], check_pair_name[i][1], - check_pair_value[i][0], check_pair_value[i][1]); + check_pair_name[i][0], check_pair_name[i][1], + check_pair_value[i][0], check_pair_value[i][1]); if (err_attr_name) { *err_attr_name = err_name; } else { @@ -4345,9 +5033,9 @@ static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_n int current_height = 0; mm_camcorder_get_attributes(handle, NULL, - MMCAM_CAMERA_WIDTH, ¤t_width, - MMCAM_CAMERA_HEIGHT, ¤t_height, - NULL); + MMCAM_CAMERA_WIDTH, ¤t_width, + MMCAM_CAMERA_HEIGHT, ¤t_height, + NULL); if (current_width != check_pair_value[i][0] || current_height != check_pair_value[i][1]) { @@ -4390,33 +5078,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);