4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Jeongmo Yang <jm80.yang@samsung.com>
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
23 /*=======================================================================================
25 =======================================================================================*/
26 #include "mm_camcorder_internal.h"
27 #include "mm_camcorder_gstcommon.h"
29 #include <gst/video/colorbalance.h>
30 #include <gst/video/cameracontrol.h>
31 #include <gst/video/videooverlay.h>
33 /*-----------------------------------------------------------------------
34 | MACRO DEFINITIONS: |
35 -----------------------------------------------------------------------*/
36 #define MMCAMCORDER_DEFAULT_CAMERA_WIDTH 640
37 #define MMCAMCORDER_DEFAULT_CAMERA_HEIGHT 480
39 /*---------------------------------------------------------------------------------------
40 | GLOBAL VARIABLE DEFINITIONS for internal |
41 ---------------------------------------------------------------------------------------*/
43 /*-----------------------------------------------------------------------
44 | LOCAL VARIABLE DEFINITIONS for internal |
45 -----------------------------------------------------------------------*/
46 /* Readonly attributes list.
47 * If you want to make some attributes read only, write down here.
48 * It will make them read only after composing whole attributes.
51 static int readonly_attributes[] = {
52 MM_CAM_CAMERA_DEVICE_COUNT,
53 MM_CAM_CAMERA_DEVICE_NAME,
54 MM_CAM_CAMERA_FACING_DIRECTION,
55 MM_CAM_CAMERA_SHUTTER_SPEED,
56 MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE,
57 MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING,
58 MM_CAM_CAPTURED_SCREENNAIL,
59 MM_CAM_RECOMMEND_DISPLAY_ROTATION,
60 MM_CAM_SUPPORT_ZSL_CAPTURE,
61 MM_CAM_SUPPORT_ZERO_COPY_FORMAT,
62 MM_CAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB
65 /*-----------------------------------------------------------------------
66 | LOCAL FUNCTION PROTOTYPES: |
67 -----------------------------------------------------------------------*/
68 /* STATIC INTERNAL FUNCTION */
69 static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width, int height);
70 static int __mmcamcorder_set_conf_to_valid_info(MMHandleType handle);
71 static int __mmcamcorder_release_conf_valid_info(MMHandleType handle);
72 static bool __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx);
73 static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args);
75 /*=======================================================================
76 | FUNCTION DEFINITIONS |
77 =======================================================================*/
78 /*-----------------------------------------------------------------------
79 | GLOBAL FUNCTION DEFINITIONS: |
80 -----------------------------------------------------------------------*/
82 _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
86 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
87 MMHandleType attrs = 0;
88 mmf_attrs_construct_info_t *attrs_const_info = NULL;
89 unsigned int attr_count = 0;
92 static int depth[] = {MM_CAMCORDER_AUDIO_FORMAT_PCM_U8, MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE};
93 static int flip_list[] = { MM_FLIP_NONE };
94 static int rotation_list[] = { MM_VIDEO_INPUT_ROTATION_NONE };
95 static int visible_values[] = { 0, 1 }; /*0: off, 1:on*/
96 static int tag_orientation_values[] =
98 1, /*The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side.*/
99 2, /*the 0th row is at the visual top of the image, and the 0th column is the visual right-hand side.*/
100 3, /*the 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side.*/
101 4, /*the 0th row is at the visual bottom of the image, and the 0th column is the visual left-hand side.*/
102 5, /*the 0th row is the visual left-hand side of the image, and the 0th column is the visual top.*/
103 6, /*the 0th row is the visual right-hand side of the image, and the 0th column is the visual top.*/
104 7, /*the 0th row is the visual right-hand side of the image, and the 0th column is the visual bottom.*/
105 8, /*the 0th row is the visual left-hand side of the image, and the 0th column is the visual bottom.*/
108 if (hcamcorder == NULL) {
109 _mmcam_dbg_err("handle is NULL");
113 /* Create attribute constructor */
114 _mmcam_dbg_log("start");
116 /* alloc 'mmf_attrs_construct_info_t' */
117 attr_count = MM_CAM_ATTRIBUTE_NUM;
118 attrs_const_info = malloc(attr_count * sizeof(mmf_attrs_construct_info_t));
119 if (!attrs_const_info) {
120 _mmcam_dbg_err("Fail to alloc constructor.");
124 /* alloc default attribute info */
125 hcamcorder->cam_attrs_const_info = (mm_cam_attr_construct_info *)malloc(sizeof(mm_cam_attr_construct_info) * attr_count);
126 if (hcamcorder->cam_attrs_const_info == NULL) {
127 _mmcam_dbg_err("failed to alloc default attribute info");
128 free(attrs_const_info);
129 attrs_const_info = NULL;
133 /* basic attributes' info */
134 mm_cam_attr_construct_info temp_info[] = {
137 MM_CAM_MODE, /* ID */
139 MMF_VALUE_TYPE_INT, /* Type */
140 MM_ATTRS_FLAG_RW, /* Flag */
141 {(void*)MM_CAMCORDER_MODE_VIDEO_CAPTURE}, /* Default value */
142 MM_ATTRS_VALID_TYPE_INT_RANGE, /* Validity type */
143 {.int_min = MM_CAMCORDER_MODE_VIDEO_CAPTURE}, /* Validity val1 (min, *array,...) */
144 {.int_max = MM_CAMCORDER_MODE_AUDIO}, /* Validity val2 (max, count, ...) */
145 NULL, /* Runtime setting function of the attribute */
152 {(void*)MM_AUDIO_DEVICE_MIC},
153 MM_ATTRS_VALID_TYPE_INT_RANGE,
155 {.int_max = (MM_AUDIO_DEVICE_NUM-1)},
159 MM_CAM_CAMERA_DEVICE_COUNT,
160 "camera-device-count",
163 {(void*)MM_VIDEO_DEVICE_NUM},
164 MM_ATTRS_VALID_TYPE_INT_RANGE,
165 {.int_min = MM_VIDEO_DEVICE_NONE},
166 {.int_max = MM_VIDEO_DEVICE_NUM},
170 MM_CAM_AUDIO_ENCODER,
174 {(void*)MM_AUDIO_CODEC_AMR},
175 MM_ATTRS_VALID_TYPE_INT_ARRAY,
181 MM_CAM_VIDEO_ENCODER,
185 {(void*)MM_VIDEO_CODEC_MPEG4},
186 MM_ATTRS_VALID_TYPE_INT_ARRAY,
192 MM_CAM_IMAGE_ENCODER,
196 {(void*)MM_IMAGE_CODEC_JPEG},
197 MM_ATTRS_VALID_TYPE_INT_ARRAY,
207 {(void*)MM_FILE_FORMAT_MP4},
208 MM_ATTRS_VALID_TYPE_INT_ARRAY,
214 MM_CAM_CAMERA_DEVICE_NAME,
215 "camera-device-name",
216 MMF_VALUE_TYPE_STRING,
219 MM_ATTRS_VALID_TYPE_NONE,
225 MM_CAM_AUDIO_SAMPLERATE,
230 MM_ATTRS_VALID_TYPE_INT_RANGE,
232 {.int_max = _MMCAMCORDER_MAX_INT},
240 {(void*)MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE},
241 MM_ATTRS_VALID_TYPE_INT_ARRAY,
248 MM_CAM_AUDIO_CHANNEL,
253 MM_ATTRS_VALID_TYPE_INT_RANGE,
261 MMF_VALUE_TYPE_DOUBLE,
264 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
266 {.double_max = 10.0},
267 _mmcamcorder_commit_audio_volume,
270 MM_CAM_AUDIO_INPUT_ROUTE,
274 {(void*)MM_AUDIOROUTE_USE_EXTERNAL_SETTING},
275 MM_ATTRS_VALID_TYPE_INT_RANGE,
276 {.int_min = MM_AUDIOROUTE_USE_EXTERNAL_SETTING},
277 {.int_max = MM_AUDIOROUTE_CAPTURE_STEREOMIC_ONLY},
278 _mmcamcorder_commit_audio_input_route,
281 MM_CAM_FILTER_SCENE_MODE,
286 MM_ATTRS_VALID_TYPE_INT_ARRAY,
289 _mmcamcorder_commit_filter_scene_mode,
292 MM_CAM_FILTER_BRIGHTNESS,
297 MM_ATTRS_VALID_TYPE_INT_RANGE,
300 _mmcamcorder_commit_filter,
303 MM_CAM_FILTER_CONTRAST,
308 MM_ATTRS_VALID_TYPE_INT_RANGE,
311 _mmcamcorder_commit_filter,
319 MM_ATTRS_VALID_TYPE_INT_ARRAY,
322 _mmcamcorder_commit_filter,
325 MM_CAM_FILTER_COLOR_TONE,
330 MM_ATTRS_VALID_TYPE_INT_ARRAY,
333 _mmcamcorder_commit_filter,
336 MM_CAM_FILTER_SATURATION,
341 MM_ATTRS_VALID_TYPE_INT_RANGE,
344 _mmcamcorder_commit_filter,
352 MM_ATTRS_VALID_TYPE_INT_RANGE,
355 _mmcamcorder_commit_filter,
359 MM_CAM_FILTER_SHARPNESS,
364 MM_ATTRS_VALID_TYPE_INT_RANGE,
367 _mmcamcorder_commit_filter,
370 MM_CAM_CAMERA_FORMAT,
374 {(void*)MM_PIXEL_FORMAT_YUYV},
375 MM_ATTRS_VALID_TYPE_INT_ARRAY,
381 MM_CAM_CAMERA_RECORDING_MOTION_RATE,
382 "camera-recording-motion-rate",
383 MMF_VALUE_TYPE_DOUBLE,
386 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
388 {.double_max = _MMCAMCORDER_MAX_INT},
389 _mmcamcorder_commit_camera_recording_motion_rate,
397 MM_ATTRS_VALID_TYPE_INT_ARRAY,
400 _mmcamcorder_commit_camera_fps,
407 {(void*)MMCAMCORDER_DEFAULT_CAMERA_WIDTH},
408 MM_ATTRS_VALID_TYPE_INT_ARRAY,
411 _mmcamcorder_commit_camera_width,
414 MM_CAM_CAMERA_HEIGHT,
418 {(void*)MMCAMCORDER_DEFAULT_CAMERA_HEIGHT},
419 MM_ATTRS_VALID_TYPE_INT_ARRAY,
422 _mmcamcorder_commit_camera_height,
425 MM_CAM_CAMERA_DIGITAL_ZOOM,
426 "camera-digital-zoom",
430 MM_ATTRS_VALID_TYPE_INT_RANGE,
433 _mmcamcorder_commit_camera_zoom,
436 MM_CAM_CAMERA_OPTICAL_ZOOM,
437 "camera-optical-zoom",
441 MM_ATTRS_VALID_TYPE_INT_RANGE,
444 _mmcamcorder_commit_camera_zoom,
447 MM_CAM_CAMERA_FOCUS_MODE,
451 {(void*)MM_CAMCORDER_FOCUS_MODE_NONE},
452 MM_ATTRS_VALID_TYPE_INT_ARRAY,
455 _mmcamcorder_commit_camera_focus_mode,
458 MM_CAM_CAMERA_AF_SCAN_RANGE,
459 "camera-af-scan-range",
463 MM_ATTRS_VALID_TYPE_INT_ARRAY,
466 _mmcamcorder_commit_camera_af_scan_range,
470 MM_CAM_CAMERA_EXPOSURE_MODE,
471 "camera-exposure-mode",
475 MM_ATTRS_VALID_TYPE_INT_ARRAY,
478 _mmcamcorder_commit_camera_capture_mode,
481 MM_CAM_CAMERA_EXPOSURE_VALUE,
482 "camera-exposure-value",
486 MM_ATTRS_VALID_TYPE_INT_RANGE,
489 _mmcamcorder_commit_camera_capture_mode,
492 MM_CAM_CAMERA_F_NUMBER,
497 MM_ATTRS_VALID_TYPE_INT_ARRAY,
500 _mmcamcorder_commit_camera_capture_mode,
503 MM_CAM_CAMERA_SHUTTER_SPEED,
504 "camera-shutter-speed",
508 MM_ATTRS_VALID_TYPE_INT_ARRAY,
511 _mmcamcorder_commit_camera_capture_mode,
519 MM_ATTRS_VALID_TYPE_INT_ARRAY,
522 _mmcamcorder_commit_camera_capture_mode,
530 MM_ATTRS_VALID_TYPE_INT_ARRAY,
533 _mmcamcorder_commit_camera_wdr,
536 MM_CAM_CAMERA_ANTI_HANDSHAKE,
537 "camera-anti-handshake",
541 MM_ATTRS_VALID_TYPE_INT_ARRAY,
544 _mmcamcorder_commit_camera_anti_handshake,
547 MM_CAM_CAMERA_FPS_AUTO,
552 MM_ATTRS_VALID_TYPE_INT_RANGE,
558 MM_CAM_CAMERA_DELAY_ATTR_SETTING,
559 "camera-delay-attr-setting",
563 MM_ATTRS_VALID_TYPE_INT_RANGE,
569 MM_CAM_AUDIO_ENCODER_BITRATE,
570 "audio-encoder-bitrate",
574 MM_ATTRS_VALID_TYPE_INT_RANGE,
576 {.int_max = _MMCAMCORDER_MAX_INT},
581 MM_CAM_VIDEO_ENCODER_BITRATE,
582 "video-encoder-bitrate",
586 MM_ATTRS_VALID_TYPE_INT_RANGE,
588 {.int_max = _MMCAMCORDER_MAX_INT},
592 MM_CAM_IMAGE_ENCODER_QUALITY,
593 "image-encoder-quality",
597 MM_ATTRS_VALID_TYPE_INT_RANGE,
600 _mmcamcorder_commit_image_encoder_quality,
603 MM_CAM_CAPTURE_FORMAT,
607 {(void*)MM_PIXEL_FORMAT_ENCODED},
608 MM_ATTRS_VALID_TYPE_INT_ARRAY,
614 MM_CAM_CAPTURE_WIDTH,
619 MM_ATTRS_VALID_TYPE_INT_ARRAY,
622 _mmcamcorder_commit_capture_width ,
625 MM_CAM_CAPTURE_HEIGHT,
630 MM_ATTRS_VALID_TYPE_INT_ARRAY,
633 _mmcamcorder_commit_capture_height,
636 MM_CAM_CAPTURE_COUNT,
641 MM_ATTRS_VALID_TYPE_INT_RANGE,
644 _mmcamcorder_commit_capture_count,
647 MM_CAM_CAPTURE_INTERVAL,
652 MM_ATTRS_VALID_TYPE_INT_RANGE,
654 {.int_max = _MMCAMCORDER_MAX_INT},
658 MM_CAM_CAPTURE_BREAK_CONTINUOUS_SHOT,
659 "capture-break-cont-shot",
663 MM_ATTRS_VALID_TYPE_INT_RANGE,
666 _mmcamcorder_commit_capture_break_cont_shot,
669 MM_CAM_DISPLAY_HANDLE,
674 MM_ATTRS_VALID_TYPE_NONE,
677 _mmcamcorder_commit_display_handle,
680 MM_CAM_DISPLAY_DEVICE,
684 {(void*)MM_DISPLAY_DEVICE_MAINLCD},
685 MM_ATTRS_VALID_TYPE_INT_ARRAY,
692 MM_CAM_DISPLAY_SURFACE,
696 {(void*)MM_DISPLAY_SURFACE_X},
697 MM_ATTRS_VALID_TYPE_INT_ARRAY,
703 MM_CAM_DISPLAY_RECT_X,
708 MM_ATTRS_VALID_TYPE_INT_RANGE,
710 {.int_max = _MMCAMCORDER_MAX_INT},
711 _mmcamcorder_commit_display_rect,
714 MM_CAM_DISPLAY_RECT_Y,
719 MM_ATTRS_VALID_TYPE_INT_RANGE,
721 {.int_max = _MMCAMCORDER_MAX_INT},
722 _mmcamcorder_commit_display_rect,
725 MM_CAM_DISPLAY_RECT_WIDTH,
726 "display-rect-width",
730 MM_ATTRS_VALID_TYPE_INT_RANGE,
732 {.int_max = _MMCAMCORDER_MAX_INT},
733 _mmcamcorder_commit_display_rect,
736 MM_CAM_DISPLAY_RECT_HEIGHT,
737 "display-rect-height",
741 MM_ATTRS_VALID_TYPE_INT_RANGE,
743 {.int_max = _MMCAMCORDER_MAX_INT},
744 _mmcamcorder_commit_display_rect,
747 MM_CAM_DISPLAY_SOURCE_X,
752 MM_ATTRS_VALID_TYPE_INT_RANGE,
754 {.int_max = _MMCAMCORDER_MAX_INT},
758 MM_CAM_DISPLAY_SOURCE_Y,
763 MM_ATTRS_VALID_TYPE_INT_RANGE,
765 {.int_max = _MMCAMCORDER_MAX_INT},
769 MM_CAM_DISPLAY_SOURCE_WIDTH,
774 MM_ATTRS_VALID_TYPE_INT_RANGE,
776 {.int_max = _MMCAMCORDER_MAX_INT},
780 MM_CAM_DISPLAY_SOURCE_HEIGHT,
781 "display-src-height",
785 MM_ATTRS_VALID_TYPE_INT_RANGE,
787 {.int_max = _MMCAMCORDER_MAX_INT},
791 MM_CAM_DISPLAY_ROTATION,
795 {(void*)MM_DISPLAY_ROTATION_NONE},
796 MM_ATTRS_VALID_TYPE_INT_RANGE,
797 {.int_min = MM_DISPLAY_ROTATION_NONE},
798 {.int_max = MM_DISPLAY_ROTATION_270},
799 _mmcamcorder_commit_display_rotation,
802 MM_CAM_DISPLAY_VISIBLE,
807 MM_ATTRS_VALID_TYPE_INT_ARRAY,
809 {ARRAY_SIZE(visible_values)},
810 _mmcamcorder_commit_display_visible,
813 MM_CAM_DISPLAY_SCALE,
818 MM_ATTRS_VALID_TYPE_INT_RANGE,
819 {.int_min = MM_DISPLAY_SCALE_DEFAULT},
820 {.int_max = MM_DISPLAY_SCALE_TRIPLE_LENGTH},
821 _mmcamcorder_commit_display_scale,
824 MM_CAM_DISPLAY_GEOMETRY_METHOD,
825 "display-geometry-method",
829 MM_ATTRS_VALID_TYPE_INT_RANGE,
830 {.int_min = MM_DISPLAY_METHOD_LETTER_BOX},
831 {.int_max = MM_DISPLAY_METHOD_CUSTOM_ROI},
832 _mmcamcorder_commit_display_geometry_method,
835 MM_CAM_TARGET_FILENAME,
837 MMF_VALUE_TYPE_STRING,
840 MM_ATTRS_VALID_TYPE_NONE,
843 _mmcamcorder_commit_target_filename,
846 MM_CAM_TARGET_MAX_SIZE,
851 MM_ATTRS_VALID_TYPE_INT_RANGE,
853 {.int_max = _MMCAMCORDER_MAX_INT},
857 MM_CAM_TARGET_TIME_LIMIT,
862 MM_ATTRS_VALID_TYPE_INT_RANGE,
864 {.int_max = _MMCAMCORDER_MAX_INT},
873 MM_ATTRS_VALID_TYPE_INT_RANGE,
879 MM_CAM_TAG_IMAGE_DESCRIPTION,
880 "tag-image-description",
881 MMF_VALUE_TYPE_STRING,
884 MM_ATTRS_VALID_TYPE_NONE,
890 MM_CAM_TAG_ORIENTATION,
895 MM_ATTRS_VALID_TYPE_INT_ARRAY,
896 {tag_orientation_values},
897 {ARRAY_SIZE(tag_orientation_values)},
903 MMF_VALUE_TYPE_STRING,
906 MM_ATTRS_VALID_TYPE_NONE,
915 MMF_VALUE_TYPE_DOUBLE,
918 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
919 {.double_min = -360.0},
920 {.double_max = 360.0},
924 MM_CAM_TAG_LONGITUDE,
926 MMF_VALUE_TYPE_DOUBLE,
929 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
930 {.double_min = -360.0},
931 {.double_max = 360.0},
937 MMF_VALUE_TYPE_DOUBLE,
940 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
941 {.double_min = -999999.0},
942 {.double_max = 999999.0},
946 MM_CAM_STROBE_CONTROL,
951 MM_ATTRS_VALID_TYPE_INT_RANGE,
954 _mmcamcorder_commit_strobe,
957 MM_CAM_STROBE_CAPABILITIES,
958 "strobe-capabilities",
962 MM_ATTRS_VALID_TYPE_INT_RANGE,
965 _mmcamcorder_commit_strobe,
973 MM_ATTRS_VALID_TYPE_INT_ARRAY,
976 _mmcamcorder_commit_strobe,
984 MM_ATTRS_VALID_TYPE_INT_ARRAY,
987 _mmcamcorder_commit_detect,
990 MM_CAM_DETECT_NUMBER,
995 MM_ATTRS_VALID_TYPE_INT_RANGE,
998 _mmcamcorder_commit_detect,
1001 MM_CAM_DETECT_FOCUS_SELECT,
1002 "detect-focus-select",
1006 MM_ATTRS_VALID_TYPE_INT_RANGE,
1009 _mmcamcorder_commit_detect,
1012 MM_CAM_DETECT_SELECT_NUMBER,
1013 "detect-select-number",
1017 MM_ATTRS_VALID_TYPE_INT_RANGE,
1020 _mmcamcorder_commit_detect,
1024 MM_CAM_DETECT_STATUS,
1029 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1032 _mmcamcorder_commit_detect,
1035 MM_CAM_CAPTURE_ZERO_SYSTEMLAG,
1036 "capture-zero-systemlag",
1040 MM_ATTRS_VALID_TYPE_INT_RANGE,
1046 MM_CAM_CAMERA_AF_TOUCH_X,
1047 "camera-af-touch-x",
1051 MM_ATTRS_VALID_TYPE_INT_RANGE,
1053 {.int_max = _MMCAMCORDER_MAX_INT},
1054 _mmcamcorder_commit_camera_af_touch_area,
1057 MM_CAM_CAMERA_AF_TOUCH_Y,
1058 "camera-af-touch-y",
1062 MM_ATTRS_VALID_TYPE_INT_RANGE,
1064 {.int_max = _MMCAMCORDER_MAX_INT},
1065 _mmcamcorder_commit_camera_af_touch_area,
1068 MM_CAM_CAMERA_AF_TOUCH_WIDTH,
1069 "camera-af-touch-width",
1073 MM_ATTRS_VALID_TYPE_INT_RANGE,
1075 {.int_max = _MMCAMCORDER_MAX_INT},
1076 _mmcamcorder_commit_camera_af_touch_area,
1079 MM_CAM_CAMERA_AF_TOUCH_HEIGHT,
1080 "camera-af-touch-height",
1084 MM_ATTRS_VALID_TYPE_INT_RANGE,
1086 {.int_max = _MMCAMCORDER_MAX_INT},
1087 _mmcamcorder_commit_camera_af_touch_area,
1090 MM_CAM_CAMERA_FOCAL_LENGTH,
1091 "camera-focal-length",
1092 MMF_VALUE_TYPE_DOUBLE,
1095 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
1096 {.double_min = 0.0},
1097 {.double_max = 1000.0},
1098 _mmcamcorder_commit_camera_capture_mode,
1101 MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE,
1102 "recommend-preview-format-for-capture",
1105 {(void*)MM_PIXEL_FORMAT_YUYV},
1106 MM_ATTRS_VALID_TYPE_INT_RANGE,
1107 {.int_min = MM_PIXEL_FORMAT_NV12},
1108 {.int_max = (MM_PIXEL_FORMAT_NUM-1)},
1112 MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING,
1113 "recommend-preview-format-for-recording",
1116 {(void*)MM_PIXEL_FORMAT_NV12},
1117 MM_ATTRS_VALID_TYPE_INT_RANGE,
1118 {.int_min = MM_PIXEL_FORMAT_NV12},
1119 {.int_max = (MM_PIXEL_FORMAT_NUM-1)},
1123 MM_CAM_TAG_GPS_ENABLE,
1128 MM_ATTRS_VALID_TYPE_INT_RANGE,
1135 MM_CAM_TAG_GPS_TIME_STAMP,
1136 "tag-gps-time-stamp",
1137 MMF_VALUE_TYPE_DOUBLE,
1140 MM_ATTRS_VALID_TYPE_NONE,
1146 MM_CAM_TAG_GPS_DATE_STAMP,
1147 "tag-gps-date-stamp",
1148 MMF_VALUE_TYPE_STRING,
1151 MM_ATTRS_VALID_TYPE_NONE,
1157 MM_CAM_TAG_GPS_PROCESSING_METHOD,
1158 "tag-gps-processing-method",
1159 MMF_VALUE_TYPE_STRING,
1162 MM_ATTRS_VALID_TYPE_NONE,
1168 MM_CAM_CAMERA_ROTATION,
1172 {(void*)MM_VIDEO_INPUT_ROTATION_NONE},
1173 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1175 {ARRAY_SIZE(rotation_list)},
1176 _mmcamcorder_commit_camera_rotate,
1179 MM_CAM_CAPTURED_SCREENNAIL,
1180 "captured-screennail",
1181 MMF_VALUE_TYPE_DATA,
1182 MM_ATTRS_FLAG_READABLE,
1184 MM_ATTRS_VALID_TYPE_NONE,
1190 MM_CAM_CAPTURE_SOUND_ENABLE,
1191 "capture-sound-enable",
1195 MM_ATTRS_VALID_TYPE_INT_RANGE,
1198 _mmcamcorder_commit_capture_sound_enable,
1201 MM_CAM_RECOMMEND_DISPLAY_ROTATION,
1202 "recommend-display-rotation",
1205 {(void*)MM_DISPLAY_ROTATION_270},
1206 MM_ATTRS_VALID_TYPE_INT_RANGE,
1207 {.int_min = MM_DISPLAY_ROTATION_NONE},
1208 {.int_max = MM_DISPLAY_ROTATION_270},
1216 {(void*)MM_FLIP_NONE},
1217 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1219 {ARRAY_SIZE(flip_list)},
1220 _mmcamcorder_commit_camera_flip,
1223 MM_CAM_CAMERA_HDR_CAPTURE,
1224 "camera-hdr-capture",
1228 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1231 _mmcamcorder_commit_camera_hdr_capture,
1234 MM_CAM_DISPLAY_MODE,
1238 {(void*)MM_DISPLAY_MODE_DEFAULT},
1239 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1242 _mmcamcorder_commit_display_mode,
1246 MM_CAM_AUDIO_DISABLE,
1251 MM_ATTRS_VALID_TYPE_INT_RANGE,
1254 _mmcamcorder_commit_audio_disable,
1257 MM_CAM_RECOMMEND_CAMERA_WIDTH,
1258 "recommend-camera-width",
1261 {(void*)MMCAMCORDER_DEFAULT_CAMERA_WIDTH},
1262 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1268 MM_CAM_RECOMMEND_CAMERA_HEIGHT,
1269 "recommend-camera-height",
1272 {(void*)MMCAMCORDER_DEFAULT_CAMERA_HEIGHT},
1273 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1279 MM_CAM_CAPTURED_EXIF_RAW_DATA,
1280 "captured-exif-raw-data",
1281 MMF_VALUE_TYPE_DATA,
1282 MM_ATTRS_FLAG_READABLE,
1284 MM_ATTRS_VALID_TYPE_NONE,
1290 MM_CAM_DISPLAY_EVAS_SURFACE_SINK,
1291 "display-evas-surface-sink",
1292 MMF_VALUE_TYPE_STRING,
1293 MM_ATTRS_FLAG_READABLE,
1295 MM_ATTRS_VALID_TYPE_NONE,
1301 MM_CAM_DISPLAY_EVAS_DO_SCALING,
1302 "display-evas-do-scaling",
1306 MM_ATTRS_VALID_TYPE_INT_RANGE,
1309 _mmcamcorder_commit_display_evas_do_scaling,
1312 MM_CAM_CAMERA_FACING_DIRECTION,
1313 "camera-facing-direction",
1316 {(void*)MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR},
1317 MM_ATTRS_VALID_TYPE_INT_RANGE,
1318 {.int_min = MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR},
1319 {.int_max = MM_CAMCORDER_CAMERA_FACING_DIRECTION_FRONT},
1323 MM_CAM_DISPLAY_FLIP,
1327 {(void*)MM_FLIP_NONE},
1328 MM_ATTRS_VALID_TYPE_INT_RANGE,
1329 {.int_min = MM_FLIP_NONE},
1330 {.int_max = MM_FLIP_BOTH},
1331 _mmcamcorder_commit_display_flip,
1334 MM_CAM_CAMERA_VIDEO_STABILIZATION,
1335 "camera-video-stabilization",
1338 {(void*)MM_CAMCORDER_VIDEO_STABILIZATION_OFF},
1339 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1342 _mmcamcorder_commit_camera_video_stabilization,
1345 MM_CAM_TAG_VIDEO_ORIENTATION,
1346 "tag-video-orientation",
1349 {(void*)MM_CAMCORDER_TAG_VIDEO_ORT_NONE},
1350 MM_ATTRS_VALID_TYPE_INT_RANGE,
1351 {.int_min = MM_CAMCORDER_TAG_VIDEO_ORT_NONE},
1352 {.int_max = MM_CAMCORDER_TAG_VIDEO_ORT_270},
1362 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1365 _mmcamcorder_commit_video_size,
1368 MM_CAM_VIDEO_HEIGHT,
1373 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1376 _mmcamcorder_commit_video_size,
1379 MM_CAM_SUPPORT_ZSL_CAPTURE,
1380 "support-zsl-capture",
1384 MM_ATTRS_VALID_TYPE_INT_RANGE,
1390 MM_CAM_SUPPORT_ZERO_COPY_FORMAT,
1391 "support-zero-copy-format",
1395 MM_ATTRS_VALID_TYPE_INT_RANGE,
1401 MM_CAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB,
1402 "support-media-packet-preview-cb",
1406 MM_ATTRS_VALID_TYPE_INT_RANGE,
1413 memcpy(hcamcorder->cam_attrs_const_info, temp_info, sizeof(mm_cam_attr_construct_info) * attr_count);
1415 for (idx = 0 ; idx < attr_count ; idx++) {
1416 /* attribute order check. This should be same. */
1417 if (idx != hcamcorder->cam_attrs_const_info[idx].attrid) {
1418 _mmcam_dbg_err("Please check attributes order. Is the idx same with enum val?");
1419 free(attrs_const_info);
1420 attrs_const_info = NULL;
1421 free(hcamcorder->cam_attrs_const_info);
1422 hcamcorder->cam_attrs_const_info = NULL;
1426 attrs_const_info[idx].name = hcamcorder->cam_attrs_const_info[idx].name;
1427 attrs_const_info[idx].value_type = hcamcorder->cam_attrs_const_info[idx].value_type;
1428 attrs_const_info[idx].flags = hcamcorder->cam_attrs_const_info[idx].flags;
1429 attrs_const_info[idx].default_value = hcamcorder->cam_attrs_const_info[idx].default_value.value_void;
1432 /* Camcorder Attributes */
1433 _mmcam_dbg_log("Create Camcorder Attributes[%p, %d]", attrs_const_info, attr_count);
1435 attrs = mmf_attrs_new_from_data("Camcorder_Attributes",
1438 _mmcamcorder_commit_camcorder_attrs,
1441 free(attrs_const_info);
1442 attrs_const_info = NULL;
1445 _mmcam_dbg_err("Fail to alloc attribute handle");
1446 free(hcamcorder->cam_attrs_const_info);
1447 hcamcorder->cam_attrs_const_info = NULL;
1451 __mmcamcorder_set_conf_to_valid_info(handle);
1453 for (idx = 0; idx < attr_count; idx++)
1455 /* _mmcam_dbg_log("Valid type [%s:%d, %d, %d]", cam_attrs_const_info[idx].name, cam_attrs_const_info[idx].validity_type
1456 , cam_attrs_const_info[idx].validity_value1, cam_attrs_const_info[idx].validity_value2);
1458 mmf_attrs_set_valid_type (attrs, idx, hcamcorder->cam_attrs_const_info[idx].validity_type);
1460 switch (hcamcorder->cam_attrs_const_info[idx].validity_type)
1462 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
1463 if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array &&
1464 hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
1465 mmf_attrs_set_valid_array(attrs, idx,
1466 (const int *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array),
1467 hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
1468 hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
1471 case MM_ATTRS_VALID_TYPE_INT_RANGE:
1472 mmf_attrs_set_valid_range(attrs, idx,
1473 hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_min,
1474 hcamcorder->cam_attrs_const_info[idx].validity_value_2.int_max,
1475 hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
1477 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
1478 if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array &&
1479 hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
1480 mmf_attrs_set_valid_double_array(attrs, idx,
1481 (const double *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array),
1482 hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
1483 hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
1486 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
1487 mmf_attrs_set_valid_double_range(attrs, idx,
1488 hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_min,
1489 hcamcorder->cam_attrs_const_info[idx].validity_value_2.double_max,
1490 hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
1492 case MM_ATTRS_VALID_TYPE_NONE:
1494 case MM_ATTRS_VALID_TYPE_INVALID:
1496 _mmcam_dbg_err("Valid type error.");
1501 __mmcamcorder_release_conf_valid_info(handle);
1508 _mmcamcorder_dealloc_attribute(MMHandleType handle, MMHandleType attrs)
1510 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1512 if (hcamcorder == NULL) {
1513 _mmcam_dbg_err("handle is NULL");
1520 mmf_attrs_free(attrs);
1521 _mmcam_dbg_log("released attribute");
1524 if (hcamcorder->cam_attrs_const_info) {
1525 free(hcamcorder->cam_attrs_const_info);
1526 hcamcorder->cam_attrs_const_info = NULL;
1527 _mmcam_dbg_log("released attribute info");
1533 _mmcamcorder_get_attributes(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
1535 MMHandleType attrs = 0;
1536 int ret = MM_ERROR_NONE;
1538 mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1539 // mmf_return_val_if_fail( err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1541 attrs = MMF_CAMCORDER_ATTRS(handle);
1542 mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
1544 ret = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, var_args);
1551 _mmcamcorder_set_attributes(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
1553 MMHandleType attrs = 0;
1554 int ret = MM_ERROR_NONE;
1556 mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1557 // mmf_return_val_if_fail( err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1559 if (!_MMCAMCORDER_TRYLOCK_CMD(handle)) {
1560 _mmcam_dbg_err("Another command is running.");
1561 return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1564 attrs = MMF_CAMCORDER_ATTRS(handle);
1566 ret = __mmcamcorder_check_valid_pair( handle, err_attr_name, attribute_name, var_args );
1568 _mmcam_dbg_err("handle 0x%x, attrs is NULL, attr name [%s]", handle, attribute_name);
1569 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1572 if (ret == MM_ERROR_NONE) {
1573 ret = mm_attrs_set_valist(attrs, err_attr_name, attribute_name, var_args);
1576 _MMCAMCORDER_UNLOCK_CMD(handle);
1578 if (ret != MM_ERROR_NONE) {
1579 _mmcam_dbg_err("failed error code 0x%x - handle %p", ret, (mmf_camcorder_t *)handle);
1587 _mmcamcorder_get_attribute_info(MMHandleType handle, const char *attr_name, MMCamAttrsInfo *info)
1589 MMHandleType attrs = 0;
1590 MMAttrsInfo attrinfo;
1591 int ret = MM_ERROR_NONE;
1593 mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1594 mmf_return_val_if_fail( attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1595 mmf_return_val_if_fail( info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1597 attrs = MMF_CAMCORDER_ATTRS(handle);
1598 mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
1600 ret = mm_attrs_get_info_by_name(attrs, attr_name, (MMAttrsInfo*)&attrinfo);
1602 if (ret == MM_ERROR_NONE)
1604 memset(info, 0x00, sizeof(MMCamAttrsInfo));
1605 info->type = attrinfo.type;
1606 info->flag = attrinfo.flag;
1607 info->validity_type= attrinfo.validity_type;
1609 switch(attrinfo.validity_type)
1611 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
1612 info->int_array.array = attrinfo.int_array.array;
1613 info->int_array.count = attrinfo.int_array.count;
1614 info->int_array.def = attrinfo.int_array.dval;
1616 case MM_ATTRS_VALID_TYPE_INT_RANGE:
1617 info->int_range.min = attrinfo.int_range.min;
1618 info->int_range.max = attrinfo.int_range.max;
1619 info->int_range.def = attrinfo.int_range.dval;
1621 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
1622 info->double_array.array = attrinfo.double_array.array;
1623 info->double_array.count = attrinfo.double_array.count;
1624 info->double_array.def = attrinfo.double_array.dval;
1626 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
1627 info->double_range.min = attrinfo.double_range.min;
1628 info->double_range.max = attrinfo.double_range.max;
1629 info->double_range.def = attrinfo.double_range.dval;
1631 case MM_ATTRS_VALID_TYPE_NONE:
1633 case MM_ATTRS_VALID_TYPE_INVALID:
1644 _mmcamcorder_commit_camcorder_attrs (int attr_idx, const char *attr_name, const mmf_value_t *value, void *commit_param)
1647 mmf_camcorder_t *hcamcorder = NULL;
1649 mmf_return_val_if_fail(commit_param, FALSE);
1650 mmf_return_val_if_fail(attr_idx >= 0, FALSE);
1651 mmf_return_val_if_fail(attr_name, FALSE);
1652 mmf_return_val_if_fail(value, FALSE);
1654 hcamcorder = MMF_CAMCORDER(commit_param);
1656 if (hcamcorder->cam_attrs_const_info[attr_idx].attr_commit) {
1657 bret = hcamcorder->cam_attrs_const_info[attr_idx].attr_commit((MMHandleType)commit_param, attr_idx, value);
1666 int __mmcamcorder_set_conf_to_valid_info(MMHandleType handle)
1669 int total_count = 0;
1671 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1673 if (hcamcorder == NULL) {
1674 _mmcam_dbg_err("handle is NULL");
1675 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1679 total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER, &format);
1680 hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_1.int_array = format;
1681 hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_2.count = total_count;
1684 total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER, &format);
1685 hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_1.int_array = format;
1686 hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_2.count = total_count;
1689 total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER, &format);
1690 hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_1.int_array = format;
1691 hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_2.count = total_count;
1694 total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_MUX, &format);
1695 hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_1.int_array = format;
1696 hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_2.count = total_count;
1698 return MM_ERROR_NONE;
1702 int __mmcamcorder_release_conf_valid_info(MMHandleType handle)
1704 int *allocated_memory = NULL;
1706 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1708 if (hcamcorder == NULL) {
1709 _mmcam_dbg_err("handle is NULL");
1710 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1713 _mmcam_dbg_log("START");
1715 /* Audio encoder info */
1716 allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_1.int_array);
1717 if (allocated_memory) {
1718 free(allocated_memory);
1719 hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_1.int_array = NULL;
1720 hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_2.count = 0;
1723 /* Video encoder info */
1724 allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_1.int_array);
1725 if (allocated_memory) {
1726 free(allocated_memory);
1727 hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_1.int_array = NULL;
1728 hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_2.count = 0;
1731 /* Image encoder info */
1732 allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_1.int_array);
1733 if (allocated_memory) {
1734 free(allocated_memory);
1735 hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_1.int_array = NULL;
1736 hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_2.count = 0;
1739 /* File format info */
1740 allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_1.int_array);
1741 if (allocated_memory) {
1742 free(allocated_memory);
1743 hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_1.int_array = NULL;
1744 hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_2.count = 0;
1747 _mmcam_dbg_log("DONE");
1749 return MM_ERROR_NONE;
1753 bool _mmcamcorder_commit_capture_width (MMHandleType handle, int attr_idx, const mmf_value_t *value)
1755 MMHandleType attr = 0;
1756 int current_state = MM_CAMCORDER_STATE_NONE;
1758 attr = MMF_CAMCORDER_ATTRS(handle);
1759 mmf_return_val_if_fail(attr, FALSE);
1761 _mmcam_dbg_log("(%d)", attr_idx);
1763 current_state = _mmcamcorder_get_state(handle);
1764 if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
1765 int flags = MM_ATTRS_FLAG_NONE;
1766 int capture_width, capture_height;
1767 MMCamAttrsInfo info;
1769 mm_camcorder_get_attribute_info(handle, MMCAM_CAPTURE_HEIGHT, &info);
1772 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
1773 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_HEIGHT, &capture_height, NULL);
1774 capture_width = value->value.i_val;
1776 /* Check whether they are valid pair */
1777 return __mmcamcorder_set_capture_resolution(handle, capture_width, capture_height);
1782 _mmcam_dbg_log("Capture resolution can't be set.(state=%d)", current_state);
1788 bool _mmcamcorder_commit_capture_height (MMHandleType handle, int attr_idx, const mmf_value_t *value)
1790 int current_state = MM_CAMCORDER_STATE_NONE;
1792 current_state = _mmcamcorder_get_state(handle);
1794 if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
1795 int capture_width, capture_height;
1797 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_WIDTH, &capture_width, NULL);
1798 capture_height = value->value.i_val;
1800 return __mmcamcorder_set_capture_resolution(handle, capture_width, capture_height);
1802 _mmcam_dbg_log("Capture resolution can't be set.(state=%d)", current_state);
1809 bool _mmcamcorder_commit_capture_break_cont_shot (MMHandleType handle, int attr_idx, const mmf_value_t *value)
1811 int current_state = _mmcamcorder_get_state( handle);
1812 int ivalue = value->value.i_val;
1814 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1815 _MMCamcorderSubContext *sc = NULL;
1816 GstCameraControl *control = NULL;
1817 type_element *VideosrcElement = NULL;
1819 const char *videosrc_name = NULL;
1821 _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
1822 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
1825 _mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
1827 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
1831 if (ivalue && current_state == MM_CAMCORDER_STATE_CAPTURING) {
1832 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
1833 _mmcam_dbg_warn("Can't cast Video source into camera control.");
1837 control = GST_CAMERA_CONTROL( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst );
1838 gst_camera_control_set_capture_command( control, GST_CAMERA_CONTROL_CAPTURE_COMMAND_STOP_MULTISHOT );
1840 _mmcam_dbg_warn( "Commit Break continuous shot : Set command OK. current state[%d]", current_state );
1842 _mmcam_dbg_warn( "Commit Break continuous shot : No effect. value[%d],current state[%d]", ivalue, current_state );
1849 bool _mmcamcorder_commit_capture_count(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1851 int mode = MM_CAMCORDER_MODE_VIDEO_CAPTURE;
1852 int current_state = MM_CAMCORDER_STATE_NONE;
1854 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1856 mmf_return_val_if_fail(hcamcorder, FALSE);
1858 current_state = _mmcamcorder_get_state(handle);
1859 mm_camcorder_get_attributes(handle, NULL, MMCAM_MODE, &mode, NULL);
1861 _mmcam_dbg_log("current state %d, mode %d, set count %d",
1862 current_state, mode, value->value.i_val);
1864 if (mode != MM_CAMCORDER_MODE_AUDIO &&
1865 current_state != MM_CAMCORDER_STATE_CAPTURING) {
1868 _mmcam_dbg_err("Invalid mode[%d] or state[%d]", mode, current_state);
1874 bool _mmcamcorder_commit_capture_sound_enable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1876 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1878 mmf_return_val_if_fail(hcamcorder, FALSE);
1880 _mmcam_dbg_log("shutter sound policy: %d", hcamcorder->shutter_sound_policy);
1882 /* return error when disable shutter sound if policy is TRUE */
1883 if (!value->value.i_val &&
1884 hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON) {
1885 _mmcam_dbg_err("not permitted DISABLE SHUTTER SOUND");
1888 _mmcam_dbg_log("set value [%d] success", value->value.i_val);
1894 bool _mmcamcorder_commit_audio_volume (MMHandleType handle, int attr_idx, const mmf_value_t *value)
1896 int current_state = MM_CAMCORDER_STATE_NONE;
1897 _MMCamcorderSubContext *sc = NULL;
1900 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
1905 current_state = _mmcamcorder_get_state( handle);
1907 if ((current_state == MM_CAMCORDER_STATE_RECORDING)||(current_state == MM_CAMCORDER_STATE_PAUSED)) {
1908 double mslNewVal = 0;
1909 mslNewVal = value->value.d_val;
1911 if (sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst) {
1912 if (mslNewVal == 0.0) {
1913 /* Because data probe of audio src do the same job, it doesn't need to set mute here. Already null raw data. */
1914 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "volume", 1.0);
1916 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "mute", FALSE);
1917 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "volume", mslNewVal);
1921 _mmcam_dbg_log("Commit : volume(%f)", mslNewVal);
1924 _mmcam_dbg_log("Commit : nothing to commit. status(%d)", current_state);
1932 bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mmf_value_t *value)
1934 _mmcam_dbg_log("FPS(%d)", value->value.i_val);
1939 bool _mmcamcorder_commit_camera_recording_motion_rate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1941 int current_state = MM_CAMCORDER_STATE_NONE;
1942 _MMCamcorderSubContext *sc = NULL;
1944 mmf_return_val_if_fail(handle, FALSE);
1946 current_state = _mmcamcorder_get_state(handle);
1948 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
1949 _mmcam_dbg_warn("invalid state %d", current_state);
1953 /* Verify recording motion rate */
1954 if (value->value.d_val > 0.0) {
1955 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
1960 /* set is_slow flag */
1961 if (value->value.d_val != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
1962 sc->is_modified_rate = TRUE;
1964 sc->is_modified_rate = FALSE;
1967 _mmcam_dbg_log("Set slow motion rate %lf", value->value.d_val);
1970 _mmcam_dbg_warn("Failed to set recording motion rate %lf", value->value.d_val);
1976 bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1978 MMHandleType attr = 0;
1979 int current_state = MM_CAMCORDER_STATE_NONE;
1981 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1982 _MMCamcorderSubContext *sc = NULL;
1984 mmf_return_val_if_fail(hcamcorder, FALSE);
1986 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
1991 attr = MMF_CAMCORDER_ATTRS(handle);
1992 mmf_return_val_if_fail(attr, FALSE);
1994 _mmcam_dbg_log("Width(%d)", value->value.i_val);
1996 current_state = _mmcamcorder_get_state(handle);
1998 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
1999 _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state);
2002 int flags = MM_ATTRS_FLAG_NONE;
2003 MMCamAttrsInfo info;
2004 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_HEIGHT, &info);
2007 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
2008 int width = value->value.i_val;
2010 int preview_format = MM_PIXEL_FORMAT_NV12;
2011 int codec_type = MM_IMAGE_CODEC_JPEG;
2013 mm_camcorder_get_attributes(handle, NULL,
2014 MMCAM_CAMERA_HEIGHT, &height,
2015 MMCAM_CAMERA_FORMAT, &preview_format,
2016 MMCAM_IMAGE_ENCODER, &codec_type,
2019 if (current_state == MM_CAMCORDER_STATE_PREPARE) {
2020 if (!pthread_mutex_trylock(&(hcamcorder->restart_preview_lock))) {
2021 _mmcam_dbg_log("restart preview");
2023 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
2024 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
2026 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
2028 /* get preview format */
2029 sc->info_image->preview_format = preview_format;
2030 sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format);
2031 ret = _mmcamcorder_set_camera_resolution(handle, width, height);
2033 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
2034 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
2036 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
2039 pthread_mutex_unlock(&(hcamcorder->restart_preview_lock));
2041 _mmcam_dbg_err("currently locked for preview restart");
2045 /* get preview format */
2046 sc->info_image->preview_format = preview_format;
2047 sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format);
2048 ret = _mmcamcorder_set_camera_resolution(handle, width, height);
2059 bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2062 int current_state = MM_CAMCORDER_STATE_NONE;
2063 MMHandleType attr = 0;
2064 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2065 _MMCamcorderSubContext *sc = NULL;
2067 mmf_return_val_if_fail(hcamcorder, FALSE);
2069 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2074 attr = MMF_CAMCORDER_ATTRS(hcamcorder);
2075 mmf_return_val_if_fail(attr, FALSE);
2077 _mmcam_dbg_log("Height(%d)", value->value.i_val);
2078 current_state = _mmcamcorder_get_state( handle);
2080 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2081 _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state);
2085 int height = value->value.i_val;
2086 int preview_format = MM_PIXEL_FORMAT_NV12;
2087 int codec_type = MM_IMAGE_CODEC_JPEG;
2088 int video_stabilization = 0;
2090 mm_camcorder_get_attributes(handle, NULL,
2091 MMCAM_CAMERA_WIDTH, &width,
2092 MMCAM_CAMERA_FORMAT, &preview_format,
2093 MMCAM_IMAGE_ENCODER, &codec_type,
2094 MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization,
2097 sc->info_video->preview_width = width;
2098 sc->info_video->preview_height = height;
2100 if (current_state == MM_CAMCORDER_STATE_PREPARE) {
2101 if (!pthread_mutex_trylock(&(hcamcorder->restart_preview_lock))) {
2102 _mmcam_dbg_log("restart preview");
2104 _mmcam_dbg_log("set empty buffers");
2106 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
2107 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
2109 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
2111 /* get preview format */
2112 sc->info_image->preview_format = preview_format;
2113 sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format);
2115 ret = _mmcamcorder_set_camera_resolution(handle, width, height);
2117 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
2118 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
2120 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
2123 pthread_mutex_unlock(&(hcamcorder->restart_preview_lock));
2125 _mmcam_dbg_err("currently locked for preview restart");
2129 /* get preview format */
2130 sc->info_image->preview_format = preview_format;
2131 sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format);
2132 ret = _mmcamcorder_set_camera_resolution(handle, width, height);
2140 bool _mmcamcorder_commit_video_size(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2142 int current_state = MM_CAMCORDER_STATE_NONE;
2143 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2145 mmf_return_val_if_fail(hcamcorder, FALSE);
2147 current_state = _mmcamcorder_get_state(handle);
2148 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2149 _mmcam_dbg_err("Video Resolution can't be changed.(state=%d)", current_state);
2152 _mmcam_dbg_warn("Video Resolution %d [attr_idx %d] ",
2153 value->value.i_val, attr_idx);
2159 bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2161 _MMCamcorderSubContext *sc = NULL;
2162 int current_state = MM_CAMCORDER_STATE_NONE;
2163 GstCameraControl *control = NULL;
2164 int zoom_level = value->value.i_val;
2167 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2172 _mmcam_dbg_log("(%d)", attr_idx);
2174 current_state = _mmcamcorder_get_state(handle);
2175 if (current_state < MM_CAMCORDER_STATE_READY) {
2176 _mmcam_dbg_log("will be applied when preview starts");
2178 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
2179 _mmcam_dbg_warn("Can not set while CAPTURING");
2183 if (attr_idx == MM_CAM_CAMERA_OPTICAL_ZOOM) {
2184 zoom_type = GST_CAMERA_CONTROL_OPTICAL_ZOOM;
2186 zoom_type = GST_CAMERA_CONTROL_DIGITAL_ZOOM;
2189 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2192 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2193 _mmcam_dbg_log("Can't cast Video source into camera control.");
2197 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2198 ret = gst_camera_control_set_zoom(control, zoom_type, zoom_level);
2200 _mmcam_dbg_log("Succeed in operating Zoom[%d].", zoom_level);
2203 _mmcam_dbg_warn("Failed to operate Zoom. Type[%d],Level[%d]", zoom_type, zoom_level);
2206 _mmcam_dbg_log("pointer of video src is null");
2213 bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2215 MMHandleType attr = 0;
2216 int current_state = MM_CAMCORDER_STATE_NONE;
2217 _MMCamcorderSubContext *sc = NULL;
2218 GstCameraControl *control = NULL;
2220 int set_focus_mode = 0;
2221 int cur_focus_mode = 0;
2222 int cur_focus_range = 0;
2224 attr = MMF_CAMCORDER_ATTRS(handle);
2225 mmf_return_val_if_fail(attr, FALSE);
2227 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2231 _mmcam_dbg_log("Focus mode(%d)", value->value.i_val);
2233 /* check whether set or not */
2234 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2235 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2239 current_state = _mmcamcorder_get_state(handle);
2240 if (current_state < MM_CAMCORDER_STATE_NULL) {
2241 _mmcam_dbg_log("Focus mode will be changed later.(state=%d)", current_state);
2245 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2246 int flags = MM_ATTRS_FLAG_NONE;
2247 MMCamAttrsInfo info;
2249 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2250 _mmcam_dbg_log("Can't cast Video source into camera control.");
2254 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2256 mslVal = value->value.i_val;
2257 set_focus_mode = _mmcamcorder_convert_msl_to_sensor( handle, attr_idx, mslVal );
2259 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_SCAN_RANGE, &info);
2262 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
2263 if (gst_camera_control_get_focus(control, &cur_focus_mode, &cur_focus_range)) {
2264 if (gst_camera_control_set_focus(control, set_focus_mode, cur_focus_range)) {
2265 _mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal);
2268 _mmcam_dbg_warn("Failed to set AF mode[%d]", mslVal);
2271 _mmcam_dbg_err("failed to get focus mode");
2276 _mmcam_dbg_log("pointer of video src is null");
2283 bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2285 _MMCamcorderSubContext *sc = NULL;
2286 GstCameraControl *control = NULL;
2287 int current_state = MM_CAMCORDER_STATE_NONE;
2290 int msl_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
2291 int converted_mode = 0;
2293 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2297 _mmcam_dbg_log("(%d)", attr_idx);
2299 /* check whether set or not */
2300 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2301 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2305 mslVal = value->value.i_val;
2306 newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal);
2308 current_state = _mmcamcorder_get_state(handle);
2309 if (current_state < MM_CAMCORDER_STATE_READY) {
2310 _mmcam_dbg_log("af scan range will be changed later.(state=%d)", current_state);
2314 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2315 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2316 _mmcam_dbg_log("Can't cast Video source into camera control.");
2320 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2322 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FOCUS_MODE, &msl_mode, NULL);
2323 converted_mode = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_CAMERA_FOCUS_MODE, msl_mode );
2325 if (gst_camera_control_set_focus(control, converted_mode, newVal)) {
2326 //_mmcam_dbg_log( "Succeed in setting AF mode[%d]", mslVal );
2329 _mmcam_dbg_warn( "Failed to set AF mode[%d]", mslVal );
2332 _mmcam_dbg_log("pointer of video src is null");
2337 bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2339 _MMCamcorderSubContext *sc = NULL;
2340 GstCameraControl *control = NULL;
2341 GstCameraControlRectType set_area = { 0, 0, 0, 0 }, get_area = { 0, 0, 0, 0 };
2343 int current_state = MM_CAMCORDER_STATE_NONE;
2345 int focus_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
2347 gboolean do_set = FALSE;
2349 MMCamAttrsInfo info_y, info_w, info_h;
2351 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2355 _mmcam_dbg_log("(%d)", attr_idx);
2357 current_state = _mmcamcorder_get_state( handle);
2359 if( current_state < MM_CAMCORDER_STATE_PREPARE )
2361 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2365 ret = mm_camcorder_get_attributes(handle, NULL,
2366 MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
2368 if( ret != MM_ERROR_NONE )
2370 _mmcam_dbg_warn( "Failed to get FOCUS MODE.[%x]", ret );
2374 if ((focus_mode != MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO ) && (focus_mode != MM_CAMCORDER_FOCUS_MODE_CONTINUOUS))
2376 _mmcam_dbg_warn( "Focus mode is NOT TOUCH AUTO or CONTINUOUS(current[%d]). return FALSE", focus_mode );
2380 if( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst )
2382 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst))
2384 _mmcam_dbg_log("Can't cast Video source into camera control.");
2390 case MM_CAM_CAMERA_AF_TOUCH_X:
2391 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_Y, &info_y);
2392 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_WIDTH, &info_w);
2393 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h);
2394 if( !( (info_y.flag|info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED) )
2396 set_area.x = value->value.i_val;
2397 mm_camcorder_get_attributes(handle, NULL,
2398 MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
2399 MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
2400 MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
2406 _mmcam_dbg_log( "Just store AF area[x:%d]", value->value.i_val );
2410 case MM_CAM_CAMERA_AF_TOUCH_Y:
2411 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_WIDTH, &info_w);
2412 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h);
2413 if( !( (info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED) )
2415 set_area.y = value->value.i_val;
2416 mm_camcorder_get_attributes(handle, NULL,
2417 MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
2418 MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
2419 MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
2425 _mmcam_dbg_log( "Just store AF area[y:%d]", value->value.i_val );
2429 case MM_CAM_CAMERA_AF_TOUCH_WIDTH:
2430 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h);
2431 if( !( info_h.flag & MM_ATTRS_FLAG_MODIFIED) )
2433 set_area.width = value->value.i_val;
2434 mm_camcorder_get_attributes(handle, NULL,
2435 MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
2436 MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
2437 MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
2443 _mmcam_dbg_log( "Just store AF area[width:%d]", value->value.i_val );
2447 case MM_CAM_CAMERA_AF_TOUCH_HEIGHT:
2448 set_area.height = value->value.i_val;
2449 mm_camcorder_get_attributes(handle, NULL,
2450 MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
2451 MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
2452 MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
2462 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2464 ret = gst_camera_control_get_auto_focus_area( control, &get_area );
2467 _mmcam_dbg_warn( "Failed to get AF area" );
2471 if( get_area.x == set_area.x && get_area.y == set_area.y )
2472 // width and height are not supported now.
2473 // get_area.width == set_area.width && get_area.height == set_area.height
2475 _mmcam_dbg_log( "No need to set AF area[x,y:%d,%d]", get_area.x, get_area.y );
2479 ret = gst_camera_control_set_auto_focus_area( control, set_area );
2482 _mmcam_dbg_log( "Succeed to set AF area[%d,%d,%dx%d]", set_area.x, set_area.y, set_area.width, set_area.height );
2487 _mmcam_dbg_warn( "Failed to set AF area[%d,%d,%dx%d]", set_area.x, set_area.y, set_area.width, set_area.height );
2493 _mmcam_dbg_log("pointer of video src is null");
2500 bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2502 GstCameraControl *control = NULL;
2503 int ivalue = value->value.i_val;
2504 int mslVal1 = 0, mslVal2 = 0;
2505 int newVal1 = 0, newVal2 = 0;
2506 int exposure_type = 0;
2507 int current_state = MM_CAMCORDER_STATE_NONE;
2508 _MMCamcorderSubContext *sc = NULL;
2510 int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
2511 gboolean check_scene_mode = FALSE;
2513 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2517 /* check whether set or not */
2518 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2519 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2523 current_state = _mmcamcorder_get_state( handle);
2524 if (current_state < MM_CAMCORDER_STATE_READY) {
2528 if (attr_idx == MM_CAM_CAMERA_F_NUMBER) {
2529 exposure_type = GST_CAMERA_CONTROL_F_NUMBER;
2530 mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
2531 mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
2532 } else if (attr_idx == MM_CAM_CAMERA_SHUTTER_SPEED) {
2533 exposure_type = GST_CAMERA_CONTROL_SHUTTER_SPEED;
2534 mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
2535 mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
2536 } else if (attr_idx == MM_CAM_CAMERA_ISO) {
2537 exposure_type = GST_CAMERA_CONTROL_ISO;
2539 newVal1 = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal1);
2540 check_scene_mode = TRUE;
2541 } else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_MODE) {
2542 exposure_type = GST_CAMERA_CONTROL_EXPOSURE_MODE;
2544 newVal1 = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal1);
2545 check_scene_mode = TRUE;
2546 } else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_VALUE) {
2547 exposure_type = GST_CAMERA_CONTROL_EXPOSURE_VALUE;
2548 mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
2549 mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
2552 if (check_scene_mode) {
2553 mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
2554 if (scene_mode != MM_CAMCORDER_SCENE_MODE_NORMAL) {
2555 _mmcam_dbg_warn("can not set [%d] when scene mode is NOT normal.", attr_idx);
2560 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2563 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2564 _mmcam_dbg_log("Can't cast Video source into camera control.");
2568 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2570 ret = gst_camera_control_set_exposure(control, exposure_type, newVal1, newVal2);
2572 _mmcam_dbg_log("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
2575 _mmcam_dbg_warn("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
2578 _mmcam_dbg_log("pointer of video src is null");
2585 bool _mmcamcorder_commit_camera_wdr (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2587 GstCameraControl *control = NULL;
2591 _MMCamcorderSubContext *sc = NULL;
2592 int current_state = MM_CAMCORDER_STATE_NONE;
2594 mmf_return_val_if_fail(handle && value, FALSE);
2596 /* check whether set or not */
2597 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2598 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2602 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2607 /* check current state */
2608 current_state = _mmcamcorder_get_state( handle);
2609 if (current_state < MM_CAMCORDER_STATE_READY) {
2610 _mmcam_dbg_log("will be applied when preview starts");
2612 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
2613 _mmcam_dbg_warn("Can not set while CAPTURING");
2617 mslVal = value->value.i_val;
2618 newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_WDR, mslVal);
2620 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2621 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2622 _mmcam_dbg_log("Can't cast Video source into camera control.");
2626 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2627 if (gst_camera_control_get_wdr(control, &cur_value)) {
2628 if (newVal != cur_value) {
2629 if (gst_camera_control_set_wdr(control, newVal)) {
2630 _mmcam_dbg_log( "Success - set wdr[%d]", mslVal );
2633 _mmcam_dbg_warn("Failed to set WDR. NewVal[%d],CurVal[%d]", newVal, cur_value);
2636 _mmcam_dbg_log( "No need to set new WDR. Current[%d]", mslVal );
2640 _mmcam_dbg_warn( "Failed to get WDR." );
2643 _mmcam_dbg_log("pointer of video src is null");
2650 bool _mmcamcorder_commit_camera_anti_handshake(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2652 int current_state = MM_CAMCORDER_STATE_NONE;
2654 /* check whether set or not */
2655 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2656 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2660 current_state = _mmcamcorder_get_state(handle);
2661 if (current_state < MM_CAMCORDER_STATE_READY) {
2662 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2664 } else if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2665 _mmcam_dbg_err("Invaild state (state %d)", current_state);
2669 return _mmcamcorder_set_videosrc_anti_shake(handle, value->value.i_val);
2673 bool _mmcamcorder_commit_camera_video_stabilization(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2675 int current_state = MM_CAMCORDER_STATE_NONE;
2677 current_state = _mmcamcorder_get_state(handle);
2678 if (current_state < MM_CAMCORDER_STATE_READY) {
2679 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2681 } else if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2682 _mmcam_dbg_err("Invaild state (state %d)", current_state);
2686 return _mmcamcorder_set_videosrc_stabilization(handle, value->value.i_val);
2690 bool _mmcamcorder_commit_camera_rotate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2692 int current_state = MM_CAMCORDER_STATE_NONE;
2694 _mmcam_dbg_log("rotate(%d)", value->value.i_val);
2696 current_state = _mmcamcorder_get_state(handle);
2698 if (current_state > MM_CAMCORDER_STATE_READY) {
2699 _mmcam_dbg_err("camera rotation setting failed.(state=%d)", current_state);
2702 return _mmcamcorder_set_videosrc_rotation(handle, value->value.i_val);
2707 bool _mmcamcorder_commit_image_encoder_quality(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2709 int current_state = MM_CAMCORDER_STATE_NONE;
2711 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2712 _MMCamcorderSubContext *sc = NULL;
2714 mmf_return_val_if_fail(handle, FALSE);
2717 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
2718 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
2722 /* check current state */
2723 current_state = _mmcamcorder_get_state(handle);
2724 if (current_state < MM_CAMCORDER_STATE_READY) {
2725 _mmcam_dbg_log("NOT initialized. this will be applied later");
2729 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2731 _mmcam_dbg_log("Image encoder quality(%d)", value->value.i_val);
2733 if (current_state == MM_CAMCORDER_STATE_PREPARE) {
2734 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-jpg-quality", value->value.i_val);
2737 _mmcam_dbg_err("invalid state %d", current_state);
2743 bool _mmcamcorder_commit_target_filename(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2745 _MMCamcorderSubContext *sc = NULL;
2746 const char * filename = NULL;
2749 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2755 filename = mmf_value_get_string(value, &size);
2757 if (sc->info_video) {
2758 if (sc->info_video->filename) {
2759 free(sc->info_video->filename);
2760 sc->info_video->filename = NULL;
2762 sc->info_video->filename = strdup(filename);
2763 if (sc->info_video->filename == NULL) {
2764 _mmcam_dbg_err("failed to strdup filename [%s]", filename);
2769 if (sc->encode_element && sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst) {
2770 _mmcam_dbg_log("new file location set.[%s] filesink %p", filename, sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst);
2771 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", filename);
2772 _mmcam_dbg_log("new file location set.(%s)", filename);
2774 _mmcam_dbg_log("element is not created yet. [%s] will be set later...", filename);
2783 bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2785 GstColorBalance *balance = NULL;
2786 GstColorBalanceChannel *Colorchannel = NULL;
2787 const GList *controls = NULL;
2788 const GList *item = NULL;
2791 int current_state = MM_CAMCORDER_STATE_NONE;
2792 const char *control_label = NULL;
2793 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2794 _MMCamcorderSubContext *sc = NULL;
2796 int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
2797 gboolean check_scene_mode = FALSE;
2799 if (hcamcorder == NULL) {
2800 _mmcam_dbg_log("handle is NULL");
2804 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2808 /* check whether set or not */
2809 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2810 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2814 current_state = _mmcamcorder_get_state(handle);
2815 if (current_state < MM_CAMCORDER_STATE_READY) {
2816 _mmcam_dbg_log("will be applied when preview starts");
2818 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
2819 _mmcam_dbg_warn("Can not set while CAPTURING");
2823 if (value->type != MM_ATTRS_TYPE_INT) {
2824 _mmcam_dbg_warn("Mismatched value type (%d)", value->type);
2827 mslNewVal = value->value.i_val;
2831 case MM_CAM_FILTER_BRIGHTNESS:
2832 control_label = "brightness";
2833 check_scene_mode = TRUE;
2836 case MM_CAM_FILTER_CONTRAST:
2837 control_label = "contrast";
2840 case MM_CAM_FILTER_WB:
2841 control_label = "white balance";
2842 check_scene_mode = TRUE;
2845 case MM_CAM_FILTER_COLOR_TONE:
2846 control_label = "color tone";
2849 case MM_CAM_FILTER_SATURATION:
2850 control_label = "saturation";
2851 check_scene_mode = TRUE;
2854 case MM_CAM_FILTER_HUE:
2855 control_label = "hue";
2858 case MM_CAM_FILTER_SHARPNESS:
2859 control_label = "sharpness";
2860 check_scene_mode = TRUE;
2863 _mmcam_dbg_err("unknown attribute index %d", attr_idx);
2867 if (check_scene_mode) {
2868 mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
2869 if (scene_mode != MM_CAMCORDER_SCENE_MODE_NORMAL) {
2870 _mmcam_dbg_warn("can not set %s when scene mode is NOT normal.", control_label);
2875 newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslNewVal);
2876 if (newVal == _MMCAMCORDER_SENSOR_ENUM_NONE) {
2880 _mmcam_dbg_log("label(%s): MSL(%d)->Sensor(%d)", control_label, mslNewVal, newVal);
2882 if (!GST_IS_COLOR_BALANCE(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2883 _mmcam_dbg_log("Can't cast Video source into color balance.");
2887 balance = GST_COLOR_BALANCE(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2888 controls = gst_color_balance_list_channels(balance);
2889 if (controls == NULL) {
2890 _mmcam_dbg_log("There is no list of colorbalance controls");
2894 for (item = controls ; item && item->data ; item = item->next) {
2895 Colorchannel = item->data;
2896 //_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label);
2898 if (!strcmp(Colorchannel->label, control_label)) {
2899 gst_color_balance_set_value (balance, Colorchannel, newVal);
2900 _mmcam_dbg_log("Set complete - %s[msl:%d,real:%d]", Colorchannel->label, mslNewVal, newVal);
2906 _mmcam_dbg_err("failed to find color channel item");
2914 bool _mmcamcorder_commit_filter_scene_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2916 GstCameraControl *control = NULL;
2917 int mslVal = value->value.i_val;
2918 int newVal = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_FILTER_SCENE_MODE, mslVal );
2919 _MMCamcorderSubContext *sc = NULL;
2920 int current_state = MM_CAMCORDER_STATE_NONE;
2922 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2926 /* check whether set or not */
2927 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2928 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2932 current_state = _mmcamcorder_get_state(handle);
2933 if (current_state < MM_CAMCORDER_STATE_READY) {
2934 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2938 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2941 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2942 _mmcam_dbg_log("Can't cast Video source into camera control.");
2946 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2947 ret = gst_camera_control_set_exposure(control, GST_CAMERA_CONTROL_PROGRAM_MODE, newVal, 0);
2949 _mmcam_dbg_log("Succeed in setting program mode[%d].", mslVal);
2951 if (mslVal == MM_CAMCORDER_SCENE_MODE_NORMAL) {
2955 , MM_CAM_FILTER_BRIGHTNESS
2957 , MM_CAM_FILTER_SATURATION
2958 , MM_CAM_FILTER_SHARPNESS
2959 , MM_CAM_FILTER_COLOR_TONE
2960 , MM_CAM_CAMERA_EXPOSURE_MODE
2962 mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
2964 for (i = 0 ; i < ARRAY_SIZE(attr_idxs) ; i++) {
2965 if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs[i])) {
2966 mmf_attribute_set_modified(&(attr->items[attr_idxs[i]]));
2973 _mmcam_dbg_log( "Failed to set program mode[%d].", mslVal );
2976 _mmcam_dbg_warn("pointer of video src is null");
2983 bool _mmcamcorder_commit_filter_flip (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2985 _mmcam_dbg_warn("Filter Flip(%d)", value->value.i_val);
2990 bool _mmcamcorder_commit_audio_input_route (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2992 _mmcam_dbg_log("Commit : Do nothing. this attr will be removed soon.");
2998 bool _mmcamcorder_commit_audio_disable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3000 int current_state = MM_CAMCORDER_STATE_NONE;
3002 current_state = _mmcamcorder_get_state(handle);
3003 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
3004 _mmcam_dbg_warn("Can NOT Disable AUDIO. invalid state %d", current_state);
3007 _mmcam_dbg_log("Disable AUDIO when Recording");
3013 bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3015 int current_state = MM_CAMCORDER_STATE_NONE;
3016 const char *videosink_name = NULL;
3017 void *p_handle = NULL;
3019 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3020 _MMCamcorderSubContext *sc = NULL;
3022 mmf_return_val_if_fail(handle, FALSE);
3025 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3026 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3030 /* check current state */
3031 current_state = _mmcamcorder_get_state(handle);
3032 if (current_state < MM_CAMCORDER_STATE_READY) {
3033 _mmcam_dbg_log("NOT initialized. this will be applied later");
3037 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3039 p_handle = value->value.p_val;
3041 /* get videosink name */
3042 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3043 _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
3045 if (!strcmp(videosink_name, "xvimagesink") ||
3046 !strcmp(videosink_name, "ximagesink")) {
3047 _mmcam_dbg_log("Commit : Set XID[%x]", *(int*)(p_handle));
3048 gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), *(int*)(p_handle));
3049 } else if (!strcmp(videosink_name, "evasimagesink") ||
3050 !strcmp(videosink_name, "evaspixmapsink")) {
3051 _mmcam_dbg_log("Commit : Set evas object [%p]", p_handle);
3052 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "evas-object", p_handle);
3054 _mmcam_dbg_warn("Commit : Nothing to commit with this element[%s]", videosink_name);
3058 _mmcam_dbg_warn("Display handle is NULL");
3066 bool _mmcamcorder_commit_display_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3068 int current_state = MM_CAMCORDER_STATE_NONE;
3069 const char *videosink_name = NULL;
3071 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3072 _MMCamcorderSubContext *sc = NULL;
3074 mmf_return_val_if_fail(handle, FALSE);
3077 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3078 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3082 /* check current state */
3083 current_state = _mmcamcorder_get_state(handle);
3084 if (current_state < MM_CAMCORDER_STATE_READY) {
3085 _mmcam_dbg_log("NOT initialized. this will be applied later");
3089 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3091 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3092 _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
3094 if (!strcmp(videosink_name, "xvimagesink")) {
3095 _mmcam_dbg_log("Commit : display mode [%d]", value->value.i_val);
3096 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-mode", value->value.i_val);
3099 _mmcam_dbg_warn("Commit : This element [%s] does not support display mode", videosink_name);
3105 bool _mmcamcorder_commit_display_rotation(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3107 int current_state = MM_CAMCORDER_STATE_NONE;
3109 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3111 mmf_return_val_if_fail(handle, FALSE);
3114 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3115 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3119 /* check current state */
3120 current_state = _mmcamcorder_get_state(handle);
3121 if (current_state < MM_CAMCORDER_STATE_READY) {
3122 _mmcam_dbg_log("NOT initialized. this will be applied later [rotate:%d]", value->value.i_val);
3126 return _mmcamcorder_set_display_rotation(handle, value->value.i_val);
3130 bool _mmcamcorder_commit_display_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3132 int current_state = MM_CAMCORDER_STATE_NONE;
3134 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3136 mmf_return_val_if_fail(handle, FALSE);
3139 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3140 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3144 /* check current state */
3145 current_state = _mmcamcorder_get_state(handle);
3146 if (current_state < MM_CAMCORDER_STATE_READY) {
3147 _mmcam_dbg_log("NOT initialized. this will be applied later [flip:%d]", value->value.i_val);
3151 return _mmcamcorder_set_display_flip(handle, value->value.i_val);
3155 bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3157 int current_state = MM_CAMCORDER_STATE_NONE;
3158 const char *videosink_name = NULL;
3160 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3161 _MMCamcorderSubContext *sc = NULL;
3163 mmf_return_val_if_fail(handle, FALSE);
3166 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3167 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3171 /* check current state */
3172 current_state = _mmcamcorder_get_state(handle);
3173 if (current_state < MM_CAMCORDER_STATE_READY) {
3174 _mmcam_dbg_log("NOT initialized. this will be applied later");
3178 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3180 /* Get videosink name */
3181 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3182 if (!strcmp(videosink_name, "xvimagesink") ||
3183 !strcmp(videosink_name, "evaspixmapsink")) {
3184 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "visible", value->value.i_val);
3185 _mmcam_dbg_log("Set visible [%d] done.", value->value.i_val);
3188 _mmcam_dbg_warn("videosink[%s] does not support VISIBLE.", videosink_name);
3194 bool _mmcamcorder_commit_display_geometry_method (MMHandleType handle, int attr_idx, const mmf_value_t *value)
3197 int current_state = MM_CAMCORDER_STATE_NONE;
3198 const char *videosink_name = NULL;
3200 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3201 _MMCamcorderSubContext *sc = NULL;
3203 mmf_return_val_if_fail(handle, FALSE);
3206 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3207 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3211 /* check current state */
3212 current_state = _mmcamcorder_get_state(handle);
3213 if (current_state < MM_CAMCORDER_STATE_READY) {
3214 _mmcam_dbg_log("NOT initialized. this will be applied later");
3218 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3220 /* Get videosink name */
3221 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3222 if (!strcmp(videosink_name, "xvimagesink") ||
3223 !strcmp(videosink_name, "evaspixmapsink")) {
3224 method = value->value.i_val;
3225 MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-geometry-method", method);
3228 _mmcam_dbg_warn("videosink[%s] does not support geometry method.", videosink_name);
3234 bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3236 int current_state = MM_CAMCORDER_STATE_NONE;
3238 const char *videosink_name = NULL;
3240 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3241 _MMCamcorderSubContext *sc = NULL;
3243 mmf_return_val_if_fail(handle, FALSE);
3246 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3247 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3251 /* check current state */
3252 current_state = _mmcamcorder_get_state(handle);
3253 if (current_state < MM_CAMCORDER_STATE_READY) {
3254 _mmcam_dbg_log("NOT initialized. this will be applied later");
3258 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3260 /* check current method */
3261 mm_camcorder_get_attributes(handle, NULL,
3262 MMCAM_DISPLAY_GEOMETRY_METHOD, &method,
3264 if (method != MM_DISPLAY_METHOD_CUSTOM_ROI) {
3265 _mmcam_dbg_log("current method[%d] is not supported rect", method);
3269 /* Get videosink name */
3270 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3271 if (!strcmp(videosink_name, "xvimagesink") ||
3272 !strcmp(videosink_name, "evaspixmapsink")) {
3276 int rect_height = 0;
3277 int flags = MM_ATTRS_FLAG_NONE;
3278 MMCamAttrsInfo info;
3280 mm_camcorder_get_attributes(handle, NULL,
3281 MMCAM_DISPLAY_RECT_X, &rect_x,
3282 MMCAM_DISPLAY_RECT_Y, &rect_y,
3283 MMCAM_DISPLAY_RECT_WIDTH, &rect_width,
3284 MMCAM_DISPLAY_RECT_HEIGHT, &rect_height,
3287 case MM_CAM_DISPLAY_RECT_X:
3288 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_Y, &info);
3290 memset(&info, 0x00, sizeof(info));
3291 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
3293 memset(&info, 0x00, sizeof(info));
3294 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
3297 rect_x = value->value.i_val;
3299 case MM_CAM_DISPLAY_RECT_Y:
3300 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
3302 memset(&info, 0x00, sizeof(info));
3303 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
3306 rect_y = value->value.i_val;
3308 case MM_CAM_DISPLAY_RECT_WIDTH:
3309 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
3312 rect_width = value->value.i_val;
3314 case MM_CAM_DISPLAY_RECT_HEIGHT:
3315 rect_height = value->value.i_val;
3318 _mmcam_dbg_err("Wrong attr_idx!");
3322 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
3323 _mmcam_dbg_log("RECT(x,y,w,h) = (%d,%d,%d,%d)",
3324 rect_x, rect_y, rect_width, rect_height);
3325 g_object_set(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
3326 "dst-roi-x", rect_x,
3327 "dst-roi-y", rect_y,
3328 "dst-roi-w", rect_width,
3329 "dst-roi-h", rect_height,
3335 _mmcam_dbg_warn("videosink[%s] does not support display rect.", videosink_name);
3341 bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3344 int current_state = MM_CAMCORDER_STATE_NONE;
3345 const char *videosink_name = NULL;
3346 GstElement *vs_element = NULL;
3348 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3349 _MMCamcorderSubContext *sc = NULL;
3351 mmf_return_val_if_fail(handle, FALSE);
3354 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3355 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3359 /* check current state */
3360 current_state = _mmcamcorder_get_state(handle);
3361 if (current_state < MM_CAMCORDER_STATE_READY) {
3362 _mmcam_dbg_log("NOT initialized. this will be applied later");
3366 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3368 /* Get videosink name */
3369 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3370 zoom = value->value.i_val;
3371 if (!strcmp(videosink_name, "xvimagesink")) {
3372 vs_element = sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst;
3374 MMCAMCORDER_G_OBJECT_SET(vs_element, "zoom", (float)(zoom + 1));
3375 _mmcam_dbg_log("Set display zoom to %d", zoom + 1);
3379 _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
3385 bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3387 int current_state = MM_CAMCORDER_STATE_NONE;
3389 const char *videosink_name = NULL;
3391 mmf_camcorder_t *hcamcorder= MMF_CAMCORDER( handle);
3392 _MMCamcorderSubContext *sc = NULL;
3394 mmf_return_val_if_fail(handle, FALSE);
3397 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3398 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3402 /* check current state */
3403 current_state = _mmcamcorder_get_state(handle);
3404 if (current_state < MM_CAMCORDER_STATE_READY) {
3405 _mmcam_dbg_log("NOT initialized. this will be applied later");
3409 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3411 do_scaling = value->value.i_val;
3413 /* Get videosink name */
3414 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3415 if (!strcmp(videosink_name, "evaspixmapsink")) {
3416 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "origin-size", !do_scaling);
3417 _mmcam_dbg_log("Set origin-size to %d", !(value->value.i_val));
3420 _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
3426 bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_value_t *value)
3429 _MMCamcorderSubContext *sc = NULL;
3430 int strobe_type, mslVal, newVal, cur_value;
3431 int current_state = MM_CAMCORDER_STATE_NONE;
3433 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3437 _mmcam_dbg_log( "Commit : strobe attribute(%d)", attr_idx );
3440 current_state = _mmcamcorder_get_state( handle);
3442 if (current_state < MM_CAMCORDER_STATE_READY) {
3443 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
3445 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
3446 _mmcam_dbg_warn("invalid state[capturing]");
3450 mslVal = value->value.i_val;
3453 case MM_CAM_STROBE_CONTROL:
3454 strobe_type = GST_CAMERA_CONTROL_STROBE_CONTROL;
3455 newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_CONTROL, mslVal);
3457 case MM_CAM_STROBE_CAPABILITIES:
3458 strobe_type = GST_CAMERA_CONTROL_STROBE_CAPABILITIES;
3461 case MM_CAM_STROBE_MODE:
3462 /* check whether set or not */
3463 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3464 _mmcam_dbg_log("skip set value %d", mslVal);
3468 strobe_type = GST_CAMERA_CONTROL_STROBE_MODE;
3469 newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_MODE, mslVal);
3472 _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
3476 GstCameraControl *control = NULL;
3477 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
3478 _mmcam_dbg_err("Can't cast Video source into camera control.");
3481 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3483 if (gst_camera_control_get_strobe(control, strobe_type, &cur_value)) {
3484 if (newVal != cur_value) {
3485 if (gst_camera_control_set_strobe(control, strobe_type, newVal)) {
3486 _mmcam_dbg_log("Succeed in setting strobe. Type[%d],value[%d]", strobe_type, mslVal);
3489 _mmcam_dbg_warn("Set strobe failed. Type[%d],value[%d]", strobe_type, mslVal);
3493 _mmcam_dbg_log("No need to set strobe. Type[%d],value[%d]", strobe_type, mslVal);
3497 _mmcam_dbg_warn("Failed to get strobe. Type[%d]", strobe_type);
3506 bool _mmcamcorder_commit_camera_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3509 int current_state = MM_CAMCORDER_STATE_NONE;
3511 if ((void *)handle == NULL) {
3512 _mmcam_dbg_warn("handle is NULL");
3516 _mmcam_dbg_log("Commit : flip %d", value->value.i_val);
3519 current_state = _mmcamcorder_get_state(handle);
3520 if (current_state > MM_CAMCORDER_STATE_READY) {
3521 _mmcam_dbg_err("Can not set camera FLIP horizontal at state %d", current_state);
3523 } else if (current_state < MM_CAMCORDER_STATE_READY) {
3524 _mmcam_dbg_log("Pipeline is not created yet. This will be set when create pipeline.");
3528 ret = _mmcamcorder_set_videosrc_flip(handle, value->value.i_val);
3530 _mmcam_dbg_log("ret %d", ret);
3536 bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3538 int set_hdr_mode = MM_CAMCORDER_HDR_OFF;
3539 int current_state = MM_CAMCORDER_STATE_NONE;
3540 _MMCamcorderSubContext *sc = NULL;
3542 if ((void *)handle == NULL) {
3543 _mmcam_dbg_warn("handle is NULL");
3547 _mmcam_dbg_log("Commit : HDR Capture %d", value->value.i_val);
3549 /* check whether set or not */
3550 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3551 _mmcam_dbg_log("skip set value %d", value->value.i_val);
3556 current_state = _mmcamcorder_get_state(handle);
3557 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
3558 _mmcam_dbg_err("can NOT set HDR capture at state %d", current_state);
3562 if (current_state >= MM_CAMCORDER_STATE_READY) {
3563 int current_value = 0;
3565 set_hdr_mode = value->value.i_val;
3566 mm_camcorder_get_attributes(handle, NULL,
3567 MMCAM_CAMERA_HDR_CAPTURE, ¤t_value,
3570 if (set_hdr_mode == current_value) {
3571 _mmcam_dbg_log("same HDR value : %d, do nothing", set_hdr_mode);
3575 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3577 if (current_state == MM_CAMCORDER_STATE_PREPARE) {
3578 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
3579 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
3581 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
3583 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
3584 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
3587 set_hdr_mode = value->value.i_val;
3588 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hdr-capture", set_hdr_mode);
3589 sc->info_image->hdr_capture_mode = set_hdr_mode;
3590 _mmcam_dbg_log("set HDR mode : %d", set_hdr_mode);
3592 if (current_state == MM_CAMCORDER_STATE_PREPARE) {
3593 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
3596 _mmcam_dbg_err("sc is NULL. can not set HDR capture");
3605 bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3608 _MMCamcorderSubContext *sc = NULL;
3609 int detect_type = GST_CAMERA_CONTROL_FACE_DETECT_MODE;
3611 int current_value = 0;
3612 int current_state = MM_CAMCORDER_STATE_NONE;
3613 GstCameraControl *control = NULL;
3615 if ((void *)handle == NULL) {
3616 _mmcam_dbg_warn("handle is NULL");
3620 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3625 _mmcam_dbg_log("Commit : detect attribute(%d)", attr_idx);
3628 current_state = _mmcamcorder_get_state( handle);
3629 if (current_state < MM_CAMCORDER_STATE_READY) {
3630 _mmcam_dbg_log("will be applied when preview starts");
3634 set_value = value->value.i_val;
3637 case MM_CAM_DETECT_MODE:
3638 /* check whether set or not */
3639 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3640 _mmcam_dbg_log("skip set value %d", set_value);
3644 detect_type = GST_CAMERA_CONTROL_FACE_DETECT_MODE;
3646 case MM_CAM_DETECT_NUMBER:
3647 detect_type = GST_CAMERA_CONTROL_FACE_DETECT_NUMBER;
3649 case MM_CAM_DETECT_FOCUS_SELECT:
3650 detect_type = GST_CAMERA_CONTROL_FACE_FOCUS_SELECT;
3652 case MM_CAM_DETECT_SELECT_NUMBER:
3653 detect_type = GST_CAMERA_CONTROL_FACE_SELECT_NUMBER;
3655 case MM_CAM_DETECT_STATUS:
3656 detect_type = GST_CAMERA_CONTROL_FACE_DETECT_STATUS;
3659 _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
3663 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
3664 _mmcam_dbg_err("Can't cast Video source into camera control.");
3667 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3669 if (gst_camera_control_get_detect(control, detect_type, ¤t_value)) {
3670 if (current_value == set_value) {
3671 _mmcam_dbg_log("No need to set detect(same). Type[%d],value[%d]", detect_type, set_value);
3674 if (!gst_camera_control_set_detect(control, detect_type, set_value)) {
3675 _mmcam_dbg_warn("Set detect failed. Type[%d],value[%d]",
3676 detect_type, set_value);
3679 _mmcam_dbg_log("Set detect success. Type[%d],value[%d]",
3680 detect_type, set_value);
3685 _mmcam_dbg_warn("Get detect failed. Type[%d]", detect_type);
3695 __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx)
3697 mmf_attrs_t *attr = (mmf_attrs_t*)handle;
3700 if (mm_attrs_get_flags(handle, idx, &flag) == MM_ERROR_NONE) {
3701 if (flag == MM_ATTRS_FLAG_NONE) {
3708 if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_RANGE) {
3710 mm_attrs_get_valid_range((MMHandleType)attr, idx, &min, &max);
3714 } else if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_ARRAY) {
3717 mm_attrs_get_valid_array((MMHandleType)attr, idx, &count, &array);
3728 _mmcamcorder_set_attribute_to_camsensor(MMHandleType handle)
3730 mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
3731 mmf_attrs_t *attr = NULL;
3733 int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
3735 unsigned int i = 0 ;
3737 int attr_idxs_default[] = {
3738 MM_CAM_CAMERA_DIGITAL_ZOOM
3739 , MM_CAM_CAMERA_OPTICAL_ZOOM
3741 , MM_CAM_FILTER_CONTRAST
3743 , MM_CAM_STROBE_MODE
3744 , MM_CAM_DETECT_MODE
3747 int attr_idxs_extra[] = {
3749 , MM_CAM_FILTER_BRIGHTNESS
3751 , MM_CAM_FILTER_SATURATION
3752 , MM_CAM_FILTER_SHARPNESS
3753 , MM_CAM_FILTER_COLOR_TONE
3754 , MM_CAM_CAMERA_EXPOSURE_MODE
3757 mmf_return_val_if_fail(hcamcorder, FALSE);
3759 _mmcam_dbg_log("Set all attribute again.");
3761 attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
3763 _mmcam_dbg_err("Get attribute handle failed.");
3766 /* Get Scene mode */
3767 mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
3769 _mmcam_dbg_log("attribute count(%d)", attr->count);
3771 for (i = 0 ; i < ARRAY_SIZE(attr_idxs_default) ; i++) {
3772 if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_default[i])) {
3773 mmf_attribute_set_modified(&(attr->items[attr_idxs_default[i]]));
3777 /* Set extra if scene mode is NORMAL */
3778 if (scene_mode == MM_CAMCORDER_SCENE_MODE_NORMAL) {
3779 for (i = 0 ; i < ARRAY_SIZE(attr_idxs_extra) ; i++) {
3780 if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_extra[i])) {
3781 mmf_attribute_set_modified(&(attr->items[attr_idxs_extra[i]]));
3785 /* Set scene mode if scene mode is NOT NORMAL */
3786 if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, MM_CAM_FILTER_SCENE_MODE)) {
3787 mmf_attribute_set_modified(&(attr->items[MM_CAM_FILTER_SCENE_MODE]));
3791 if (mmf_attrs_commit((MMHandleType)attr) == -1) {
3798 _mmcam_dbg_log("Done.");
3804 int _mmcamcorder_lock_readonly_attributes(MMHandleType handle)
3806 mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
3809 mmf_attrs_t *attr = NULL;
3810 int nerror = MM_ERROR_NONE ;
3812 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
3814 attr = (mmf_attrs_t*) MMF_CAMCORDER_ATTRS(handle);
3815 mmf_return_val_if_fail(attr, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3819 table_size = ARRAY_SIZE(readonly_attributes);
3820 _mmcam_dbg_log("%d", table_size);
3821 for (i = 0; i < table_size; i++)
3823 int sCategory = readonly_attributes[i];
3825 mmf_attribute_set_readonly(&(attr->items[sCategory]));
3832 int _mmcamcorder_set_disabled_attributes(MMHandleType handle)
3834 mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
3835 //int table_size = 0;
3837 mmf_attrs_t *attr = NULL;
3838 type_string_array * disabled_attr = NULL;
3840 int nerror = MM_ERROR_NONE ;
3842 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
3844 attr = (mmf_attrs_t*) MMF_CAMCORDER_ATTRS(handle);
3845 mmf_return_val_if_fail(attr, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3850 _mmcamcorder_conf_get_value_string_array(hcamcorder->conf_main,
3851 CONFIGURE_CATEGORY_MAIN_GENERAL,
3852 "DisabledAttributes",
3854 if (disabled_attr != NULL && disabled_attr->value) {
3855 cnt_str = disabled_attr->count;
3856 for (i = 0; i < cnt_str; i++) {
3858 _mmcam_dbg_log("[%d]%s", i, disabled_attr->value[i] );
3859 nerror = mm_attrs_get_index((MMHandleType)attr, disabled_attr->value[i], &idx);
3860 if (nerror == MM_ERROR_NONE) {
3861 mmf_attribute_set_disabled(&(attr->items[idx]));
3863 _mmcam_dbg_warn("No ATTR named %s[%d]",disabled_attr->value[i], i);
3872 /*---------------------------------------------------------------------------------------
3873 | INTERNAL FUNCTION DEFINITIONS: |
3874 ---------------------------------------------------------------------------------------*/
3875 static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width, int height)
3877 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3878 _MMCamcorderSubContext *sc = NULL;
3879 int current_state = MM_CAMCORDER_STATE_NULL;
3881 mmf_return_val_if_fail(hcamcorder, FALSE);
3883 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3888 current_state = _mmcamcorder_get_state(handle);
3890 if (sc->element && sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
3891 if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
3892 _mmcam_dbg_log("set capture width and height [%dx%d] to camera plugin", width, height);
3893 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-width", width);
3894 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-height", height);
3896 _mmcam_dbg_warn("invalid state[%d]", current_state);
3900 _mmcam_dbg_log("element is not created yet");
3908 __mmcamcorder_check_valid_pair( MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args )
3910 #define INIT_VALUE -1
3911 #define CHECK_COUNT 3
3913 mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
3914 MMHandleType attrs = 0;
3916 int ret = MM_ERROR_NONE;
3918 const char *name = NULL;
3919 const char *check_pair_name[CHECK_COUNT][3] = {
3920 {MMCAM_CAMERA_WIDTH, MMCAM_CAMERA_HEIGHT, "MMCAM_CAMERA_WIDTH and HEIGHT"},
3921 {MMCAM_CAPTURE_WIDTH, MMCAM_CAPTURE_HEIGHT, "MMCAM_CAPTURE_WIDTH and HEIGHT"},
3922 {MMCAM_VIDEO_WIDTH, MMCAM_VIDEO_HEIGHT, "MMCAM_VIDEO_WIDTH and HEIGHT"},
3925 int check_pair_value[CHECK_COUNT][2] = {
3926 {INIT_VALUE, INIT_VALUE},
3927 {INIT_VALUE, INIT_VALUE},
3928 {INIT_VALUE, INIT_VALUE},
3931 if (hcamcorder == NULL || attribute_name == NULL) {
3932 _mmcam_dbg_warn("handle[%p] or attribute_name[%p] is NULL.",
3933 hcamcorder, attribute_name );
3934 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
3937 if (err_attr_name) {
3938 *err_attr_name = NULL;
3941 //_mmcam_dbg_log( "ENTER" );
3943 attrs = MMF_CAMCORDER_ATTRS(handle);
3945 name = attribute_name;
3949 MMAttrsType attr_type = MM_ATTRS_TYPE_INVALID;
3951 /*_mmcam_dbg_log("NAME : %s", name);*/
3953 /* attribute name check */
3954 if ((ret = mm_attrs_get_index(attrs, name, &idx)) != MM_ERROR_NONE) {
3955 if (err_attr_name) {
3956 *err_attr_name = strdup(name);
3959 if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY) { //to avoid confusing
3960 return MM_ERROR_COMMON_ATTR_NOT_EXIST;
3967 if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE) {
3971 switch (attr_type) {
3972 case MM_ATTRS_TYPE_INT:
3974 gboolean matched = FALSE;
3975 for (i = 0 ; i < CHECK_COUNT ; i++) {
3976 for (j = 0 ; j < 2 ; j++) {
3977 if (!strcmp(name, check_pair_name[i][j])) {
3978 check_pair_value[i][j] = va_arg((var_args), int);
3979 _mmcam_dbg_log("%s : %d", check_pair_name[i][j], check_pair_value[i][j]);
3988 if (matched == FALSE) {
3989 va_arg((var_args), int);
3993 case MM_ATTRS_TYPE_DOUBLE:
3994 va_arg((var_args), double);
3996 case MM_ATTRS_TYPE_STRING:
3997 va_arg((var_args), char*); /* string */
3998 va_arg((var_args), int); /* size */
4000 case MM_ATTRS_TYPE_DATA:
4001 va_arg((var_args), void*); /* data */
4002 va_arg((var_args), int); /* size */
4004 case MM_ATTRS_TYPE_INVALID:
4006 _mmcam_dbg_err("Not supported attribute type(%d, name:%s)", attr_type, name);
4007 if (err_attr_name) {
4008 *err_attr_name = strdup(name);
4010 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
4014 name = va_arg(var_args, const char*);
4017 for (i = 0 ; i < CHECK_COUNT ; i++) {
4018 if (check_pair_value[i][0] != INIT_VALUE || check_pair_value[i][1] != INIT_VALUE) {
4019 gboolean check_result = FALSE;
4020 char *err_name = NULL;
4021 MMCamAttrsInfo attr_info_0, attr_info_1;
4023 if (check_pair_value[i][0] == INIT_VALUE) {
4024 mm_attrs_get_int_by_name(attrs, check_pair_name[i][0], &check_pair_value[i][0]);
4025 err_name = strdup(check_pair_name[i][1]);
4026 } else if (check_pair_value[i][1] == INIT_VALUE) {
4027 mm_attrs_get_int_by_name(attrs, check_pair_name[i][1], &check_pair_value[i][1]);
4028 err_name = strdup(check_pair_name[i][0]);
4030 err_name = strdup(check_pair_name[i][2]);
4033 mm_camcorder_get_attribute_info(handle, check_pair_name[i][0], &attr_info_0);
4034 mm_camcorder_get_attribute_info(handle, check_pair_name[i][1], &attr_info_1);
4036 check_result = FALSE;
4038 for( j = 0 ; j < attr_info_0.int_array.count ; j++ ) {
4039 if (attr_info_0.int_array.array[j] == check_pair_value[i][0] &&
4040 attr_info_1.int_array.array[j] == check_pair_value[i][1]) {
4042 _mmcam_dbg_log("Valid Pair[%s,%s] existed %dx%d[index:%d]",
4043 check_pair_name[i][0], check_pair_name[i][1],
4044 check_pair_value[i][0], check_pair_value[i][1], i);
4046 check_result = TRUE;
4051 if (check_result == FALSE) {
4052 _mmcam_dbg_err("INVALID pair[%s,%s] %dx%d",
4053 check_pair_name[i][0], check_pair_name[i][1],
4054 check_pair_value[i][0], check_pair_value[i][1]);
4055 if (err_attr_name) {
4056 *err_attr_name = err_name;
4064 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
4074 /*_mmcam_dbg_log("DONE");*/
4076 return MM_ERROR_NONE;
4080 bool _mmcamcorder_check_supported_attribute(MMHandleType handle, int attr_index)
4084 if ((void *)handle == NULL) {
4085 _mmcam_dbg_warn("handle %p is NULL", handle);
4089 memset(&info, 0x0, sizeof(MMAttrsInfo));
4091 mm_attrs_get_info(MMF_CAMCORDER_ATTRS(handle), attr_index, &info);
4093 switch (info.validity_type) {
4094 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
4095 _mmcam_dbg_log("int array count %d", info.int_array.count)
4096 if (info.int_array.count <= 1) {
4100 case MM_ATTRS_VALID_TYPE_INT_RANGE:
4101 _mmcam_dbg_log("int range min %d, max %d",info.int_range.min, info.int_range.max);
4102 if (info.int_range.min >= info.int_range.max) {
4106 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
4107 _mmcam_dbg_log("double array count %d", info.double_array.count)
4108 if (info.double_array.count <= 1) {
4112 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
4113 _mmcam_dbg_log("double range min %lf, max %lf",info.int_range.min, info.int_range.max);
4114 if (info.double_range.min >= info.double_range.max) {
4119 _mmcam_dbg_warn("invalid type %d", info.validity_type);