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
38 #define MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_BITRATE (1024*1024*10)
39 #define MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_GOP_INTERVAL 1000
40 #define MMCAMCORDER_DEFAULT_REPLAY_GAIN_REFERENCE_LEVEL 89.0
42 /*---------------------------------------------------------------------------------------
43 | GLOBAL VARIABLE DEFINITIONS for internal |
44 ---------------------------------------------------------------------------------------*/
46 /*-----------------------------------------------------------------------
47 | LOCAL VARIABLE DEFINITIONS for internal |
48 -----------------------------------------------------------------------*/
49 /* Readonly attributes list.
50 * If you want to make some attributes read only, write down here.
51 * It will make them read only after composing whole attributes.
54 static int readonly_attributes[] = {
55 MM_CAM_CAMERA_DEVICE_COUNT,
56 MM_CAM_CAMERA_DEVICE_NAME,
57 MM_CAM_CAMERA_FACING_DIRECTION,
58 MM_CAM_CAMERA_SHUTTER_SPEED,
59 MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE,
60 MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING,
61 MM_CAM_CAPTURED_SCREENNAIL,
62 MM_CAM_RECOMMEND_DISPLAY_ROTATION,
63 MM_CAM_SUPPORT_ZSL_CAPTURE,
64 MM_CAM_SUPPORT_ZERO_COPY_FORMAT,
65 MM_CAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB
68 /*-----------------------------------------------------------------------
69 | LOCAL FUNCTION PROTOTYPES: |
70 -----------------------------------------------------------------------*/
71 /* STATIC INTERNAL FUNCTION */
72 static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width, int height);
73 static int __mmcamcorder_set_conf_to_valid_info(MMHandleType handle);
74 static int __mmcamcorder_release_conf_valid_info(MMHandleType handle);
75 static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args);
77 /*=======================================================================
78 | FUNCTION DEFINITIONS |
79 =======================================================================*/
80 /*-----------------------------------------------------------------------
81 | GLOBAL FUNCTION DEFINITIONS: |
82 -----------------------------------------------------------------------*/
84 _mmcamcorder_alloc_attribute(MMHandleType handle)
88 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
89 MMHandleType attrs = 0;
90 mmf_attrs_construct_info_t *attrs_const_info = NULL;
91 unsigned int attr_count = 0;
94 static int depth[] = {MM_CAMCORDER_AUDIO_FORMAT_PCM_U8, MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE};
95 static int flip_list[] = { MM_FLIP_NONE };
96 static int rotation_list[] = { MM_VIDEO_INPUT_ROTATION_NONE };
97 static int visible_values[] = { 0, 1 }; /*0: off, 1:on*/
98 static int tag_orientation_values[] = {
99 1, /*The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side.*/
100 2, /*the 0th row is at the visual top of the image, and the 0th column is the visual right-hand side.*/
101 3, /*the 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side.*/
102 4, /*the 0th row is at the visual bottom of the image, and the 0th column is the visual left-hand side.*/
103 5, /*the 0th row is the visual left-hand side of the image, and the 0th column is the visual top.*/
104 6, /*the 0th row is the visual right-hand side of the image, and the 0th column is the visual top.*/
105 7, /*the 0th row is the visual right-hand side of the image, and the 0th column is the visual bottom.*/
106 8, /*the 0th row is the visual left-hand side of the image, and the 0th column is the visual bottom.*/
109 if (hcamcorder == NULL) {
110 _mmcam_dbg_err("handle is NULL");
114 /* Create attribute constructor */
115 _mmcam_dbg_log("start");
117 /* alloc 'mmf_attrs_construct_info_t' */
118 attr_count = MM_CAM_ATTRIBUTE_NUM;
119 attrs_const_info = malloc(attr_count * sizeof(mmf_attrs_construct_info_t));
120 if (!attrs_const_info) {
121 _mmcam_dbg_err("Fail to alloc constructor.");
125 /* alloc default attribute info */
126 hcamcorder->cam_attrs_const_info = (mm_cam_attr_construct_info *)malloc(sizeof(mm_cam_attr_construct_info) * attr_count);
127 if (hcamcorder->cam_attrs_const_info == NULL) {
128 _mmcam_dbg_err("failed to alloc default attribute info");
129 free(attrs_const_info);
130 attrs_const_info = NULL;
134 /* basic attributes' info */
135 mm_cam_attr_construct_info temp_info[] = {
138 MM_CAM_MODE, /* ID */
140 MMF_VALUE_TYPE_INT, /* Type */
141 MM_ATTRS_FLAG_RW, /* Flag */
142 {(void*)MM_CAMCORDER_MODE_VIDEO_CAPTURE}, /* Default value */
143 MM_ATTRS_VALID_TYPE_INT_RANGE, /* Validity type */
144 {.int_min = MM_CAMCORDER_MODE_VIDEO_CAPTURE}, /* Validity val1 (min, *array,...) */
145 {.int_max = MM_CAMCORDER_MODE_AUDIO}, /* Validity val2 (max, count, ...) */
146 NULL, /* Runtime setting function of the attribute */
153 {(void*)MM_AUDIO_DEVICE_MIC},
154 MM_ATTRS_VALID_TYPE_INT_ARRAY,
160 MM_CAM_CAMERA_DEVICE_COUNT,
161 "camera-device-count",
164 {(void*)MM_VIDEO_DEVICE_NUM},
165 MM_ATTRS_VALID_TYPE_INT_RANGE,
166 {.int_min = MM_VIDEO_DEVICE_NONE},
167 {.int_max = MM_VIDEO_DEVICE_NUM},
171 MM_CAM_AUDIO_ENCODER,
175 {(void*)MM_AUDIO_CODEC_AMR},
176 MM_ATTRS_VALID_TYPE_INT_ARRAY,
182 MM_CAM_VIDEO_ENCODER,
186 {(void*)MM_VIDEO_CODEC_MPEG4},
187 MM_ATTRS_VALID_TYPE_INT_ARRAY,
193 MM_CAM_IMAGE_ENCODER,
197 {(void*)MM_IMAGE_CODEC_JPEG},
198 MM_ATTRS_VALID_TYPE_INT_ARRAY,
208 {(void*)MM_FILE_FORMAT_MP4},
209 MM_ATTRS_VALID_TYPE_INT_ARRAY,
215 MM_CAM_CAMERA_DEVICE_NAME,
216 "camera-device-name",
217 MMF_VALUE_TYPE_STRING,
220 MM_ATTRS_VALID_TYPE_NONE,
226 MM_CAM_AUDIO_SAMPLERATE,
231 MM_ATTRS_VALID_TYPE_INT_RANGE,
233 {.int_max = _MMCAMCORDER_MAX_INT},
241 {(void*)MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE},
242 MM_ATTRS_VALID_TYPE_INT_ARRAY,
249 MM_CAM_AUDIO_CHANNEL,
254 MM_ATTRS_VALID_TYPE_INT_RANGE,
262 MMF_VALUE_TYPE_DOUBLE,
264 {.value_double = 1.0},
265 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
267 {.double_max = 10.0},
268 _mmcamcorder_commit_audio_volume,
271 MM_CAM_AUDIO_INPUT_ROUTE,
275 {(void*)MM_AUDIOROUTE_USE_EXTERNAL_SETTING},
276 MM_ATTRS_VALID_TYPE_INT_RANGE,
277 {.int_min = MM_AUDIOROUTE_USE_EXTERNAL_SETTING},
278 {.int_max = MM_AUDIOROUTE_CAPTURE_STEREOMIC_ONLY},
279 _mmcamcorder_commit_audio_input_route,
282 MM_CAM_FILTER_SCENE_MODE,
287 MM_ATTRS_VALID_TYPE_INT_ARRAY,
290 _mmcamcorder_commit_filter_scene_mode,
293 MM_CAM_FILTER_BRIGHTNESS,
298 MM_ATTRS_VALID_TYPE_INT_RANGE,
301 _mmcamcorder_commit_filter,
304 MM_CAM_FILTER_CONTRAST,
309 MM_ATTRS_VALID_TYPE_INT_RANGE,
312 _mmcamcorder_commit_filter,
320 MM_ATTRS_VALID_TYPE_INT_ARRAY,
323 _mmcamcorder_commit_filter,
326 MM_CAM_FILTER_COLOR_TONE,
331 MM_ATTRS_VALID_TYPE_INT_ARRAY,
334 _mmcamcorder_commit_filter,
337 MM_CAM_FILTER_SATURATION,
342 MM_ATTRS_VALID_TYPE_INT_RANGE,
345 _mmcamcorder_commit_filter,
353 MM_ATTRS_VALID_TYPE_INT_RANGE,
356 _mmcamcorder_commit_filter,
360 MM_CAM_FILTER_SHARPNESS,
365 MM_ATTRS_VALID_TYPE_INT_RANGE,
368 _mmcamcorder_commit_filter,
371 MM_CAM_CAMERA_FORMAT,
375 {(void*)MM_PIXEL_FORMAT_YUYV},
376 MM_ATTRS_VALID_TYPE_INT_ARRAY,
379 _mmcamcorder_commit_camera_format,
382 MM_CAM_CAMERA_RECORDING_MOTION_RATE,
383 "camera-recording-motion-rate",
384 MMF_VALUE_TYPE_DOUBLE,
386 {.value_double = 1.0},
387 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
389 {.double_max = _MMCAMCORDER_MAX_DOUBLE},
390 _mmcamcorder_commit_camera_recording_motion_rate,
398 MM_ATTRS_VALID_TYPE_INT_RANGE,
401 _mmcamcorder_commit_camera_fps,
408 {(void*)MMCAMCORDER_DEFAULT_CAMERA_WIDTH},
409 MM_ATTRS_VALID_TYPE_INT_ARRAY,
412 _mmcamcorder_commit_camera_width,
415 MM_CAM_CAMERA_HEIGHT,
419 {(void*)MMCAMCORDER_DEFAULT_CAMERA_HEIGHT},
420 MM_ATTRS_VALID_TYPE_INT_ARRAY,
423 _mmcamcorder_commit_camera_height,
426 MM_CAM_CAMERA_DIGITAL_ZOOM,
427 "camera-digital-zoom",
431 MM_ATTRS_VALID_TYPE_INT_RANGE,
434 _mmcamcorder_commit_camera_zoom,
437 MM_CAM_CAMERA_OPTICAL_ZOOM,
438 "camera-optical-zoom",
442 MM_ATTRS_VALID_TYPE_INT_RANGE,
445 _mmcamcorder_commit_camera_zoom,
448 MM_CAM_CAMERA_FOCUS_MODE,
452 {(void*)MM_CAMCORDER_FOCUS_MODE_NONE},
453 MM_ATTRS_VALID_TYPE_INT_ARRAY,
456 _mmcamcorder_commit_camera_focus_mode,
459 MM_CAM_CAMERA_AF_SCAN_RANGE,
460 "camera-af-scan-range",
464 MM_ATTRS_VALID_TYPE_INT_ARRAY,
467 _mmcamcorder_commit_camera_af_scan_range,
471 MM_CAM_CAMERA_EXPOSURE_MODE,
472 "camera-exposure-mode",
476 MM_ATTRS_VALID_TYPE_INT_ARRAY,
479 _mmcamcorder_commit_camera_capture_mode,
482 MM_CAM_CAMERA_EXPOSURE_VALUE,
483 "camera-exposure-value",
487 MM_ATTRS_VALID_TYPE_INT_RANGE,
490 _mmcamcorder_commit_camera_capture_mode,
493 MM_CAM_CAMERA_F_NUMBER,
498 MM_ATTRS_VALID_TYPE_INT_ARRAY,
501 _mmcamcorder_commit_camera_capture_mode,
504 MM_CAM_CAMERA_SHUTTER_SPEED,
505 "camera-shutter-speed",
509 MM_ATTRS_VALID_TYPE_INT_ARRAY,
512 _mmcamcorder_commit_camera_capture_mode,
520 MM_ATTRS_VALID_TYPE_INT_ARRAY,
523 _mmcamcorder_commit_camera_capture_mode,
531 MM_ATTRS_VALID_TYPE_INT_ARRAY,
534 _mmcamcorder_commit_camera_wdr,
537 MM_CAM_CAMERA_ANTI_HANDSHAKE,
538 "camera-anti-handshake",
542 MM_ATTRS_VALID_TYPE_INT_ARRAY,
545 _mmcamcorder_commit_camera_anti_handshake,
548 MM_CAM_CAMERA_FPS_AUTO,
553 MM_ATTRS_VALID_TYPE_INT_RANGE,
556 _mmcamcorder_commit_camera_fps,
559 MM_CAM_CAMERA_DELAY_ATTR_SETTING,
560 "camera-delay-attr-setting",
564 MM_ATTRS_VALID_TYPE_INT_RANGE,
570 MM_CAM_AUDIO_ENCODER_BITRATE,
571 "audio-encoder-bitrate",
575 MM_ATTRS_VALID_TYPE_INT_RANGE,
577 {.int_max = _MMCAMCORDER_MAX_INT},
578 _mmcamcorder_commit_encoder_bitrate,
582 MM_CAM_VIDEO_ENCODER_BITRATE,
583 "video-encoder-bitrate",
587 MM_ATTRS_VALID_TYPE_INT_RANGE,
589 {.int_max = _MMCAMCORDER_MAX_INT},
590 _mmcamcorder_commit_encoder_bitrate,
593 MM_CAM_IMAGE_ENCODER_QUALITY,
594 "image-encoder-quality",
598 MM_ATTRS_VALID_TYPE_INT_RANGE,
601 _mmcamcorder_commit_image_encoder_quality,
604 MM_CAM_CAPTURE_FORMAT,
608 {(void*)MM_PIXEL_FORMAT_ENCODED},
609 MM_ATTRS_VALID_TYPE_INT_ARRAY,
615 MM_CAM_CAPTURE_WIDTH,
620 MM_ATTRS_VALID_TYPE_INT_ARRAY,
623 _mmcamcorder_commit_capture_width ,
626 MM_CAM_CAPTURE_HEIGHT,
631 MM_ATTRS_VALID_TYPE_INT_ARRAY,
634 _mmcamcorder_commit_capture_height,
637 MM_CAM_CAPTURE_COUNT,
642 MM_ATTRS_VALID_TYPE_INT_RANGE,
645 _mmcamcorder_commit_capture_count,
648 MM_CAM_CAPTURE_INTERVAL,
653 MM_ATTRS_VALID_TYPE_INT_RANGE,
655 {.int_max = _MMCAMCORDER_MAX_INT},
659 MM_CAM_CAPTURE_BREAK_CONTINUOUS_SHOT,
660 "capture-break-cont-shot",
664 MM_ATTRS_VALID_TYPE_INT_RANGE,
667 _mmcamcorder_commit_capture_break_cont_shot,
670 MM_CAM_DISPLAY_HANDLE,
675 MM_ATTRS_VALID_TYPE_NONE,
678 _mmcamcorder_commit_display_handle,
681 MM_CAM_DISPLAY_DEVICE,
685 {(void*)MM_DISPLAY_DEVICE_MAINLCD},
686 MM_ATTRS_VALID_TYPE_INT_ARRAY,
693 MM_CAM_DISPLAY_SURFACE,
697 {(void*)MM_DISPLAY_SURFACE_OVERLAY},
698 MM_ATTRS_VALID_TYPE_INT_ARRAY,
704 MM_CAM_DISPLAY_RECT_X,
709 MM_ATTRS_VALID_TYPE_INT_RANGE,
711 {.int_max = _MMCAMCORDER_MAX_INT},
712 _mmcamcorder_commit_display_rect,
715 MM_CAM_DISPLAY_RECT_Y,
720 MM_ATTRS_VALID_TYPE_INT_RANGE,
722 {.int_max = _MMCAMCORDER_MAX_INT},
723 _mmcamcorder_commit_display_rect,
726 MM_CAM_DISPLAY_RECT_WIDTH,
727 "display-rect-width",
731 MM_ATTRS_VALID_TYPE_INT_RANGE,
733 {.int_max = _MMCAMCORDER_MAX_INT},
734 _mmcamcorder_commit_display_rect,
737 MM_CAM_DISPLAY_RECT_HEIGHT,
738 "display-rect-height",
742 MM_ATTRS_VALID_TYPE_INT_RANGE,
744 {.int_max = _MMCAMCORDER_MAX_INT},
745 _mmcamcorder_commit_display_rect,
748 MM_CAM_DISPLAY_SOURCE_X,
753 MM_ATTRS_VALID_TYPE_INT_RANGE,
755 {.int_max = _MMCAMCORDER_MAX_INT},
759 MM_CAM_DISPLAY_SOURCE_Y,
764 MM_ATTRS_VALID_TYPE_INT_RANGE,
766 {.int_max = _MMCAMCORDER_MAX_INT},
770 MM_CAM_DISPLAY_SOURCE_WIDTH,
775 MM_ATTRS_VALID_TYPE_INT_RANGE,
777 {.int_max = _MMCAMCORDER_MAX_INT},
781 MM_CAM_DISPLAY_SOURCE_HEIGHT,
782 "display-src-height",
786 MM_ATTRS_VALID_TYPE_INT_RANGE,
788 {.int_max = _MMCAMCORDER_MAX_INT},
792 MM_CAM_DISPLAY_ROTATION,
796 {(void*)MM_DISPLAY_ROTATION_NONE},
797 MM_ATTRS_VALID_TYPE_INT_RANGE,
798 {.int_min = MM_DISPLAY_ROTATION_NONE},
799 {.int_max = MM_DISPLAY_ROTATION_270},
800 _mmcamcorder_commit_display_rotation,
804 MM_CAM_DISPLAY_VISIBLE,
809 MM_ATTRS_VALID_TYPE_INT_ARRAY,
811 {ARRAY_SIZE(visible_values)},
812 _mmcamcorder_commit_display_visible,
815 MM_CAM_DISPLAY_SCALE,
820 MM_ATTRS_VALID_TYPE_INT_RANGE,
821 {.int_min = MM_DISPLAY_SCALE_DEFAULT},
822 {.int_max = MM_DISPLAY_SCALE_TRIPLE_LENGTH},
823 _mmcamcorder_commit_display_scale,
826 MM_CAM_DISPLAY_GEOMETRY_METHOD,
827 "display-geometry-method",
831 MM_ATTRS_VALID_TYPE_INT_RANGE,
832 {.int_min = MM_DISPLAY_METHOD_LETTER_BOX},
833 {.int_max = MM_DISPLAY_METHOD_CUSTOM_ROI},
834 _mmcamcorder_commit_display_geometry_method,
837 MM_CAM_TARGET_FILENAME,
839 MMF_VALUE_TYPE_STRING,
842 MM_ATTRS_VALID_TYPE_NONE,
845 _mmcamcorder_commit_target_filename,
848 MM_CAM_TARGET_MAX_SIZE,
853 MM_ATTRS_VALID_TYPE_INT_RANGE,
855 {.int_max = _MMCAMCORDER_MAX_INT},
856 _mmcamcorder_commit_recording_max_limit,
859 MM_CAM_TARGET_TIME_LIMIT,
864 MM_ATTRS_VALID_TYPE_INT_RANGE,
866 {.int_max = _MMCAMCORDER_MAX_INT},
867 _mmcamcorder_commit_recording_max_limit,
875 MM_ATTRS_VALID_TYPE_INT_RANGE,
878 _mmcamcorder_commit_tag,
881 MM_CAM_TAG_IMAGE_DESCRIPTION,
882 "tag-image-description",
883 MMF_VALUE_TYPE_STRING,
886 MM_ATTRS_VALID_TYPE_NONE,
889 _mmcamcorder_commit_tag,
892 MM_CAM_TAG_ORIENTATION,
897 MM_ATTRS_VALID_TYPE_INT_ARRAY,
898 {tag_orientation_values},
899 {ARRAY_SIZE(tag_orientation_values)},
900 _mmcamcorder_commit_tag,
905 MMF_VALUE_TYPE_STRING,
908 MM_ATTRS_VALID_TYPE_NONE,
911 _mmcamcorder_commit_tag,
917 MMF_VALUE_TYPE_DOUBLE,
919 {.value_double = 0.0},
920 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
921 {.double_min = -360.0},
922 {.double_max = 360.0},
923 _mmcamcorder_commit_tag,
926 MM_CAM_TAG_LONGITUDE,
928 MMF_VALUE_TYPE_DOUBLE,
930 {.value_double = 0.0},
931 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
932 {.double_min = -360.0},
933 {.double_max = 360.0},
934 _mmcamcorder_commit_tag,
939 MMF_VALUE_TYPE_DOUBLE,
941 {.value_double = 0.0},
942 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
943 {.double_min = -999999.0},
944 {.double_max = 999999.0},
945 _mmcamcorder_commit_tag,
948 MM_CAM_STROBE_CONTROL,
953 MM_ATTRS_VALID_TYPE_INT_RANGE,
956 _mmcamcorder_commit_strobe,
959 MM_CAM_STROBE_CAPABILITIES,
960 "strobe-capabilities",
964 MM_ATTRS_VALID_TYPE_INT_RANGE,
967 _mmcamcorder_commit_strobe,
975 MM_ATTRS_VALID_TYPE_INT_ARRAY,
978 _mmcamcorder_commit_strobe,
986 MM_ATTRS_VALID_TYPE_INT_ARRAY,
989 _mmcamcorder_commit_detect,
992 MM_CAM_DETECT_NUMBER,
997 MM_ATTRS_VALID_TYPE_INT_RANGE,
1000 _mmcamcorder_commit_detect,
1003 MM_CAM_DETECT_FOCUS_SELECT,
1004 "detect-focus-select",
1008 MM_ATTRS_VALID_TYPE_INT_RANGE,
1011 _mmcamcorder_commit_detect,
1014 MM_CAM_DETECT_SELECT_NUMBER,
1015 "detect-select-number",
1019 MM_ATTRS_VALID_TYPE_INT_RANGE,
1022 _mmcamcorder_commit_detect,
1026 MM_CAM_DETECT_STATUS,
1031 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1034 _mmcamcorder_commit_detect,
1037 MM_CAM_CAPTURE_ZERO_SYSTEMLAG,
1038 "capture-zero-systemlag",
1042 MM_ATTRS_VALID_TYPE_INT_RANGE,
1048 MM_CAM_CAMERA_AF_TOUCH_X,
1049 "camera-af-touch-x",
1053 MM_ATTRS_VALID_TYPE_INT_RANGE,
1055 {.int_max = _MMCAMCORDER_MAX_INT},
1056 _mmcamcorder_commit_camera_af_touch_area,
1059 MM_CAM_CAMERA_AF_TOUCH_Y,
1060 "camera-af-touch-y",
1064 MM_ATTRS_VALID_TYPE_INT_RANGE,
1066 {.int_max = _MMCAMCORDER_MAX_INT},
1067 _mmcamcorder_commit_camera_af_touch_area,
1070 MM_CAM_CAMERA_AF_TOUCH_WIDTH,
1071 "camera-af-touch-width",
1075 MM_ATTRS_VALID_TYPE_INT_RANGE,
1077 {.int_max = _MMCAMCORDER_MAX_INT},
1078 _mmcamcorder_commit_camera_af_touch_area,
1081 MM_CAM_CAMERA_AF_TOUCH_HEIGHT,
1082 "camera-af-touch-height",
1086 MM_ATTRS_VALID_TYPE_INT_RANGE,
1088 {.int_max = _MMCAMCORDER_MAX_INT},
1089 _mmcamcorder_commit_camera_af_touch_area,
1092 MM_CAM_CAMERA_FOCAL_LENGTH,
1093 "camera-focal-length",
1094 MMF_VALUE_TYPE_DOUBLE,
1096 {.value_double = 0.0},
1097 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
1098 {.double_min = 0.0},
1099 {.double_max = 1000.0},
1100 _mmcamcorder_commit_camera_capture_mode,
1103 MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE,
1104 "recommend-preview-format-for-capture",
1107 {(void*)MM_PIXEL_FORMAT_YUYV},
1108 MM_ATTRS_VALID_TYPE_INT_RANGE,
1109 {.int_min = MM_PIXEL_FORMAT_NV12},
1110 {.int_max = (MM_PIXEL_FORMAT_NUM-1)},
1114 MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING,
1115 "recommend-preview-format-for-recording",
1118 {(void*)MM_PIXEL_FORMAT_NV12},
1119 MM_ATTRS_VALID_TYPE_INT_RANGE,
1120 {.int_min = MM_PIXEL_FORMAT_NV12},
1121 {.int_max = (MM_PIXEL_FORMAT_NUM-1)},
1125 MM_CAM_TAG_GPS_ENABLE,
1130 MM_ATTRS_VALID_TYPE_INT_RANGE,
1133 _mmcamcorder_commit_tag,
1137 MM_CAM_TAG_GPS_TIME_STAMP,
1138 "tag-gps-time-stamp",
1139 MMF_VALUE_TYPE_DOUBLE,
1141 {.value_double = 0.0},
1142 MM_ATTRS_VALID_TYPE_NONE,
1145 _mmcamcorder_commit_tag,
1148 MM_CAM_TAG_GPS_DATE_STAMP,
1149 "tag-gps-date-stamp",
1150 MMF_VALUE_TYPE_STRING,
1153 MM_ATTRS_VALID_TYPE_NONE,
1156 _mmcamcorder_commit_tag,
1159 MM_CAM_TAG_GPS_PROCESSING_METHOD,
1160 "tag-gps-processing-method",
1161 MMF_VALUE_TYPE_STRING,
1164 MM_ATTRS_VALID_TYPE_NONE,
1167 _mmcamcorder_commit_tag,
1170 MM_CAM_CAMERA_ROTATION,
1174 {(void*)MM_VIDEO_INPUT_ROTATION_NONE},
1175 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1177 {ARRAY_SIZE(rotation_list)},
1178 _mmcamcorder_commit_camera_rotate,
1181 MM_CAM_CAPTURED_SCREENNAIL,
1182 "captured-screennail",
1183 MMF_VALUE_TYPE_DATA,
1184 MM_ATTRS_FLAG_READABLE,
1186 MM_ATTRS_VALID_TYPE_NONE,
1192 MM_CAM_CAPTURE_SOUND_ENABLE,
1193 "capture-sound-enable",
1197 MM_ATTRS_VALID_TYPE_INT_RANGE,
1200 _mmcamcorder_commit_capture_sound_enable,
1203 MM_CAM_RECOMMEND_DISPLAY_ROTATION,
1204 "recommend-display-rotation",
1207 {(void*)MM_DISPLAY_ROTATION_270},
1208 MM_ATTRS_VALID_TYPE_INT_RANGE,
1209 {.int_min = MM_DISPLAY_ROTATION_NONE},
1210 {.int_max = MM_DISPLAY_ROTATION_270},
1218 {(void*)MM_FLIP_NONE},
1219 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1221 {ARRAY_SIZE(flip_list)},
1222 _mmcamcorder_commit_camera_flip,
1225 MM_CAM_CAMERA_HDR_CAPTURE,
1226 "camera-hdr-capture",
1230 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1233 _mmcamcorder_commit_camera_hdr_capture,
1236 MM_CAM_DISPLAY_MODE,
1240 {(void*)MM_DISPLAY_MODE_DEFAULT},
1241 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1244 _mmcamcorder_commit_display_mode,
1248 MM_CAM_AUDIO_DISABLE,
1253 MM_ATTRS_VALID_TYPE_INT_RANGE,
1256 _mmcamcorder_commit_audio_disable,
1259 MM_CAM_RECOMMEND_CAMERA_WIDTH,
1260 "recommend-camera-width",
1263 {(void*)MMCAMCORDER_DEFAULT_CAMERA_WIDTH},
1264 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1270 MM_CAM_RECOMMEND_CAMERA_HEIGHT,
1271 "recommend-camera-height",
1274 {(void*)MMCAMCORDER_DEFAULT_CAMERA_HEIGHT},
1275 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1281 MM_CAM_CAPTURED_EXIF_RAW_DATA,
1282 "captured-exif-raw-data",
1283 MMF_VALUE_TYPE_DATA,
1284 MM_ATTRS_FLAG_READABLE,
1286 MM_ATTRS_VALID_TYPE_NONE,
1292 MM_CAM_DISPLAY_EVAS_SURFACE_SINK,
1293 "display-evas-surface-sink",
1294 MMF_VALUE_TYPE_STRING,
1295 MM_ATTRS_FLAG_READABLE,
1297 MM_ATTRS_VALID_TYPE_NONE,
1303 MM_CAM_DISPLAY_EVAS_DO_SCALING,
1304 "display-evas-do-scaling",
1308 MM_ATTRS_VALID_TYPE_INT_RANGE,
1311 _mmcamcorder_commit_display_evas_do_scaling,
1314 MM_CAM_CAMERA_FACING_DIRECTION,
1315 "camera-facing-direction",
1318 {(void*)MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR},
1319 MM_ATTRS_VALID_TYPE_INT_RANGE,
1320 {.int_min = MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR},
1321 {.int_max = MM_CAMCORDER_CAMERA_FACING_DIRECTION_FRONT},
1325 MM_CAM_DISPLAY_FLIP,
1329 {(void*)MM_FLIP_NONE},
1330 MM_ATTRS_VALID_TYPE_INT_RANGE,
1331 {.int_min = MM_FLIP_NONE},
1332 {.int_max = MM_FLIP_BOTH},
1333 _mmcamcorder_commit_display_flip,
1336 MM_CAM_CAMERA_VIDEO_STABILIZATION,
1337 "camera-video-stabilization",
1340 {(void*)MM_CAMCORDER_VIDEO_STABILIZATION_OFF},
1341 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1344 _mmcamcorder_commit_camera_video_stabilization,
1347 MM_CAM_TAG_VIDEO_ORIENTATION,
1348 "tag-video-orientation",
1351 {(void*)MM_CAMCORDER_TAG_VIDEO_ORT_NONE},
1352 MM_ATTRS_VALID_TYPE_INT_RANGE,
1353 {.int_min = MM_CAMCORDER_TAG_VIDEO_ORT_NONE},
1354 {.int_max = MM_CAMCORDER_TAG_VIDEO_ORT_270},
1359 MM_CAM_CAMERA_PAN_MECHA,
1364 MM_ATTRS_VALID_TYPE_INT_RANGE,
1367 _mmcamcorder_commit_camera_pan,
1370 MM_CAM_CAMERA_PAN_ELEC,
1375 MM_ATTRS_VALID_TYPE_INT_RANGE,
1378 _mmcamcorder_commit_camera_pan,
1381 MM_CAM_CAMERA_TILT_MECHA,
1382 "camera-tilt-mecha",
1386 MM_ATTRS_VALID_TYPE_INT_RANGE,
1389 _mmcamcorder_commit_camera_tilt,
1392 MM_CAM_CAMERA_TILT_ELEC,
1397 MM_ATTRS_VALID_TYPE_INT_RANGE,
1400 _mmcamcorder_commit_camera_tilt,
1403 MM_CAM_CAMERA_PTZ_TYPE,
1408 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1411 _mmcamcorder_commit_camera_ptz_type,
1419 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1422 _mmcamcorder_commit_video_size,
1425 MM_CAM_VIDEO_HEIGHT,
1430 MM_ATTRS_VALID_TYPE_INT_ARRAY,
1433 _mmcamcorder_commit_video_size,
1436 MM_CAM_SUPPORT_ZSL_CAPTURE,
1437 "support-zsl-capture",
1441 MM_ATTRS_VALID_TYPE_INT_RANGE,
1447 MM_CAM_SUPPORT_ZERO_COPY_FORMAT,
1448 "support-zero-copy-format",
1452 MM_ATTRS_VALID_TYPE_INT_RANGE,
1458 MM_CAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB,
1459 "support-media-packet-preview-cb",
1463 MM_ATTRS_VALID_TYPE_INT_RANGE,
1470 MM_CAM_ENCODED_PREVIEW_BITRATE,
1471 "encoded-preview-bitrate",
1474 {(void*)MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_BITRATE},
1475 MM_ATTRS_VALID_TYPE_INT_RANGE,
1477 {.int_max = _MMCAMCORDER_MAX_INT},
1478 _mmcamcorder_commit_encoded_preview_bitrate,
1481 MM_CAM_ENCODED_PREVIEW_GOP_INTERVAL,
1482 "encoded-preview-gop-interval",
1485 {(void*)MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_GOP_INTERVAL},
1486 MM_ATTRS_VALID_TYPE_INT_RANGE,
1488 {.int_max = _MMCAMCORDER_MAX_INT},
1489 _mmcamcorder_commit_encoded_preview_gop_interval,
1492 MM_CAM_RECORDER_TAG_ENABLE,
1493 "recorder-tag-enable",
1497 MM_ATTRS_VALID_TYPE_INT_RANGE,
1503 MM_CAM_DISPLAY_SOCKET_PATH,
1504 "display-socket-path",
1505 MMF_VALUE_TYPE_STRING,
1508 MM_ATTRS_VALID_TYPE_NONE,
1519 MM_ATTRS_VALID_TYPE_INT_RANGE,
1521 {.int_max = _MMCAMCORDER_MAX_INT},
1525 MM_CAM_ROOT_DIRECTORY,
1527 MMF_VALUE_TYPE_STRING,
1530 MM_ATTRS_VALID_TYPE_NONE,
1536 MM_CAM_SOUND_STREAM_INDEX,
1537 "sound-stream-index",
1541 MM_ATTRS_VALID_TYPE_INT_RANGE,
1543 {.int_max = _MMCAMCORDER_MAX_INT},
1547 MM_CAM_SOUND_STREAM_TYPE,
1548 "sound-stream-type",
1549 MMF_VALUE_TYPE_STRING,
1552 MM_ATTRS_VALID_TYPE_NONE,
1555 _mmcamcorder_commit_sound_stream_info,
1558 MM_CAM_DISPLAY_REUSE_HINT,
1559 "display-reuse-hint",
1563 MM_ATTRS_VALID_TYPE_INT_RANGE,
1569 MM_CAM_DISPLAY_REUSE_ELEMENT,
1570 "display-reuse-element",
1571 MMF_VALUE_TYPE_DATA,
1574 MM_ATTRS_VALID_TYPE_NONE,
1580 MM_CAM_GDBUS_CONNECTION,
1582 MMF_VALUE_TYPE_DATA,
1585 MM_ATTRS_VALID_TYPE_NONE,
1591 MM_CAM_AUDIO_REPLAY_GAIN_ENABLE,
1592 "audio-replay-gain-enable",
1596 MM_ATTRS_VALID_TYPE_INT_RANGE,
1599 _mmcamcorder_commit_audio_replay_gain,
1602 MM_CAM_AUDIO_REPLAY_GAIN_REFERENCE_LEVEL,
1603 "audio-replay-gain-reference-level",
1604 MMF_VALUE_TYPE_DOUBLE,
1606 {.value_double = MMCAMCORDER_DEFAULT_REPLAY_GAIN_REFERENCE_LEVEL},
1607 MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
1608 {.double_min = 0.0},
1609 {.double_max = 150.0},
1610 _mmcamcorder_commit_audio_replay_gain,
1614 memcpy(hcamcorder->cam_attrs_const_info, temp_info, sizeof(mm_cam_attr_construct_info) * attr_count);
1616 for (idx = 0 ; idx < attr_count ; idx++) {
1617 /* attribute order check. This should be same. */
1618 if (idx != hcamcorder->cam_attrs_const_info[idx].attrid) {
1619 _mmcam_dbg_err("Please check attributes order. Is the idx same with enum val?");
1620 free(attrs_const_info);
1621 attrs_const_info = NULL;
1622 free(hcamcorder->cam_attrs_const_info);
1623 hcamcorder->cam_attrs_const_info = NULL;
1627 attrs_const_info[idx].name = hcamcorder->cam_attrs_const_info[idx].name;
1628 attrs_const_info[idx].value_type = hcamcorder->cam_attrs_const_info[idx].value_type;
1629 attrs_const_info[idx].flags = hcamcorder->cam_attrs_const_info[idx].flags;
1630 attrs_const_info[idx].default_value = hcamcorder->cam_attrs_const_info[idx].default_value.value_void;
1633 /* Camcorder Attributes */
1634 _mmcam_dbg_log("Create Camcorder Attributes[%p, %d]", attrs_const_info, attr_count);
1636 attrs = mmf_attrs_new_from_data("Camcorder_Attributes",
1639 _mmcamcorder_commit_camcorder_attrs,
1642 free(attrs_const_info);
1643 attrs_const_info = NULL;
1646 _mmcam_dbg_err("Fail to alloc attribute handle");
1647 free(hcamcorder->cam_attrs_const_info);
1648 hcamcorder->cam_attrs_const_info = NULL;
1652 __mmcamcorder_set_conf_to_valid_info(handle);
1654 for (idx = 0; idx < attr_count; idx++) {
1655 mm_cam_attr_construct_info *attr_info = &hcamcorder->cam_attrs_const_info[idx];
1658 _mmcam_dbg_log("Valid type [%s:%d, %d, %d]",
1659 attr_info->name, attr_info->validity_type,
1660 attr_info->validity_value1, attr_info->validity_value2);
1662 mmf_attrs_set_valid_type(attrs, idx, attr_info->validity_type);
1664 switch (attr_info->validity_type) {
1665 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
1666 if (attr_info->validity_value_1.int_array &&
1667 attr_info->validity_value_2.count > 0) {
1668 mmf_attrs_set_valid_array(attrs, idx,
1669 (const int *)(attr_info->validity_value_1.int_array),
1670 attr_info->validity_value_2.count,
1671 attr_info->default_value.value_int);
1674 case MM_ATTRS_VALID_TYPE_INT_RANGE:
1675 mmf_attrs_set_valid_range(attrs, idx,
1676 attr_info->validity_value_1.int_min,
1677 attr_info->validity_value_2.int_max,
1678 attr_info->default_value.value_int);
1680 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
1681 if (attr_info->validity_value_1.double_array &&
1682 attr_info->validity_value_2.count > 0) {
1683 mmf_attrs_set_valid_double_array(attrs, idx,
1684 (const double *)(attr_info->validity_value_1.double_array),
1685 attr_info->validity_value_2.count,
1686 attr_info->default_value.value_double);
1689 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
1690 mmf_attrs_set_valid_double_range(attrs, idx,
1691 attr_info->validity_value_1.double_min,
1692 attr_info->validity_value_2.double_max,
1693 attr_info->default_value.value_double);
1694 ((mmf_attrs_t *)attrs)->items[idx].value.value.d_val = attr_info->default_value.value_double;
1696 case MM_ATTRS_VALID_TYPE_NONE:
1698 case MM_ATTRS_VALID_TYPE_INVALID:
1700 _mmcam_dbg_err("Valid type error.");
1705 __mmcamcorder_release_conf_valid_info(handle);
1712 _mmcamcorder_dealloc_attribute(MMHandleType handle, MMHandleType attrs)
1714 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1716 if (hcamcorder == NULL) {
1717 _mmcam_dbg_err("handle is NULL");
1724 mmf_attrs_free(attrs);
1725 _mmcam_dbg_log("released attribute");
1728 if (hcamcorder->cam_attrs_const_info) {
1729 free(hcamcorder->cam_attrs_const_info);
1730 hcamcorder->cam_attrs_const_info = NULL;
1731 _mmcam_dbg_log("released attribute info");
1739 _mmcamcorder_get_attributes(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
1741 MMHandleType attrs = 0;
1742 int ret = MM_ERROR_NONE;
1744 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
1745 /*mmf_return_val_if_fail(err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);*/
1747 attrs = MMF_CAMCORDER_ATTRS(handle);
1748 mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1750 ret = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, var_args);
1757 _mmcamcorder_set_attributes(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
1759 MMHandleType attrs = 0;
1760 int ret = MM_ERROR_NONE;
1762 char *tmp_err_attr_name = NULL;
1763 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1764 va_list var_args_copy;
1766 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
1768 if (!_MMCAMCORDER_TRYLOCK_CMD(handle)) {
1769 _mmcam_dbg_err("Another command is running.");
1770 return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1773 /* copy var_args to keep original var_args */
1774 va_copy(var_args_copy, var_args);
1776 attrs = MMF_CAMCORDER_ATTRS(handle);
1778 ret = __mmcamcorder_check_valid_pair(handle, &tmp_err_attr_name, attribute_name, var_args);
1780 _mmcam_dbg_err("handle %p, attrs is NULL, attr name [%s]", handle, attribute_name);
1781 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1784 if (ret == MM_ERROR_NONE) {
1785 hcamcorder->error_code = MM_ERROR_NONE;
1786 /* In 64bit environment, unexpected result is returned if var_args is used again. */
1787 ret = mm_attrs_set_valist(attrs, &tmp_err_attr_name, attribute_name, var_args_copy);
1790 va_end(var_args_copy);
1792 _MMCAMCORDER_UNLOCK_CMD(handle);
1794 if (ret != MM_ERROR_NONE) {
1795 if (ret == MM_ERROR_COMMON_OUT_OF_RANGE) {
1796 if (mm_attrs_get_index(attrs, tmp_err_attr_name, &err_index) == MM_ERROR_NONE &&
1797 _mmcamcorder_check_supported_attribute(handle, err_index)) {
1798 _mmcam_dbg_err("[%s] is supported, but value is invalid",
1799 tmp_err_attr_name ? tmp_err_attr_name : "NULL");
1800 ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1804 if (hcamcorder->error_code != MM_ERROR_NONE) {
1805 _mmcam_dbg_err("error_code is set. ret 0x%x -> modified 0x%x", ret, hcamcorder->error_code);
1806 ret = hcamcorder->error_code;
1807 hcamcorder->error_code = MM_ERROR_NONE;
1810 _mmcam_dbg_err("failed error code 0x%x - handle %p", ret, (mmf_camcorder_t *)handle);
1813 if (tmp_err_attr_name) {
1814 if (!err_attr_name) {
1815 _mmcam_dbg_err("set attribute[%s] error, but err name is NULL", tmp_err_attr_name);
1816 free(tmp_err_attr_name);
1817 tmp_err_attr_name = NULL;
1819 *err_attr_name = tmp_err_attr_name;
1828 _mmcamcorder_get_attribute_info(MMHandleType handle, const char *attr_name, MMCamAttrsInfo *info)
1830 MMHandleType attrs = 0;
1831 MMAttrsInfo attrinfo;
1832 int ret = MM_ERROR_NONE;
1834 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
1835 mmf_return_val_if_fail(attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
1836 mmf_return_val_if_fail(info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
1838 attrs = MMF_CAMCORDER_ATTRS(handle);
1839 mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
1841 ret = mm_attrs_get_info_by_name(attrs, attr_name, (MMAttrsInfo*)&attrinfo);
1843 if (ret == MM_ERROR_NONE) {
1844 memset(info, 0x00, sizeof(MMCamAttrsInfo));
1845 info->type = attrinfo.type;
1846 info->flag = attrinfo.flag;
1847 info->validity_type = attrinfo.validity_type;
1849 switch (attrinfo.validity_type) {
1850 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
1851 info->int_array.array = attrinfo.int_array.array;
1852 info->int_array.count = attrinfo.int_array.count;
1853 info->int_array.def = attrinfo.int_array.dval;
1855 case MM_ATTRS_VALID_TYPE_INT_RANGE:
1856 info->int_range.min = attrinfo.int_range.min;
1857 info->int_range.max = attrinfo.int_range.max;
1858 info->int_range.def = attrinfo.int_range.dval;
1860 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
1861 info->double_array.array = attrinfo.double_array.array;
1862 info->double_array.count = attrinfo.double_array.count;
1863 info->double_array.def = attrinfo.double_array.dval;
1865 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
1866 info->double_range.min = attrinfo.double_range.min;
1867 info->double_range.max = attrinfo.double_range.max;
1868 info->double_range.def = attrinfo.double_range.dval;
1870 case MM_ATTRS_VALID_TYPE_NONE:
1872 case MM_ATTRS_VALID_TYPE_INVALID:
1883 _mmcamcorder_commit_camcorder_attrs(int attr_idx, const char *attr_name, const mmf_value_t *value, void *commit_param)
1886 mmf_camcorder_t *hcamcorder = NULL;
1888 mmf_return_val_if_fail(commit_param, FALSE);
1889 mmf_return_val_if_fail(attr_idx >= 0, FALSE);
1890 mmf_return_val_if_fail(attr_name, FALSE);
1891 mmf_return_val_if_fail(value, FALSE);
1893 hcamcorder = MMF_CAMCORDER(commit_param);
1895 if (hcamcorder->cam_attrs_const_info[attr_idx].attr_commit)
1896 bret = hcamcorder->cam_attrs_const_info[attr_idx].attr_commit((MMHandleType)commit_param, attr_idx, value);
1904 int __mmcamcorder_set_conf_to_valid_info(MMHandleType handle)
1907 int total_count = 0;
1909 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1911 if (hcamcorder == NULL) {
1912 _mmcam_dbg_err("handle is NULL");
1913 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1917 total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER, &format);
1918 hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_1.int_array = format;
1919 hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_2.count = total_count;
1922 total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER, &format);
1923 hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_1.int_array = format;
1924 hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_2.count = total_count;
1927 total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER, &format);
1928 hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_1.int_array = format;
1929 hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_2.count = total_count;
1932 total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_MUX, &format);
1933 hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_1.int_array = format;
1934 hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_2.count = total_count;
1936 return MM_ERROR_NONE;
1940 int __mmcamcorder_release_conf_valid_info(MMHandleType handle)
1942 int *allocated_memory = NULL;
1944 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1946 if (hcamcorder == NULL) {
1947 _mmcam_dbg_err("handle is NULL");
1948 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1951 _mmcam_dbg_log("START");
1953 /* Audio encoder info */
1954 allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_1.int_array);
1955 if (allocated_memory) {
1956 free(allocated_memory);
1957 hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_1.int_array = NULL;
1958 hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_2.count = 0;
1961 /* Video encoder info */
1962 allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_1.int_array);
1963 if (allocated_memory) {
1964 free(allocated_memory);
1965 hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_1.int_array = NULL;
1966 hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_2.count = 0;
1969 /* Image encoder info */
1970 allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_1.int_array);
1971 if (allocated_memory) {
1972 free(allocated_memory);
1973 hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_1.int_array = NULL;
1974 hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_2.count = 0;
1977 /* File format info */
1978 allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_1.int_array);
1979 if (allocated_memory) {
1980 free(allocated_memory);
1981 hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_1.int_array = NULL;
1982 hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_2.count = 0;
1985 _mmcam_dbg_log("DONE");
1987 return MM_ERROR_NONE;
1991 bool _mmcamcorder_commit_capture_width(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1993 MMHandleType attr = 0;
1994 int current_state = MM_CAMCORDER_STATE_NONE;
1996 mmf_return_val_if_fail(handle && value, FALSE);
1998 attr = MMF_CAMCORDER_ATTRS(handle);
1999 mmf_return_val_if_fail(attr, FALSE);
2001 /*_mmcam_dbg_log("(%d)", attr_idx);*/
2003 current_state = _mmcamcorder_get_state(handle);
2004 if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
2005 int flags = MM_ATTRS_FLAG_NONE;
2006 int capture_width, capture_height;
2007 MMCamAttrsInfo info;
2009 mm_camcorder_get_attribute_info(handle, MMCAM_CAPTURE_HEIGHT, &info);
2012 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
2013 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_HEIGHT, &capture_height, NULL);
2014 capture_width = value->value.i_val;
2016 /* Check whether they are valid pair */
2017 return __mmcamcorder_set_capture_resolution(handle, capture_width, capture_height);
2022 _mmcam_dbg_log("Capture resolution can't be set.(state=%d)", current_state);
2028 bool _mmcamcorder_commit_capture_height(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2030 int current_state = MM_CAMCORDER_STATE_NONE;
2032 current_state = _mmcamcorder_get_state(handle);
2034 if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
2035 int capture_width, capture_height;
2037 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_WIDTH, &capture_width, NULL);
2038 capture_height = value->value.i_val;
2040 return __mmcamcorder_set_capture_resolution(handle, capture_width, capture_height);
2042 _mmcam_dbg_log("Capture resolution can't be set.(state=%d)", current_state);
2049 bool _mmcamcorder_commit_capture_break_cont_shot(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2051 int current_state = 0;
2053 const char *videosrc_name = NULL;
2054 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2055 _MMCamcorderSubContext *sc = NULL;
2056 _MMCamcorderImageInfo *info = NULL;
2057 GstCameraControl *control = NULL;
2058 type_element *VideosrcElement = NULL;
2060 mmf_return_val_if_fail(handle && value, FALSE);
2062 current_state = _mmcamcorder_get_state(handle);
2063 ivalue = value->value.i_val;
2065 _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
2066 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
2069 _mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
2071 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2075 info = sc->info_image;
2077 _mmcam_dbg_err("info image is NULL");
2081 if (ivalue && current_state == MM_CAMCORDER_STATE_CAPTURING) {
2082 if (info->capture_send_count > 0) {
2083 info->capturing = FALSE;
2084 _mmcam_dbg_warn("capturing -> FALSE and skip capture callback since now");
2087 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2088 _mmcam_dbg_warn("Can't cast Video source into camera control.");
2092 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2094 gst_camera_control_set_capture_command(control, GST_CAMERA_CONTROL_CAPTURE_COMMAND_STOP_MULTISHOT);
2095 _mmcam_dbg_warn("Commit Break continuous shot : Set command OK. current state[%d]", current_state);
2097 _mmcam_dbg_warn("cast CAMERA_CONTROL failed");
2100 _mmcam_dbg_warn("Commit Break continuous shot : No effect. value[%d],current state[%d]", ivalue, current_state);
2107 bool _mmcamcorder_commit_capture_count(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2109 int mode = MM_CAMCORDER_MODE_VIDEO_CAPTURE;
2110 int current_state = MM_CAMCORDER_STATE_NONE;
2111 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2113 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2115 current_state = _mmcamcorder_get_state(handle);
2116 mm_camcorder_get_attributes(handle, NULL, MMCAM_MODE, &mode, NULL);
2118 _mmcam_dbg_log("current state %d, mode %d, set count %d",
2119 current_state, mode, value->value.i_val);
2121 if (mode != MM_CAMCORDER_MODE_AUDIO &&
2122 current_state != MM_CAMCORDER_STATE_CAPTURING) {
2125 _mmcam_dbg_err("Invalid mode[%d] or state[%d]", mode, current_state);
2131 bool _mmcamcorder_commit_capture_sound_enable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2133 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2135 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2137 _mmcam_dbg_log("shutter sound policy: %d", hcamcorder->shutter_sound_policy);
2139 /* return error when disable shutter sound if policy is TRUE */
2140 if (!value->value.i_val &&
2141 hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON) {
2142 _mmcam_dbg_err("not permitted DISABLE SHUTTER SOUND");
2145 _mmcam_dbg_log("set value [%d] success", value->value.i_val);
2151 bool _mmcamcorder_commit_audio_volume(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2153 int current_state = MM_CAMCORDER_STATE_NONE;
2154 _MMCamcorderSubContext *sc = NULL;
2157 mmf_return_val_if_fail(handle && value, FALSE);
2159 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2163 current_state = _mmcamcorder_get_state(handle);
2165 if ((current_state == MM_CAMCORDER_STATE_RECORDING) || (current_state == MM_CAMCORDER_STATE_PAUSED)) {
2166 double mslNewVal = 0;
2167 mslNewVal = value->value.d_val;
2169 if (sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst) {
2170 if (mslNewVal == 0.0) {
2171 /* Because data probe of audio src do the same job, it doesn't need to set mute here. Already null raw data. */
2172 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "volume", 1.0);
2174 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "mute", FALSE);
2175 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "volume", mslNewVal);
2179 _mmcam_dbg_log("Commit : volume(%f)", mslNewVal);
2182 _mmcam_dbg_log("Commit : nothing to commit. status(%d)", current_state);
2190 bool _mmcamcorder_commit_camera_format(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2192 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2193 int current_state = MM_CAMCORDER_STATE_NONE;
2195 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2197 current_state = _mmcamcorder_get_state(handle);
2198 if (current_state > MM_CAMCORDER_STATE_READY) {
2199 _mmcam_dbg_err("invalid state %d", current_state);
2200 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
2208 bool _mmcamcorder_commit_camera_fps(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2210 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2211 MMCamAttrsInfo fps_info;
2212 int resolution_width = 0;
2213 int resolution_height = 0;
2216 int current_state = MM_CAMCORDER_STATE_NONE;
2218 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2220 current_state = _mmcamcorder_get_state(handle);
2221 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2222 _mmcam_dbg_err("invalid state %d", current_state);
2223 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
2227 if (attr_idx == MM_CAM_CAMERA_FPS_AUTO)
2230 _mmcam_dbg_log("FPS(%d)", value->value.i_val);
2232 ret = mm_camcorder_get_attributes(handle, NULL,
2233 MMCAM_CAMERA_WIDTH, &resolution_width,
2234 MMCAM_CAMERA_HEIGHT, &resolution_height,
2237 if (ret != MM_ERROR_NONE) {
2238 _mmcam_dbg_err("FAILED : coult not get resolution values.");
2242 ret = mm_camcorder_get_fps_list_by_resolution(handle, resolution_width, resolution_height, &fps_info);
2243 if (ret != MM_ERROR_NONE) {
2244 _mmcam_dbg_err("FAILED : coult not get FPS values by resolution.");
2248 for (i = 0 ; i < fps_info.int_array.count ; i++) {
2249 if (value->value.i_val == fps_info.int_array.array[i])
2253 _mmcam_dbg_err("FAILED : %d is not supported FPS", value->value.i_val);
2259 bool _mmcamcorder_commit_camera_recording_motion_rate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2261 int current_state = MM_CAMCORDER_STATE_NONE;
2262 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2263 _MMCamcorderSubContext *sc = NULL;
2265 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2267 current_state = _mmcamcorder_get_state(handle);
2268 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2269 _mmcam_dbg_warn("invalid state %d", current_state);
2270 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
2274 /* Verify recording motion rate */
2275 if (value->value.d_val > 0.0) {
2276 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2280 /* set is_slow flag */
2281 if (value->value.d_val != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE)
2282 sc->is_modified_rate = TRUE;
2284 sc->is_modified_rate = FALSE;
2286 _mmcam_dbg_log("Set slow motion rate %lf", value->value.d_val);
2289 _mmcam_dbg_warn("Failed to set recording motion rate %lf", value->value.d_val);
2295 bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2297 MMHandleType attr = 0;
2298 int current_state = MM_CAMCORDER_STATE_NONE;
2300 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2301 _MMCamcorderSubContext *sc = NULL;
2303 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2305 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2309 attr = MMF_CAMCORDER_ATTRS(handle);
2310 mmf_return_val_if_fail(attr, FALSE);
2312 _mmcam_dbg_log("Width(%d)", value->value.i_val);
2314 current_state = _mmcamcorder_get_state(handle);
2316 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2317 _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state);
2320 int flags = MM_ATTRS_FLAG_NONE;
2321 MMCamAttrsInfo info;
2322 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_HEIGHT, &info);
2325 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
2326 int width = value->value.i_val;
2328 int preview_format = MM_PIXEL_FORMAT_NV12;
2329 int codec_type = MM_IMAGE_CODEC_JPEG;
2331 mm_camcorder_get_attributes(handle, NULL,
2332 MMCAM_CAMERA_HEIGHT, &height,
2333 MMCAM_CAMERA_FORMAT, &preview_format,
2334 MMCAM_IMAGE_ENCODER, &codec_type,
2337 if (current_state == MM_CAMCORDER_STATE_PREPARE) {
2338 if (hcamcorder->resolution_changed == FALSE) {
2339 _mmcam_dbg_log("no need to restart preview");
2343 hcamcorder->resolution_changed = FALSE;
2345 if (g_mutex_trylock(&hcamcorder->restart_preview_lock)) {
2346 _mmcam_dbg_log("restart preview");
2348 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
2349 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
2351 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
2353 /* check decoder recreation */
2354 if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) {
2355 _mmcam_dbg_err("_mmcamcorder_recreate_decoder_for_encoded_preview failed");
2356 g_mutex_unlock(&hcamcorder->restart_preview_lock);
2360 /* get preview format */
2361 sc->info_image->preview_format = preview_format;
2362 sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format);
2363 ret = _mmcamcorder_set_camera_resolution(handle, width, height);
2365 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
2366 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
2368 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
2371 g_mutex_unlock(&hcamcorder->restart_preview_lock);
2373 _mmcam_dbg_err("currently locked for preview restart");
2377 /* get preview format */
2378 sc->info_image->preview_format = preview_format;
2379 sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format);
2380 ret = _mmcamcorder_set_camera_resolution(handle, width, height);
2391 bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2394 int current_state = MM_CAMCORDER_STATE_NONE;
2395 MMHandleType attr = 0;
2396 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2397 _MMCamcorderSubContext *sc = NULL;
2399 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2401 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2405 attr = MMF_CAMCORDER_ATTRS(hcamcorder);
2406 mmf_return_val_if_fail(attr, FALSE);
2408 _mmcam_dbg_log("Height(%d)", value->value.i_val);
2409 current_state = _mmcamcorder_get_state(handle);
2411 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2412 _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state);
2413 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
2417 int height = value->value.i_val;
2418 int preview_format = MM_PIXEL_FORMAT_NV12;
2419 int codec_type = MM_IMAGE_CODEC_JPEG;
2420 int video_stabilization = 0;
2422 mm_camcorder_get_attributes(handle, NULL,
2423 MMCAM_CAMERA_WIDTH, &width,
2424 MMCAM_CAMERA_FORMAT, &preview_format,
2425 MMCAM_IMAGE_ENCODER, &codec_type,
2426 MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization,
2429 sc->info_video->preview_width = width;
2430 sc->info_video->preview_height = height;
2432 if (current_state == MM_CAMCORDER_STATE_PREPARE) {
2433 if (hcamcorder->resolution_changed == FALSE) {
2434 _mmcam_dbg_log("no need to restart preview");
2438 hcamcorder->resolution_changed = FALSE;
2440 if (g_mutex_trylock(&hcamcorder->restart_preview_lock)) {
2441 _mmcam_dbg_log("restart preview");
2443 _mmcam_dbg_log("set empty buffers");
2445 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
2446 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
2448 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
2450 /* check decoder recreation */
2451 if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) {
2452 _mmcam_dbg_err("_mmcamcorder_recreate_decoder_for_encoded_preview failed");
2453 g_mutex_unlock(&hcamcorder->restart_preview_lock);
2457 /* get preview format */
2458 sc->info_image->preview_format = preview_format;
2459 sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format);
2461 ret = _mmcamcorder_set_camera_resolution(handle, width, height);
2463 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
2464 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
2466 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
2469 g_mutex_unlock(&hcamcorder->restart_preview_lock);
2471 _mmcam_dbg_err("currently locked for preview restart");
2475 /* get preview format */
2476 sc->info_image->preview_format = preview_format;
2477 sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format);
2478 ret = _mmcamcorder_set_camera_resolution(handle, width, height);
2486 bool _mmcamcorder_commit_video_size(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2488 int current_state = MM_CAMCORDER_STATE_NONE;
2489 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2491 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2493 current_state = _mmcamcorder_get_state(handle);
2494 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2495 _mmcam_dbg_err("Video Resolution can't be changed.(state=%d)", current_state);
2496 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
2499 _mmcam_dbg_warn("Video Resolution %d [attr_idx %d] ",
2500 value->value.i_val, attr_idx);
2506 bool _mmcamcorder_commit_camera_zoom(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2508 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2509 _MMCamcorderSubContext *sc = NULL;
2510 int current_state = MM_CAMCORDER_STATE_NONE;
2511 GstCameraControl *control = NULL;
2515 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2517 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2521 zoom_level = value->value.i_val;
2523 _mmcam_dbg_log("(%d)", attr_idx);
2525 current_state = _mmcamcorder_get_state(handle);
2526 if (current_state < MM_CAMCORDER_STATE_READY) {
2527 _mmcam_dbg_log("will be applied when preview starts");
2529 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
2530 _mmcam_dbg_err("Can not set while CAPTURING");
2531 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
2535 if (attr_idx == MM_CAM_CAMERA_OPTICAL_ZOOM)
2536 zoom_type = GST_CAMERA_CONTROL_OPTICAL_ZOOM;
2538 zoom_type = GST_CAMERA_CONTROL_DIGITAL_ZOOM;
2540 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2543 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2544 _mmcam_dbg_log("Can't cast Video source into camera control.");
2548 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2549 if (control == NULL) {
2550 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2554 ret = gst_camera_control_set_zoom(control, zoom_type, zoom_level);
2556 _mmcam_dbg_log("Succeed in operating Zoom[%d].", zoom_level);
2559 _mmcam_dbg_warn("Failed to operate Zoom. Type[%d],Level[%d]", zoom_type, zoom_level);
2562 _mmcam_dbg_log("pointer of video src is null");
2569 bool _mmcamcorder_commit_camera_ptz_type(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2571 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2572 _MMCamcorderSubContext *sc = NULL;
2573 int current_state = MM_CAMCORDER_STATE_NONE;
2575 GstCameraControl *CameraControl = NULL;
2576 GstCameraControlChannel *CameraControlChannel = NULL;
2577 const GList *controls = NULL;
2578 const GList *item = NULL;
2580 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2582 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2583 mmf_return_val_if_fail(sc, TRUE);
2585 _mmcam_dbg_log("ptz type : %d", value->value.i_val);
2587 current_state = _mmcamcorder_get_state(handle);
2588 if (current_state < MM_CAMCORDER_STATE_PREPARE ||
2589 current_state == MM_CAMCORDER_STATE_CAPTURING) {
2590 _mmcam_dbg_err("invalid state[%d]", current_state);
2591 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
2595 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2596 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2597 _mmcam_dbg_log("Can't cast Video source into camera control.");
2601 CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2602 if (CameraControl == NULL) {
2603 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2607 controls = gst_camera_control_list_channels(CameraControl);
2608 if (controls == NULL) {
2609 _mmcam_dbg_err("gst_camera_control_list_channels failed");
2613 for (item = controls ; item && item->data ; item = item->next) {
2614 CameraControlChannel = item->data;
2615 _mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label);
2616 if (!strcmp(CameraControlChannel->label, "ptz")) {
2617 if (gst_camera_control_set_value(CameraControl, CameraControlChannel, value->value.i_val)) {
2618 _mmcam_dbg_warn("set ptz type %d done", value->value.i_val);
2621 _mmcam_dbg_err("failed to set ptz type %d", value->value.i_val);
2627 _mmcam_dbg_warn("failed to find tilt control channel");
2634 bool _mmcamcorder_commit_camera_pan(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2636 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2637 _MMCamcorderSubContext *sc = NULL;
2638 int current_state = MM_CAMCORDER_STATE_NONE;
2640 GstCameraControl *CameraControl = NULL;
2641 GstCameraControlChannel *CameraControlChannel = NULL;
2642 const GList *controls = NULL;
2643 const GList *item = NULL;
2645 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2647 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2648 mmf_return_val_if_fail(sc, TRUE);
2650 _mmcam_dbg_log("pan : %d", value->value.i_val);
2652 current_state = _mmcamcorder_get_state(handle);
2653 if (current_state < MM_CAMCORDER_STATE_PREPARE ||
2654 current_state == MM_CAMCORDER_STATE_CAPTURING) {
2655 _mmcam_dbg_err("invalid state[%d]", current_state);
2656 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
2660 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2661 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2662 _mmcam_dbg_log("Can't cast Video source into camera control.");
2666 CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2667 if (CameraControl == NULL) {
2668 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2672 controls = gst_camera_control_list_channels(CameraControl);
2673 if (controls == NULL) {
2674 _mmcam_dbg_err("gst_camera_control_list_channels failed");
2678 for (item = controls ; item && item->data ; item = item->next) {
2679 CameraControlChannel = item->data;
2680 _mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label);
2681 if (!strcmp(CameraControlChannel->label, "pan")) {
2682 if (gst_camera_control_set_value(CameraControl, CameraControlChannel, value->value.i_val)) {
2683 _mmcam_dbg_warn("set pan %d done", value->value.i_val);
2686 _mmcam_dbg_err("failed to set pan %d", value->value.i_val);
2692 _mmcam_dbg_warn("failed to find pan control channel");
2699 bool _mmcamcorder_commit_camera_tilt(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2701 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2702 _MMCamcorderSubContext *sc = NULL;
2703 int current_state = MM_CAMCORDER_STATE_NONE;
2705 GstCameraControl *CameraControl = NULL;
2706 GstCameraControlChannel *CameraControlChannel = NULL;
2707 const GList *controls = NULL;
2708 const GList *item = NULL;
2710 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2712 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2713 mmf_return_val_if_fail(sc, TRUE);
2715 _mmcam_dbg_log("tilt : %d", value->value.i_val);
2717 current_state = _mmcamcorder_get_state(handle);
2718 if (current_state < MM_CAMCORDER_STATE_PREPARE ||
2719 current_state == MM_CAMCORDER_STATE_CAPTURING) {
2720 _mmcam_dbg_err("invalid state[%d]", current_state);
2721 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
2725 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2726 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2727 _mmcam_dbg_log("Can't cast Video source into camera control.");
2731 CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2732 if (CameraControl == NULL) {
2733 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2737 controls = gst_camera_control_list_channels(CameraControl);
2738 if (controls == NULL) {
2739 _mmcam_dbg_err("gst_camera_control_list_channels failed");
2743 for (item = controls ; item && item->data ; item = item->next) {
2744 CameraControlChannel = item->data;
2745 _mmcam_dbg_log("CameraControlChannel->label %s", CameraControlChannel->label);
2746 if (!strcmp(CameraControlChannel->label, "tilt")) {
2747 if (gst_camera_control_set_value(CameraControl, CameraControlChannel, value->value.i_val)) {
2748 _mmcam_dbg_warn("set tilt %d done", value->value.i_val);
2751 _mmcam_dbg_err("failed to set tilt %d", value->value.i_val);
2757 _mmcam_dbg_warn("failed to find tilt control channel");
2764 bool _mmcamcorder_commit_camera_focus_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2766 MMHandleType attr = 0;
2767 int current_state = MM_CAMCORDER_STATE_NONE;
2768 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2769 _MMCamcorderSubContext *sc = NULL;
2770 GstCameraControl *control = NULL;
2772 int set_focus_mode = 0;
2773 int cur_focus_mode = 0;
2774 int cur_focus_range = 0;
2776 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2778 attr = MMF_CAMCORDER_ATTRS(handle);
2779 mmf_return_val_if_fail(attr, FALSE);
2781 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2785 _mmcam_dbg_log("Focus mode(%d)", value->value.i_val);
2787 /* check whether set or not */
2788 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2789 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2793 current_state = _mmcamcorder_get_state(handle);
2794 if (current_state < MM_CAMCORDER_STATE_NULL) {
2795 _mmcam_dbg_log("Focus mode will be changed later.(state=%d)", current_state);
2797 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
2798 _mmcam_dbg_err("Can not set while CAPTURING");
2799 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
2803 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2804 int flags = MM_ATTRS_FLAG_NONE;
2805 MMCamAttrsInfo info;
2807 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2808 _mmcam_dbg_log("Can't cast Video source into camera control.");
2812 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2813 if (control == NULL) {
2814 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2818 mslVal = value->value.i_val;
2819 set_focus_mode = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal);
2821 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_SCAN_RANGE, &info);
2824 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
2825 if (gst_camera_control_get_focus(control, &cur_focus_mode, &cur_focus_range)) {
2826 if (set_focus_mode != cur_focus_mode) {
2827 if (gst_camera_control_set_focus(control, set_focus_mode, cur_focus_range)) {
2828 _mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal);
2831 _mmcam_dbg_warn("Failed to set AF mode[%d]", mslVal);
2834 _mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal);
2838 _mmcam_dbg_warn("Failed to get AF mode, so do not set new AF mode[%d]", mslVal);
2842 _mmcam_dbg_log("pointer of video src is null");
2849 bool _mmcamcorder_commit_camera_af_scan_range(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2851 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2852 _MMCamcorderSubContext *sc = NULL;
2853 GstCameraControl *control = NULL;
2854 int current_state = MM_CAMCORDER_STATE_NONE;
2857 int cur_focus_mode = 0;
2858 int cur_focus_range = 0;
2859 int msl_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
2860 int converted_mode = 0;
2862 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2864 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2868 _mmcam_dbg_log("(%d)", attr_idx);
2870 /* check whether set or not */
2871 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2872 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2876 mslVal = value->value.i_val;
2877 newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal);
2879 current_state = _mmcamcorder_get_state(handle);
2880 if (current_state < MM_CAMCORDER_STATE_PREPARE) {
2881 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2883 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
2884 _mmcam_dbg_err("Can not set while CAPTURING");
2885 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
2889 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2890 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2891 _mmcam_dbg_log("Can't cast Video source into camera control.");
2895 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2896 if (control == NULL) {
2897 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2901 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FOCUS_MODE, &msl_mode, NULL);
2902 converted_mode = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_FOCUS_MODE, msl_mode);
2904 if (gst_camera_control_get_focus(control, &cur_focus_mode, &cur_focus_range)) {
2905 if ((newVal != cur_focus_range) || (converted_mode != cur_focus_mode)) {
2906 if (gst_camera_control_set_focus(control, converted_mode, newVal)) {
2907 /*_mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal);*/
2910 _mmcam_dbg_warn("Failed to set AF mode[%d]", mslVal);
2913 /*_mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal);*/
2917 _mmcam_dbg_warn("Failed to get AF mode, so do not set new AF mode[%d]", mslVal);
2920 _mmcam_dbg_log("pointer of video src is null");
2927 bool _mmcamcorder_commit_camera_af_touch_area(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2929 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2930 _MMCamcorderSubContext *sc = NULL;
2931 GstCameraControl *control = NULL;
2932 GstCameraControlRectType set_area = { 0, 0, 0, 0 };
2933 GstCameraControlRectType get_area = { 0, 0, 0, 0 };
2935 int current_state = MM_CAMCORDER_STATE_NONE;
2937 int focus_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
2939 gboolean do_set = FALSE;
2941 MMCamAttrsInfo info_y;
2942 MMCamAttrsInfo info_w;
2943 MMCamAttrsInfo info_h;
2945 mmf_return_val_if_fail(hcamcorder && value, FALSE);
2947 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2951 _mmcam_dbg_log("(%d)", attr_idx);
2953 current_state = _mmcamcorder_get_state(handle);
2954 if (current_state < MM_CAMCORDER_STATE_PREPARE) {
2955 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2957 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
2958 _mmcam_dbg_err("Can not set while CAPTURING");
2959 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
2963 ret = mm_camcorder_get_attributes(handle, NULL,
2964 MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
2966 if (ret != MM_ERROR_NONE) {
2967 _mmcam_dbg_warn("Failed to get FOCUS MODE.[%x]", ret);
2971 if ((focus_mode != MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO) && (focus_mode != MM_CAMCORDER_FOCUS_MODE_CONTINUOUS)) {
2972 _mmcam_dbg_warn("Focus mode is NOT TOUCH AUTO or CONTINUOUS(current[%d]). return FALSE", focus_mode);
2976 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2977 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2978 _mmcam_dbg_log("Can't cast Video source into camera control.");
2982 memset(&info_y, 0x0, sizeof(MMCamAttrsInfo));
2983 memset(&info_w, 0x0, sizeof(MMCamAttrsInfo));
2984 memset(&info_h, 0x0, sizeof(MMCamAttrsInfo));
2987 case MM_CAM_CAMERA_AF_TOUCH_X:
2988 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_Y, &info_y);
2989 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_WIDTH, &info_w);
2990 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h);
2991 if (!((info_y.flag|info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED)) {
2992 set_area.x = value->value.i_val;
2993 mm_camcorder_get_attributes(handle, NULL,
2994 MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
2995 MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
2996 MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
3000 _mmcam_dbg_log("Just store AF area[x:%d]", value->value.i_val);
3004 case MM_CAM_CAMERA_AF_TOUCH_Y:
3005 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_WIDTH, &info_w);
3006 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h);
3007 if (!((info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED)) {
3008 set_area.y = value->value.i_val;
3009 mm_camcorder_get_attributes(handle, NULL,
3010 MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
3011 MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
3012 MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
3016 _mmcam_dbg_log("Just store AF area[y:%d]", value->value.i_val);
3020 case MM_CAM_CAMERA_AF_TOUCH_WIDTH:
3021 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h);
3022 if (!(info_h.flag & MM_ATTRS_FLAG_MODIFIED)) {
3023 set_area.width = value->value.i_val;
3024 mm_camcorder_get_attributes(handle, NULL,
3025 MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
3026 MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
3027 MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
3031 _mmcam_dbg_log("Just store AF area[width:%d]", value->value.i_val);
3035 case MM_CAM_CAMERA_AF_TOUCH_HEIGHT:
3036 set_area.height = value->value.i_val;
3037 mm_camcorder_get_attributes(handle, NULL,
3038 MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
3039 MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
3040 MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
3049 _MMCamcorderVideoInfo *info = sc->info_video;
3052 _mmcam_dbg_err("video info is NULL");
3056 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3057 if (control == NULL) {
3058 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
3063 if (current_state >= MM_CAMCORDER_STATE_RECORDING && info->support_dual_stream == FALSE &&
3064 (info->preview_width != info->video_width || info->preview_height != info->video_height)) {
3065 float ratio_width = 0.0;
3066 float ratio_height = 0.0;
3068 if (info->preview_width != 0 && info->preview_height != 0) {
3069 ratio_width = (float)info->video_width / (float)info->preview_width;
3070 ratio_height = (float)info->video_height / (float)info->preview_height;
3072 _mmcam_dbg_log("original area %d,%d,%dx%d, resolution ratio : width %f, height %f",
3073 set_area.x, set_area.y, set_area.width, set_area.height, ratio_width, ratio_height);
3075 set_area.x = (int)((float)set_area.x * ratio_width);
3076 set_area.y = (int)((float)set_area.y * ratio_height);
3077 set_area.width = (int)((float)set_area.width * ratio_width);
3078 set_area.height = (int)((float)set_area.height * ratio_height);
3080 if (set_area.width <= 0)
3083 if (set_area.height <= 0)
3084 set_area.height = 1;
3086 _mmcam_dbg_log("converted area %d,%d,%dx%d",
3087 set_area.x, set_area.y, set_area.width, set_area.height);
3089 _mmcam_dbg_warn("invalid preview size %dx%d, skip AF area converting",
3090 info->preview_width, info->preview_height);
3094 ret = gst_camera_control_get_auto_focus_area(control, &get_area);
3096 _mmcam_dbg_warn("Failed to get AF area");
3100 /* width and height are not supported now */
3101 if (get_area.x == set_area.x && get_area.y == set_area.y) {
3102 _mmcam_dbg_log("No need to set AF area[x,y:%d,%d]",
3103 get_area.x, get_area.y);
3107 ret = gst_camera_control_set_auto_focus_area(control, set_area);
3109 _mmcam_dbg_log("Succeed to set AF area[%d,%d,%dx%d]",
3110 set_area.x, set_area.y, set_area.width, set_area.height);
3113 _mmcam_dbg_warn("Failed to set AF area[%d,%d,%dx%d]",
3114 set_area.x, set_area.y, set_area.width, set_area.height);
3118 _mmcam_dbg_log("pointer of video src is null");
3125 bool _mmcamcorder_commit_camera_capture_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3127 GstCameraControl *control = NULL;
3133 int exposure_type = 0;
3134 int current_state = MM_CAMCORDER_STATE_NONE;
3135 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3136 _MMCamcorderSubContext *sc = NULL;
3138 int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
3139 gboolean check_scene_mode = FALSE;
3141 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3143 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3147 /* check whether set or not */
3148 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3149 _mmcam_dbg_log("skip set value %d", value->value.i_val);
3153 current_state = _mmcamcorder_get_state(handle);
3154 if (current_state < MM_CAMCORDER_STATE_READY) {
3155 _mmcam_dbg_log("will be applied when preview starts");
3157 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
3158 _mmcam_dbg_err("Can not set while CAPTURING");
3159 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
3163 ivalue = value->value.i_val;
3165 if (attr_idx == MM_CAM_CAMERA_F_NUMBER) {
3166 exposure_type = GST_CAMERA_CONTROL_F_NUMBER;
3167 mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR(ivalue);
3168 mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR(ivalue);
3169 } else if (attr_idx == MM_CAM_CAMERA_SHUTTER_SPEED) {
3170 exposure_type = GST_CAMERA_CONTROL_SHUTTER_SPEED;
3171 mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR(ivalue);
3172 mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR(ivalue);
3173 } else if (attr_idx == MM_CAM_CAMERA_ISO) {
3174 exposure_type = GST_CAMERA_CONTROL_ISO;
3176 newVal1 = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal1);
3177 check_scene_mode = TRUE;
3178 } else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_MODE) {
3179 exposure_type = GST_CAMERA_CONTROL_EXPOSURE_MODE;
3181 newVal1 = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal1);
3182 check_scene_mode = TRUE;
3183 } else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_VALUE) {
3184 exposure_type = GST_CAMERA_CONTROL_EXPOSURE_VALUE;
3185 mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR(ivalue);
3186 mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR(ivalue);
3189 if (check_scene_mode) {
3190 mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
3191 if (scene_mode != MM_CAMCORDER_SCENE_MODE_NORMAL) {
3192 _mmcam_dbg_warn("can not set [%d] when scene mode is NOT normal.", attr_idx);
3197 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
3200 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
3201 _mmcam_dbg_log("Can't cast Video source into camera control.");
3205 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3206 if (control == NULL) {
3207 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
3211 ret = gst_camera_control_set_exposure(control, exposure_type, newVal1, newVal2);
3213 _mmcam_dbg_log("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2);
3216 _mmcam_dbg_warn("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2);
3219 _mmcam_dbg_log("pointer of video src is null");
3226 bool _mmcamcorder_commit_camera_wdr(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3228 GstCameraControl *control = NULL;
3232 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3233 _MMCamcorderSubContext *sc = NULL;
3234 int current_state = MM_CAMCORDER_STATE_NONE;
3236 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3238 /* check whether set or not */
3239 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3240 _mmcam_dbg_log("skip set value %d", value->value.i_val);
3244 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3248 /* check current state */
3249 current_state = _mmcamcorder_get_state(handle);
3250 if (current_state < MM_CAMCORDER_STATE_READY) {
3251 _mmcam_dbg_log("will be applied when preview starts");
3253 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
3254 _mmcam_dbg_err("Can not set while CAPTURING");
3255 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
3259 mslVal = value->value.i_val;
3260 newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_WDR, mslVal);
3262 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
3263 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
3264 _mmcam_dbg_log("Can't cast Video source into camera control.");
3268 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3269 if (control == NULL) {
3270 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
3274 if (gst_camera_control_get_wdr(control, &cur_value)) {
3275 if (newVal != cur_value) {
3276 if (gst_camera_control_set_wdr(control, newVal)) {
3277 _mmcam_dbg_log("Success - set wdr[%d]", mslVal);
3280 _mmcam_dbg_warn("Failed to set WDR. NewVal[%d],CurVal[%d]", newVal, cur_value);
3283 _mmcam_dbg_log("No need to set new WDR. Current[%d]", mslVal);
3287 _mmcam_dbg_warn("Failed to get WDR.");
3290 _mmcam_dbg_log("pointer of video src is null");
3297 bool _mmcamcorder_commit_camera_anti_handshake(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3299 int current_state = MM_CAMCORDER_STATE_NONE;
3300 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3302 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3304 /* check whether set or not */
3305 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3306 _mmcam_dbg_log("skip set value %d", value->value.i_val);
3310 current_state = _mmcamcorder_get_state(handle);
3311 if (current_state < MM_CAMCORDER_STATE_READY) {
3312 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
3314 } else if (current_state > MM_CAMCORDER_STATE_PREPARE) {
3315 _mmcam_dbg_err("Invaild state (state %d)", current_state);
3316 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
3320 return _mmcamcorder_set_videosrc_anti_shake(handle, value->value.i_val);
3324 bool _mmcamcorder_commit_encoder_bitrate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3328 int current_state = MM_CAMCORDER_STATE_NONE;
3329 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3330 _MMCamcorderSubContext *sc = NULL;
3332 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3334 bitrate = value->value.i_val;
3336 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3337 if (!sc || !sc->encode_element) {
3338 _mmcam_dbg_log("will be applied later - idx %d, bitrate %d", attr_idx, bitrate);
3342 current_state = _mmcamcorder_get_state(handle);
3343 if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
3344 _mmcam_dbg_err("Can not set while RECORDING - attr idx %d", attr_idx);
3345 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
3349 if (attr_idx == MM_CAM_AUDIO_ENCODER_BITRATE) {
3350 mm_camcorder_get_attributes(handle, NULL, MMCAM_AUDIO_ENCODER, &audio_enc, NULL);
3352 _mmcamcorder_set_encoder_bitrate(MM_CAMCORDER_ENCODER_TYPE_AUDIO, audio_enc,
3353 bitrate, sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst);
3355 _mmcamcorder_set_encoder_bitrate(MM_CAMCORDER_ENCODER_TYPE_VIDEO, 0,
3356 bitrate, sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst);
3363 bool _mmcamcorder_commit_camera_video_stabilization(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3365 int current_state = MM_CAMCORDER_STATE_NONE;
3366 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3368 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3370 current_state = _mmcamcorder_get_state(handle);
3371 if (current_state < MM_CAMCORDER_STATE_READY) {
3372 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
3374 } else if (current_state > MM_CAMCORDER_STATE_PREPARE) {
3375 _mmcam_dbg_err("Invaild state (state %d)", current_state);
3376 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
3380 return _mmcamcorder_set_videosrc_stabilization(handle, value->value.i_val);
3384 bool _mmcamcorder_commit_camera_rotate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3386 int current_state = MM_CAMCORDER_STATE_NONE;
3387 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3389 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3391 _mmcam_dbg_log("rotate(%d)", value->value.i_val);
3393 current_state = _mmcamcorder_get_state(handle);
3395 if (current_state > MM_CAMCORDER_STATE_READY) {
3396 _mmcam_dbg_err("camera rotation setting failed.(state=%d)", current_state);
3397 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
3400 return _mmcamcorder_set_videosrc_rotation(handle, value->value.i_val);
3405 bool _mmcamcorder_commit_image_encoder_quality(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3407 int current_state = MM_CAMCORDER_STATE_NONE;
3409 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3410 _MMCamcorderSubContext *sc = NULL;
3412 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3415 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3416 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3420 /* check current state */
3421 current_state = _mmcamcorder_get_state(handle);
3422 if (current_state < MM_CAMCORDER_STATE_READY) {
3423 _mmcam_dbg_log("NOT initialized. this will be applied later");
3425 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
3426 _mmcam_dbg_err("Can not set while CAPTURING");
3427 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
3431 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3433 _mmcam_dbg_log("Image encoder quality(%d)", value->value.i_val);
3435 if (current_state == MM_CAMCORDER_STATE_PREPARE) {
3436 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-jpg-quality", value->value.i_val);
3439 _mmcam_dbg_err("invalid state %d", current_state);
3445 bool _mmcamcorder_commit_target_filename(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3448 const char *filename = NULL;
3450 mmf_return_val_if_fail(handle && value, FALSE);
3453 filename = mmf_value_get_string(value, &size);
3454 if (filename == NULL) {
3455 _mmcam_dbg_err("NULL filename");
3459 _mmcam_dbg_log("set filename [%s]", filename);
3465 bool _mmcamcorder_commit_recording_max_limit(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3467 int current_state = MM_CAMCORDER_STATE_NONE;
3468 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3470 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3472 current_state = _mmcamcorder_get_state(handle);
3473 if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
3474 _mmcam_dbg_err("Can not set while RECORDING");
3475 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
3483 bool _mmcamcorder_commit_filter(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3485 GstColorBalance *balance = NULL;
3486 GstColorBalanceChannel *Colorchannel = NULL;
3487 const GList *controls = NULL;
3488 const GList *item = NULL;
3491 int current_state = MM_CAMCORDER_STATE_NONE;
3492 const char *control_label = NULL;
3493 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3494 _MMCamcorderSubContext *sc = NULL;
3496 int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
3497 gboolean check_scene_mode = FALSE;
3499 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3501 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3505 /* check whether set or not */
3506 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3507 _mmcam_dbg_log("skip set value %d", value->value.i_val);
3511 current_state = _mmcamcorder_get_state(handle);
3512 if (current_state < MM_CAMCORDER_STATE_READY) {
3513 _mmcam_dbg_log("will be applied when preview starts");
3515 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
3516 _mmcam_dbg_err("Can not set while CAPTURING");
3517 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
3521 if (value->type != MM_ATTRS_TYPE_INT) {
3522 _mmcam_dbg_warn("Mismatched value type (%d)", value->type);
3525 mslNewVal = value->value.i_val;
3529 case MM_CAM_FILTER_BRIGHTNESS:
3530 control_label = "brightness";
3531 check_scene_mode = TRUE;
3534 case MM_CAM_FILTER_CONTRAST:
3535 control_label = "contrast";
3538 case MM_CAM_FILTER_WB:
3539 control_label = "white balance";
3540 check_scene_mode = TRUE;
3543 case MM_CAM_FILTER_COLOR_TONE:
3544 control_label = "color tone";
3547 case MM_CAM_FILTER_SATURATION:
3548 control_label = "saturation";
3549 check_scene_mode = TRUE;
3552 case MM_CAM_FILTER_HUE:
3553 control_label = "hue";
3556 case MM_CAM_FILTER_SHARPNESS:
3557 control_label = "sharpness";
3558 check_scene_mode = TRUE;
3561 _mmcam_dbg_err("unknown attribute index %d", attr_idx);
3565 if (check_scene_mode) {
3566 mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
3567 if (scene_mode != MM_CAMCORDER_SCENE_MODE_NORMAL) {
3568 _mmcam_dbg_warn("can not set %s when scene mode is NOT normal.", control_label);
3573 newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslNewVal);
3574 if (newVal == _MMCAMCORDER_SENSOR_ENUM_NONE)
3577 /*_mmcam_dbg_log("label(%s): MSL(%d)->Sensor(%d)", control_label, mslNewVal, newVal);*/
3579 if (!GST_IS_COLOR_BALANCE(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
3580 _mmcam_dbg_log("Can't cast Video source into color balance.");
3584 balance = GST_COLOR_BALANCE(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3585 if (balance == NULL) {
3586 _mmcam_dbg_err("cast COLOR_BALANCE failed");
3590 controls = gst_color_balance_list_channels(balance);
3591 if (controls == NULL) {
3592 _mmcam_dbg_log("There is no list of colorbalance controls");
3596 for (item = controls ; item && item->data ; item = item->next) {
3597 Colorchannel = item->data;
3598 /*_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label);*/
3600 if (!strcmp(Colorchannel->label, control_label)) {
3601 gst_color_balance_set_value(balance, Colorchannel, newVal);
3602 _mmcam_dbg_log("Set complete - %s[msl:%d,real:%d]", Colorchannel->label, mslNewVal, newVal);
3608 _mmcam_dbg_err("failed to find color channel item");
3616 bool _mmcamcorder_commit_filter_scene_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3620 int current_state = MM_CAMCORDER_STATE_NONE;
3621 GstCameraControl *control = NULL;
3622 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3623 _MMCamcorderSubContext *sc = NULL;
3625 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3627 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3631 mslVal = value->value.i_val;
3632 newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_FILTER_SCENE_MODE, mslVal);
3634 /* check whether set or not */
3635 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3636 _mmcam_dbg_log("skip set value %d", value->value.i_val);
3640 current_state = _mmcamcorder_get_state(handle);
3641 if (current_state < MM_CAMCORDER_STATE_READY) {
3642 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
3644 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
3645 _mmcam_dbg_err("Can not set while CAPTURING");
3646 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
3650 if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
3653 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
3654 _mmcam_dbg_log("Can't cast Video source into camera control.");
3658 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3659 if (control == NULL) {
3660 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
3664 ret = gst_camera_control_set_exposure(control, GST_CAMERA_CONTROL_PROGRAM_MODE, newVal, 0);
3666 _mmcam_dbg_log("Succeed in setting program mode[%d].", mslVal);
3668 if (mslVal == MM_CAMCORDER_SCENE_MODE_NORMAL) {
3672 MM_CAM_FILTER_BRIGHTNESS,
3674 MM_CAM_FILTER_SATURATION,
3675 MM_CAM_FILTER_SHARPNESS,
3676 MM_CAM_FILTER_COLOR_TONE,
3677 MM_CAM_CAMERA_EXPOSURE_MODE
3679 mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
3681 for (i = 0 ; i < ARRAY_SIZE(attr_idxs) ; i++) {
3682 if (_mmcamcorder_check_supported_attribute(handle, attr_idxs[i]))
3683 mmf_attribute_set_modified(&(attr->items[attr_idxs[i]]));
3689 _mmcam_dbg_log("Failed to set program mode[%d].", mslVal);
3692 _mmcam_dbg_warn("pointer of video src is null");
3699 bool _mmcamcorder_commit_filter_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3701 mmf_return_val_if_fail(handle && value, FALSE);
3703 _mmcam_dbg_warn("Filter Flip(%d)", value->value.i_val);
3709 bool _mmcamcorder_commit_audio_input_route(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3711 mmf_return_val_if_fail(handle && value, FALSE);
3713 _mmcam_dbg_log("Commit : Do nothing. this attr will be removed soon.");
3719 bool _mmcamcorder_commit_audio_disable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3721 int current_state = MM_CAMCORDER_STATE_NONE;
3722 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3724 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3726 current_state = _mmcamcorder_get_state(handle);
3727 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
3728 _mmcam_dbg_warn("Can NOT Disable AUDIO. invalid state %d", current_state);
3729 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
3732 _mmcam_dbg_log("Disable AUDIO when Recording");
3738 bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3740 int current_state = MM_CAMCORDER_STATE_NONE;
3741 const char *videosink_name = NULL;
3742 void *p_handle = NULL;
3744 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3745 _MMCamcorderSubContext *sc = NULL;
3747 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3750 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3751 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3755 /* check current state */
3756 current_state = _mmcamcorder_get_state(handle);
3757 if (current_state < MM_CAMCORDER_STATE_READY) {
3758 _mmcam_dbg_log("NOT initialized. this will be applied later");
3762 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3764 p_handle = value->value.p_val;
3766 /* get videosink name */
3767 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3768 if (videosink_name == NULL) {
3769 _mmcam_dbg_err("Please check videosink element in configuration file");
3773 _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
3775 if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "ximagesink")) {
3776 _mmcam_dbg_log("Commit : Set XID[%x]", *(int *)(p_handle));
3777 gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), *(int *)(p_handle));
3778 } else if (!strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "evaspixmapsink")) {
3779 _mmcam_dbg_log("Commit : Set evas object [%p]", p_handle);
3780 MMCAMCORDER_G_OBJECT_SET_POINTER(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "evas-object", p_handle);
3781 } else if (!strcmp(videosink_name, "tizenwlsink")) {
3782 _mmcam_dbg_log("wayland global surface id : %d", *(int *)(p_handle));
3783 gst_video_overlay_set_wl_window_wl_surface_id(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), (guintptr)*(int *)(p_handle));
3785 _mmcam_dbg_warn("Commit : Nothing to commit with this element[%s]", videosink_name);
3789 _mmcam_dbg_warn("Display handle is NULL");
3797 bool _mmcamcorder_commit_display_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3799 int current_state = MM_CAMCORDER_STATE_NONE;
3800 const char *videosink_name = NULL;
3802 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3803 _MMCamcorderSubContext *sc = NULL;
3805 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3808 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3809 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3813 /* check current state */
3814 current_state = _mmcamcorder_get_state(handle);
3815 if (current_state < MM_CAMCORDER_STATE_READY) {
3816 _mmcam_dbg_log("NOT initialized. this will be applied later");
3820 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3822 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3823 if (videosink_name == NULL) {
3824 _mmcam_dbg_err("Please check videosink element in configuration file");
3828 _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
3830 if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink")) {
3831 _mmcam_dbg_log("Commit : display mode [%d]", value->value.i_val);
3832 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-mode", value->value.i_val);
3834 _mmcam_dbg_warn("[%s] does not support display mode, but no error", videosink_name);
3841 bool _mmcamcorder_commit_display_rotation(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3843 int current_state = MM_CAMCORDER_STATE_NONE;
3845 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3847 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3850 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3851 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3855 /* check current state */
3856 current_state = _mmcamcorder_get_state(handle);
3857 if (current_state < MM_CAMCORDER_STATE_READY) {
3858 _mmcam_dbg_log("NOT initialized. this will be applied later [rotate:%d]", value->value.i_val);
3862 return _mmcamcorder_set_display_rotation(handle, value->value.i_val, _MMCAMCORDER_VIDEOSINK_SINK);
3866 bool _mmcamcorder_commit_display_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3868 int current_state = MM_CAMCORDER_STATE_NONE;
3870 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3872 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3875 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3876 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3880 /* check current state */
3881 current_state = _mmcamcorder_get_state(handle);
3882 if (current_state < MM_CAMCORDER_STATE_READY) {
3883 _mmcam_dbg_log("NOT initialized. this will be applied later [flip:%d]", value->value.i_val);
3887 return _mmcamcorder_set_display_flip(handle, value->value.i_val, _MMCAMCORDER_VIDEOSINK_SINK);
3891 bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3893 int current_state = MM_CAMCORDER_STATE_NONE;
3894 const char *videosink_name = NULL;
3896 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3897 _MMCamcorderSubContext *sc = NULL;
3899 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3902 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3903 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3907 /* check current state */
3908 current_state = _mmcamcorder_get_state(handle);
3909 if (current_state < MM_CAMCORDER_STATE_READY) {
3910 _mmcam_dbg_log("NOT initialized. this will be applied later");
3914 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3916 /* Get videosink name */
3917 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3918 if (videosink_name == NULL) {
3919 _mmcam_dbg_err("Please check videosink element in configuration file");
3923 if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") ||
3924 !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) {
3925 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "visible", value->value.i_val);
3926 _mmcam_dbg_log("Set visible [%d] done.", value->value.i_val);
3928 _mmcam_dbg_warn("[%s] does not support VISIBLE, but no error", videosink_name);
3935 bool _mmcamcorder_commit_display_geometry_method(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3938 int current_state = MM_CAMCORDER_STATE_NONE;
3939 const char *videosink_name = NULL;
3941 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3942 _MMCamcorderSubContext *sc = NULL;
3944 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3947 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3948 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3952 /* check current state */
3953 current_state = _mmcamcorder_get_state(handle);
3954 if (current_state < MM_CAMCORDER_STATE_READY) {
3955 _mmcam_dbg_log("NOT initialized. this will be applied later");
3959 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3961 /* Get videosink name */
3962 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3963 if (videosink_name == NULL) {
3964 _mmcam_dbg_err("Please check videosink element in configuration file");
3968 if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") ||
3969 !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) {
3970 method = value->value.i_val;
3971 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-geometry-method", method);
3973 _mmcam_dbg_warn("[%s] does not support geometry method, but no error", videosink_name);
3980 bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3982 int current_state = MM_CAMCORDER_STATE_NONE;
3983 int ret = MM_ERROR_NONE;
3984 const char *videosink_name = NULL;
3986 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3987 _MMCamcorderSubContext *sc = NULL;
3989 mmf_return_val_if_fail(hcamcorder && value, FALSE);
3992 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3993 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3997 /* check current state */
3998 current_state = _mmcamcorder_get_state(handle);
3999 if (current_state < MM_CAMCORDER_STATE_READY) {
4000 _mmcam_dbg_log("NOT initialized. this will be applied later");
4004 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4006 /* Get videosink name */
4007 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
4008 if (videosink_name == NULL) {
4009 _mmcam_dbg_err("Please check videosink element in configuration file");
4013 if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") ||
4014 !strcmp(videosink_name, "evaspixmapsink")) {
4018 int rect_height = 0;
4019 int flags = MM_ATTRS_FLAG_NONE;
4020 MMCamAttrsInfo info;
4022 mm_camcorder_get_attributes(handle, NULL,
4023 MMCAM_DISPLAY_RECT_X, &rect_x,
4024 MMCAM_DISPLAY_RECT_Y, &rect_y,
4025 MMCAM_DISPLAY_RECT_WIDTH, &rect_width,
4026 MMCAM_DISPLAY_RECT_HEIGHT, &rect_height,
4029 case MM_CAM_DISPLAY_RECT_X:
4030 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_Y, &info);
4032 memset(&info, 0x00, sizeof(info));
4033 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
4035 memset(&info, 0x00, sizeof(info));
4036 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
4039 rect_x = value->value.i_val;
4041 case MM_CAM_DISPLAY_RECT_Y:
4042 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
4044 memset(&info, 0x00, sizeof(info));
4045 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
4048 rect_y = value->value.i_val;
4050 case MM_CAM_DISPLAY_RECT_WIDTH:
4051 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
4054 rect_width = value->value.i_val;
4056 case MM_CAM_DISPLAY_RECT_HEIGHT:
4057 rect_height = value->value.i_val;
4060 _mmcam_dbg_err("Wrong attr_idx!");
4064 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
4065 _mmcam_dbg_log("RECT(x,y,w,h) = (%d,%d,%d,%d)", rect_x, rect_y, rect_width, rect_height);
4067 if (!strcmp(videosink_name, "tizenwlsink")) {
4068 ret = gst_video_overlay_set_display_roi_area(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst),
4069 rect_x, rect_y, rect_width, rect_height);
4071 _mmcam_dbg_err("FAILED : could not set display roi area.");
4075 g_object_set(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
4076 "dst-roi-x", rect_x,
4077 "dst-roi-y", rect_y,
4078 "dst-roi-w", rect_width,
4079 "dst-roi-h", rect_height,
4084 _mmcam_dbg_warn("[%s] does not support display rect, but no error", videosink_name);
4091 bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4094 int current_state = MM_CAMCORDER_STATE_NONE;
4095 const char *videosink_name = NULL;
4096 GstElement *vs_element = NULL;
4098 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4099 _MMCamcorderSubContext *sc = NULL;
4101 mmf_return_val_if_fail(hcamcorder && value, FALSE);
4104 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
4105 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
4109 /* check current state */
4110 current_state = _mmcamcorder_get_state(handle);
4111 if (current_state < MM_CAMCORDER_STATE_READY) {
4112 _mmcam_dbg_log("NOT initialized. this will be applied later");
4116 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4118 /* Get videosink name */
4119 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
4120 if (videosink_name == NULL) {
4121 _mmcam_dbg_err("Please check videosink element in configuration file");
4125 zoom = value->value.i_val;
4126 if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink")) {
4127 vs_element = sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst;
4129 MMCAMCORDER_G_OBJECT_SET(vs_element, "zoom", (float)(zoom + 1));
4130 _mmcam_dbg_log("Set display zoom to %d", zoom + 1);
4134 _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
4140 bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4142 int current_state = MM_CAMCORDER_STATE_NONE;
4144 const char *videosink_name = NULL;
4146 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4147 _MMCamcorderSubContext *sc = NULL;
4149 mmf_return_val_if_fail(handle && value, FALSE);
4152 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
4153 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
4157 /* check current state */
4158 current_state = _mmcamcorder_get_state(handle);
4159 if (current_state < MM_CAMCORDER_STATE_READY) {
4160 _mmcam_dbg_log("NOT initialized. this will be applied later");
4164 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4166 do_scaling = value->value.i_val;
4168 /* Get videosink name */
4169 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
4170 if (videosink_name == NULL) {
4171 _mmcam_dbg_err("Please check videosink element in configuration file");
4175 if (!strcmp(videosink_name, "evaspixmapsink")) {
4176 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "origin-size", !do_scaling);
4177 _mmcam_dbg_log("Set origin-size to %d", !(value->value.i_val));
4180 _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
4186 bool _mmcamcorder_commit_strobe(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4189 _MMCamcorderSubContext *sc = NULL;
4190 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4191 int strobe_type, mslVal, newVal, cur_value;
4192 int current_state = MM_CAMCORDER_STATE_NONE;
4194 mmf_return_val_if_fail(hcamcorder && value, FALSE);
4196 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4200 /*_mmcam_dbg_log( "Commit : strobe attribute(%d)", attr_idx );*/
4202 mslVal = value->value.i_val;
4204 /* check flash state */
4205 if (attr_idx == MM_CAM_STROBE_MODE) {
4206 int flash_brightness = 0;
4208 /* get current flash brightness */
4209 if (_mmcamcorder_get_device_flash_brightness(hcamcorder->gdbus_conn, &flash_brightness) != MM_ERROR_NONE) {
4210 _mmcam_dbg_err("_mmcamcorder_get_device_flash_brightness failed");
4211 hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
4215 _mmcam_dbg_log("flash brightness %d", flash_brightness);
4217 if (flash_brightness > 0 &&
4218 mslVal != MM_CAMCORDER_STROBE_MODE_OFF) {
4219 /* other module already turned on flash */
4220 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_BUSY;
4221 _mmcam_dbg_err("other module already turned on flash. avoid to set flash mode here.");
4224 _mmcam_dbg_log("keep going");
4229 current_state = _mmcamcorder_get_state(handle);
4230 if (current_state < MM_CAMCORDER_STATE_READY) {
4231 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
4233 } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
4234 _mmcam_dbg_err("Can not set while CAPTURING");
4235 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
4240 case MM_CAM_STROBE_CONTROL:
4241 strobe_type = GST_CAMERA_CONTROL_STROBE_CONTROL;
4242 newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_CONTROL, mslVal);
4244 case MM_CAM_STROBE_CAPABILITIES:
4245 strobe_type = GST_CAMERA_CONTROL_STROBE_CAPABILITIES;
4248 case MM_CAM_STROBE_MODE:
4249 /* check whether set or not */
4250 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
4251 _mmcam_dbg_log("skip set value %d", mslVal);
4255 strobe_type = GST_CAMERA_CONTROL_STROBE_MODE;
4256 newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_MODE, mslVal);
4259 _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
4263 GstCameraControl *control = NULL;
4264 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
4265 _mmcam_dbg_err("Can't cast Video source into camera control.");
4268 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
4269 if (control == NULL) {
4270 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
4274 if (gst_camera_control_get_strobe(control, strobe_type, &cur_value)) {
4275 if (newVal != cur_value) {
4276 if (gst_camera_control_set_strobe(control, strobe_type, newVal)) {
4277 _mmcam_dbg_log("Succeed in setting strobe. Type[%d],value[%d]", strobe_type, mslVal);
4280 _mmcam_dbg_warn("Set strobe failed. Type[%d],value[%d]", strobe_type, mslVal);
4284 _mmcam_dbg_log("No need to set strobe. Type[%d],value[%d]", strobe_type, mslVal);
4288 _mmcam_dbg_warn("Failed to get strobe. Type[%d]", strobe_type);
4297 bool _mmcamcorder_commit_camera_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4300 int current_state = MM_CAMCORDER_STATE_NONE;
4301 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4303 mmf_return_val_if_fail(hcamcorder && value, FALSE);
4305 _mmcam_dbg_log("Commit : flip %d", value->value.i_val);
4308 current_state = _mmcamcorder_get_state(handle);
4309 if (current_state > MM_CAMCORDER_STATE_READY) {
4310 _mmcam_dbg_err("Can not set camera FLIP horizontal at state %d", current_state);
4311 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
4313 } else if (current_state < MM_CAMCORDER_STATE_READY) {
4314 _mmcam_dbg_log("Pipeline is not created yet. This will be set when create pipeline.");
4318 ret = _mmcamcorder_set_videosrc_flip(handle, value->value.i_val);
4320 _mmcam_dbg_log("ret %d", ret);
4326 bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4328 int set_hdr_mode = MM_CAMCORDER_HDR_OFF;
4329 int current_state = MM_CAMCORDER_STATE_NONE;
4330 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4331 _MMCamcorderSubContext *sc = NULL;
4333 mmf_return_val_if_fail(hcamcorder && value, FALSE);
4335 /*_mmcam_dbg_log("Commit : HDR Capture %d", value->value.i_val);*/
4337 /* check whether set or not */
4338 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
4339 _mmcam_dbg_log("skip set value %d", value->value.i_val);
4344 current_state = _mmcamcorder_get_state(handle);
4345 if (current_state > MM_CAMCORDER_STATE_PREPARE) {
4346 _mmcam_dbg_err("can NOT set HDR capture at state %d", current_state);
4347 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
4351 if (current_state >= MM_CAMCORDER_STATE_READY) {
4352 int current_value = 0;
4354 set_hdr_mode = value->value.i_val;
4355 mm_camcorder_get_attributes(handle, NULL,
4356 MMCAM_CAMERA_HDR_CAPTURE, ¤t_value,
4359 if (set_hdr_mode == current_value) {
4360 _mmcam_dbg_log("same HDR value : %d, do nothing", set_hdr_mode);
4364 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4366 if (current_state == MM_CAMCORDER_STATE_PREPARE) {
4367 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
4368 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
4370 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
4372 /* check decoder recreation */
4373 if (!_mmcamcorder_recreate_decoder_for_encoded_preview(handle)) {
4374 _mmcam_dbg_err("_mmcamcorder_recreate_decoder_for_encoded_preview failed");
4378 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
4379 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
4382 set_hdr_mode = value->value.i_val;
4383 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hdr-capture", set_hdr_mode);
4384 sc->info_image->hdr_capture_mode = set_hdr_mode;
4385 _mmcam_dbg_log("set HDR mode : %d", set_hdr_mode);
4387 if (current_state == MM_CAMCORDER_STATE_PREPARE)
4388 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
4390 _mmcam_dbg_err("sc is NULL. can not set HDR capture");
4399 bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4402 _MMCamcorderSubContext *sc = NULL;
4403 int detect_type = GST_CAMERA_CONTROL_FACE_DETECT_MODE;
4405 int current_value = 0;
4406 int current_state = MM_CAMCORDER_STATE_NONE;
4407 GstCameraControl *control = NULL;
4409 mmf_return_val_if_fail(handle && value, FALSE);
4411 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4415 /*_mmcam_dbg_log("Commit : detect attribute(%d)", attr_idx);*/
4418 current_state = _mmcamcorder_get_state(handle);
4419 if (current_state < MM_CAMCORDER_STATE_READY) {
4420 _mmcam_dbg_log("will be applied when preview starts");
4424 set_value = value->value.i_val;
4427 case MM_CAM_DETECT_MODE:
4428 /* check whether set or not */
4429 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
4430 _mmcam_dbg_log("skip set value %d", set_value);
4434 detect_type = GST_CAMERA_CONTROL_FACE_DETECT_MODE;
4436 case MM_CAM_DETECT_NUMBER:
4437 detect_type = GST_CAMERA_CONTROL_FACE_DETECT_NUMBER;
4439 case MM_CAM_DETECT_FOCUS_SELECT:
4440 detect_type = GST_CAMERA_CONTROL_FACE_FOCUS_SELECT;
4442 case MM_CAM_DETECT_SELECT_NUMBER:
4443 detect_type = GST_CAMERA_CONTROL_FACE_SELECT_NUMBER;
4445 case MM_CAM_DETECT_STATUS:
4446 detect_type = GST_CAMERA_CONTROL_FACE_DETECT_STATUS;
4449 _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
4453 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
4454 _mmcam_dbg_err("Can't cast Video source into camera control.");
4457 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
4458 if (control == NULL) {
4459 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
4463 if (gst_camera_control_get_detect(control, detect_type, ¤t_value)) {
4464 if (current_value == set_value) {
4465 _mmcam_dbg_log("No need to set detect(same). Type[%d],value[%d]", detect_type, set_value);
4468 if (!gst_camera_control_set_detect(control, detect_type, set_value)) {
4469 _mmcam_dbg_warn("Set detect failed. Type[%d],value[%d]",
4470 detect_type, set_value);
4473 _mmcam_dbg_log("Set detect success. Type[%d],value[%d]",
4474 detect_type, set_value);
4479 _mmcam_dbg_warn("Get detect failed. Type[%d]", detect_type);
4488 bool _mmcamcorder_commit_encoded_preview_bitrate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4490 int current_state = MM_CAMCORDER_STATE_NONE;
4491 int preview_format = MM_PIXEL_FORMAT_NV12;
4493 mmf_return_val_if_fail(handle && value, FALSE);
4495 _mmcam_dbg_log("Commit : encoded preview bitrate - %d", value->value.i_val);
4497 /* check preview format */
4498 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FORMAT, &preview_format, NULL);
4499 if (preview_format != MM_PIXEL_FORMAT_ENCODED_H264) {
4500 _mmcam_dbg_err("current preview format[%d] is not encoded format", preview_format);
4505 current_state = _mmcamcorder_get_state(handle);
4506 if (current_state < MM_CAMCORDER_STATE_READY) {
4507 _mmcam_dbg_log("will be applied when preview starts");
4511 return _mmcamcorder_set_encoded_preview_bitrate(handle, value->value.i_val);
4515 bool _mmcamcorder_commit_encoded_preview_gop_interval(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4517 int current_state = MM_CAMCORDER_STATE_NONE;
4518 int preview_format = MM_PIXEL_FORMAT_NV12;
4520 mmf_return_val_if_fail(handle && value, FALSE);
4522 _mmcam_dbg_log("Commit : encoded preview I-frame interval - %d", value->value.i_val);
4524 /* check preview format */
4525 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FORMAT, &preview_format, NULL);
4526 if (preview_format != MM_PIXEL_FORMAT_ENCODED_H264) {
4527 _mmcam_dbg_err("current preview format[%d] is not encoded format", preview_format);
4532 current_state = _mmcamcorder_get_state(handle);
4533 if (current_state < MM_CAMCORDER_STATE_READY) {
4534 _mmcam_dbg_log("will be applied when preview starts");
4538 return _mmcamcorder_set_encoded_preview_gop_interval(handle, value->value.i_val);
4542 bool _mmcamcorder_commit_sound_stream_info(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4544 int stream_index = 0;
4545 char *stream_type = NULL;
4546 _MMCamcorderSubContext *sc = NULL;
4548 mmf_return_val_if_fail(handle && value, FALSE);
4550 stream_type = value->value.s_val;
4552 _mmcam_dbg_err("NULL string");
4556 mm_camcorder_get_attributes(handle, NULL,
4557 MMCAM_SOUND_STREAM_INDEX, &stream_index,
4559 if (stream_index < 0) {
4560 _mmcam_dbg_err("invalid stream index %d", stream_index);
4564 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4565 if (!sc || !sc->encode_element ||
4566 !sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst) {
4567 _mmcam_dbg_warn("audiosrc element is not initialized, it will be set later");
4571 _mmcam_dbg_warn("Commit : sound stream info - type %s, index %d", stream_type, stream_index);
4573 return _mmcamcorder_set_sound_stream_info(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, stream_type, stream_index);
4577 bool _mmcamcorder_commit_tag(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4579 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4580 int current_state = MM_CAMCORDER_STATE_NONE;
4582 mmf_return_val_if_fail(hcamcorder && value, FALSE);
4584 current_state = _mmcamcorder_get_state(handle);
4585 if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
4586 _mmcam_dbg_err("Can not set while CAPTURING");
4587 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
4594 bool _mmcamcorder_commit_audio_replay_gain(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4596 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4598 mmf_return_val_if_fail(hcamcorder && value, FALSE);
4600 if (attr_idx == MM_CAM_AUDIO_REPLAY_GAIN_ENABLE) {
4601 /* Replay gain enable */
4602 int current_state = MM_CAMCORDER_STATE_NONE;
4603 int audio_disable = FALSE;
4605 current_state = _mmcamcorder_get_state(handle);
4606 if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
4607 _mmcam_dbg_err("Can not set replay gain enable [state : %d]", current_state);
4608 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
4612 mm_camcorder_get_attributes(handle, NULL,
4613 MMCAM_AUDIO_DISABLE, &audio_disable,
4616 if (audio_disable) {
4617 _mmcam_dbg_err("audio is disabled");
4618 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_CONDITION;
4622 _mmcam_dbg_log("set replay gain enable : %d", value->value.i_val);
4623 } else if (attr_idx == MM_CAM_AUDIO_REPLAY_GAIN_REFERENCE_LEVEL) {
4624 /* Replay gain reference level */
4625 int replay_gain_enable = FALSE;
4627 mm_camcorder_get_attributes(handle, NULL,
4628 MMCAM_AUDIO_REPLAY_GAIN_ENABLE, &replay_gain_enable,
4631 if (replay_gain_enable == FALSE) {
4632 _mmcam_dbg_err("replay gain is disabled");
4633 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_CONDITION;
4637 _mmcam_dbg_log("set reference level for replay gain : %lf dB", value->value.d_val);
4639 _mmcam_dbg_err("unknown attribute id %d", attr_idx);
4647 bool _mmcamcorder_set_attribute_to_camsensor(MMHandleType handle)
4649 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4650 mmf_attrs_t *attr = NULL;
4652 int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
4656 int attr_idxs_default[] = {
4657 MM_CAM_CAMERA_DIGITAL_ZOOM,
4658 MM_CAM_CAMERA_OPTICAL_ZOOM,
4660 MM_CAM_FILTER_CONTRAST,
4665 int attr_idxs_extra[] = {
4667 MM_CAM_FILTER_BRIGHTNESS,
4669 MM_CAM_FILTER_SATURATION,
4670 MM_CAM_FILTER_SHARPNESS,
4671 MM_CAM_FILTER_COLOR_TONE,
4672 MM_CAM_CAMERA_EXPOSURE_MODE
4675 mmf_return_val_if_fail(hcamcorder, FALSE);
4677 _mmcam_dbg_log("commit some attributes again");
4679 attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
4681 _mmcam_dbg_err("Get attribute handle failed.");
4684 /* Get Scene mode */
4685 mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
4687 _mmcam_dbg_log("attribute count(%d)", attr->count);
4689 for (i = 0 ; i < ARRAY_SIZE(attr_idxs_default) ; i++) {
4690 if (_mmcamcorder_check_supported_attribute(handle, attr_idxs_default[i]))
4691 mmf_attribute_set_modified(&(attr->items[attr_idxs_default[i]]));
4694 /* Set extra if scene mode is NORMAL */
4695 if (scene_mode == MM_CAMCORDER_SCENE_MODE_NORMAL) {
4696 for (i = 0 ; i < ARRAY_SIZE(attr_idxs_extra) ; i++) {
4697 if (_mmcamcorder_check_supported_attribute(handle, attr_idxs_extra[i]))
4698 mmf_attribute_set_modified(&(attr->items[attr_idxs_extra[i]]));
4701 /* Set scene mode if scene mode is NOT NORMAL */
4702 if (_mmcamcorder_check_supported_attribute(handle, MM_CAM_FILTER_SCENE_MODE))
4703 mmf_attribute_set_modified(&(attr->items[MM_CAM_FILTER_SCENE_MODE]));
4706 if (mmf_attrs_commit((MMHandleType)attr) == -1)
4712 _mmcam_dbg_log("Done.");
4718 bool _mmcamcorder_set_attribute_to_camsensor2(MMHandleType handle)
4720 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4721 mmf_attrs_t *attr = NULL;
4729 mmf_return_val_if_fail(hcamcorder, FALSE);
4731 _mmcam_dbg_log("commit some attribute again[2]");
4733 attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
4735 _mmcam_dbg_err("Get attribute handle failed.");
4738 _mmcam_dbg_log("attribute count(%d)", attr->count);
4740 for (i = 0 ; i < ARRAY_SIZE(attr_idxs) ; i++) {
4741 if (_mmcamcorder_check_supported_attribute(handle, attr_idxs[i]))
4742 mmf_attribute_set_modified(&(attr->items[attr_idxs[i]]));
4745 if (mmf_attrs_commit((MMHandleType)attr) == -1)
4751 _mmcam_dbg_log("Done.");
4757 int _mmcamcorder_lock_readonly_attributes(MMHandleType handle)
4759 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4762 mmf_attrs_t *attr = NULL;
4763 int nerror = MM_ERROR_NONE;
4765 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
4767 attr = (mmf_attrs_t*) MMF_CAMCORDER_ATTRS(handle);
4768 mmf_return_val_if_fail(attr, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
4772 table_size = ARRAY_SIZE(readonly_attributes);
4773 _mmcam_dbg_log("%d", table_size);
4774 for (i = 0; i < table_size; i++) {
4775 int sCategory = readonly_attributes[i];
4777 mmf_attribute_set_readonly(&(attr->items[sCategory]));
4784 int _mmcamcorder_set_disabled_attributes(MMHandleType handle)
4786 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4788 mmf_attrs_t *attr = NULL;
4789 type_string_array * disabled_attr = NULL;
4791 int nerror = MM_ERROR_NONE ;
4793 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
4795 attr = (mmf_attrs_t*) MMF_CAMCORDER_ATTRS(handle);
4796 mmf_return_val_if_fail(attr, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
4801 _mmcamcorder_conf_get_value_string_array(hcamcorder->conf_main,
4802 CONFIGURE_CATEGORY_MAIN_GENERAL,
4803 "DisabledAttributes",
4805 if (disabled_attr != NULL && disabled_attr->value) {
4806 cnt_str = disabled_attr->count;
4807 for (i = 0; i < cnt_str; i++) {
4809 _mmcam_dbg_log("[%d]%s", i, disabled_attr->value[i]);
4810 nerror = mm_attrs_get_index((MMHandleType)attr, disabled_attr->value[i], &idx);
4812 if (nerror == MM_ERROR_NONE)
4813 mmf_attribute_set_disabled(&(attr->items[idx]));
4815 _mmcam_dbg_warn("No ATTR named %s[%d]", disabled_attr->value[i], i);
4823 /*---------------------------------------------------------------------------------------
4824 | INTERNAL FUNCTION DEFINITIONS: |
4825 ---------------------------------------------------------------------------------------*/
4826 static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width, int height)
4828 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4829 _MMCamcorderSubContext *sc = NULL;
4830 int current_state = MM_CAMCORDER_STATE_NULL;
4832 mmf_return_val_if_fail(hcamcorder, FALSE);
4834 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4838 current_state = _mmcamcorder_get_state(handle);
4840 if (sc->element && sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
4841 if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
4842 _mmcam_dbg_log("set capture width and height [%dx%d] to camera plugin", width, height);
4843 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-width", width);
4844 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-height", height);
4846 _mmcam_dbg_warn("invalid state[%d]", current_state);
4850 _mmcam_dbg_log("element is not created yet");
4857 static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
4859 #define INIT_VALUE -1
4860 #define CHECK_COUNT 3
4862 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4863 MMHandleType attrs = 0;
4865 int ret = MM_ERROR_NONE;
4868 const char *name = NULL;
4869 const char *check_pair_name[CHECK_COUNT][3] = {
4870 {MMCAM_CAMERA_WIDTH, MMCAM_CAMERA_HEIGHT, "MMCAM_CAMERA_WIDTH and HEIGHT"},
4871 {MMCAM_CAPTURE_WIDTH, MMCAM_CAPTURE_HEIGHT, "MMCAM_CAPTURE_WIDTH and HEIGHT"},
4872 {MMCAM_VIDEO_WIDTH, MMCAM_VIDEO_HEIGHT, "MMCAM_VIDEO_WIDTH and HEIGHT"},
4875 int check_pair_value[CHECK_COUNT][2] = {
4876 {INIT_VALUE, INIT_VALUE},
4877 {INIT_VALUE, INIT_VALUE},
4878 {INIT_VALUE, INIT_VALUE},
4881 if (hcamcorder == NULL || attribute_name == NULL) {
4882 _mmcam_dbg_warn("handle[%p] or attribute_name[%p] is NULL.",
4883 hcamcorder, attribute_name);
4884 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
4888 *err_attr_name = NULL;
4890 /*_mmcam_dbg_log( "ENTER" );*/
4892 attrs = MMF_CAMCORDER_ATTRS(handle);
4894 name = attribute_name;
4898 MMAttrsType attr_type = MM_ATTRS_TYPE_INVALID;
4900 /*_mmcam_dbg_log("NAME : %s", name);*/
4902 /* attribute name check */
4903 if ((ret = mm_attrs_get_index(attrs, name, &idx)) != MM_ERROR_NONE) {
4905 *err_attr_name = strdup(name);
4907 if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY)
4908 return MM_ERROR_COMMON_ATTR_NOT_EXIST;
4914 if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE)
4917 switch (attr_type) {
4918 case MM_ATTRS_TYPE_INT:
4920 gboolean matched = FALSE;
4921 for (i = 0 ; i < CHECK_COUNT ; i++) {
4922 for (j = 0 ; j < 2 ; j++) {
4923 if (!strcmp(name, check_pair_name[i][j])) {
4924 check_pair_value[i][j] = va_arg((var_args), int);
4925 _mmcam_dbg_log("%s : %d", check_pair_name[i][j], check_pair_value[i][j]);
4933 if (matched == FALSE)
4934 va_arg((var_args), int);
4937 case MM_ATTRS_TYPE_DOUBLE:
4938 va_arg((var_args), double);
4940 case MM_ATTRS_TYPE_STRING:
4941 va_arg((var_args), char*); /* string */
4942 va_arg((var_args), int); /* size */
4944 case MM_ATTRS_TYPE_DATA:
4945 va_arg((var_args), void*); /* data */
4946 va_arg((var_args), int); /* size */
4948 case MM_ATTRS_TYPE_INVALID:
4950 _mmcam_dbg_err("Not supported attribute type(%d, name:%s)", attr_type, name);
4952 *err_attr_name = strdup(name);
4954 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
4958 name = va_arg(var_args, const char*);
4961 for (i = 0 ; i < CHECK_COUNT ; i++) {
4962 if (check_pair_value[i][0] != INIT_VALUE || check_pair_value[i][1] != INIT_VALUE) {
4963 gboolean check_result = FALSE;
4964 char *err_name = NULL;
4965 MMCamAttrsInfo attr_info_0, attr_info_1;
4967 if (check_pair_value[i][0] == INIT_VALUE) {
4968 mm_attrs_get_int_by_name(attrs, check_pair_name[i][0], &check_pair_value[i][0]);
4969 err_name = strdup(check_pair_name[i][1]);
4970 } else if (check_pair_value[i][1] == INIT_VALUE) {
4971 mm_attrs_get_int_by_name(attrs, check_pair_name[i][1], &check_pair_value[i][1]);
4972 err_name = strdup(check_pair_name[i][0]);
4974 err_name = strdup(check_pair_name[i][2]);
4977 mm_camcorder_get_attribute_info(handle, check_pair_name[i][0], &attr_info_0);
4978 mm_camcorder_get_attribute_info(handle, check_pair_name[i][1], &attr_info_1);
4980 check_result = FALSE;
4982 for (j = 0 ; j < attr_info_0.int_array.count ; j++) {
4983 if (attr_info_0.int_array.array[j] == check_pair_value[i][0] &&
4984 attr_info_1.int_array.array[j] == check_pair_value[i][1]) {
4986 _mmcam_dbg_log("Valid Pair[%s,%s] existed %dx%d[index:%d]",
4987 check_pair_name[i][0], check_pair_name[i][1],
4988 check_pair_value[i][0], check_pair_value[i][1], i);
4990 check_result = TRUE;
4995 if (check_result == FALSE) {
4996 _mmcam_dbg_err("INVALID pair[%s,%s] %dx%d",
4997 check_pair_name[i][0], check_pair_name[i][1],
4998 check_pair_value[i][0], check_pair_value[i][1]);
4999 if (err_attr_name) {
5000 *err_attr_name = err_name;
5008 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
5011 if (!strcmp(check_pair_name[i][0], MMCAM_CAMERA_WIDTH)) {
5012 int current_width = 0;
5013 int current_height = 0;
5015 mm_camcorder_get_attributes(handle, NULL,
5016 MMCAM_CAMERA_WIDTH, ¤t_width,
5017 MMCAM_CAMERA_HEIGHT, ¤t_height,
5020 if (current_width != check_pair_value[i][0] ||
5021 current_height != check_pair_value[i][1]) {
5022 hcamcorder->resolution_changed = TRUE;
5024 hcamcorder->resolution_changed = FALSE;
5027 _mmcam_dbg_log("resolution changed : %d", hcamcorder->resolution_changed);
5037 /*_mmcam_dbg_log("DONE");*/
5039 return MM_ERROR_NONE;
5043 bool _mmcamcorder_check_supported_attribute(MMHandleType handle, int attr_index)
5047 if ((void *)handle == NULL) {
5048 _mmcam_dbg_warn("handle %p is NULL", handle);
5052 memset(&info, 0x0, sizeof(MMAttrsInfo));
5054 mm_attrs_get_info(MMF_CAMCORDER_ATTRS(handle), attr_index, &info);
5056 switch (info.validity_type) {
5057 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
5059 _mmcam_dbg_log("int array count %d", info.int_array.count);
5061 if (info.int_array.count < 1)
5064 case MM_ATTRS_VALID_TYPE_INT_RANGE:
5066 _mmcam_dbg_log("int range min %d, max %d",info.int_range.min, info.int_range.max);
5068 if (info.int_range.min > info.int_range.max)
5071 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
5073 _mmcam_dbg_log("double array count %d", info.double_array.count);
5075 if (info.double_array.count < 1)
5078 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
5080 _mmcam_dbg_log("double range min %lf, max %lf",info.int_range.min, info.int_range.max);
5082 if (info.double_range.min >= info.double_range.max)
5086 _mmcam_dbg_warn("invalid type %d", info.validity_type);