• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
2  *
3  * Redistribution and use in source and binary forms, with or without
4  * modification, are permitted provided that the following conditions are
5  * met:
6  *     * Redistributions of source code must retain the above copyright
7  *       notice, this list of conditions and the following disclaimer.
8  *     * Redistributions in binary form must reproduce the above
9  *       copyright notice, this list of conditions and the following
10  *       disclaimer in the documentation and/or other materials provided
11  *       with the distribution.
12  *     * Neither the name of The Linux Foundation nor the names of its
13  *       contributors may be used to endorse or promote products derived
14  *       from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  *
28  */
29 
30 #define LOG_TAG "QCameraParameters"
31 
32 #include <cutils/properties.h>
33 #include <math.h>
34 #include <utils/Errors.h>
35 #include <string.h>
36 #include <stdlib.h>
37 #include <gralloc_priv.h>
38 #include "QCamera2HWI.h"
39 #include "QCameraParameters.h"
40 
41 #define ASPECT_TOLERANCE 0.001
42 #define FLIP_V_H (FLIP_H | FLIP_V)
43 
44 namespace qcamera {
45 // Parameter keys to communicate between camera application and driver.
46 const char QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES[] = "hfr-size-values";
47 const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_MODE[] = "preview-frame-rate-mode";
48 const char QCameraParameters::KEY_QC_SUPPORTED_PREVIEW_FRAME_RATE_MODES[] = "preview-frame-rate-modes";
49 const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE[] = "frame-rate-auto";
50 const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE[] = "frame-rate-fixed";
51 const char QCameraParameters::KEY_QC_TOUCH_AF_AEC[] = "touch-af-aec";
52 const char QCameraParameters::KEY_QC_SUPPORTED_TOUCH_AF_AEC[] = "touch-af-aec-values";
53 const char QCameraParameters::KEY_QC_TOUCH_INDEX_AEC[] = "touch-index-aec";
54 const char QCameraParameters::KEY_QC_TOUCH_INDEX_AF[] = "touch-index-af";
55 const char QCameraParameters::KEY_QC_SCENE_DETECT[] = "scene-detect";
56 const char QCameraParameters::KEY_QC_SUPPORTED_SCENE_DETECT[] = "scene-detect-values";
57 const char QCameraParameters::KEY_QC_ISO_MODE[] = "iso";
58 const char QCameraParameters::KEY_QC_SUPPORTED_ISO_MODES[] = "iso-values";
59 const char QCameraParameters::KEY_QC_LENSSHADE[] = "lensshade";
60 const char QCameraParameters::KEY_QC_SUPPORTED_LENSSHADE_MODES[] = "lensshade-values";
61 const char QCameraParameters::KEY_QC_AUTO_EXPOSURE[] = "auto-exposure";
62 const char QCameraParameters::KEY_QC_SUPPORTED_AUTO_EXPOSURE[] = "auto-exposure-values";
63 const char QCameraParameters::KEY_QC_DENOISE[] = "denoise";
64 const char QCameraParameters::KEY_QC_SUPPORTED_DENOISE[] = "denoise-values";
65 const char QCameraParameters::KEY_QC_FOCUS_ALGO[] = "selectable-zone-af";
66 const char QCameraParameters::KEY_QC_SUPPORTED_FOCUS_ALGOS[] = "selectable-zone-af-values";
67 const char QCameraParameters::KEY_QC_FACE_DETECTION[] = "face-detection";
68 const char QCameraParameters::KEY_QC_SUPPORTED_FACE_DETECTION[] = "face-detection-values";
69 const char QCameraParameters::KEY_QC_FACE_RECOGNITION[] = "face-recognition";
70 const char QCameraParameters::KEY_QC_SUPPORTED_FACE_RECOGNITION[] = "face-recognition-values";
71 const char QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT[] = "mce";
72 const char QCameraParameters::KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES[] = "mce-values";
73 const char QCameraParameters::KEY_QC_DIS[] = "dis";
74 const char QCameraParameters::KEY_QC_SUPPORTED_DIS_MODES[] = "dis-values";
75 const char QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE[] = "video-hfr";
76 const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES[] = "video-hfr-values";
77 const char QCameraParameters::KEY_QC_REDEYE_REDUCTION[] = "redeye-reduction";
78 const char QCameraParameters::KEY_QC_SUPPORTED_REDEYE_REDUCTION[] = "redeye-reduction-values";
79 const char QCameraParameters::KEY_QC_HIGH_DYNAMIC_RANGE_IMAGING[] = "hdr";
80 const char QCameraParameters::KEY_QC_SUPPORTED_HDR_IMAGING_MODES[] = "hdr-values";
81 const char QCameraParameters::KEY_QC_ZSL[] = "zsl";
82 const char QCameraParameters::KEY_QC_SUPPORTED_ZSL_MODES[] = "zsl-values";
83 const char QCameraParameters::KEY_QC_ZSL_BURST_INTERVAL[] = "capture-burst-interval";
84 const char QCameraParameters::KEY_QC_ZSL_BURST_LOOKBACK[] = "capture-burst-retroactive";
85 const char QCameraParameters::KEY_QC_ZSL_QUEUE_DEPTH[] = "capture-burst-queue-depth";
86 const char QCameraParameters::KEY_QC_CAMERA_MODE[] = "camera-mode";
87 const char QCameraParameters::KEY_QC_AE_BRACKET_HDR[] = "ae-bracket-hdr";
88 const char QCameraParameters::KEY_QC_SUPPORTED_AE_BRACKET_MODES[] = "ae-bracket-hdr-values";
89 const char QCameraParameters::KEY_QC_SUPPORTED_RAW_FORMATS[] = "raw-format-values";
90 const char QCameraParameters::KEY_QC_RAW_FORMAT[] = "raw-format";
91 const char QCameraParameters::KEY_QC_ORIENTATION[] = "orientation";
92 const char QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF[] = "selectable-zone-af";
93 const char QCameraParameters::KEY_QC_CAPTURE_BURST_EXPOSURE[] = "capture-burst-exposures";
94 const char QCameraParameters::KEY_QC_NUM_SNAPSHOT_PER_SHUTTER[] = "num-snaps-per-shutter";
95 const char QCameraParameters::KEY_QC_NO_DISPLAY_MODE[] = "no-display-mode";
96 const char QCameraParameters::KEY_QC_RAW_PICUTRE_SIZE[] = "raw-size";
97 const char QCameraParameters::KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES[] = "skinToneEnhancement-values";
98 const char QCameraParameters::KEY_QC_SUPPORTED_LIVESNAPSHOT_SIZES[] = "supported-live-snapshot-sizes";
99 const char QCameraParameters::KEY_QC_HDR_NEED_1X[] = "hdr-need-1x";
100 const char QCameraParameters::KEY_QC_PREVIEW_FLIP[] = "preview-flip";
101 const char QCameraParameters::KEY_QC_VIDEO_FLIP[] = "video-flip";
102 const char QCameraParameters::KEY_QC_SNAPSHOT_PICTURE_FLIP[] = "snapshot-picture-flip";
103 const char QCameraParameters::KEY_QC_SUPPORTED_FLIP_MODES[] = "flip-mode-values";
104 const char QCameraParameters::KEY_QC_VIDEO_HDR[] = "video-hdr";
105 const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HDR_MODES[] = "video-hdr-values";
106 
107 // Values for effect settings.
108 const char QCameraParameters::EFFECT_EMBOSS[] = "emboss";
109 const char QCameraParameters::EFFECT_SKETCH[] = "sketch";
110 const char QCameraParameters::EFFECT_NEON[] = "neon";
111 
112 // Values for auto exposure settings.
113 const char QCameraParameters::TOUCH_AF_AEC_OFF[] = "touch-off";
114 const char QCameraParameters::TOUCH_AF_AEC_ON[] = "touch-on";
115 
116 // Values for scene mode settings.
117 const char QCameraParameters::SCENE_MODE_ASD[] = "asd";   // corresponds to CAMERA_BESTSHOT_AUTO in HAL
118 const char QCameraParameters::SCENE_MODE_BACKLIGHT[] = "backlight";
119 const char QCameraParameters::SCENE_MODE_FLOWERS[] = "flowers";
120 const char QCameraParameters::SCENE_MODE_AR[] = "AR";
121 const char QCameraParameters::SCENE_MODE_HDR[] = "hdr";
122 
123 // Formats for setPreviewFormat and setPictureFormat.
124 const char QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO[] = "yuv420sp-adreno";
125 const char QCameraParameters::PIXEL_FORMAT_YV12[] = "yuv420p";
126 const char QCameraParameters::PIXEL_FORMAT_NV12[] = "nv12";
127 
128 // Values for raw image formats
129 const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV[] = "yuv-raw8-yuyv";
130 const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU[] = "yuv-raw8-yvyu";
131 const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY[] = "yuv-raw8-uyvy";
132 const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY[] = "yuv-raw8-vyuy";
133 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG[] = "bayer-qcom-8gbrg";
134 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG[] = "bayer-qcom-8grbg";
135 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB[] = "bayer-qcom-8rggb";
136 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR[] = "bayer-qcom-8bggr";
137 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG[] = "bayer-qcom-10gbrg";
138 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG[] = "bayer-qcom-10grbg";
139 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB[] = "bayer-qcom-10rggb";
140 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR[] = "bayer-qcom-10bggr";
141 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG[] = "bayer-qcom-12gbrg";
142 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG[] = "bayer-qcom-12grbg";
143 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB[] = "bayer-qcom-12rggb";
144 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR[] = "bayer-qcom-12bggr";
145 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG[] = "bayer-mipi-8gbrg";
146 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG[] = "bayer-mipi-8grbg";
147 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB[] = "bayer-mipi-8rggb";
148 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR[] = "bayer-mipi-8bggr";
149 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG[] = "bayer-mipi-10gbrg";
150 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG[] = "bayer-mipi-10grbg";
151 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB[] = "bayer-mipi-10rggb";
152 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR[] = "bayer-mipi-10bggr";
153 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG[] = "bayer-mipi-12gbrg";
154 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG[] = "bayer-mipi-12grbg";
155 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB[] = "bayer-mipi-12rggb";
156 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR[] = "bayer-mipi-12bggr";
157 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG[] = "bayer-ideal-qcom-8gbrg";
158 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG[] = "bayer-ideal-qcom-8grbg";
159 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB[] = "bayer-ideal-qcom-8rggb";
160 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR[] = "bayer-ideal-qcom-8bggr";
161 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG[] = "bayer-ideal-qcom-10gbrg";
162 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG[] = "bayer-ideal-qcom-10grbg";
163 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB[] = "bayer-ideal-qcom-10rggb";
164 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR[] = "bayer-ideal-qcom-10bggr";
165 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG[] = "bayer-ideal-qcom-12gbrg";
166 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG[] = "bayer-ideal-qcom-12grbg";
167 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB[] = "bayer-ideal-qcom-12rggb";
168 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR[] = "bayer-ideal-qcom-12bggr";
169 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG[] = "bayer-ideal-mipi-8gbrg";
170 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG[] = "bayer-ideal-mipi-8grbg";
171 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB[] = "bayer-ideal-mipi-8rggb";
172 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR[] = "bayer-ideal-mipi-8bggr";
173 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG[] = "bayer-ideal-mipi-10gbrg";
174 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG[] = "bayer-ideal-mipi-10grbg";
175 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB[] = "bayer-ideal-mipi-10rggb";
176 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR[] = "bayer-ideal-mipi-10bggr";
177 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG[] = "bayer-ideal-mipi-12gbrg";
178 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG[] = "bayer-ideal-mipi-12grbg";
179 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB[] = "bayer-ideal-mipi-12rggb";
180 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR[] = "bayer-ideal-mipi-12bggr";
181 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG[] = "bayer-ideal-plain8-8gbrg";
182 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG[] = "bayer-ideal-plain8-8grbg";
183 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB[] = "bayer-ideal-plain8-8rggb";
184 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR[] = "bayer-ideal-plain8-8bggr";
185 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG[] = "bayer-ideal-plain16-8gbrg";
186 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG[] = "bayer-ideal-plain16-8grbg";
187 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB[] = "bayer-ideal-plain16-8rggb";
188 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR[] = "bayer-ideal-plain16-8bggr";
189 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG[] = "bayer-ideal-plain16-10gbrg";
190 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG[] = "bayer-ideal-plain16-10grbg";
191 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB[] = "bayer-ideal-plain16-10rggb";
192 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR[] = "bayer-ideal-plain16-10bggr";
193 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG[] = "bayer-ideal-plain16-12gbrg";
194 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG[] = "bayer-ideal-plain16-12grbg";
195 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB[] = "bayer-ideal-plain16-12rggb";
196 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR[] = "bayer-ideal-plain16-12bggr";
197 
198 // Values for ISO Settings
199 const char QCameraParameters::ISO_AUTO[] = "auto";
200 const char QCameraParameters::ISO_HJR[] = "ISO_HJR";
201 const char QCameraParameters::ISO_100[] = "ISO100";
202 const char QCameraParameters::ISO_200[] = "ISO200";
203 const char QCameraParameters::ISO_400[] = "ISO400";
204 const char QCameraParameters::ISO_800[] = "ISO800";
205 const char QCameraParameters::ISO_1600[] = "ISO1600";
206 
207 // Values for auto exposure settings.
208 const char QCameraParameters::AUTO_EXPOSURE_FRAME_AVG[] = "frame-average";
209 const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED[] = "center-weighted";
210 const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING[] = "spot-metering";
211 const char QCameraParameters::AUTO_EXPOSURE_SMART_METERING[] = "smart-metering";
212 const char QCameraParameters::AUTO_EXPOSURE_USER_METERING[] = "user-metering";
213 const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING_ADV[] = "spot-metering-adv";
214 const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED_ADV[] = "center-weighted-adv";
215 
216 const char QCameraParameters::KEY_QC_GPS_LATITUDE_REF[] = "gps-latitude-ref";
217 const char QCameraParameters::KEY_QC_GPS_LONGITUDE_REF[] = "gps-longitude-ref";
218 const char QCameraParameters::KEY_QC_GPS_ALTITUDE_REF[] = "gps-altitude-ref";
219 const char QCameraParameters::KEY_QC_GPS_STATUS[] = "gps-status";
220 
221 const char QCameraParameters::KEY_QC_HISTOGRAM[] = "histogram";
222 const char QCameraParameters::KEY_QC_SUPPORTED_HISTOGRAM_MODES[] = "histogram-values";
223 
224 const char QCameraParameters::VALUE_ENABLE[] = "enable";
225 const char QCameraParameters::VALUE_DISABLE[] = "disable";
226 const char QCameraParameters::VALUE_OFF[] = "off";
227 const char QCameraParameters::VALUE_ON[] = "on";
228 const char QCameraParameters::VALUE_TRUE[] = "true";
229 const char QCameraParameters::VALUE_FALSE[] = "false";
230 
231 const char QCameraParameters::KEY_QC_SHARPNESS[] = "sharpness";
232 const char QCameraParameters::KEY_QC_MIN_SHARPNESS[] = "min-sharpness";
233 const char QCameraParameters::KEY_QC_MAX_SHARPNESS[] = "max-sharpness";
234 const char QCameraParameters::KEY_QC_SHARPNESS_STEP[] = "sharpness-step";
235 const char QCameraParameters::KEY_QC_CONTRAST[] = "contrast";
236 const char QCameraParameters::KEY_QC_MIN_CONTRAST[] = "min-contrast";
237 const char QCameraParameters::KEY_QC_MAX_CONTRAST[] = "max-contrast";
238 const char QCameraParameters::KEY_QC_CONTRAST_STEP[] = "contrast-step";
239 const char QCameraParameters::KEY_QC_SATURATION[] = "saturation";
240 const char QCameraParameters::KEY_QC_MIN_SATURATION[] = "min-saturation";
241 const char QCameraParameters::KEY_QC_MAX_SATURATION[] = "max-saturation";
242 const char QCameraParameters::KEY_QC_SATURATION_STEP[] = "saturation-step";
243 const char QCameraParameters::KEY_QC_BRIGHTNESS[] = "luma-adaptation";
244 const char QCameraParameters::KEY_QC_MIN_BRIGHTNESS[] = "min-brightness";
245 const char QCameraParameters::KEY_QC_MAX_BRIGHTNESS[] = "max-brightness";
246 const char QCameraParameters::KEY_QC_BRIGHTNESS_STEP[] = "brightness-step";
247 const char QCameraParameters::KEY_QC_SCE_FACTOR[] = "skinToneEnhancement";
248 const char QCameraParameters::KEY_QC_MIN_SCE_FACTOR[] = "min-sce-factor";
249 const char QCameraParameters::KEY_QC_MAX_SCE_FACTOR[] = "max-sce-factor";
250 const char QCameraParameters::KEY_QC_SCE_FACTOR_STEP[] = "sce-factor-step";
251 
252 const char QCameraParameters::KEY_QC_SUPPORTED_CAMERA_FEATURES[] = "qc-camera-features";
253 const char QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES[] = "qc-max-num-requested-faces";
254 
255 //Values for DENOISE
256 const char QCameraParameters::DENOISE_OFF[] = "denoise-off";
257 const char QCameraParameters::DENOISE_ON[] = "denoise-on";
258 
259 // Values for selectable zone af Settings
260 const char QCameraParameters::FOCUS_ALGO_AUTO[] = "auto";
261 const char QCameraParameters::FOCUS_ALGO_SPOT_METERING[] = "spot-metering";
262 const char QCameraParameters::FOCUS_ALGO_CENTER_WEIGHTED[] = "center-weighted";
263 const char QCameraParameters::FOCUS_ALGO_FRAME_AVERAGE[] = "frame-average";
264 
265 // Values for HFR settings.
266 const char QCameraParameters::VIDEO_HFR_OFF[] = "off";
267 const char QCameraParameters::VIDEO_HFR_2X[] = "60";
268 const char QCameraParameters::VIDEO_HFR_3X[] = "90";
269 const char QCameraParameters::VIDEO_HFR_4X[] = "120";
270 const char QCameraParameters::VIDEO_HFR_5X[] = "150";
271 
272 // Values for HDR Bracketing settings.
273 const char QCameraParameters::AE_BRACKET_OFF[] = "Off";
274 const char QCameraParameters::AE_BRACKET[] = "AE-Bracket";
275 
276 // Values for FLIP settings.
277 const char QCameraParameters::FLIP_MODE_OFF[] = "off";
278 const char QCameraParameters::FLIP_MODE_V[] = "flip-v";
279 const char QCameraParameters::FLIP_MODE_H[] = "flip-h";
280 const char QCameraParameters::FLIP_MODE_VH[] = "flip-vh";
281 
282 static const char* portrait = "portrait";
283 static const char* landscape = "landscape";
284 
285 const cam_dimension_t QCameraParameters::THUMBNAIL_SIZES_MAP[] = {
286     { 512, 288 }, //1.777778
287     { 480, 288 }, //1.666667
288     { 256, 154 }, //1.66233
289     { 432, 288 }, //1.5
290     { 320, 240 }, //1.33333
291     { 176, 144 }, //1.222222
292     { 0, 0 }      // required by Android SDK
293 };
294 
295 const QCameraParameters::QCameraMap QCameraParameters::AUTO_EXPOSURE_MAP[] = {
296     { AUTO_EXPOSURE_FRAME_AVG,           CAM_AEC_MODE_FRAME_AVERAGE },
297     { AUTO_EXPOSURE_CENTER_WEIGHTED,     CAM_AEC_MODE_CENTER_WEIGHTED },
298     { AUTO_EXPOSURE_SPOT_METERING,       CAM_AEC_MODE_SPOT_METERING },
299     { AUTO_EXPOSURE_SMART_METERING,      CAM_AEC_MODE_SMART_METERING },
300     { AUTO_EXPOSURE_USER_METERING,       CAM_AEC_MODE_USER_METERING },
301     { AUTO_EXPOSURE_SPOT_METERING_ADV,   CAM_AEC_MODE_SPOT_METERING_ADV },
302     { AUTO_EXPOSURE_CENTER_WEIGHTED_ADV, CAM_AEC_MODE_CENTER_WEIGHTED_ADV },
303 };
304 
305 const QCameraParameters::QCameraMap QCameraParameters::PREVIEW_FORMATS_MAP[] = {
306     {PIXEL_FORMAT_YUV420SP,        CAM_FORMAT_YUV_420_NV21},
307     {PIXEL_FORMAT_YUV420P,         CAM_FORMAT_YUV_420_YV12},
308     {PIXEL_FORMAT_YUV420SP_ADRENO, CAM_FORMAT_YUV_420_NV21_ADRENO},
309     {PIXEL_FORMAT_YV12,            CAM_FORMAT_YUV_420_YV12},
310     {PIXEL_FORMAT_NV12,            CAM_FORMAT_YUV_420_NV12}
311 };
312 
313 const QCameraParameters::QCameraMap QCameraParameters::PICTURE_TYPES_MAP[] = {
314     {PIXEL_FORMAT_JPEG,                          CAM_FORMAT_JPEG},
315     {PIXEL_FORMAT_YUV422SP,                      CAM_FORMAT_YUV_422_NV16},
316     {QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV,          CAM_FORMAT_YUV_RAW_8BIT_YUYV},
317     {QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU,          CAM_FORMAT_YUV_RAW_8BIT_YVYU},
318     {QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY,          CAM_FORMAT_YUV_RAW_8BIT_UYVY},
319     {QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY,          CAM_FORMAT_YUV_RAW_8BIT_VYUY},
320     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG,       CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GBRG},
321     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG,       CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GRBG},
322     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB,       CAM_FORMAT_BAYER_QCOM_RAW_8BPP_RGGB},
323     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR,       CAM_FORMAT_BAYER_QCOM_RAW_8BPP_BGGR},
324     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG,      CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GBRG},
325     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG,      CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GRBG},
326     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB,      CAM_FORMAT_BAYER_QCOM_RAW_10BPP_RGGB},
327     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR,      CAM_FORMAT_BAYER_QCOM_RAW_10BPP_BGGR},
328     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG,      CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GBRG},
329     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG,      CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GRBG},
330     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB,      CAM_FORMAT_BAYER_QCOM_RAW_12BPP_RGGB},
331     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR,      CAM_FORMAT_BAYER_QCOM_RAW_12BPP_BGGR},
332     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG,       CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GBRG},
333     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG,       CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GRBG},
334     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB,       CAM_FORMAT_BAYER_MIPI_RAW_8BPP_RGGB},
335     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR,       CAM_FORMAT_BAYER_MIPI_RAW_8BPP_BGGR},
336     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG,      CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GBRG},
337     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG,      CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GRBG},
338     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB,      CAM_FORMAT_BAYER_MIPI_RAW_10BPP_RGGB},
339     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR,      CAM_FORMAT_BAYER_MIPI_RAW_10BPP_BGGR},
340     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG,      CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GBRG},
341     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG,      CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GRBG},
342     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB,      CAM_FORMAT_BAYER_MIPI_RAW_12BPP_RGGB},
343     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR,      CAM_FORMAT_BAYER_MIPI_RAW_12BPP_BGGR},
344     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG,     CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_GBRG},
345     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG,     CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_GRBG},
346     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB,     CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_RGGB},
347     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR,     CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_BGGR},
348     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_GBRG},
349     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_GRBG},
350     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_RGGB},
351     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_BGGR},
352     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_GBRG},
353     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_GRBG},
354     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_RGGB},
355     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_BGGR},
356     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG,     CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_GBRG},
357     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG,     CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_GRBG},
358     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB,     CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_RGGB},
359     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR,     CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_BGGR},
360     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_GBRG},
361     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_GRBG},
362     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_RGGB},
363     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_BGGR},
364     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_GBRG},
365     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_GRBG},
366     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_RGGB},
367     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_BGGR},
368     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG,   CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_GBRG},
369     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG,   CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_GRBG},
370     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB,   CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_RGGB},
371     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR,   CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_BGGR},
372     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG,  CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_GBRG},
373     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG,  CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_GRBG},
374     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB,  CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_RGGB},
375     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR,  CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_BGGR},
376     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GBRG},
377     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GRBG},
378     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_RGGB},
379     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_BGGR},
380     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_GBRG},
381     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_GRBG},
382     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_RGGB},
383     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_BGGR}
384 };
385 
386 const QCameraParameters::QCameraMap QCameraParameters::RAW_FORMATS_MAP[] = {
387 };
388 
389 const QCameraParameters::QCameraMap QCameraParameters::FOCUS_MODES_MAP[] = {
390     { FOCUS_MODE_AUTO,               CAM_FOCUS_MODE_AUTO },
391     { FOCUS_MODE_INFINITY,           CAM_FOCUS_MODE_INFINITY },
392     { FOCUS_MODE_MACRO,              CAM_FOCUS_MODE_MACRO },
393     { FOCUS_MODE_FIXED,              CAM_FOCUS_MODE_FIXED },
394     { FOCUS_MODE_EDOF,               CAM_FOCUS_MODE_EDOF },
395     { FOCUS_MODE_CONTINUOUS_PICTURE, CAM_FOCUS_MODE_CONTINOUS_PICTURE },
396     { FOCUS_MODE_CONTINUOUS_VIDEO,   CAM_FOCUS_MODE_CONTINOUS_VIDEO }
397 };
398 
399 const QCameraParameters::QCameraMap QCameraParameters::EFFECT_MODES_MAP[] = {
400     { EFFECT_NONE,       CAM_EFFECT_MODE_OFF },
401     { EFFECT_MONO,       CAM_EFFECT_MODE_MONO },
402     { EFFECT_NEGATIVE,   CAM_EFFECT_MODE_NEGATIVE },
403     { EFFECT_SOLARIZE,   CAM_EFFECT_MODE_SOLARIZE },
404     { EFFECT_SEPIA,      CAM_EFFECT_MODE_SEPIA },
405     { EFFECT_POSTERIZE,  CAM_EFFECT_MODE_POSTERIZE },
406     { EFFECT_WHITEBOARD, CAM_EFFECT_MODE_WHITEBOARD },
407     { EFFECT_BLACKBOARD, CAM_EFFECT_MODE_BLACKBOARD },
408     { EFFECT_AQUA,       CAM_EFFECT_MODE_AQUA },
409     { EFFECT_EMBOSS,     CAM_EFFECT_MODE_EMBOSS },
410     { EFFECT_SKETCH,     CAM_EFFECT_MODE_SKETCH },
411     { EFFECT_NEON,       CAM_EFFECT_MODE_NEON }
412 };
413 
414 const QCameraParameters::QCameraMap QCameraParameters::SCENE_MODES_MAP[] = {
415     { SCENE_MODE_AUTO,           CAM_SCENE_MODE_OFF },
416     { SCENE_MODE_ACTION,         CAM_SCENE_MODE_ACTION },
417     { SCENE_MODE_PORTRAIT,       CAM_SCENE_MODE_PORTRAIT },
418     { SCENE_MODE_LANDSCAPE,      CAM_SCENE_MODE_LANDSCAPE },
419     { SCENE_MODE_NIGHT,          CAM_SCENE_MODE_NIGHT },
420     { SCENE_MODE_NIGHT_PORTRAIT, CAM_SCENE_MODE_NIGHT_PORTRAIT },
421     { SCENE_MODE_THEATRE,        CAM_SCENE_MODE_THEATRE },
422     { SCENE_MODE_BEACH,          CAM_SCENE_MODE_BEACH },
423     { SCENE_MODE_SNOW,           CAM_SCENE_MODE_SNOW },
424     { SCENE_MODE_SUNSET,         CAM_SCENE_MODE_SUNSET },
425     { SCENE_MODE_STEADYPHOTO,    CAM_SCENE_MODE_ANTISHAKE },
426     { SCENE_MODE_FIREWORKS ,     CAM_SCENE_MODE_FIREWORKS },
427     { SCENE_MODE_SPORTS ,        CAM_SCENE_MODE_SPORTS },
428     { SCENE_MODE_PARTY,          CAM_SCENE_MODE_PARTY },
429     { SCENE_MODE_CANDLELIGHT,    CAM_SCENE_MODE_CANDLELIGHT },
430     { SCENE_MODE_ASD,            CAM_SCENE_MODE_AUTO },
431     { SCENE_MODE_BACKLIGHT,      CAM_SCENE_MODE_BACKLIGHT },
432     { SCENE_MODE_FLOWERS,        CAM_SCENE_MODE_FLOWERS },
433     { SCENE_MODE_AR,             CAM_SCENE_MODE_AR },
434     { SCENE_MODE_HDR,            CAM_SCENE_MODE_OFF },
435 };
436 
437 const QCameraParameters::QCameraMap QCameraParameters::FLASH_MODES_MAP[] = {
438     { FLASH_MODE_OFF,   CAM_FLASH_MODE_OFF },
439     { FLASH_MODE_AUTO,  CAM_FLASH_MODE_AUTO },
440     { FLASH_MODE_ON,    CAM_FLASH_MODE_ON },
441     { FLASH_MODE_TORCH, CAM_FLASH_MODE_TORCH }
442 };
443 
444 const QCameraParameters::QCameraMap QCameraParameters::FOCUS_ALGO_MAP[] = {
445     { FOCUS_ALGO_AUTO,            CAM_FOCUS_ALGO_AUTO },
446     { FOCUS_ALGO_SPOT_METERING,   CAM_FOCUS_ALGO_SPOT },
447     { FOCUS_ALGO_CENTER_WEIGHTED, CAM_FOCUS_ALGO_CENTER_WEIGHTED },
448     { FOCUS_ALGO_FRAME_AVERAGE,   CAM_FOCUS_ALGO_AVERAGE }
449 };
450 
451 const QCameraParameters::QCameraMap QCameraParameters::WHITE_BALANCE_MODES_MAP[] = {
452     { WHITE_BALANCE_AUTO,            CAM_WB_MODE_AUTO },
453     { WHITE_BALANCE_INCANDESCENT,    CAM_WB_MODE_INCANDESCENT },
454     { WHITE_BALANCE_FLUORESCENT,     CAM_WB_MODE_FLUORESCENT },
455     { WHITE_BALANCE_WARM_FLUORESCENT,CAM_WB_MODE_WARM_FLUORESCENT},
456     { WHITE_BALANCE_DAYLIGHT,        CAM_WB_MODE_DAYLIGHT },
457     { WHITE_BALANCE_CLOUDY_DAYLIGHT, CAM_WB_MODE_CLOUDY_DAYLIGHT },
458     { WHITE_BALANCE_TWILIGHT,        CAM_WB_MODE_TWILIGHT },
459     { WHITE_BALANCE_SHADE,           CAM_WB_MODE_SHADE }
460 };
461 
462 const QCameraParameters::QCameraMap QCameraParameters::ANTIBANDING_MODES_MAP[] = {
463     { ANTIBANDING_OFF,  CAM_ANTIBANDING_MODE_OFF },
464     { ANTIBANDING_50HZ, CAM_ANTIBANDING_MODE_50HZ },
465     { ANTIBANDING_60HZ, CAM_ANTIBANDING_MODE_60HZ },
466     { ANTIBANDING_AUTO, CAM_ANTIBANDING_MODE_AUTO }
467 };
468 
469 const QCameraParameters::QCameraMap QCameraParameters::ISO_MODES_MAP[] = {
470     { ISO_AUTO,  CAM_ISO_MODE_AUTO },
471     { ISO_HJR,   CAM_ISO_MODE_DEBLUR },
472     { ISO_100,   CAM_ISO_MODE_100 },
473     { ISO_200,   CAM_ISO_MODE_200 },
474     { ISO_400,   CAM_ISO_MODE_400 },
475     { ISO_800,   CAM_ISO_MODE_800 },
476     { ISO_1600,  CAM_ISO_MODE_1600 }
477 };
478 
479 const QCameraParameters::QCameraMap QCameraParameters::HFR_MODES_MAP[] = {
480     { VIDEO_HFR_OFF, CAM_HFR_MODE_OFF },
481     { VIDEO_HFR_2X,  CAM_HFR_MODE_60FPS },
482     { VIDEO_HFR_3X,  CAM_HFR_MODE_90FPS },
483     { VIDEO_HFR_4X,  CAM_HFR_MODE_120FPS },
484     { VIDEO_HFR_5X,  CAM_HFR_MODE_150FPS }
485 };
486 
487 const QCameraParameters::QCameraMap QCameraParameters::BRACKETING_MODES_MAP[] = {
488     { AE_BRACKET_OFF, CAM_EXP_BRACKETING_OFF },
489     { AE_BRACKET,         CAM_EXP_BRACKETING_ON }
490 };
491 
492 const QCameraParameters::QCameraMap QCameraParameters::ON_OFF_MODES_MAP[] = {
493     { VALUE_OFF, 0 },
494     { VALUE_ON,  1 }
495 };
496 
497 const QCameraParameters::QCameraMap QCameraParameters::TOUCH_AF_AEC_MODES_MAP[] = {
498     { QCameraParameters::TOUCH_AF_AEC_OFF, 0 },
499     { QCameraParameters::TOUCH_AF_AEC_ON, 1 }
500 };
501 
502 const QCameraParameters::QCameraMap QCameraParameters::ENABLE_DISABLE_MODES_MAP[] = {
503     { VALUE_ENABLE,  1 },
504     { VALUE_DISABLE, 0 }
505 };
506 
507 const QCameraParameters::QCameraMap QCameraParameters::DENOISE_ON_OFF_MODES_MAP[] = {
508     { DENOISE_OFF, 0 },
509     { DENOISE_ON,  1 }
510 };
511 
512 const QCameraParameters::QCameraMap QCameraParameters::TRUE_FALSE_MODES_MAP[] = {
513     { VALUE_FALSE, 0},
514     { VALUE_TRUE,  1}
515 };
516 
517 const QCameraParameters::QCameraMap QCameraParameters::FLIP_MODES_MAP[] = {
518     {FLIP_MODE_OFF, 0},
519     {FLIP_MODE_V, FLIP_V},
520     {FLIP_MODE_H, FLIP_H},
521     {FLIP_MODE_VH, FLIP_V_H}
522 };
523 
524 #define DEFAULT_CAMERA_AREA "(0, 0, 0, 0, 0)"
525 #define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
526 
527 /*===========================================================================
528  * FUNCTION   : QCameraParameters
529  *
530  * DESCRIPTION: default constructor of QCameraParameters
531  *
532  * PARAMETERS : none
533  *
534  * RETURN     : None
535  *==========================================================================*/
QCameraParameters()536 QCameraParameters::QCameraParameters()
537     : CameraParameters(),
538       m_pCapability(NULL),
539       m_pCamOpsTbl(NULL),
540       m_pParamHeap(NULL),
541       m_pParamBuf(NULL),
542       m_bZslMode(false),
543       m_bZslMode_new(false),
544       m_bRecordingHint(false),
545       m_bRecordingHint_new(false),
546       m_bHistogramEnabled(false),
547       m_nFaceProcMask(0),
548       m_bDebugFps(false),
549       mFocusMode(CAM_FOCUS_MODE_MAX),
550       mPreviewFormat(CAM_FORMAT_YUV_420_NV21),
551       mPictureFormat(CAM_FORMAT_JPEG),
552       m_bNeedRestart(false),
553       m_bNoDisplayMode(false),
554       m_bWNROn(false),
555       m_bNeedLockCAF(false),
556       m_bCAFLocked(false),
557       m_bAFRunning(false),
558       m_tempMap()
559 {
560     char value[PROPERTY_VALUE_MAX];
561     // TODO: may move to parameter instead of sysprop
562     property_get("persist.debug.sf.showfps", value, "0");
563     m_bDebugFps = atoi(value) > 0 ? true : false;
564 
565     // For thermal mode, it should be set as system property
566     // because system property applies to all applications, while
567     // parameters only apply to specific app.
568     property_get("persist.camera.thermal.mode", value, "fps");
569     if (!strcmp(value, "frameskip")) {
570         m_ThermalMode = QCAMERA_THERMAL_ADJUST_FRAMESKIP;
571     } else {
572         if (strcmp(value, "fps"))
573             ALOGE("%s: Invalid camera thermal mode %s", __func__, value);
574         m_ThermalMode = QCAMERA_THERMAL_ADJUST_FPS;
575     }
576 
577     memset(&m_LiveSnapshotSize, 0, sizeof(m_LiveSnapshotSize));
578 }
579 
580 /*===========================================================================
581  * FUNCTION   : QCameraParameters
582  *
583  * DESCRIPTION: constructor of QCameraParameters
584  *
585  * PARAMETERS :
586  *   @params  : parameters in string
587  *
588  * RETURN     : None
589  *==========================================================================*/
QCameraParameters(const String8 & params)590 QCameraParameters::QCameraParameters(const String8 &params)
591     : CameraParameters(params),
592     m_pCapability(NULL),
593     m_pCamOpsTbl(NULL),
594     m_pParamHeap(NULL),
595     m_pParamBuf(NULL),
596     m_bZslMode(false),
597     m_bZslMode_new(false),
598     m_bRecordingHint(false),
599     m_bRecordingHint_new(false),
600     m_bHistogramEnabled(false),
601     m_nFaceProcMask(0),
602     m_bDebugFps(false),
603     mFocusMode(CAM_FOCUS_MODE_MAX),
604     mPreviewFormat(CAM_FORMAT_YUV_420_NV21),
605     mPictureFormat(CAM_FORMAT_JPEG),
606     m_bNeedRestart(false),
607     m_bNoDisplayMode(false),
608     m_bWNROn(false),
609     m_bNeedLockCAF(false),
610     m_bCAFLocked(false),
611     m_bAFRunning(false),
612     m_tempMap()
613 {
614     memset(&m_LiveSnapshotSize, 0, sizeof(m_LiveSnapshotSize));
615 }
616 
617 /*===========================================================================
618  * FUNCTION   : ~QCameraParameters
619  *
620  * DESCRIPTION: deconstructor of QCameraParameters
621  *
622  * PARAMETERS : none
623  *
624  * RETURN     : None
625  *==========================================================================*/
~QCameraParameters()626 QCameraParameters::~QCameraParameters()
627 {
628     deinit();
629 }
630 
631 /*===========================================================================
632  * FUNCTION   : createSizesString
633  *
634  * DESCRIPTION: create string obj contains array of dimensions
635  *
636  * PARAMETERS :
637  *   @sizes   : array of dimensions
638  *   @len     : size of dimension array
639  *
640  * RETURN     : string obj
641  *==========================================================================*/
createSizesString(const cam_dimension_t * sizes,int len)642 String8 QCameraParameters::createSizesString(const cam_dimension_t *sizes, int len)
643 {
644     String8 str;
645     char buffer[32];
646 
647     if (len > 0) {
648         snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height);
649         str.append(buffer);
650     }
651     for (int i = 1; i < len; i++) {
652         snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height);
653         str.append(buffer);
654     }
655     return str;
656 }
657 
658 /*===========================================================================
659  * FUNCTION   : createValuesString
660  *
661  * DESCRIPTION: create string obj contains array of values from map when matched
662  *              from input values array
663  *
664  * PARAMETERS :
665  *   @values  : array of values
666  *   @len     : size of values array
667  *   @map     : map contains the mapping between values and enums
668  *   @map_len : size of the map
669  *
670  * RETURN     : string obj
671  *==========================================================================*/
createValuesString(const int * values,int len,const QCameraMap * map,int map_len)672 String8 QCameraParameters::createValuesString(const int *values,
673                                               int len,
674                                               const QCameraMap* map,
675                                               int map_len)
676 {
677     String8 str;
678     int count = 0;
679 
680     for (int i = 0; i < len; i++ ) {
681         for (int j = 0; j < map_len; j ++)
682             if (map[j].val == values[i]) {
683                 if (NULL != map[j].desc) {
684                     if (count > 0) {
685                         str.append(",");
686                     }
687                     str.append(map[j].desc);
688                     count++;
689                     break; //loop j
690                 }
691             }
692     }
693     return str;
694 }
695 
696 /*===========================================================================
697  * FUNCTION   : createValuesStringFromMap
698  *
699  * DESCRIPTION: create string obj contains array of values directly from map
700  *
701  * PARAMETERS :
702  *   @map     : map contains the mapping between values and enums
703  *   @map_len : size of the map
704  *
705  * RETURN     : string obj
706  *==========================================================================*/
createValuesStringFromMap(const QCameraMap * map,int map_len)707 String8 QCameraParameters::createValuesStringFromMap(const QCameraMap* map,
708                                                      int map_len)
709 {
710     String8 str;
711 
712     for (int i = 0; i < map_len; i++) {
713         if (NULL != map[i].desc) {
714             if (i > 0) {
715                 str.append(",");
716             }
717             str.append(map[i].desc);
718         }
719     }
720     return str;
721 }
722 
723 /*===========================================================================
724  * FUNCTION   : createZoomRatioValuesString
725  *
726  * DESCRIPTION: create string obj contains array of zoom ratio values
727  *
728  * PARAMETERS :
729  *   @zoomRaios  : array of zoom ratios
730  *   @length     : size of the array
731  *
732  * RETURN     : string obj
733  *==========================================================================*/
createZoomRatioValuesString(int * zoomRatios,int length)734 String8 QCameraParameters::createZoomRatioValuesString(int *zoomRatios, int length)
735 {
736     String8 str;
737     char buffer[32] = {0};
738 
739     if(length > 0){
740         snprintf(buffer, sizeof(buffer), "%d", zoomRatios[0]);
741         str.append(buffer);
742     }
743 
744     for (int i =1;i<length;i++){
745         memset(buffer, 0, sizeof(buffer));
746         snprintf(buffer, sizeof(buffer), ",%d", zoomRatios[i]);
747         str.append(buffer);
748     }
749     return str;
750 }
751 
752 /*===========================================================================
753  * FUNCTION   : createHfrValuesString
754  *
755  * DESCRIPTION: create string obj contains array of hfr values from map when
756  *              matched from input hfr values
757  *
758  * PARAMETERS :
759  *   @values  : array of hfr info
760  *   @len     : size of the array
761  *   @map     : map of hfr string value and enum
762  *   map_len  : size of map
763  *
764  * RETURN     : string obj
765  *==========================================================================*/
createHfrValuesString(const cam_hfr_info_t * values,int len,const QCameraMap * map,int map_len)766 String8 QCameraParameters::createHfrValuesString(
767                                 const cam_hfr_info_t *values,
768                                 int len,
769                                 const QCameraMap* map,
770                                 int map_len)
771 {
772     String8 str;
773     int count = 0;
774 
775     for (int i = 0; i < len; i++ ) {
776         for (int j = 0; j < map_len; j ++)
777             if (map[j].val == (int)values[i].mode) {
778                 if (NULL != map[j].desc) {
779                     if (count > 0) {
780                         str.append(",");
781                     }
782                      str.append(map[j].desc);
783                      count++;
784                      break; //loop j
785                 }
786             }
787     }
788     return str;
789 }
790 
791 /*===========================================================================
792  * FUNCTION   : createHfrSizesString
793  *
794  * DESCRIPTION: create string obj contains array of hfr sizes
795  *
796  * PARAMETERS :
797  *   @values  : array of hfr info
798  *   @len     : size of the array
799  *
800  * RETURN     : string obj
801  *==========================================================================*/
createHfrSizesString(const cam_hfr_info_t * values,int len)802 String8 QCameraParameters::createHfrSizesString(
803                                 const cam_hfr_info_t *values,
804                                 int len)
805 {
806     String8 str;
807     char buffer[32];
808 
809     if (len > 0) {
810         snprintf(buffer, sizeof(buffer), "%dx%d",
811                  values[0].dim.width, values[0].dim.height);
812         str.append(buffer);
813     }
814     for (int i = 1; i < len; i++) {
815         snprintf(buffer, sizeof(buffer), ",%dx%d",
816                  values[i].dim.width, values[i].dim.height);
817         str.append(buffer);
818     }
819     return str;
820 }
821 
822 /*===========================================================================
823  * FUNCTION   : compareFPSValues
824  *
825  * DESCRIPTION: helper function for fps sorting
826  *
827  * PARAMETERS :
828  *   @p1     : first array element
829  *   @p2     : second array element
830  *
831  * RETURN     : -1 - left element is greater than right
832  *              0  - elements are equals
833  *              1  - left element is less than right
834  *==========================================================================*/
compareFPSValues(const void * p1,const void * p2)835 int QCameraParameters::compareFPSValues(const void *p1, const void *p2)
836 {
837     if ( *( (int *) p1) > *( (int *) p2) ) {
838         return -1;
839     } else if (  *( (int *) p1) < *( (int *) p2) ) {
840         return 1;
841     }
842 
843     return 0;
844 }
845 
846 /*===========================================================================
847  * FUNCTION   : createFpsString
848  *
849  * DESCRIPTION: create string obj contains array of FPS rates
850  *
851  * PARAMETERS :
852  *   @fps     : array of fps ranges
853  *   @len     : size of the array
854  *
855  * RETURN     : string obj
856  *==========================================================================*/
createFpsString(const cam_fps_range_t * fps,int len)857 String8 QCameraParameters::createFpsString(const cam_fps_range_t *fps, int len)
858 {
859     String8 str;
860     char buffer[32];
861     int duplicate = INT_MAX;
862 
863     int *fpsValues = new int[len];
864 
865     for (int i = 0; i < len; i++ ) {
866         fpsValues[i] = int(fps[i].max_fps);
867     }
868 
869     qsort(fpsValues, len, sizeof(int), compareFPSValues);
870 
871     for (int i = 0; i < len; i++ ) {
872         if ( duplicate != fpsValues[i] ) {
873             snprintf(buffer, sizeof(buffer), "%d", fpsValues[i]);
874             str.append(buffer);
875             if (i < len-1) {
876                 str.append(",");
877             }
878             duplicate = fpsValues[i];
879         }
880     }
881 
882     delete [] fpsValues;
883 
884     return str;
885 }
886 
887 /*===========================================================================
888  * FUNCTION   : createFpsRangeString
889  *
890  * DESCRIPTION: create string obj contains array of FPS ranges
891  *
892  * PARAMETERS :
893  *   @fps     : array of fps ranges
894  *   @len     : size of the array
895  *   @default_fps_index : reference to index of default fps range
896  *
897  * RETURN     : string obj
898  *==========================================================================*/
createFpsRangeString(const cam_fps_range_t * fps,int len,int & default_fps_index)899 String8 QCameraParameters::createFpsRangeString(const cam_fps_range_t* fps,
900                                                 int len,
901                                                 int &default_fps_index)
902 {
903     String8 str;
904     char buffer[32];
905     int max_range = 0;
906     int min_fps, max_fps;
907 
908     if (len > 0) {
909         min_fps = int(fps[0].min_fps * 1000);
910         max_fps = int(fps[0].max_fps * 1000);
911         max_range = max_fps - min_fps;
912         default_fps_index = 0;
913         snprintf(buffer, sizeof(buffer), "(%d,%d)", min_fps, max_fps);
914         str.append(buffer);
915     }
916     for (int i = 1; i < len; i++) {
917         min_fps = int(fps[i].min_fps * 1000);
918         max_fps = int(fps[i].max_fps * 1000);
919         if (max_range < (max_fps - min_fps)) {
920             max_range = max_fps - min_fps;
921             default_fps_index = i;
922         }
923         snprintf(buffer, sizeof(buffer), ",(%d,%d)", min_fps, max_fps);
924         str.append(buffer);
925     }
926     return str;
927 }
928 
929 /*===========================================================================
930  * FUNCTION   : lookupAttr
931  *
932  * DESCRIPTION: lookup a value by its name
933  *
934  * PARAMETERS :
935  *   @attr    : map contains <name, value>
936  *   @len     : size of the map
937  *   @name    : name to be looked up
938  *
939  * RETURN     : valid value if found
940  *              NAME_NOT_FOUND if not found
941  *==========================================================================*/
lookupAttr(const QCameraMap arr[],int len,const char * name)942 int QCameraParameters::lookupAttr(const QCameraMap arr[], int len, const char *name)
943 {
944     if (name) {
945         for (int i = 0; i < len; i++) {
946             if (!strcmp(arr[i].desc, name))
947                 return arr[i].val;
948         }
949     }
950     return NAME_NOT_FOUND;
951 }
952 
953 /*===========================================================================
954  * FUNCTION   : lookupNameByValue
955  *
956  * DESCRIPTION: lookup a name by its value
957  *
958  * PARAMETERS :
959  *   @attr    : map contains <name, value>
960  *   @len     : size of the map
961  *   @value   : value to be looked up
962  *
963  * RETURN     : name str or NULL if not found
964  *==========================================================================*/
lookupNameByValue(const QCameraMap arr[],int len,int value)965 const char *QCameraParameters::lookupNameByValue(const QCameraMap arr[], int len, int value)
966 {
967     for (int i = 0; i < len; i++) {
968         if (arr[i].val == value) {
969             return arr[i].desc;
970         }
971     }
972     return NULL;
973 }
974 
975 /*===========================================================================
976  * FUNCTION   : setPreviewSize
977  *
978  * DESCRIPTION: set preview size from user setting
979  *
980  * PARAMETERS :
981  *   @params  : user setting parameters
982  *
983  * RETURN     : int32_t type of status
984  *              NO_ERROR  -- success
985  *              none-zero failure code
986  *==========================================================================*/
setPreviewSize(const QCameraParameters & params)987 int32_t QCameraParameters::setPreviewSize(const QCameraParameters& params)
988 {
989     int width, height;
990     params.getPreviewSize(&width, &height);
991     ALOGV("Requested preview size %d x %d", width, height);
992 
993     // Validate the preview size
994     for (size_t i = 0; i < m_pCapability->preview_sizes_tbl_cnt; ++i) {
995         if (width ==  m_pCapability->preview_sizes_tbl[i].width
996            && height ==  m_pCapability->preview_sizes_tbl[i].height) {
997             // check if need to restart preview in case of preview size change
998             int old_width, old_height;
999             CameraParameters::getPreviewSize(&old_width, &old_height);
1000             if (width != old_width || height != old_height) {
1001                 m_bNeedRestart = true;
1002             }
1003 
1004             // set the new value
1005             CameraParameters::setPreviewSize(width, height);
1006             return NO_ERROR;
1007         }
1008     }
1009     ALOGE("Invalid preview size requested: %dx%d", width, height);
1010     return BAD_VALUE;
1011 }
1012 
1013 /*===========================================================================
1014  * FUNCTION   : setPictureSize
1015  *
1016  * DESCRIPTION: set picture size from user setting
1017  *
1018  * PARAMETERS :
1019  *   @params  : user setting parameters
1020  *
1021  * RETURN     : int32_t type of status
1022  *              NO_ERROR  -- success
1023  *              none-zero failure code
1024  *==========================================================================*/
setPictureSize(const QCameraParameters & params)1025 int32_t QCameraParameters::setPictureSize(const QCameraParameters& params)
1026 {
1027     int width, height;
1028     params.getPictureSize(&width, &height);
1029     ALOGV("Requested picture size %d x %d", width, height);
1030 
1031     // Validate the picture size
1032     for (size_t i = 0; i < m_pCapability->picture_sizes_tbl_cnt; ++i) {
1033         if (width ==  m_pCapability->picture_sizes_tbl[i].width
1034            && height ==  m_pCapability->picture_sizes_tbl[i].height) {
1035             // check if need to restart preview in case of picture size change
1036             int old_width, old_height;
1037             CameraParameters::getPictureSize(&old_width, &old_height);
1038             if ((m_bZslMode || m_bRecordingHint) &&
1039                 (width != old_width || height != old_height)) {
1040                 m_bNeedRestart = true;
1041             }
1042 
1043             // set the new value
1044             CameraParameters::setPictureSize(width, height);
1045             return NO_ERROR;
1046         }
1047     }
1048     ALOGE("Invalid picture size requested: %dx%d", width, height);
1049     return BAD_VALUE;
1050 }
1051 
1052 /*===========================================================================
1053  * FUNCTION   : setVideoSize
1054  *
1055  * DESCRIPTION: set video size from user setting
1056  *
1057  * PARAMETERS :
1058  *   @params  : user setting parameters
1059  *
1060  * RETURN     : int32_t type of status
1061  *              NO_ERROR  -- success
1062  *              none-zero failure code
1063  *==========================================================================*/
setVideoSize(const QCameraParameters & params)1064 int32_t QCameraParameters::setVideoSize(const QCameraParameters& params)
1065 {
1066     const char *str= NULL;
1067     int width, height;
1068     str = params.get(KEY_VIDEO_SIZE);
1069     if(!str) {
1070         //If application didn't set this parameter string, use the values from
1071         //getPreviewSize() as video dimensions.
1072         params.getPreviewSize(&width, &height);
1073         ALOGE("No Record Size requested, use the preview dimensions");
1074     } else {
1075         params.getVideoSize(&width, &height);
1076     }
1077 
1078     // Validate the video size
1079     for (size_t i = 0; i < m_pCapability->video_sizes_tbl_cnt; ++i) {
1080         if (width ==  m_pCapability->video_sizes_tbl[i].width
1081                 && height ==  m_pCapability->video_sizes_tbl[i].height) {
1082             // check if need to restart preview in case of video size change
1083             int old_width, old_height;
1084             CameraParameters::getVideoSize(&old_width, &old_height);
1085             if (m_bRecordingHint &&
1086                (width != old_width || height != old_height)) {
1087                 m_bNeedRestart = true;
1088             }
1089 
1090             // set the new value
1091             CameraParameters::setVideoSize(width, height);
1092             return NO_ERROR;
1093         }
1094     }
1095 
1096     ALOGE("Invalid video size requested: %dx%d", width, height);
1097     return BAD_VALUE;
1098 }
1099 
1100 /*===========================================================================
1101  * FUNCTION   : setLiveSnapshotSize
1102  *
1103  * DESCRIPTION: set live snapshot size
1104  *
1105  * PARAMETERS :
1106  *   @params  : user setting parameters
1107  *
1108  * RETURN     : int32_t type of status
1109  *              NO_ERROR  -- success
1110  *              none-zero failure code
1111  *==========================================================================*/
setLiveSnapshotSize(const QCameraParameters & params)1112 int32_t QCameraParameters::setLiveSnapshotSize(const QCameraParameters& params)
1113 {
1114     char value[PROPERTY_VALUE_MAX];
1115     property_get("persist.camera.opt.livepic", value, "1");
1116     bool useOptimal = atoi(value) > 0 ? true : false;
1117 
1118     // use picture size from user setting
1119     params.getPictureSize(&m_LiveSnapshotSize.width, &m_LiveSnapshotSize.height);
1120 
1121     uint8_t livesnapshot_sizes_tbl_cnt = m_pCapability->livesnapshot_sizes_tbl_cnt;
1122     cam_dimension_t *livesnapshot_sizes_tbl = &m_pCapability->livesnapshot_sizes_tbl[0];
1123 
1124     // check if HFR is enabled
1125     const char *hfrStr = params.get(KEY_QC_VIDEO_HIGH_FRAME_RATE);
1126     cam_hfr_mode_t hfrMode = CAM_HFR_MODE_OFF;
1127     if (hfrStr != NULL) {
1128         int32_t value = lookupAttr(HFR_MODES_MAP,
1129                                    sizeof(HFR_MODES_MAP)/sizeof(QCameraMap),
1130                                    hfrStr);
1131         if (value != NAME_NOT_FOUND) {
1132             // if HFR is enabled, change live snapshot size
1133             if (value > CAM_HFR_MODE_OFF) {
1134                 for (int i = 0; i < m_pCapability->hfr_tbl_cnt; i++) {
1135                     if (m_pCapability->hfr_tbl[i].mode == value) {
1136                         livesnapshot_sizes_tbl_cnt =
1137                             m_pCapability->hfr_tbl[i].livesnapshot_sizes_tbl_cnt;
1138                         livesnapshot_sizes_tbl =
1139                             &m_pCapability->hfr_tbl[i].livesnapshot_sizes_tbl[0];
1140                         hfrMode = m_pCapability->hfr_tbl[i].mode;
1141                         break;
1142                     }
1143                 }
1144             }
1145         }
1146     }
1147 
1148     if (useOptimal || hfrMode != CAM_HFR_MODE_OFF) {
1149         bool found = false;
1150 
1151         // first check if picture size is within the list of supported sizes
1152         for (int i = 0; i < livesnapshot_sizes_tbl_cnt; ++i) {
1153             if (m_LiveSnapshotSize.width == livesnapshot_sizes_tbl[i].width &&
1154                 m_LiveSnapshotSize.height == livesnapshot_sizes_tbl[i].height) {
1155                 found = true;
1156                 break;
1157             }
1158         }
1159 
1160         if (!found) {
1161             // use optimal live snapshot size from supported list,
1162             // that has same preview aspect ratio
1163             int width = 0, height = 0;
1164             params.getPreviewSize(&width, &height);
1165 
1166             double previewAspectRatio = (double)width / height;
1167             for (int i = 0; i < livesnapshot_sizes_tbl_cnt; ++i) {
1168                 double ratio = (double)livesnapshot_sizes_tbl[i].width /
1169                                 livesnapshot_sizes_tbl[i].height;
1170                 if (fabs(previewAspectRatio - ratio) <= ASPECT_TOLERANCE) {
1171                     m_LiveSnapshotSize = livesnapshot_sizes_tbl[i];
1172                     found = true;
1173                     break;
1174                 }
1175             }
1176 
1177             if (!found && hfrMode != CAM_HFR_MODE_OFF) {
1178                 // Cannot find matching aspect ration from supported live snapshot list
1179                 // choose the max dim from preview and video size
1180                 ALOGI("%s: Cannot find matching aspect ratio, choose max of preview or video size", __func__);
1181                 params.getVideoSize(&m_LiveSnapshotSize.width, &m_LiveSnapshotSize.height);
1182                 if (m_LiveSnapshotSize.width < width && m_LiveSnapshotSize.height < height) {
1183                     m_LiveSnapshotSize.width = width;
1184                     m_LiveSnapshotSize.height = height;
1185                 }
1186             }
1187         }
1188     }
1189     ALOGI("%s: live snapshot size %d x %d", __func__,
1190           m_LiveSnapshotSize.width, m_LiveSnapshotSize.height);
1191 
1192     return NO_ERROR;
1193 }
1194 
1195 /*===========================================================================
1196  * FUNCTION   : setPreviewFormat
1197  *
1198  * DESCRIPTION: set preview format from user setting
1199  *
1200  * PARAMETERS :
1201  *   @params  : user setting parameters
1202  *
1203  * RETURN     : int32_t type of status
1204  *              NO_ERROR  -- success
1205  *              none-zero failure code
1206  *==========================================================================*/
setPreviewFormat(const QCameraParameters & params)1207 int32_t QCameraParameters::setPreviewFormat(const QCameraParameters& params)
1208 {
1209     const char *str = params.getPreviewFormat();
1210     int32_t previewFormat =
1211         lookupAttr(PREVIEW_FORMATS_MAP,
1212                    sizeof(PREVIEW_FORMATS_MAP) / sizeof(QCameraMap),
1213                    str);
1214     if (previewFormat != NAME_NOT_FOUND) {
1215         mPreviewFormat = (cam_format_t)previewFormat;
1216 
1217         CameraParameters::setPreviewFormat(str);
1218         ALOGV("%s: format %d\n", __func__, mPreviewFormat);
1219         return NO_ERROR;
1220     }
1221     ALOGE("Invalid preview format value: %s", (str == NULL) ? "NULL" : str);
1222     return BAD_VALUE;
1223 }
1224 
1225 /*===========================================================================
1226  * FUNCTION   : setPictureFormat
1227  *
1228  * DESCRIPTION: set picture format from user setting
1229  *
1230  * PARAMETERS :
1231  *   @params  : user setting parameters
1232  *
1233  * RETURN     : int32_t type of status
1234  *              NO_ERROR  -- success
1235  *              none-zero failure code
1236  *==========================================================================*/
setPictureFormat(const QCameraParameters & params)1237 int32_t QCameraParameters::setPictureFormat(const QCameraParameters& params)
1238 {
1239     const char *str = params.getPictureFormat();
1240     int32_t pictureFormat =
1241         lookupAttr(PICTURE_TYPES_MAP,
1242                    sizeof(PICTURE_TYPES_MAP) / sizeof(QCameraMap),
1243                    str);
1244     if (pictureFormat != NAME_NOT_FOUND) {
1245         mPictureFormat = pictureFormat;
1246 
1247         CameraParameters::setPictureFormat(str);
1248         ALOGE("%s: format %d\n", __func__, mPictureFormat);
1249         return NO_ERROR;
1250     }
1251     ALOGE("Invalid picture format value: %s", (str == NULL) ? "NULL" : str);
1252     return BAD_VALUE;
1253 }
1254 
1255 /*===========================================================================
1256  * FUNCTION   : setJpegThumbnailSize
1257  *
1258  * DESCRIPTION: set jpeg thumbnail size from user setting
1259  *
1260  * PARAMETERS :
1261  *   @params  : user setting parameters
1262  *
1263  * RETURN     : int32_t type of status
1264  *              NO_ERROR  -- success
1265  *              none-zero failure code
1266  *==========================================================================*/
setJpegThumbnailSize(const QCameraParameters & params)1267 int32_t QCameraParameters::setJpegThumbnailSize(const QCameraParameters& params)
1268 {
1269     int width = params.getInt(KEY_JPEG_THUMBNAIL_WIDTH);
1270     int height = params.getInt(KEY_JPEG_THUMBNAIL_HEIGHT);
1271 
1272     ALOGV("requested jpeg thumbnail size %d x %d", width, height);
1273 
1274     int sizes_cnt = sizeof(THUMBNAIL_SIZES_MAP) / sizeof(cam_dimension_t);
1275 
1276     int pic_width = 0, pic_height = 0;
1277     params.getPictureSize(&pic_width, &pic_height);
1278     if (pic_height == 0) {
1279         ALOGE("%s: picture size is invalid (%d x %d)", __func__, pic_width, pic_height);
1280         return BAD_VALUE;
1281     }
1282     double picAspectRatio = (double)pic_width / pic_height;
1283 
1284     int optimalWidth = 0, optimalHeight = 0;
1285     if (width != 0 || height != 0) {
1286         // If input jpeg thumnmail size is (0,0), meaning no thumbnail needed
1287         // hornor this setting.
1288         // Otherwise, find optimal jpeg thumbnail size that has same aspect ration
1289         // as picture size
1290 
1291         // Try to find a size matches aspect ratio and has the largest width
1292         for (int i = 0; i < sizes_cnt; i++) {
1293             if (THUMBNAIL_SIZES_MAP[i].height == 0) {
1294                 // No thumbnail case, just skip
1295                 continue;
1296             }
1297             double ratio =
1298                 (double)THUMBNAIL_SIZES_MAP[i].width / THUMBNAIL_SIZES_MAP[i].height;
1299             if (fabs(ratio - picAspectRatio) > ASPECT_TOLERANCE)  {
1300                 continue;
1301             }
1302             if (THUMBNAIL_SIZES_MAP[i].width > optimalWidth) {
1303                 optimalWidth = THUMBNAIL_SIZES_MAP[i].width;
1304                 optimalHeight = THUMBNAIL_SIZES_MAP[i].height;
1305             }
1306         }
1307     }
1308 
1309     set(KEY_JPEG_THUMBNAIL_WIDTH, optimalWidth);
1310     set(KEY_JPEG_THUMBNAIL_HEIGHT, optimalHeight);
1311     return NO_ERROR;
1312 }
1313 
1314 /*===========================================================================
1315  * FUNCTION   : setJpegQuality
1316  *
1317  * DESCRIPTION: set jpeg encpding quality from user setting
1318  *
1319  * PARAMETERS :
1320  *   @params  : user setting parameters
1321  *
1322  * RETURN     : int32_t type of status
1323  *              NO_ERROR  -- success
1324  *              none-zero failure code
1325  *==========================================================================*/
setJpegQuality(const QCameraParameters & params)1326 int32_t QCameraParameters::setJpegQuality(const QCameraParameters& params)
1327 {
1328     int32_t rc = NO_ERROR;
1329     int quality = params.getInt(KEY_JPEG_QUALITY);
1330     if (quality >= 0 && quality <= 100) {
1331         set(KEY_JPEG_QUALITY, quality);
1332     } else {
1333         ALOGE("%s: Invalid jpeg quality=%d", __func__, quality);
1334         rc = BAD_VALUE;
1335     }
1336 
1337     quality = params.getInt(KEY_JPEG_THUMBNAIL_QUALITY);
1338     if (quality >= 0 && quality <= 100) {
1339         set(KEY_JPEG_THUMBNAIL_QUALITY, quality);
1340     } else {
1341         ALOGE("%s: Invalid jpeg thumbnail quality=%d", __func__, quality);
1342         rc = BAD_VALUE;
1343     }
1344     return rc;
1345 }
1346 
1347 /*===========================================================================
1348  * FUNCTION   : setOrientaion
1349  *
1350  * DESCRIPTION: set orientaion from user setting
1351  *
1352  * PARAMETERS :
1353  *   @params  : user setting parameters
1354  *
1355  * RETURN     : int32_t type of status
1356  *              NO_ERROR  -- success
1357  *              none-zero failure code
1358  *==========================================================================*/
setOrientation(const QCameraParameters & params)1359 int32_t QCameraParameters::setOrientation(const QCameraParameters& params)
1360 {
1361     const char *str = params.get(KEY_QC_ORIENTATION);
1362 
1363     if (str != NULL) {
1364         if (strcmp(str, portrait) == 0 || strcmp(str, landscape) == 0) {
1365             // Camera service needs this to decide if the preview frames and raw
1366             // pictures should be rotated.
1367             set(KEY_QC_ORIENTATION, str);
1368         } else {
1369             ALOGE("%s: Invalid orientation value: %s", __func__, str);
1370             return BAD_VALUE;
1371         }
1372     }
1373     return NO_ERROR;
1374 }
1375 
1376 /*===========================================================================
1377  * FUNCTION   : setAutoExposure
1378  *
1379  * DESCRIPTION: set auto exposure value from user setting
1380  *
1381  * PARAMETERS :
1382  *   @params  : user setting parameters
1383  *
1384  * RETURN     : int32_t type of status
1385  *              NO_ERROR  -- success
1386  *              none-zero failure code
1387  *==========================================================================*/
setAutoExposure(const QCameraParameters & params)1388 int32_t QCameraParameters::setAutoExposure(const QCameraParameters& params)
1389 {
1390     const char *str = params.get(KEY_QC_AUTO_EXPOSURE);
1391     const char *prev_str = get(KEY_QC_AUTO_EXPOSURE);
1392     if (str != NULL) {
1393         if (prev_str == NULL ||
1394             strcmp(str, prev_str) != 0) {
1395             return setAutoExposure(str);
1396         }
1397     }
1398     return NO_ERROR;
1399 }
1400 
1401 /*===========================================================================
1402  * FUNCTION   : setPreviewFpsRange
1403  *
1404  * DESCRIPTION: set preview FPS range from user setting
1405  *
1406  * PARAMETERS :
1407  *   @params  : user setting parameters
1408  *
1409  * RETURN     : int32_t type of status
1410  *              NO_ERROR  -- success
1411  *              none-zero failure code
1412  *==========================================================================*/
setPreviewFpsRange(const QCameraParameters & params)1413 int32_t QCameraParameters::setPreviewFpsRange(const QCameraParameters& params)
1414 {
1415     int minFps,maxFps;
1416     int prevMinFps, prevMaxFps;
1417     int rc = NO_ERROR;
1418     bool found = false;
1419 
1420     CameraParameters::getPreviewFpsRange(&prevMinFps, &prevMaxFps);
1421     ALOGV("%s: Existing FpsRange Values:(%d, %d)", __func__, prevMinFps, prevMaxFps);
1422     params.getPreviewFpsRange(&minFps, &maxFps);
1423     ALOGV("%s: Requested FpsRange Values:(%d, %d)", __func__, minFps, maxFps);
1424 
1425     if(minFps == prevMinFps && maxFps == prevMaxFps) {
1426         ALOGV("%s: No change in FpsRange", __func__);
1427         rc = NO_ERROR;
1428         goto end;
1429     }
1430     for(int i = 0; i < m_pCapability->fps_ranges_tbl_cnt; i++) {
1431         // if the value is in the supported list
1432         if(minFps >= m_pCapability->fps_ranges_tbl[i].min_fps * 1000 &&
1433            maxFps <= m_pCapability->fps_ranges_tbl[i].max_fps * 1000) {
1434             found = true;
1435             ALOGV("%s: FPS i=%d : minFps = %d, maxFps = %d ", __func__, i, minFps, maxFps);
1436             setPreviewFpsRange(minFps, maxFps);
1437             break;
1438         }
1439     }
1440     if(found == false){
1441         ALOGE("%s: error: FPS range value not supported", __func__);
1442         rc = BAD_VALUE;
1443     }
1444 end:
1445     return rc;
1446 }
1447 
1448 /*===========================================================================
1449  * FUNCTION   : setPreviewFrameRate
1450  *
1451  * DESCRIPTION: set preview frame rate from user setting
1452  *
1453  * PARAMETERS :
1454  *   @params  : user setting parameters
1455  *
1456  * RETURN     : int32_t type of status
1457  *              NO_ERROR  -- success
1458  *              none-zero failure code
1459  *==========================================================================*/
setPreviewFrameRate(const QCameraParameters & params)1460 int32_t QCameraParameters::setPreviewFrameRate(const QCameraParameters& params)
1461 {
1462     uint16_t fps = (uint16_t)params.getPreviewFrameRate();
1463     ALOGV("%s: requested preview frame rate is %d", __func__, fps);
1464     CameraParameters::setPreviewFrameRate(fps);
1465     return NO_ERROR;
1466 }
1467 
1468 /*===========================================================================
1469  * FUNCTION   : setEffect
1470  *
1471  * DESCRIPTION: set effect value from user setting
1472  *
1473  * PARAMETERS :
1474  *   @params  : user setting parameters
1475  *
1476  * RETURN     : int32_t type of status
1477  *              NO_ERROR  -- success
1478  *              none-zero failure code
1479  *==========================================================================*/
setEffect(const QCameraParameters & params)1480 int32_t QCameraParameters::setEffect(const QCameraParameters& params)
1481 {
1482     const char *str = params.get(KEY_EFFECT);
1483     const char *prev_str = get(KEY_EFFECT);
1484     if (str != NULL) {
1485         if (prev_str == NULL ||
1486             strcmp(str, prev_str) != 0) {
1487             return setEffect(str);
1488         }
1489     }
1490     return NO_ERROR;
1491 }
1492 
1493 /*===========================================================================
1494  * FUNCTION   : setFocusMode
1495  *
1496  * DESCRIPTION: set focus mode from user setting
1497  *
1498  * PARAMETERS :
1499  *   @params  : user setting parameters
1500  *
1501  * RETURN     : int32_t type of status
1502  *              NO_ERROR  -- success
1503  *              none-zero failure code
1504  *==========================================================================*/
setFocusMode(const QCameraParameters & params)1505 int32_t QCameraParameters::setFocusMode(const QCameraParameters& params)
1506 {
1507     const char *str = params.get(KEY_FOCUS_MODE);
1508     const char *prev_str = get(KEY_FOCUS_MODE);
1509     if (str != NULL) {
1510         if (prev_str == NULL ||
1511             strcmp(str, prev_str) != 0) {
1512             return setFocusMode(str);
1513         }
1514     }
1515     return NO_ERROR;
1516 }
1517 
1518 /*===========================================================================
1519  * FUNCTION   : setBrightness
1520  *
1521  * DESCRIPTION: set brightness control value from user setting
1522  *
1523  * PARAMETERS :
1524  *   @params  : user setting parameters
1525  *
1526  * RETURN     : int32_t type of status
1527  *              NO_ERROR  -- success
1528  *              none-zero failure code
1529  *==========================================================================*/
setBrightness(const QCameraParameters & params)1530 int32_t QCameraParameters::setBrightness(const QCameraParameters& params)
1531 {
1532     int currentBrightness = getInt(KEY_QC_BRIGHTNESS);
1533     int brightness = params.getInt(KEY_QC_BRIGHTNESS);
1534     if (currentBrightness !=  brightness) {
1535         if (brightness >= m_pCapability->brightness_ctrl.min_value &&
1536             brightness <= m_pCapability->brightness_ctrl.max_value) {
1537             ALOGV(" new brightness value : %d ", brightness);
1538             return setBrightness(brightness);
1539         } else {
1540             ALOGE("%s: invalid value %d out of (%d, %d)",
1541                   __func__, brightness,
1542                   m_pCapability->brightness_ctrl.min_value,
1543                   m_pCapability->brightness_ctrl.max_value);
1544             return BAD_VALUE;
1545         }
1546     } else {
1547         ALOGV("%s: No brightness value changed.", __func__);
1548         return NO_ERROR;
1549     }
1550 }
1551 
1552 /*===========================================================================
1553  * FUNCTION   : setSharpness
1554  *
1555  * DESCRIPTION: set sharpness control value from user setting
1556  *
1557  * PARAMETERS :
1558  *   @params  : user setting parameters
1559  *
1560  * RETURN     : int32_t type of status
1561  *              NO_ERROR  -- success
1562  *              none-zero failure code
1563  *==========================================================================*/
setSharpness(const QCameraParameters & params)1564 int32_t QCameraParameters::setSharpness(const QCameraParameters& params)
1565 {
1566     int shaprness = params.getInt(KEY_QC_SHARPNESS);
1567     int prev_sharp = getInt(KEY_QC_SHARPNESS);
1568     if (prev_sharp !=  shaprness) {
1569         if((shaprness >= m_pCapability->sharpness_ctrl.min_value) &&
1570            (shaprness <= m_pCapability->sharpness_ctrl.max_value)) {
1571             ALOGV(" new sharpness value : %d ", shaprness);
1572             return setSharpness(shaprness);
1573         } else {
1574             ALOGE("%s: invalid value %d out of (%d, %d)",
1575                   __func__, shaprness,
1576                   m_pCapability->sharpness_ctrl.min_value,
1577                   m_pCapability->sharpness_ctrl.max_value);
1578             return BAD_VALUE;
1579         }
1580     } else {
1581         ALOGV("%s: No value change in shaprness", __func__);
1582         return NO_ERROR;
1583     }
1584 }
1585 
1586 /*===========================================================================
1587  * FUNCTION   : setSkintoneEnahancement
1588  *
1589  * DESCRIPTION: set skin tone enhancement factor from user setting
1590  *
1591  * PARAMETERS :
1592  *   @params  : user setting parameters
1593  *
1594  * RETURN     : int32_t type of status
1595  *              NO_ERROR  -- success
1596  *              none-zero failure code
1597  *==========================================================================*/
setSkinToneEnhancement(const QCameraParameters & params)1598 int32_t QCameraParameters::setSkinToneEnhancement(const QCameraParameters& params)
1599 {
1600     int sceFactor = params.getInt(KEY_QC_SCE_FACTOR);
1601     int prev_sceFactor = getInt(KEY_QC_SCE_FACTOR);
1602     if (prev_sceFactor !=  sceFactor) {
1603         if((sceFactor >= m_pCapability->sce_ctrl.min_value) &&
1604            (sceFactor <= m_pCapability->sce_ctrl.max_value)) {
1605             ALOGV(" new Skintone Enhancement value : %d ", sceFactor);
1606             return setSkinToneEnhancement(sceFactor);
1607         } else {
1608             ALOGE("%s: invalid value %d out of (%d, %d)",
1609                   __func__, sceFactor,
1610                   m_pCapability->sce_ctrl.min_value,
1611                   m_pCapability->sce_ctrl.max_value);
1612             return BAD_VALUE;
1613         }
1614     } else {
1615         ALOGV("%s: No value change in skintone enhancement factor", __func__);
1616         return NO_ERROR;
1617     }
1618 }
1619 
1620 /*===========================================================================
1621  * FUNCTION   : setSaturation
1622  *
1623  * DESCRIPTION: set saturation control value from user setting
1624  *
1625  * PARAMETERS :
1626  *   @params  : user setting parameters
1627  *
1628  * RETURN     : int32_t type of status
1629  *              NO_ERROR  -- success
1630  *              none-zero failure code
1631  *==========================================================================*/
setSaturation(const QCameraParameters & params)1632 int32_t QCameraParameters::setSaturation(const QCameraParameters& params)
1633 {
1634     int saturation = params.getInt(KEY_QC_SATURATION);
1635     int prev_sat = getInt(KEY_QC_SATURATION);
1636     if (prev_sat !=  saturation) {
1637         if((saturation >= m_pCapability->saturation_ctrl.min_value) &&
1638            (saturation <= m_pCapability->saturation_ctrl.max_value)) {
1639             ALOGV(" new saturation value : %d ", saturation);
1640             return setSaturation(saturation);
1641         } else {
1642             ALOGE("%s: invalid value %d out of (%d, %d)",
1643                   __func__, saturation,
1644                   m_pCapability->saturation_ctrl.min_value,
1645                   m_pCapability->saturation_ctrl.max_value);
1646             return BAD_VALUE;
1647         }
1648     } else {
1649         ALOGV("%s: No value change in saturation factor", __func__);
1650         return NO_ERROR;
1651     }
1652 }
1653 
1654 /*===========================================================================
1655  * FUNCTION   : setContrast
1656  *
1657  * DESCRIPTION: set contrast control value from user setting
1658  *
1659  * PARAMETERS :
1660  *   @params  : user setting parameters
1661  *
1662  * RETURN     : int32_t type of status
1663  *              NO_ERROR  -- success
1664  *              none-zero failure code
1665  *==========================================================================*/
setContrast(const QCameraParameters & params)1666 int32_t QCameraParameters::setContrast(const QCameraParameters& params)
1667 {
1668     int contrast = params.getInt(KEY_QC_CONTRAST);
1669     int prev_contrast = getInt(KEY_QC_CONTRAST);
1670     if (prev_contrast !=  contrast) {
1671         if((contrast >= m_pCapability->contrast_ctrl.min_value) &&
1672            (contrast <= m_pCapability->contrast_ctrl.max_value)) {
1673             ALOGV(" new contrast value : %d ", contrast);
1674             int32_t rc = setContrast(contrast);
1675             return rc;
1676         } else {
1677             ALOGE("%s: invalid value %d out of (%d, %d)",
1678                   __func__, contrast,
1679                   m_pCapability->contrast_ctrl.min_value,
1680                   m_pCapability->contrast_ctrl.max_value);
1681             return BAD_VALUE;
1682         }
1683     } else {
1684         ALOGV("%s: No value change in contrast", __func__);
1685         return NO_ERROR;
1686     }
1687 }
1688 
1689 /*===========================================================================
1690  * FUNCTION   : setExposureCompensation
1691  *
1692  * DESCRIPTION: set exposure compensation value from user setting
1693  *
1694  * PARAMETERS :
1695  *   @params  : user setting parameters
1696  *
1697  * RETURN     : int32_t type of status
1698  *              NO_ERROR  -- success
1699  *              none-zero failure code
1700  *==========================================================================*/
setExposureCompensation(const QCameraParameters & params)1701 int32_t QCameraParameters::setExposureCompensation(const QCameraParameters & params)
1702 {
1703     int expComp = params.getInt(KEY_EXPOSURE_COMPENSATION);
1704     int prev_expComp = getInt(KEY_EXPOSURE_COMPENSATION);
1705     if (prev_expComp !=  expComp) {
1706         if((expComp >= m_pCapability->exposure_compensation_min) &&
1707            (expComp <= m_pCapability->exposure_compensation_max)) {
1708             ALOGV(" new Exposure Compensation value : %d ", expComp);
1709             return setExposureCompensation(expComp);
1710         } else {
1711             ALOGE("%s: invalid value %d out of (%d, %d)",
1712                   __func__, expComp,
1713                   m_pCapability->exposure_compensation_min,
1714                   m_pCapability->exposure_compensation_max);
1715             return BAD_VALUE;
1716         }
1717     } else {
1718         ALOGV("%s: No value change in Exposure Compensation", __func__);
1719         return NO_ERROR;
1720     }
1721 }
1722 
1723 /*===========================================================================
1724  * FUNCTION   : setWhiteBalance
1725  *
1726  * DESCRIPTION: set white balance value from user setting
1727  *
1728  * PARAMETERS :
1729  *   @params  : user setting parameters
1730  *
1731  * RETURN     : int32_t type of status
1732  *              NO_ERROR  -- success
1733  *              none-zero failure code
1734  *==========================================================================*/
setWhiteBalance(const QCameraParameters & params)1735 int32_t QCameraParameters::setWhiteBalance(const QCameraParameters& params)
1736 {
1737     const char *str = params.get(KEY_WHITE_BALANCE);
1738     const char *prev_str = get(KEY_WHITE_BALANCE);
1739     if (str != NULL) {
1740         if (prev_str == NULL ||
1741             strcmp(str, prev_str) != 0) {
1742             return setWhiteBalance(str);
1743         }
1744     }
1745     return NO_ERROR;
1746 }
1747 
1748 /*===========================================================================
1749  * FUNCTION   : setAntibanding
1750  *
1751  * DESCRIPTION: set antibanding value from user setting
1752  *
1753  * PARAMETERS :
1754  *   @params  : user setting parameters
1755  *
1756  * RETURN     : int32_t type of status
1757  *              NO_ERROR  -- success
1758  *              none-zero failure code
1759  *==========================================================================*/
setAntibanding(const QCameraParameters & params)1760 int32_t QCameraParameters::setAntibanding(const QCameraParameters& params)
1761 {
1762     const char *str = params.get(KEY_ANTIBANDING);
1763     const char *prev_str = get(KEY_ANTIBANDING);
1764     if (str != NULL) {
1765         if (prev_str == NULL ||
1766             strcmp(str, prev_str) != 0) {
1767             return setAntibanding(str);
1768         }
1769     }
1770     return NO_ERROR;
1771 }
1772 
1773 /*===========================================================================
1774  * FUNCTION   : setSceneDetect
1775  *
1776  * DESCRIPTION: set scenen detect value from user setting
1777  *
1778  * PARAMETERS :
1779  *   @params  : user setting parameters
1780  *
1781  * RETURN     : int32_t type of status
1782  *              NO_ERROR  -- success
1783  *              none-zero failure code
1784  *==========================================================================*/
setSceneDetect(const QCameraParameters & params)1785 int32_t QCameraParameters::setSceneDetect(const QCameraParameters& params)
1786 {
1787     const char *str = params.get(KEY_QC_SCENE_DETECT);
1788     const char *prev_str = get(KEY_QC_SCENE_DETECT);
1789     if (str != NULL) {
1790         if (prev_str == NULL ||
1791             strcmp(str, prev_str) != 0) {
1792             return setSceneDetect(str);
1793         }
1794     }
1795     return NO_ERROR;
1796 }
1797 
1798 /*===========================================================================
1799  * FUNCTION   : setVideoHDR
1800  *
1801  * DESCRIPTION: set video HDR value from user setting
1802  *
1803  * PARAMETERS :
1804  *   @params  : user setting parameters
1805  *
1806  * RETURN     : int32_t type of status
1807  *              NO_ERROR  -- success
1808  *              none-zero failure code
1809  *==========================================================================*/
setVideoHDR(const QCameraParameters & params)1810 int32_t QCameraParameters::setVideoHDR(const QCameraParameters& params)
1811 {
1812     const char *str = params.get(KEY_QC_VIDEO_HDR);
1813     const char *prev_str = get(KEY_QC_VIDEO_HDR);
1814     if (str != NULL) {
1815         if (prev_str == NULL ||
1816             strcmp(str, prev_str) != 0) {
1817             return setVideoHDR(str);
1818         }
1819     }
1820     return NO_ERROR;
1821 }
1822 
1823 /*===========================================================================
1824  * FUNCTION   : setFaceRecognition
1825  *
1826  * DESCRIPTION: set face recognition mode from user setting
1827  *
1828  * PARAMETERS :
1829  *   @params  : user setting parameters
1830  *
1831  * RETURN     : int32_t type of status
1832  *              NO_ERROR  -- success
1833  *              none-zero failure code
1834  *==========================================================================*/
setFaceRecognition(const QCameraParameters & params)1835 int32_t QCameraParameters::setFaceRecognition(const QCameraParameters& params)
1836 {
1837     const char *str = params.get(KEY_QC_FACE_RECOGNITION);
1838     const char *prev_str = get(KEY_QC_FACE_RECOGNITION);
1839     if (str != NULL) {
1840         if (prev_str == NULL ||
1841             strcmp(str, prev_str) != 0) {
1842             int maxFaces = params.getInt(KEY_QC_MAX_NUM_REQUESTED_FACES);
1843             return setFaceRecognition(str, maxFaces);
1844         }
1845     }
1846     return NO_ERROR;
1847 }
1848 
1849 /*===========================================================================
1850  * FUNCTION   : setZoom
1851  *
1852  * DESCRIPTION: set zoom value from user setting
1853  *
1854  * PARAMETERS :
1855  *   @params  : user setting parameters
1856  *
1857  * RETURN     : int32_t type of status
1858  *              NO_ERROR  -- success
1859  *              none-zero failure code
1860  *==========================================================================*/
setZoom(const QCameraParameters & params)1861 int32_t QCameraParameters::setZoom(const QCameraParameters& params)
1862 {
1863     if ((m_pCapability->zoom_supported == 0 ||
1864          m_pCapability->zoom_ratio_tbl_cnt == 0)) {
1865         ALOGD("%s: no zoom support", __func__);
1866         return NO_ERROR;
1867     }
1868 
1869     int zoomLevel = params.getInt(KEY_ZOOM);
1870     if((zoomLevel < 0) ||
1871        (zoomLevel >= m_pCapability->zoom_ratio_tbl_cnt)) {
1872         ALOGE("%s: invalid value %d out of (%d, %d)",
1873               __func__, zoomLevel,
1874               0, m_pCapability->zoom_ratio_tbl_cnt-1);
1875         return BAD_VALUE;
1876     }
1877 
1878     int prevZoomLevel = getInt(KEY_ZOOM);
1879     if (prevZoomLevel == zoomLevel) {
1880         ALOGV("%s: No value change in contrast", __func__);
1881         return NO_ERROR;
1882     }
1883 
1884     return setZoom(zoomLevel);
1885 }
1886 
1887 /*===========================================================================
1888  * FUNCTION   : setISOValue
1889  *
1890  * DESCRIPTION: set ISO value from user setting
1891  *
1892  * PARAMETERS :
1893  *   @params  : user setting parameters
1894  *
1895  * RETURN     : int32_t type of status
1896  *              NO_ERROR  -- success
1897  *              none-zero failure code
1898  *==========================================================================*/
setISOValue(const QCameraParameters & params)1899 int32_t  QCameraParameters::setISOValue(const QCameraParameters& params)
1900 {
1901     const char *str = params.get(KEY_QC_ISO_MODE);
1902     const char *prev_str = get(KEY_QC_ISO_MODE);
1903     if (str != NULL) {
1904         if (prev_str == NULL ||
1905             strcmp(str, prev_str) != 0) {
1906             return setISOValue(str);
1907         }
1908     }
1909     return NO_ERROR;
1910 }
1911 
1912 /*===========================================================================
1913  * FUNCTION   : setRotation
1914  *
1915  * DESCRIPTION: set rotation value from user setting
1916  *
1917  * PARAMETERS :
1918  *   @params  : user setting parameters
1919  *
1920  * RETURN     : int32_t type of status
1921  *              NO_ERROR  -- success
1922  *              none-zero failure code
1923  *==========================================================================*/
setRotation(const QCameraParameters & params)1924 int32_t QCameraParameters::setRotation(const QCameraParameters& params)
1925 {
1926     int rotation = params.getInt(KEY_ROTATION);
1927     if (rotation != -1) {
1928         if (rotation == 0 || rotation == 90 ||
1929             rotation == 180 || rotation == 270) {
1930             set(KEY_ROTATION, rotation);
1931         } else {
1932             ALOGE("Invalid rotation value: %d", rotation);
1933             return BAD_VALUE;
1934         }
1935     }
1936     return NO_ERROR;
1937 }
1938 
1939 /*===========================================================================
1940  * FUNCTION   : setFlash
1941  *
1942  * DESCRIPTION: set flash mode from user setting
1943  *
1944  * PARAMETERS :
1945  *   @params  : user setting parameters
1946  *
1947  * RETURN     : int32_t type of status
1948  *              NO_ERROR  -- success
1949  *              none-zero failure code
1950  *==========================================================================*/
setFlash(const QCameraParameters & params)1951 int32_t QCameraParameters::setFlash(const QCameraParameters& params)
1952 {
1953     const char *str = params.get(KEY_FLASH_MODE);
1954     const char *prev_str = get(KEY_FLASH_MODE);
1955     if (str != NULL) {
1956         if (prev_str == NULL ||
1957             strcmp(str, prev_str) != 0) {
1958             return setFlash(str);
1959         }
1960     }
1961     return NO_ERROR;
1962 }
1963 
1964 /*===========================================================================
1965  * FUNCTION   : setAecLock
1966  *
1967  * DESCRIPTION: set AEC lock value from user setting
1968  *
1969  * PARAMETERS :
1970  *   @params  : user setting parameters
1971  *
1972  * RETURN     : int32_t type of status
1973  *              NO_ERROR  -- success
1974  *              none-zero failure code
1975  *==========================================================================*/
setAecLock(const QCameraParameters & params)1976 int32_t QCameraParameters::setAecLock(const QCameraParameters& params)
1977 {
1978     const char *str = params.get(KEY_AUTO_EXPOSURE_LOCK);
1979     const char *prev_str = get(KEY_AUTO_EXPOSURE_LOCK);
1980     if (str != NULL) {
1981         if (prev_str == NULL ||
1982             strcmp(str, prev_str) != 0) {
1983             return setAecLock(str);
1984         }
1985     }
1986     return NO_ERROR;
1987 }
1988 
1989 /*===========================================================================
1990  * FUNCTION   : setAwbLock
1991  *
1992  * DESCRIPTION: set AWB lock from user setting
1993  *
1994  * PARAMETERS :
1995  *   @params  : user setting parameters
1996  *
1997  * RETURN     : int32_t type of status
1998  *              NO_ERROR  -- success
1999  *              none-zero failure code
2000  *==========================================================================*/
setAwbLock(const QCameraParameters & params)2001 int32_t QCameraParameters::setAwbLock(const QCameraParameters& params)
2002 {
2003     const char *str = params.get(KEY_AUTO_WHITEBALANCE_LOCK);
2004     const char *prev_str = get(KEY_AUTO_WHITEBALANCE_LOCK);
2005     if (str != NULL) {
2006         if (prev_str == NULL ||
2007             strcmp(str, prev_str) != 0) {
2008             return setAwbLock(str);
2009         }
2010     }
2011     return NO_ERROR;
2012 }
2013 
2014 /*===========================================================================
2015  * FUNCTION   : setMCEValue
2016  *
2017  * DESCRIPTION: set memory color enhancement value from user setting
2018  *
2019  * PARAMETERS :
2020  *   @params  : user setting parameters
2021  *
2022  * RETURN     : int32_t type of status
2023  *              NO_ERROR  -- success
2024  *              none-zero failure code
2025  *==========================================================================*/
setMCEValue(const QCameraParameters & params)2026 int32_t QCameraParameters::setMCEValue(const QCameraParameters& params)
2027 {
2028     const char *str = params.get(KEY_QC_MEMORY_COLOR_ENHANCEMENT);
2029     const char *prev_str = get(KEY_QC_MEMORY_COLOR_ENHANCEMENT);
2030     if (str != NULL) {
2031         if (prev_str == NULL ||
2032             strcmp(str, prev_str) != 0) {
2033             return setMCEValue(str);
2034         }
2035     }
2036     return NO_ERROR;
2037 }
2038 
2039 /*===========================================================================
2040  * FUNCTION   : setDISValue
2041  *
2042  * DESCRIPTION: enable/disable DIS from user setting
2043  *
2044  * PARAMETERS :
2045  *   @params  : user setting parameters
2046  *
2047  * RETURN     : int32_t type of status
2048  *              NO_ERROR  -- success
2049  *              none-zero failure code
2050  *==========================================================================*/
setDISValue(const QCameraParameters & params)2051 int32_t QCameraParameters::setDISValue(const QCameraParameters& params)
2052 {
2053     const char *str = params.get(KEY_QC_DIS);
2054     const char *prev_str = get(KEY_QC_DIS);
2055     if (str != NULL) {
2056         if (prev_str == NULL ||
2057             strcmp(str, prev_str) != 0) {
2058             return setDISValue(str);
2059         }
2060     }
2061     return NO_ERROR;
2062 }
2063 
2064 /*===========================================================================
2065  * FUNCTION   : setHighFrameRate
2066  *
2067  * DESCRIPTION: set hight frame rate value from user setting
2068  *
2069  * PARAMETERS :
2070  *   @params  : user setting parameters
2071  *
2072  * RETURN     : int32_t type of status
2073  *              NO_ERROR  -- success
2074  *              none-zero failure code
2075  *==========================================================================*/
setHighFrameRate(const QCameraParameters & params)2076 int32_t QCameraParameters::setHighFrameRate(const QCameraParameters& params)
2077 {
2078     const char *str = params.get(KEY_QC_VIDEO_HIGH_FRAME_RATE);
2079     const char *prev_str = get(KEY_QC_VIDEO_HIGH_FRAME_RATE);
2080     if (str != NULL) {
2081         if (prev_str == NULL ||
2082             strcmp(str, prev_str) != 0) {
2083             return setHighFrameRate(str);
2084         }
2085     }
2086     return NO_ERROR;
2087 }
2088 
2089 /*===========================================================================
2090  * FUNCTION   : setLensShadeValue
2091  *
2092  * DESCRIPTION: set lens shade value from user setting
2093  *
2094  * PARAMETERS :
2095  *   @params  : user setting parameters
2096  *
2097  * RETURN     : int32_t type of status
2098  *              NO_ERROR  -- success
2099  *              none-zero failure code
2100  *==========================================================================*/
setLensShadeValue(const QCameraParameters & params)2101 int32_t QCameraParameters::setLensShadeValue(const QCameraParameters& params)
2102 {
2103     const char *str = params.get(KEY_QC_LENSSHADE);
2104     const char *prev_str = get(KEY_QC_LENSSHADE);
2105     if (str != NULL) {
2106         if (prev_str == NULL ||
2107             strcmp(str, prev_str) != 0) {
2108             return setLensShadeValue(str);
2109         }
2110     }
2111     return NO_ERROR;
2112 }
2113 
2114 /*===========================================================================
2115  * FUNCTION   : setFocusAreas
2116  *
2117  * DESCRIPTION: set focus areas from user setting
2118  *
2119  * PARAMETERS :
2120  *   @params  : user setting parameters
2121  *
2122  * RETURN     : int32_t type of status
2123  *              NO_ERROR  -- success
2124  *              none-zero failure code
2125  *==========================================================================*/
setFocusAreas(const QCameraParameters & params)2126 int32_t QCameraParameters::setFocusAreas(const QCameraParameters& params)
2127 {
2128     const char *str = params.get(KEY_FOCUS_AREAS);
2129     if (str != NULL) {
2130         int max_num_af_areas = getInt(KEY_MAX_NUM_FOCUS_AREAS);
2131         if(max_num_af_areas == 0) {
2132             ALOGE("%s: max num of AF area is 0, cannot set focus areas", __func__);
2133             return BAD_VALUE;
2134         }
2135 
2136         const char *prev_str = get(KEY_FOCUS_AREAS);
2137         if (prev_str == NULL ||
2138             strcmp(str, prev_str) != 0) {
2139             return setFocusAreas(str);
2140         }
2141     }
2142     return NO_ERROR;
2143 }
2144 
2145 /*===========================================================================
2146  * FUNCTION   : setMeteringAreas
2147  *
2148  * DESCRIPTION: set metering areas from user setting
2149  *
2150  * PARAMETERS :
2151  *   @params  : user setting parameters
2152  *
2153  * RETURN     : int32_t type of status
2154  *              NO_ERROR  -- success
2155  *              none-zero failure code
2156  *==========================================================================*/
setMeteringAreas(const QCameraParameters & params)2157 int32_t QCameraParameters::setMeteringAreas(const QCameraParameters& params)
2158 {
2159     const char *str = params.get(KEY_METERING_AREAS);
2160     if (str != NULL) {
2161         int max_num_mtr_areas = getInt(KEY_MAX_NUM_METERING_AREAS);
2162         if(max_num_mtr_areas == 0) {
2163             ALOGE("%s: max num of metering areas is 0, cannot set focus areas", __func__);
2164             return BAD_VALUE;
2165         }
2166 
2167         const char *prev_str = get(KEY_METERING_AREAS);
2168         if (prev_str == NULL ||
2169             strcmp(str, prev_str) != 0) {
2170             return setMeteringAreas(str);
2171         }
2172     }
2173     return NO_ERROR;
2174 }
2175 
2176 /*===========================================================================
2177  * FUNCTION   : setSceneMode
2178  *
2179  * DESCRIPTION: set scenen mode from user setting
2180  *
2181  * PARAMETERS :
2182  *   @params  : user setting parameters
2183  *
2184  * RETURN     : int32_t type of status
2185  *              NO_ERROR  -- success
2186  *              none-zero failure code
2187  *==========================================================================*/
setSceneMode(const QCameraParameters & params)2188 int32_t QCameraParameters::setSceneMode(const QCameraParameters& params)
2189 {
2190     const char *str = params.get(KEY_SCENE_MODE);
2191     const char *prev_str = get(KEY_SCENE_MODE);
2192     if (str != NULL) {
2193         if (prev_str == NULL ||
2194             strcmp(str, prev_str) != 0) {
2195             if ((strcmp(str, SCENE_MODE_HDR) == 0) ||
2196                 ((prev_str != NULL) && (strcmp(prev_str, SCENE_MODE_HDR) == 0))) {
2197                 ALOGD("%s: scene mode changed between HDR and non-HDR, need restart", __func__);
2198                 m_bNeedRestart = true;
2199 
2200                 // set if hdr 1x image is needed
2201                 const char *need_hdr_1x = params.get(KEY_QC_HDR_NEED_1X);
2202                 int32_t value = 0;
2203                 if (need_hdr_1x != NULL && strcmp(need_hdr_1x, VALUE_TRUE) == 0) {
2204                     value = 1;
2205                     updateParamEntry(KEY_QC_HDR_NEED_1X, need_hdr_1x);
2206                     AddSetParmEntryToBatch(m_pParamBuf,
2207                                            CAM_INTF_PARM_HDR_NEED_1X,
2208                                            sizeof(value),
2209                                            &value);
2210                 }
2211             }
2212             return setSceneMode(str);
2213         }
2214     }
2215     return NO_ERROR;
2216 }
2217 
2218 /*===========================================================================
2219  * FUNCTION   : setSelectableZoneAf
2220  *
2221  * DESCRIPTION: set selectable zone auto focus value from user setting
2222  *
2223  * PARAMETERS :
2224  *   @params  : user setting parameters
2225  *
2226  * RETURN     : int32_t type of status
2227  *              NO_ERROR  -- success
2228  *              none-zero failure code
2229  *==========================================================================*/
setSelectableZoneAf(const QCameraParameters & params)2230 int32_t QCameraParameters::setSelectableZoneAf(const QCameraParameters& params)
2231 {
2232     const char *str = params.get(KEY_QC_SELECTABLE_ZONE_AF);
2233     const char *prev_str = get(KEY_QC_SELECTABLE_ZONE_AF);
2234     if (str != NULL) {
2235         if (prev_str == NULL ||
2236             strcmp(str, prev_str) != 0) {
2237             return setSelectableZoneAf(str);
2238         }
2239     }
2240     return NO_ERROR;
2241 }
2242 
2243 /*===========================================================================
2244  * FUNCTION   : setAEBracket
2245  *
2246  * DESCRIPTION: set AE bracket from user setting
2247  *
2248  * PARAMETERS :
2249  *   @params  : user setting parameters
2250  *
2251  * RETURN     : int32_t type of status
2252  *              NO_ERROR  -- success
2253  *              none-zero failure code
2254  *==========================================================================*/
setAEBracket(const QCameraParameters & params)2255 int32_t QCameraParameters::setAEBracket(const QCameraParameters& params)
2256 {
2257     const char *scene_mode = params.get(KEY_SCENE_MODE);
2258     if (scene_mode != NULL && strcmp(scene_mode, SCENE_MODE_HDR) == 0) {
2259         ALOGE("%s: scene mode is HDR, overwrite AE bracket setting to off", __func__);
2260         return setAEBracket(AE_BRACKET_OFF);
2261     }
2262 
2263     const char *expStr = params.get(KEY_QC_CAPTURE_BURST_EXPOSURE);
2264     if (NULL != expStr && strlen(expStr) > 0) {
2265         set(KEY_QC_CAPTURE_BURST_EXPOSURE, expStr);
2266     } else {
2267         char prop[PROPERTY_VALUE_MAX];
2268         memset(prop, 0, sizeof(prop));
2269         property_get("persist.capture.burst.exposures", prop, "");
2270         if (strlen(prop) > 0) {
2271             set(KEY_QC_CAPTURE_BURST_EXPOSURE, prop);
2272         } else {
2273             remove(KEY_QC_CAPTURE_BURST_EXPOSURE);
2274         }
2275     }
2276 
2277     const char *str = params.get(KEY_QC_AE_BRACKET_HDR);
2278     const char *prev_str = get(KEY_QC_AE_BRACKET_HDR);
2279     if (str != NULL) {
2280         if (prev_str == NULL ||
2281             strcmp(str, prev_str) != 0) {
2282             return setAEBracket(str);
2283         }
2284     }
2285     return NO_ERROR;
2286 }
2287 
2288 /*===========================================================================
2289  * FUNCTION   : setRedeyeReduction
2290  *
2291  * DESCRIPTION: set red eye reduction setting from user setting
2292  *
2293  * PARAMETERS :
2294  *   @params  : user setting parameters
2295  *
2296  * RETURN     : int32_t type of status
2297  *              NO_ERROR  -- success
2298  *              none-zero failure code
2299  *==========================================================================*/
setRedeyeReduction(const QCameraParameters & params)2300 int32_t QCameraParameters::setRedeyeReduction(const QCameraParameters& params)
2301 {
2302     const char *str = params.get(KEY_QC_REDEYE_REDUCTION);
2303     const char *prev_str = get(KEY_QC_REDEYE_REDUCTION);
2304     if (str != NULL) {
2305         if (prev_str == NULL ||
2306             strcmp(str, prev_str) != 0) {
2307             return setRedeyeReduction(str);
2308         }
2309     }
2310     return NO_ERROR;
2311 }
2312 
2313 /*===========================================================================
2314  * FUNCTION   : setGpsLocation
2315  *
2316  * DESCRIPTION: set GPS location information from user setting
2317  *
2318  * PARAMETERS :
2319  *   @params  : user setting parameters
2320  *
2321  * RETURN     : int32_t type of status
2322  *              NO_ERROR  -- success
2323  *              none-zero failure code
2324  *==========================================================================*/
setGpsLocation(const QCameraParameters & params)2325 int32_t QCameraParameters::setGpsLocation(const QCameraParameters& params)
2326 {
2327     const char *method = params.get(KEY_GPS_PROCESSING_METHOD);
2328     if (method) {
2329         set(KEY_GPS_PROCESSING_METHOD, method);
2330     }else {
2331         remove(KEY_GPS_PROCESSING_METHOD);
2332     }
2333 
2334     const char *latitude = params.get(KEY_GPS_LATITUDE);
2335     if (latitude) {
2336         set(KEY_GPS_LATITUDE, latitude);
2337     }else {
2338         remove(KEY_GPS_LATITUDE);
2339     }
2340 
2341     const char *latitudeRef = params.get(KEY_QC_GPS_LATITUDE_REF);
2342     if (latitudeRef) {
2343         set(KEY_QC_GPS_LATITUDE_REF, latitudeRef);
2344     }else {
2345         remove(KEY_QC_GPS_LATITUDE_REF);
2346     }
2347 
2348     const char *longitude = params.get(KEY_GPS_LONGITUDE);
2349     if (longitude) {
2350         set(KEY_GPS_LONGITUDE, longitude);
2351     }else {
2352         remove(KEY_GPS_LONGITUDE);
2353     }
2354 
2355     const char *longitudeRef = params.get(KEY_QC_GPS_LONGITUDE_REF);
2356     if (longitudeRef) {
2357         set(KEY_QC_GPS_LONGITUDE_REF, longitudeRef);
2358     }else {
2359         remove(KEY_QC_GPS_LONGITUDE_REF);
2360     }
2361 
2362     const char *altitudeRef = params.get(KEY_QC_GPS_ALTITUDE_REF);
2363     if (altitudeRef) {
2364         set(KEY_QC_GPS_ALTITUDE_REF, altitudeRef);
2365     }else {
2366         remove(KEY_QC_GPS_ALTITUDE_REF);
2367     }
2368 
2369     const char *altitude = params.get(KEY_GPS_ALTITUDE);
2370     if (altitude) {
2371         set(KEY_GPS_ALTITUDE, altitude);
2372     }else {
2373         remove(KEY_GPS_ALTITUDE);
2374     }
2375 
2376     const char *status = params.get(KEY_QC_GPS_STATUS);
2377     if (status) {
2378         set(KEY_QC_GPS_STATUS, status);
2379     } else {
2380         remove(KEY_QC_GPS_STATUS);
2381     }
2382 
2383     const char *timestamp = params.get(KEY_GPS_TIMESTAMP);
2384     if (timestamp) {
2385         set(KEY_GPS_TIMESTAMP, timestamp);
2386     }else {
2387         remove(KEY_GPS_TIMESTAMP);
2388     }
2389     return NO_ERROR;
2390 }
2391 
2392 /*===========================================================================
2393  * FUNCTION   : setNumOfSnapshot
2394  *
2395  * DESCRIPTION: set number of snapshot per shutter from user setting
2396  *
2397  * PARAMETERS : none
2398  *
2399  * RETURN     : int32_t type of status
2400  *              NO_ERROR  -- success
2401  *              none-zero failure code
2402  *==========================================================================*/
setNumOfSnapshot()2403 int32_t QCameraParameters::setNumOfSnapshot()
2404 {
2405     int nBurstNum = getBurstNum();
2406     uint8_t nExpnum = 0;
2407 
2408     const char *scene_mode = get(KEY_SCENE_MODE);
2409     if (scene_mode != NULL && strcmp(scene_mode, SCENE_MODE_HDR) == 0) {
2410         /* According to Android SDK, only one snapshot,
2411          * but OEM might have different requirement */
2412         const char *need_hdr_1x = get(KEY_QC_HDR_NEED_1X);
2413         if (need_hdr_1x != NULL && strcmp(need_hdr_1x, VALUE_TRUE) == 0) {
2414             nExpnum = 2; // HDR needs both 1X and processed img
2415         } else {
2416             nExpnum = 1; // HDR only needs processed img
2417         }
2418     } else {
2419         const char *bracket_str = get(KEY_QC_AE_BRACKET_HDR);
2420         if (bracket_str != NULL && strlen(bracket_str) > 0) {
2421             int value = lookupAttr(BRACKETING_MODES_MAP,
2422                                    sizeof(BRACKETING_MODES_MAP)/sizeof(QCameraMap),
2423                                    bracket_str);
2424             switch (value) {
2425             case CAM_EXP_BRACKETING_ON:
2426                 {
2427                     nExpnum = 0;
2428                     const char *str_val = get(KEY_QC_CAPTURE_BURST_EXPOSURE);
2429                     if ((str_val != NULL) && (strlen(str_val) > 0)) {
2430                         char prop[PROPERTY_VALUE_MAX];
2431                         memset(prop, 0, sizeof(prop));
2432                         strcpy(prop, str_val);
2433                         char *saveptr = NULL;
2434                         char *token = strtok_r(prop, ",", &saveptr);
2435                         while (token != NULL) {
2436                             token = strtok_r(NULL, ",", &saveptr);
2437                             nExpnum++;
2438                         }
2439                     }
2440                     if (nExpnum == 0) {
2441                         nExpnum = 1;
2442                     }
2443                 }
2444                 break;
2445             default:
2446                 nExpnum = 1;
2447                 break;
2448             }
2449         }
2450     }
2451 
2452     ALOGD("%s: nBurstNum = %d, nExpnum = %d", __func__, nBurstNum, nExpnum);
2453     set(KEY_QC_NUM_SNAPSHOT_PER_SHUTTER, nBurstNum * nExpnum);
2454     return NO_ERROR;
2455 }
2456 
2457 /*===========================================================================
2458  * FUNCTION   : setRecordingHint
2459  *
2460  * DESCRIPTION: set recording hint value from user setting
2461  *
2462  * PARAMETERS :
2463  *   @params  : user setting parameters
2464  *
2465  * RETURN     : int32_t type of status
2466  *              NO_ERROR  -- success
2467  *              none-zero failure code
2468  *==========================================================================*/
setRecordingHint(const QCameraParameters & params)2469 int32_t QCameraParameters::setRecordingHint(const QCameraParameters& params)
2470 {
2471     const char * str = params.get(KEY_RECORDING_HINT);
2472     const char *prev_str = get(KEY_RECORDING_HINT);
2473     if (str != NULL) {
2474         if (prev_str == NULL || strcmp(str, prev_str) != 0) {
2475             int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP,
2476                                        sizeof(TRUE_FALSE_MODES_MAP)/sizeof(QCameraMap),
2477                                        str);
2478             if(value != NAME_NOT_FOUND){
2479                 updateParamEntry(KEY_RECORDING_HINT, str);
2480                 setRecordingHintValue(value);
2481                 return NO_ERROR;
2482             } else {
2483                 ALOGE("Invalid recording hint value: %s", str);
2484                 return BAD_VALUE;
2485             }
2486         }
2487     }
2488     return NO_ERROR;
2489 }
2490 
2491 /*===========================================================================
2492  * FUNCTION   : setNoDisplayMode
2493  *
2494  * DESCRIPTION: set no display mode from user setting
2495  *
2496  * PARAMETERS :
2497  *   @params  : user setting parameters
2498  *
2499  * RETURN     : int32_t type of status
2500  *              NO_ERROR  -- success
2501  *              none-zero failure code
2502  *==========================================================================*/
setNoDisplayMode(const QCameraParameters & params)2503 int32_t QCameraParameters::setNoDisplayMode(const QCameraParameters& params)
2504 {
2505     const char *str_val  = params.get(KEY_QC_NO_DISPLAY_MODE);
2506     const char *prev_str = get(KEY_QC_NO_DISPLAY_MODE);
2507     if(str_val && strlen(str_val) > 0) {
2508         if (prev_str == NULL || strcmp(str_val, prev_str) != 0) {
2509             m_bNoDisplayMode = atoi(str_val);
2510             set(KEY_QC_NO_DISPLAY_MODE, str_val);
2511             m_bNeedRestart = true;
2512         }
2513     } else {
2514         m_bNoDisplayMode = false;
2515     }
2516     ALOGD("Param m_bNoDisplayMode = %d", m_bNoDisplayMode);
2517     return NO_ERROR;
2518 }
2519 
2520 /*===========================================================================
2521  * FUNCTION   : setZslMode
2522  *
2523  * DESCRIPTION: set ZSL mode from user setting
2524  *
2525  * PARAMETERS :
2526  *   @params  : user setting parameters
2527  *
2528  * RETURN     : int32_t type of status
2529  *              NO_ERROR  -- success
2530  *              none-zero failure code
2531  *==========================================================================*/
setZslMode(const QCameraParameters & params)2532 int32_t QCameraParameters::setZslMode(const QCameraParameters& params)
2533 {
2534     const char *str_val  = params.get(KEY_QC_ZSL);
2535     const char *prev_val  = get(KEY_QC_ZSL);
2536 
2537     if (str_val != NULL) {
2538         if (prev_val == NULL || strcmp(str_val, prev_val) != 0) {
2539             int32_t value = lookupAttr(ON_OFF_MODES_MAP,
2540                                        sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap),
2541                                        str_val);
2542             if (value != NAME_NOT_FOUND) {
2543                 set(KEY_QC_ZSL, str_val);
2544                 m_bZslMode_new = (value > 0)? true : false;
2545 
2546                 // ZSL mode changed, need restart preview
2547                 m_bNeedRestart = true;
2548 
2549                 return AddSetParmEntryToBatch(m_pParamBuf,
2550                                               CAM_INTF_PARM_ZSL_MODE,
2551                                               sizeof(value),
2552                                               &value);
2553             } else {
2554                 ALOGE("Invalid ZSL mode value: %s", str_val);
2555                 return BAD_VALUE;
2556             }
2557         }
2558     }
2559     return NO_ERROR;
2560 }
2561 
2562 /*===========================================================================
2563  * FUNCTION   : setWaveletDenoise
2564  *
2565  * DESCRIPTION: set wavelet denoise value from user setting
2566  *
2567  * PARAMETERS :
2568  *   @params  : user setting parameters
2569  *
2570  * RETURN     : int32_t type of status
2571  *              NO_ERROR  -- success
2572  *              none-zero failure code
2573  *==========================================================================*/
setWaveletDenoise(const QCameraParameters & params)2574 int32_t QCameraParameters::setWaveletDenoise(const QCameraParameters& params)
2575 {
2576     const char *str = params.get(KEY_QC_DENOISE);
2577     const char *prev_str = get(KEY_QC_DENOISE);
2578     if (str != NULL) {
2579         if (prev_str == NULL ||
2580             strcmp(str, prev_str) != 0) {
2581             return setWaveletDenoise(str);
2582         }
2583     }
2584     return NO_ERROR;
2585 }
2586 
2587 /*===========================================================================
2588  * FUNCTION   : setCameraMode
2589  *
2590  * DESCRIPTION: set camera mode from user setting
2591  *
2592  * PARAMETERS :
2593  *   @params  : user setting parameters
2594  *
2595  * RETURN     : int32_t type of status
2596  *              NO_ERROR  -- success
2597  *              none-zero failure code
2598  *==========================================================================*/
setCameraMode(const QCameraParameters & params)2599 int32_t QCameraParameters::setCameraMode(const QCameraParameters& params)
2600 {
2601     const char *str = params.get(KEY_QC_CAMERA_MODE);
2602     if (str != NULL) {
2603         set(KEY_QC_CAMERA_MODE, str);
2604     } else {
2605         remove(KEY_QC_CAMERA_MODE);
2606     }
2607     return NO_ERROR;
2608 }
2609 
2610 /*===========================================================================
2611  * FUNCTION   : setZslAttributes
2612  *
2613  * DESCRIPTION: set ZSL related attributes from user setting
2614  *
2615  * PARAMETERS :
2616  *   @params  : user setting parameters
2617  *
2618  * RETURN     : int32_t type of status
2619  *              NO_ERROR  -- success
2620  *              none-zero failure code
2621  *==========================================================================*/
setZslAttributes(const QCameraParameters & params)2622 int32_t QCameraParameters::setZslAttributes(const QCameraParameters& params)
2623 {
2624     // TODO: may switch to pure param instead of sysprop
2625     char prop[PROPERTY_VALUE_MAX];
2626 
2627     const char *str = params.get(KEY_QC_ZSL_BURST_INTERVAL);
2628     if (str != NULL) {
2629         set(KEY_QC_ZSL_BURST_INTERVAL, str);
2630     } else {
2631         memset(prop, 0, sizeof(prop));
2632         property_get("persist.camera.zsl.interval", prop, "1");
2633         set(KEY_QC_ZSL_BURST_INTERVAL, prop);
2634     }
2635 
2636     str = params.get(KEY_QC_ZSL_BURST_LOOKBACK);
2637     if (str != NULL) {
2638         set(KEY_QC_ZSL_BURST_LOOKBACK, str);
2639     } else {
2640         memset(prop, 0, sizeof(prop));
2641         property_get("persist.camera.zsl.backlookcnt", prop, "2");
2642         set(KEY_QC_ZSL_BURST_LOOKBACK, prop);
2643     }
2644 
2645     str = params.get(KEY_QC_ZSL_QUEUE_DEPTH);
2646     if (str != NULL) {
2647         set(KEY_QC_ZSL_QUEUE_DEPTH, str);
2648     } else {
2649         memset(prop, 0, sizeof(prop));
2650         property_get("persist.camera.zsl.queuedepth", prop, "2");
2651         set(KEY_QC_ZSL_QUEUE_DEPTH, prop);
2652     }
2653 
2654     return NO_ERROR;
2655 }
2656 
2657 /*===========================================================================
2658  * FUNCTION   : setFlip
2659  *
2660  * DESCRIPTION: set preview/ video/ picture flip mode from user setting
2661  *
2662  * PARAMETERS :
2663  *   @params  : user setting parameters
2664  *
2665  * RETURN     : int32_t type of status
2666  *              NO_ERROR  -- success
2667  *              none-zero failure code
2668  *==========================================================================*/
setFlip(const QCameraParameters & params)2669 int32_t QCameraParameters::setFlip(const QCameraParameters& params)
2670 {
2671     if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_FLIP) == 0) {
2672         ALOGD("%s: flip is not supported.", __func__);
2673         return NO_ERROR;
2674     }
2675 
2676     //check preview flip setting
2677     const char *str = params.get(KEY_QC_PREVIEW_FLIP);
2678     if(str != NULL){
2679         int32_t value = lookupAttr(FLIP_MODES_MAP,
2680                                    sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap),
2681                                    str);
2682         if(value != NAME_NOT_FOUND){
2683             set(KEY_QC_PREVIEW_FLIP, str);
2684         }
2685     }
2686 
2687     // check video filp setting
2688     str = params.get(KEY_QC_VIDEO_FLIP);
2689     if(str != NULL){
2690         int32_t value = lookupAttr(FLIP_MODES_MAP,
2691                                    sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap),
2692                                    str);
2693         if(value != NAME_NOT_FOUND){
2694             set(KEY_QC_VIDEO_FLIP, str);
2695         }
2696     }
2697 
2698     // check picture filp setting
2699     str = params.get(KEY_QC_SNAPSHOT_PICTURE_FLIP);
2700     if(str != NULL){
2701         int32_t value = lookupAttr(FLIP_MODES_MAP,
2702                                    sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap),
2703                                    str);
2704         if(value != NAME_NOT_FOUND){
2705             set(KEY_QC_SNAPSHOT_PICTURE_FLIP, str);
2706         }
2707     }
2708 
2709     return NO_ERROR;
2710 }
2711 
2712 /*===========================================================================
2713  * FUNCTION   : updateParameters
2714  *
2715  * DESCRIPTION: update parameters from user setting
2716  *
2717  * PARAMETERS :
2718  *   @params  : user setting parameters
2719  *   @needRestart : [output] if preview need restart upon setting changes
2720  *
2721  * RETURN     : int32_t type of status
2722  *              NO_ERROR  -- success
2723  *              none-zero failure code
2724  *==========================================================================*/
updateParameters(QCameraParameters & params,bool & needRestart)2725 int32_t QCameraParameters::updateParameters(QCameraParameters& params,
2726                                             bool &needRestart)
2727 {
2728     int32_t final_rc = NO_ERROR;
2729     int32_t rc;
2730     m_bNeedRestart = false;
2731 
2732     if(initBatchUpdate(m_pParamBuf) < 0 ) {
2733         ALOGE("%s:Failed to initialize group update table",__func__);
2734         rc = BAD_TYPE;
2735         goto UPDATE_PARAM_DONE;
2736     }
2737 
2738     if ((rc = setPreviewSize(params)))                  final_rc = rc;
2739     if ((rc = setVideoSize(params)))                    final_rc = rc;
2740     if ((rc = setPictureSize(params)))                  final_rc = rc;
2741     if ((rc = setPreviewFormat(params)))                final_rc = rc;
2742     if ((rc = setPictureFormat(params)))                final_rc = rc;
2743     if ((rc = setJpegThumbnailSize(params)))            final_rc = rc;
2744     if ((rc = setJpegQuality(params)))                  final_rc = rc;
2745     if ((rc = setOrientation(params)))                  final_rc = rc;
2746     if ((rc = setRotation(params)))                     final_rc = rc;
2747     if ((rc = setNoDisplayMode(params)))                final_rc = rc;
2748     if ((rc = setZslMode(params)))                      final_rc = rc;
2749     if ((rc = setZslAttributes(params)))                final_rc = rc;
2750     if ((rc = setCameraMode(params)))                   final_rc = rc;
2751     if ((rc = setRecordingHint(params)))                final_rc = rc;
2752 
2753     if ((rc = setPreviewFpsRange(params)))              final_rc = rc;
2754     if ((rc = setPreviewFrameRate(params)))             final_rc = rc;
2755     if ((rc = setAutoExposure(params)))                 final_rc = rc;
2756     if ((rc = setEffect(params)))                       final_rc = rc;
2757     if ((rc = setBrightness(params)))                   final_rc = rc;
2758     if ((rc = setZoom(params)))                         final_rc = rc;
2759     if ((rc = setSharpness(params)))                    final_rc = rc;
2760     if ((rc = setSaturation(params)))                   final_rc = rc;
2761     if ((rc = setContrast(params)))                     final_rc = rc;
2762     if ((rc = setFocusMode(params)))                    final_rc = rc;
2763     if ((rc = setISOValue(params)))                     final_rc = rc;
2764     if ((rc = setSkinToneEnhancement(params)))          final_rc = rc;
2765     if ((rc = setFlash(params)))                        final_rc = rc;
2766     if ((rc = setAecLock(params)))                      final_rc = rc;
2767     if ((rc = setAwbLock(params)))                      final_rc = rc;
2768     if ((rc = setLensShadeValue(params)))               final_rc = rc;
2769     if ((rc = setMCEValue(params)))                     final_rc = rc;
2770     if ((rc = setDISValue(params)))                     final_rc = rc;
2771     if ((rc = setHighFrameRate(params)))                final_rc = rc;
2772     if ((rc = setAntibanding(params)))                  final_rc = rc;
2773     if ((rc = setExposureCompensation(params)))         final_rc = rc;
2774     if ((rc = setWhiteBalance(params)))                 final_rc = rc;
2775     if ((rc = setSceneMode(params)))                    final_rc = rc;
2776     if ((rc = setFocusAreas(params)))                   final_rc = rc;
2777     if ((rc = setMeteringAreas(params)))                final_rc = rc;
2778     if ((rc = setSelectableZoneAf(params)))             final_rc = rc;
2779     if ((rc = setRedeyeReduction(params)))              final_rc = rc;
2780     if ((rc = setAEBracket(params)))                    final_rc = rc;
2781     if ((rc = setGpsLocation(params)))                  final_rc = rc;
2782     if ((rc = setWaveletDenoise(params)))               final_rc = rc;
2783     if ((rc = setFaceRecognition(params)))              final_rc = rc;
2784     if ((rc = setFlip(params)))                         final_rc = rc;
2785     if ((rc = setVideoHDR(params)))                     final_rc = rc;
2786 
2787     // update live snapshot size after all other parameters are set
2788     if ((rc = setLiveSnapshotSize(params)))             final_rc = rc;
2789 
2790 UPDATE_PARAM_DONE:
2791     needRestart = m_bNeedRestart;
2792     return final_rc;
2793 }
2794 
2795 /*===========================================================================
2796  * FUNCTION   : commitParameters
2797  *
2798  * DESCRIPTION: commit parameter changes to backend
2799  *
2800  * PARAMETERS : none
2801  *
2802  * RETURN     : int32_t type of status
2803  *              NO_ERROR  -- success
2804  *              none-zero failure code
2805  *==========================================================================*/
commitParameters()2806 int32_t QCameraParameters::commitParameters()
2807 {
2808     return commitSetBatch();
2809 }
2810 
2811 /*===========================================================================
2812  * FUNCTION   : initDefaultParameters
2813  *
2814  * DESCRIPTION: initialize default parameters for the first time
2815  *
2816  * PARAMETERS : none
2817  *
2818  * RETURN     : int32_t type of status
2819  *              NO_ERROR  -- success
2820  *              none-zero failure code
2821  *==========================================================================*/
initDefaultParameters()2822 int32_t QCameraParameters::initDefaultParameters()
2823 {
2824     if(initBatchUpdate(m_pParamBuf) < 0 ) {
2825         ALOGE("%s:Failed to initialize group update table", __func__);
2826         return BAD_TYPE;
2827     }
2828 
2829     /*************************Initialize Values******************************/
2830     // Set read only parameters from camera capability
2831     set(KEY_SMOOTH_ZOOM_SUPPORTED,
2832         m_pCapability->smooth_zoom_supported? VALUE_TRUE : VALUE_FALSE);
2833     set(KEY_ZOOM_SUPPORTED,
2834         m_pCapability->zoom_supported? VALUE_TRUE : VALUE_FALSE);
2835     set(KEY_VIDEO_SNAPSHOT_SUPPORTED,
2836         m_pCapability->video_snapshot_supported? VALUE_TRUE : VALUE_FALSE);
2837     set(KEY_VIDEO_STABILIZATION_SUPPORTED,
2838         m_pCapability->video_stablization_supported? VALUE_TRUE : VALUE_FALSE);
2839     set(KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
2840         m_pCapability->auto_exposure_lock_supported? VALUE_TRUE : VALUE_FALSE);
2841     set(KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
2842         m_pCapability->auto_wb_lock_supported? VALUE_TRUE : VALUE_FALSE);
2843     set(KEY_QC_SUPPORTED_CAMERA_FEATURES,
2844         m_pCapability->qcom_supported_feature_mask);
2845     set(KEY_MAX_NUM_DETECTED_FACES_HW, m_pCapability->max_num_roi);
2846     set(KEY_MAX_NUM_DETECTED_FACES_SW, m_pCapability->max_num_roi);
2847     set(KEY_QC_MAX_NUM_REQUESTED_FACES, m_pCapability->max_num_roi);
2848     // Set focal length, horizontal view angle, and vertical view angle
2849     setFloat(KEY_FOCAL_LENGTH, m_pCapability->focal_length);
2850     setFloat(KEY_HORIZONTAL_VIEW_ANGLE, m_pCapability->hor_view_angle);
2851     setFloat(KEY_VERTICAL_VIEW_ANGLE, m_pCapability->ver_view_angle);
2852 
2853     // Set supported preview sizes
2854     if (m_pCapability->preview_sizes_tbl_cnt > 0 &&
2855         m_pCapability->preview_sizes_tbl_cnt <= MAX_SIZES_CNT) {
2856         String8 previewSizeValues = createSizesString(
2857                 m_pCapability->preview_sizes_tbl, m_pCapability->preview_sizes_tbl_cnt);
2858         set(KEY_SUPPORTED_PREVIEW_SIZES, previewSizeValues.string());
2859         ALOGD("%s: supported preview sizes: %s", __func__, previewSizeValues.string());
2860         // Set default preview size
2861         CameraParameters::setPreviewSize(m_pCapability->preview_sizes_tbl[0].width,
2862                                          m_pCapability->preview_sizes_tbl[0].height);
2863     } else {
2864         ALOGE("%s: supported preview sizes cnt is 0 or exceeds max!!!", __func__);
2865     }
2866 
2867     // Set supported video sizes
2868     if (m_pCapability->video_sizes_tbl_cnt > 0 &&
2869         m_pCapability->video_sizes_tbl_cnt <= MAX_SIZES_CNT) {
2870         String8 videoSizeValues = createSizesString(
2871                 m_pCapability->video_sizes_tbl, m_pCapability->video_sizes_tbl_cnt);
2872         set(KEY_SUPPORTED_VIDEO_SIZES, videoSizeValues.string());
2873         ALOGD("%s: supported video sizes: %s", __func__, videoSizeValues.string());
2874         // Set default video size
2875         CameraParameters::setVideoSize(m_pCapability->video_sizes_tbl[0].width,
2876                                        m_pCapability->video_sizes_tbl[0].height);
2877 
2878         //Set preferred Preview size for video
2879         String8 vSize = createSizesString(&m_pCapability->video_sizes_tbl[0], 1);
2880         set(KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, vSize.string());
2881     } else {
2882         ALOGE("%s: supported video sizes cnt is 0 or exceeds max!!!", __func__);
2883     }
2884 
2885     // Set supported picture sizes
2886     if (m_pCapability->picture_sizes_tbl_cnt > 0 &&
2887         m_pCapability->picture_sizes_tbl_cnt <= MAX_SIZES_CNT) {
2888         String8 pictureSizeValues = createSizesString(
2889                 m_pCapability->picture_sizes_tbl, m_pCapability->picture_sizes_tbl_cnt);
2890         set(KEY_SUPPORTED_PICTURE_SIZES, pictureSizeValues.string());
2891         ALOGD("%s: supported pic sizes: %s", __func__, pictureSizeValues.string());
2892         // Set default picture size to the smallest resolution
2893         CameraParameters::setPictureSize(
2894            m_pCapability->picture_sizes_tbl[m_pCapability->picture_sizes_tbl_cnt-1].width,
2895            m_pCapability->picture_sizes_tbl[m_pCapability->picture_sizes_tbl_cnt-1].height);
2896     } else {
2897         ALOGE("%s: supported picture sizes cnt is 0 or exceeds max!!!", __func__);
2898     }
2899 
2900     // Set supported thumbnail sizes
2901     String8 thumbnailSizeValues = createSizesString(
2902             THUMBNAIL_SIZES_MAP,
2903             sizeof(THUMBNAIL_SIZES_MAP)/sizeof(cam_dimension_t));
2904     set(KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, thumbnailSizeValues.string());
2905     // Set default thumnail size
2906     set(KEY_JPEG_THUMBNAIL_WIDTH, THUMBNAIL_SIZES_MAP[0].width);
2907     set(KEY_JPEG_THUMBNAIL_HEIGHT, THUMBNAIL_SIZES_MAP[0].height);
2908 
2909     // Set supported livesnapshot sizes
2910     if (m_pCapability->livesnapshot_sizes_tbl_cnt > 0 &&
2911         m_pCapability->livesnapshot_sizes_tbl_cnt <= MAX_SIZES_CNT) {
2912         String8 liveSnpashotSizeValues = createSizesString(
2913                 m_pCapability->livesnapshot_sizes_tbl,
2914                 m_pCapability->livesnapshot_sizes_tbl_cnt);
2915         set(KEY_QC_SUPPORTED_LIVESNAPSHOT_SIZES, liveSnpashotSizeValues.string());
2916         ALOGI("%s: supported live snapshot sizes: %s", __func__, liveSnpashotSizeValues.string());
2917         m_LiveSnapshotSize =
2918             m_pCapability->livesnapshot_sizes_tbl[m_pCapability->livesnapshot_sizes_tbl_cnt-1];
2919     }
2920 
2921     // Set supported preview formats
2922     String8 previewFormatValues = createValuesString(
2923             (int *)m_pCapability->supported_preview_fmts,
2924             m_pCapability->supported_preview_fmt_cnt,
2925             PREVIEW_FORMATS_MAP,
2926             sizeof(PREVIEW_FORMATS_MAP)/sizeof(QCameraMap));
2927     set(KEY_SUPPORTED_PREVIEW_FORMATS, previewFormatValues.string());
2928     // Set default preview format
2929     CameraParameters::setPreviewFormat(PIXEL_FORMAT_YUV420SP);
2930 
2931     // Set default Video Format
2932     set(KEY_VIDEO_FRAME_FORMAT, PIXEL_FORMAT_YUV420SP);
2933 
2934     // Set supported picture formats
2935     String8 pictureTypeValues(PIXEL_FORMAT_JPEG);
2936     String8 str = createValuesString(
2937             (int *)m_pCapability->supported_raw_fmts,
2938             m_pCapability->supported_raw_fmt_cnt,
2939             PICTURE_TYPES_MAP,
2940             sizeof(PICTURE_TYPES_MAP)/sizeof(QCameraMap));
2941     if (str.string() != NULL) {
2942         pictureTypeValues.append(",");
2943         pictureTypeValues.append(str);
2944     }
2945 
2946     set(KEY_SUPPORTED_PICTURE_FORMATS, pictureTypeValues.string());
2947     // Set default picture Format
2948     CameraParameters::setPictureFormat(PIXEL_FORMAT_JPEG);
2949     // Set raw image size
2950     char raw_size_str[32];
2951     snprintf(raw_size_str, sizeof(raw_size_str), "%dx%d",
2952              m_pCapability->raw_dim.width, m_pCapability->raw_dim.height);
2953     set(KEY_QC_RAW_PICUTRE_SIZE, raw_size_str);
2954 
2955     //set default jpeg quality and thumbnail quality
2956     set(KEY_JPEG_QUALITY, 85);
2957     set(KEY_JPEG_THUMBNAIL_QUALITY, 85);
2958 
2959     // Set FPS ranges
2960     if (m_pCapability->fps_ranges_tbl_cnt > 0 &&
2961         m_pCapability->fps_ranges_tbl_cnt <= MAX_SIZES_CNT) {
2962         int default_fps_index = 0;
2963         String8 fpsRangeValues = createFpsRangeString(m_pCapability->fps_ranges_tbl,
2964                                                       m_pCapability->fps_ranges_tbl_cnt,
2965                                                       default_fps_index);
2966         set(KEY_SUPPORTED_PREVIEW_FPS_RANGE, fpsRangeValues.string());
2967 
2968         int min_fps =
2969             int(m_pCapability->fps_ranges_tbl[default_fps_index].min_fps * 1000);
2970         int max_fps =
2971             int(m_pCapability->fps_ranges_tbl[default_fps_index].max_fps * 1000);
2972         setPreviewFpsRange(min_fps, max_fps);
2973 
2974         // Set legacy preview fps
2975         String8 fpsValues = createFpsString(m_pCapability->fps_ranges_tbl,
2976                                             m_pCapability->fps_ranges_tbl_cnt);
2977         set(KEY_SUPPORTED_PREVIEW_FRAME_RATES, fpsValues.string());
2978         CameraParameters::setPreviewFrameRate(int(m_pCapability->fps_ranges_tbl[default_fps_index].max_fps));
2979     } else {
2980         ALOGE("%s: supported fps ranges cnt is 0 or exceeds max!!!", __func__);
2981     }
2982 
2983     // Set supported focus modes
2984     if (m_pCapability->supported_focus_modes_cnt > 0) {
2985         String8 focusModeValues = createValuesString(
2986                 (int *)m_pCapability->supported_focus_modes,
2987                 m_pCapability->supported_focus_modes_cnt,
2988                 FOCUS_MODES_MAP,
2989                 sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap));
2990         set(KEY_SUPPORTED_FOCUS_MODES, focusModeValues);
2991 
2992         // Set default focus mode and update corresponding parameter buf
2993         const char *focusMode = lookupNameByValue(FOCUS_MODES_MAP,
2994                                              sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap),
2995                                              m_pCapability->supported_focus_modes[0]);
2996         if (focusMode != NULL) {
2997             setFocusMode(focusMode);
2998         } else {
2999             setFocusMode(FOCUS_MODE_FIXED);
3000         }
3001     } else {
3002         ALOGE("%s: supported focus modes cnt is 0!!!", __func__);
3003     }
3004 
3005     // Set focus areas
3006     if (m_pCapability->max_num_focus_areas > MAX_ROI) {
3007         m_pCapability->max_num_focus_areas = MAX_ROI;
3008     }
3009     set(KEY_MAX_NUM_FOCUS_AREAS, m_pCapability->max_num_focus_areas);
3010     if (m_pCapability->max_num_focus_areas > 0) {
3011         setFocusAreas(DEFAULT_CAMERA_AREA);
3012     }
3013 
3014     // Set metering areas
3015     if (m_pCapability->max_num_metering_areas > MAX_ROI) {
3016         m_pCapability->max_num_metering_areas = MAX_ROI;
3017     }
3018     set(KEY_MAX_NUM_METERING_AREAS, m_pCapability->max_num_metering_areas);
3019     if (m_pCapability->max_num_metering_areas > 0) {
3020         setMeteringAreas(DEFAULT_CAMERA_AREA);
3021     }
3022 
3023     // Set Saturation
3024     set(KEY_QC_MIN_SATURATION, m_pCapability->saturation_ctrl.min_value);
3025     set(KEY_QC_MAX_SATURATION, m_pCapability->saturation_ctrl.max_value);
3026     set(KEY_QC_SATURATION_STEP, m_pCapability->saturation_ctrl.step);
3027     setSaturation(m_pCapability->saturation_ctrl.def_value);
3028 
3029     // Set Sharpness
3030     set(KEY_QC_MIN_SHARPNESS, m_pCapability->sharpness_ctrl.min_value);
3031     set(KEY_QC_MAX_SHARPNESS, m_pCapability->sharpness_ctrl.max_value);
3032     set(KEY_QC_SHARPNESS_STEP, m_pCapability->sharpness_ctrl.step);
3033     setSharpness(m_pCapability->sharpness_ctrl.def_value);
3034 
3035     // Set Contrast
3036     set(KEY_QC_MIN_CONTRAST, m_pCapability->contrast_ctrl.min_value);
3037     set(KEY_QC_MAX_CONTRAST, m_pCapability->contrast_ctrl.max_value);
3038     set(KEY_QC_CONTRAST_STEP, m_pCapability->contrast_ctrl.step);
3039     setContrast(m_pCapability->contrast_ctrl.def_value);
3040 
3041     // Set SCE factor
3042     set(KEY_QC_MIN_SCE_FACTOR, m_pCapability->sce_ctrl.min_value); // -100
3043     set(KEY_QC_MAX_SCE_FACTOR, m_pCapability->sce_ctrl.max_value); // 100
3044     set(KEY_QC_SCE_FACTOR_STEP, m_pCapability->sce_ctrl.step);     // 10
3045     setSkinToneEnhancement(m_pCapability->sce_ctrl.def_value);     // 0
3046 
3047     // Set Brightness
3048     set(KEY_QC_MIN_BRIGHTNESS, m_pCapability->brightness_ctrl.min_value); // 0
3049     set(KEY_QC_MAX_BRIGHTNESS, m_pCapability->brightness_ctrl.max_value); // 6
3050     set(KEY_QC_BRIGHTNESS_STEP, m_pCapability->brightness_ctrl.step);     // 1
3051     setBrightness(m_pCapability->brightness_ctrl.def_value);
3052 
3053     // Set Auto exposure
3054     String8 autoExposureValues = createValuesString(
3055             (int *)m_pCapability->supported_aec_modes,
3056             m_pCapability->supported_aec_modes_cnt,
3057             AUTO_EXPOSURE_MAP,
3058             sizeof(AUTO_EXPOSURE_MAP) / sizeof(QCameraMap));
3059     set(KEY_QC_SUPPORTED_AUTO_EXPOSURE, autoExposureValues.string());
3060     setAutoExposure(AUTO_EXPOSURE_FRAME_AVG);
3061 
3062     // Set Exposure Compensation
3063     set(KEY_MAX_EXPOSURE_COMPENSATION, m_pCapability->exposure_compensation_max); // 12
3064     set(KEY_MIN_EXPOSURE_COMPENSATION, m_pCapability->exposure_compensation_min); // -12
3065     setFloat(KEY_EXPOSURE_COMPENSATION_STEP, m_pCapability->exposure_compensation_step); // 1/6
3066     setExposureCompensation(m_pCapability->exposure_compensation_default); // 0
3067 
3068     // Set Antibanding
3069     String8 antibandingValues = createValuesString(
3070             (int *)m_pCapability->supported_antibandings,
3071             m_pCapability->supported_antibandings_cnt,
3072             ANTIBANDING_MODES_MAP,
3073             sizeof(ANTIBANDING_MODES_MAP) / sizeof(QCameraMap));
3074     set(KEY_SUPPORTED_ANTIBANDING, antibandingValues);
3075     setAntibanding(ANTIBANDING_OFF);
3076 
3077     // Set Effect
3078     String8 effectValues = createValuesString(
3079             (int *)m_pCapability->supported_effects,
3080             m_pCapability->supported_effects_cnt,
3081             EFFECT_MODES_MAP,
3082             sizeof(EFFECT_MODES_MAP) / sizeof(QCameraMap));
3083     set(KEY_SUPPORTED_EFFECTS, effectValues);
3084     setEffect(EFFECT_NONE);
3085 
3086     // Set WhiteBalance
3087     String8 whitebalanceValues = createValuesString(
3088             (int *)m_pCapability->supported_white_balances,
3089             m_pCapability->supported_white_balances_cnt,
3090             WHITE_BALANCE_MODES_MAP,
3091             sizeof(WHITE_BALANCE_MODES_MAP) / sizeof(QCameraMap));
3092     set(KEY_SUPPORTED_WHITE_BALANCE, whitebalanceValues);
3093     setWhiteBalance(WHITE_BALANCE_AUTO);
3094 
3095     // Set Flash mode
3096     String8 flashValues = createValuesString(
3097             (int *)m_pCapability->supported_flash_modes,
3098             m_pCapability->supported_flash_modes_cnt,
3099             FLASH_MODES_MAP,
3100             sizeof(FLASH_MODES_MAP) / sizeof(QCameraMap));
3101     set(KEY_SUPPORTED_FLASH_MODES, flashValues);
3102     setFlash(FLASH_MODE_OFF);
3103 
3104     // Set Scene Mode
3105     String8 sceneModeValues = createValuesString(
3106             (int *)m_pCapability->supported_scene_modes,
3107             m_pCapability->supported_scene_modes_cnt,
3108             SCENE_MODES_MAP,
3109             sizeof(SCENE_MODES_MAP) / sizeof(QCameraMap));
3110     set(KEY_SUPPORTED_SCENE_MODES, sceneModeValues);
3111     setSceneMode(SCENE_MODE_AUTO);
3112 
3113     // Set ISO Mode
3114     String8 isoValues = createValuesString(
3115             (int *)m_pCapability->supported_iso_modes,
3116             m_pCapability->supported_iso_modes_cnt,
3117             ISO_MODES_MAP,
3118             sizeof(ISO_MODES_MAP) / sizeof(QCameraMap));
3119     set(KEY_QC_SUPPORTED_ISO_MODES, isoValues);
3120     setISOValue(ISO_AUTO);
3121 
3122     // Set HFR
3123     String8 hfrValues = createHfrValuesString(
3124             m_pCapability->hfr_tbl,
3125             m_pCapability->hfr_tbl_cnt,
3126             HFR_MODES_MAP,
3127             sizeof(HFR_MODES_MAP) / sizeof(QCameraMap));
3128     set(KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES, hfrValues.string());
3129     String8 hfrSizeValues = createHfrSizesString(
3130             m_pCapability->hfr_tbl,
3131             m_pCapability->hfr_tbl_cnt);
3132     set(KEY_QC_SUPPORTED_HFR_SIZES, hfrSizeValues.string());
3133     setHighFrameRate(VIDEO_HFR_OFF);
3134 
3135     // Set Focus algorithms
3136     String8 focusAlgoValues = createValuesString(
3137             (int *)m_pCapability->supported_focus_algos,
3138             m_pCapability->supported_focus_algos_cnt,
3139             FOCUS_ALGO_MAP,
3140             sizeof(FOCUS_ALGO_MAP) / sizeof(QCameraMap));
3141     set(KEY_QC_SUPPORTED_FOCUS_ALGOS, focusAlgoValues);
3142     setSelectableZoneAf(FOCUS_ALGO_AUTO);
3143 
3144     // Set Zoom Ratios
3145     if (m_pCapability->zoom_supported > 0) {
3146         String8 zoomRatioValues = createZoomRatioValuesString(
3147                 m_pCapability->zoom_ratio_tbl,
3148                 m_pCapability->zoom_ratio_tbl_cnt);
3149         set(KEY_ZOOM_RATIOS, zoomRatioValues);
3150         set(KEY_MAX_ZOOM, m_pCapability->zoom_ratio_tbl_cnt - 1);
3151         setZoom(0);
3152     }
3153 
3154     // Set Bracketing/HDR
3155     char prop[PROPERTY_VALUE_MAX];
3156     memset(prop, 0, sizeof(prop));
3157     property_get("persist.capture.burst.exposures", prop, "");
3158     if (strlen(prop) > 0) {
3159         set(KEY_QC_CAPTURE_BURST_EXPOSURE, prop);
3160     }
3161     String8 bracketingValues = createValuesStringFromMap(
3162             BRACKETING_MODES_MAP,
3163             sizeof(BRACKETING_MODES_MAP) / sizeof(QCameraMap));
3164     set(KEY_QC_SUPPORTED_AE_BRACKET_MODES, bracketingValues);
3165     setAEBracket(AE_BRACKET_OFF);
3166 
3167     // Set Denoise
3168     String8 denoiseValues = createValuesStringFromMap(
3169        DENOISE_ON_OFF_MODES_MAP, sizeof(DENOISE_ON_OFF_MODES_MAP) / sizeof(QCameraMap));
3170     set(KEY_QC_SUPPORTED_DENOISE, denoiseValues.string());
3171 #ifdef DEFAULT_DENOISE_MODE_ON
3172     setWaveletDenoise(DENOISE_ON);
3173 #else
3174     setWaveletDenoise(DENOISE_OFF);
3175 #endif
3176 
3177     // Set feature enable/disable
3178     String8 enableDisableValues = createValuesStringFromMap(
3179         ENABLE_DISABLE_MODES_MAP, sizeof(ENABLE_DISABLE_MODES_MAP) / sizeof(QCameraMap));
3180 
3181     // Set Lens Shading
3182     set(KEY_QC_SUPPORTED_LENSSHADE_MODES, enableDisableValues);
3183     setLensShadeValue(VALUE_ENABLE);
3184 
3185     // Set MCE
3186     set(KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES, enableDisableValues);
3187     setMCEValue(VALUE_ENABLE);
3188 
3189     // Set DIS
3190     set(KEY_QC_SUPPORTED_DIS_MODES, enableDisableValues);
3191     setDISValue(VALUE_DISABLE);
3192 
3193     // Set Histogram
3194     set(KEY_QC_SUPPORTED_HISTOGRAM_MODES, enableDisableValues);
3195     set(KEY_QC_HISTOGRAM, VALUE_DISABLE);
3196 
3197     //Set Red Eye Reduction
3198     set(KEY_QC_SUPPORTED_REDEYE_REDUCTION, enableDisableValues);
3199     setRedeyeReduction(VALUE_DISABLE);
3200 
3201     //Set SkinTone Enhancement
3202     set(KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES, enableDisableValues);
3203 
3204     // Set feature on/off
3205     String8 onOffValues = createValuesStringFromMap(
3206         ON_OFF_MODES_MAP, sizeof(ON_OFF_MODES_MAP) / sizeof(QCameraMap));
3207 
3208     //Set Scene Detection
3209     set(KEY_QC_SUPPORTED_SCENE_DETECT, onOffValues);
3210     setSceneDetect(VALUE_OFF);
3211 
3212     //Set Face Detection
3213     set(KEY_QC_SUPPORTED_FACE_DETECTION, onOffValues);
3214     set(KEY_QC_FACE_DETECTION, VALUE_OFF);
3215 
3216     //Set Face Recognition
3217     set(KEY_QC_SUPPORTED_FACE_RECOGNITION, onOffValues);
3218     set(KEY_QC_FACE_RECOGNITION, VALUE_OFF);
3219 
3220     //Set ZSL
3221     set(KEY_QC_SUPPORTED_ZSL_MODES, onOffValues);
3222 #ifdef DEFAULT_ZSL_MODE_ON
3223     set(KEY_QC_ZSL, VALUE_ON);
3224     m_bZslMode = true;
3225 #else
3226     set(KEY_QC_ZSL, VALUE_OFF);
3227     m_bZslMode = false;
3228 #endif
3229     m_bZslMode_new = m_bZslMode;
3230 
3231     //Set video HDR
3232     if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_VIDEO_HDR) > 0) {
3233         set(KEY_QC_SUPPORTED_VIDEO_HDR_MODES, onOffValues);
3234         set(KEY_QC_VIDEO_HDR, VALUE_OFF);
3235     }
3236 
3237     //Set Touch AF/AEC
3238     String8 touchValues = createValuesStringFromMap(
3239        TOUCH_AF_AEC_MODES_MAP, sizeof(TOUCH_AF_AEC_MODES_MAP) / sizeof(QCameraMap));
3240 
3241     set(KEY_QC_SUPPORTED_TOUCH_AF_AEC, touchValues);
3242     set(KEY_QC_TOUCH_AF_AEC, TOUCH_AF_AEC_OFF);
3243 
3244     //set flip mode
3245     if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_FLIP) > 0) {
3246         String8 flipModes = createValuesStringFromMap(
3247            FLIP_MODES_MAP, sizeof(FLIP_MODES_MAP) / sizeof(QCameraMap));
3248         set(KEY_QC_SUPPORTED_FLIP_MODES, flipModes);
3249         set(KEY_QC_PREVIEW_FLIP, FLIP_MODE_OFF);
3250         set(KEY_QC_VIDEO_FLIP, FLIP_MODE_OFF);
3251         set(KEY_QC_SNAPSHOT_PICTURE_FLIP, FLIP_MODE_OFF);
3252     }
3253 
3254     // Set default Auto Exposure lock value
3255     setAecLock(VALUE_FALSE);
3256 
3257     // Set default AWB_LOCK lock value
3258     setAwbLock(VALUE_FALSE);
3259 
3260     // Set default Camera mode
3261     set(KEY_QC_CAMERA_MODE, 0);
3262 
3263     // TODO: hardcode for now until mctl add support for min_num_pp_bufs
3264     m_pCapability->min_num_pp_bufs = 3;
3265 
3266     int32_t rc = commitParameters();
3267     if (rc == NO_ERROR) {
3268         rc = setNumOfSnapshot();
3269     }
3270     return rc;
3271 }
3272 
3273 /*===========================================================================
3274  * FUNCTION   : init
3275  *
3276  * DESCRIPTION: initialize parameter obj
3277  *
3278  * PARAMETERS :
3279  *   @capabilities  : ptr to camera capabilities
3280  *   @mmops         : ptr to memory ops table for mapping/unmapping
3281  *
3282  * RETURN     : int32_t type of status
3283  *              NO_ERROR  -- success
3284  *              none-zero failure code
3285  *==========================================================================*/
init(cam_capability_t * capabilities,mm_camera_vtbl_t * mmOps)3286 int32_t QCameraParameters::init(cam_capability_t *capabilities, mm_camera_vtbl_t *mmOps)
3287 {
3288     int32_t rc = NO_ERROR;
3289 
3290     m_pCapability = capabilities;
3291     m_pCamOpsTbl = mmOps;
3292 
3293     //Allocate Set Param Buffer
3294     m_pParamHeap = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
3295     rc = m_pParamHeap->allocate(1, sizeof(parm_buffer_t));
3296     if(rc != OK) {
3297         rc = NO_MEMORY;
3298         ALOGE("Failed to allocate SETPARM Heap memory");
3299         goto TRANS_INIT_ERROR1;
3300     }
3301 
3302     //Map memory for parameters buffer
3303     rc = m_pCamOpsTbl->ops->map_buf(m_pCamOpsTbl->camera_handle,
3304                              CAM_MAPPING_BUF_TYPE_PARM_BUF,
3305                              m_pParamHeap->getFd(0),
3306                              sizeof(parm_buffer_t));
3307     if(rc < 0) {
3308         ALOGE("%s:failed to map SETPARM buffer",__func__);
3309         rc = FAILED_TRANSACTION;
3310         goto TRANS_INIT_ERROR2;
3311     }
3312     m_pParamBuf = (parm_buffer_t*) DATA_PTR(m_pParamHeap,0);
3313 
3314     initDefaultParameters();
3315 
3316     goto TRANS_INIT_DONE;
3317 
3318 TRANS_INIT_ERROR2:
3319     m_pParamHeap->deallocate();
3320 
3321 TRANS_INIT_ERROR1:
3322     delete m_pParamHeap;
3323     m_pParamHeap = NULL;
3324 
3325 TRANS_INIT_DONE:
3326     return rc;
3327 }
3328 
3329 /*===========================================================================
3330  * FUNCTION   : deinit
3331  *
3332  * DESCRIPTION: deinitialize
3333  *
3334  * PARAMETERS : none
3335  *
3336  * RETURN     : none
3337  *==========================================================================*/
deinit()3338 void QCameraParameters::deinit()
3339 {
3340     //clear all entries in the map
3341     String8 emptyStr;
3342     QCameraParameters::unflatten(emptyStr);
3343 
3344     if (NULL != m_pCamOpsTbl) {
3345         m_pCamOpsTbl->ops->unmap_buf(
3346                              m_pCamOpsTbl->camera_handle,
3347                              CAM_MAPPING_BUF_TYPE_PARM_BUF);
3348         m_pCamOpsTbl = NULL;
3349     }
3350     m_pCapability = NULL;
3351     if (NULL != m_pParamHeap) {
3352         m_pParamHeap->deallocate();
3353         delete m_pParamHeap;
3354         m_pParamHeap = NULL;
3355         m_pParamBuf = NULL;
3356     }
3357 
3358     m_tempMap.clear();
3359 }
3360 
3361 /*===========================================================================
3362  * FUNCTION   : parse_pair
3363  *
3364  * DESCRIPTION: helper function to parse string like "640x480" or "10000,20000"
3365  *
3366  * PARAMETERS :
3367  *   @str     : input string to be parse
3368  *   @first   : [output] first value of the pair
3369  *   @second  : [output]  second value of the pair
3370  *   @delim   : [input] delimeter to seperate the pair
3371  *   @endptr  : [output] ptr to the end of the pair string
3372  *
3373  * RETURN     : int32_t type of status
3374  *              NO_ERROR  -- success
3375  *              none-zero failure code
3376  *==========================================================================*/
parse_pair(const char * str,int * first,int * second,char delim,char ** endptr=NULL)3377 int32_t QCameraParameters::parse_pair(const char *str,
3378                                       int *first,
3379                                       int *second,
3380                                       char delim,
3381                                       char **endptr = NULL)
3382 {
3383     // Find the first integer.
3384     char *end;
3385     int w = (int)strtol(str, &end, 10);
3386     // If a delimeter does not immediately follow, give up.
3387     if (*end != delim) {
3388         ALOGE("Cannot find delimeter (%c) in str=%s", delim, str);
3389         return BAD_VALUE;
3390     }
3391 
3392     // Find the second integer, immediately after the delimeter.
3393     int h = (int)strtol(end+1, &end, 10);
3394 
3395     *first = w;
3396     *second = h;
3397 
3398     if (endptr) {
3399         *endptr = end;
3400     }
3401 
3402     return NO_ERROR;
3403 }
3404 
3405 /*===========================================================================
3406  * FUNCTION   : parseSizesList
3407  *
3408  * DESCRIPTION: helper function to parse string containing sizes
3409  *
3410  * PARAMETERS :
3411  *   @sizesStr: [input] input string to be parse
3412  *   @sizes   : [output] reference to store parsed sizes
3413  *
3414  * RETURN     : none
3415  *==========================================================================*/
parseSizesList(const char * sizesStr,Vector<Size> & sizes)3416 void QCameraParameters::parseSizesList(const char *sizesStr, Vector<Size> &sizes)
3417 {
3418     if (sizesStr == 0) {
3419         return;
3420     }
3421 
3422     char *sizeStartPtr = (char *)sizesStr;
3423 
3424     while (true) {
3425         int width, height;
3426         int success = parse_pair(sizeStartPtr, &width, &height, 'x',
3427                                  &sizeStartPtr);
3428         if (success == -1 || (*sizeStartPtr != ',' && *sizeStartPtr != '\0')) {
3429             ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr);
3430             return;
3431         }
3432         sizes.push(Size(width, height));
3433 
3434         if (*sizeStartPtr == '\0') {
3435             return;
3436         }
3437         sizeStartPtr++;
3438     }
3439 }
3440 
3441 /*===========================================================================
3442  * FUNCTION   : getSupportedHfrSizes
3443  *
3444  * DESCRIPTION: return supported HFR sizes
3445  *
3446  * PARAMETERS :
3447  *   @sizes  : [output] reference to a vector storing supported HFR sizes
3448  *
3449  * RETURN     : none
3450  *==========================================================================*/
getSupportedHfrSizes(Vector<Size> & sizes)3451 void QCameraParameters::getSupportedHfrSizes(Vector<Size> &sizes)
3452 {
3453     const char *hfrSizesStr = get(KEY_QC_SUPPORTED_HFR_SIZES);
3454     parseSizesList(hfrSizesStr, sizes);
3455 }
3456 
3457 /*===========================================================================
3458  * FUNCTION   : adjustPreviewFpsRanges
3459  *
3460  * DESCRIPTION: adjust preview FPS ranges
3461  *              according to external events
3462  *
3463  * PARAMETERS :
3464  *   @minFPS  : min FPS value
3465  *   @maxFPS  : max FPS value
3466  *
3467  * RETURN     : int32_t type of status
3468  *              NO_ERROR  -- success
3469  *              none-zero failure code
3470  *==========================================================================*/
adjustPreviewFpsRange(cam_fps_range_t * fpsRange)3471 int32_t QCameraParameters::adjustPreviewFpsRange(cam_fps_range_t *fpsRange)
3472 {
3473     if ( fpsRange == NULL ) {
3474         return BAD_VALUE;
3475     }
3476 
3477     if ( m_pParamBuf == NULL ) {
3478         return NO_INIT;
3479     }
3480 
3481     int32_t rc = initBatchUpdate(m_pParamBuf);
3482     if ( rc != NO_ERROR ) {
3483         ALOGE("%s:Failed to initialize group update table", __func__);
3484         return rc;
3485     }
3486 
3487     rc = AddSetParmEntryToBatch(m_pParamBuf,
3488                                   CAM_INTF_PARM_FPS_RANGE,
3489                                   sizeof(cam_fps_range_t),
3490                                   fpsRange);
3491     if ( rc != NO_ERROR ) {
3492         ALOGE("%s: Parameters batch failed",__func__);
3493         return rc;
3494     }
3495 
3496     rc = commitSetBatch();
3497     if ( rc != NO_ERROR ) {
3498         ALOGE("%s:Failed to commit batch parameters", __func__);
3499         return rc;
3500     }
3501 
3502     return rc;
3503 }
3504 
3505 /*===========================================================================
3506  * FUNCTION   : setPreviewFpsRanges
3507  *
3508  * DESCRIPTION: set preview FPS ranges
3509  *
3510  * PARAMETERS :
3511  *   @minFPS  : min FPS value
3512  *   @maxFPS  : max FPS value
3513  *
3514  * RETURN     : int32_t type of status
3515  *              NO_ERROR  -- success
3516  *              none-zero failure code
3517  *==========================================================================*/
setPreviewFpsRange(int minFPS,int maxFPS)3518 int32_t QCameraParameters::setPreviewFpsRange(int minFPS, int maxFPS)
3519 {
3520     char str[32];
3521     snprintf(str, sizeof(str), "%d,%d", minFPS, maxFPS);
3522     ALOGD("%s: Setting preview fps range %s", __func__, str);
3523     updateParamEntry(KEY_PREVIEW_FPS_RANGE, str);
3524     cam_fps_range_t fps_range = {(float)(minFPS / 1000.0), (float)(maxFPS / 1000.0)};
3525     return AddSetParmEntryToBatch(m_pParamBuf,
3526                                   CAM_INTF_PARM_FPS_RANGE,
3527                                   sizeof(cam_fps_range_t),
3528                                   &fps_range);
3529 }
3530 
3531 /*===========================================================================
3532  * FUNCTION   : setAutoExposure
3533  *
3534  * DESCRIPTION: set auto exposure
3535  *
3536  * PARAMETERS :
3537  *   @autoExp : auto exposure value string
3538  *
3539  * RETURN     : int32_t type of status
3540  *              NO_ERROR  -- success
3541  *              none-zero failure code
3542  *==========================================================================*/
setAutoExposure(const char * autoExp)3543 int32_t QCameraParameters::setAutoExposure(const char *autoExp)
3544 {
3545     if (autoExp != NULL) {
3546         int32_t value = lookupAttr(AUTO_EXPOSURE_MAP,
3547                                    sizeof(AUTO_EXPOSURE_MAP)/sizeof(AUTO_EXPOSURE_MAP[0]),
3548                                    autoExp);
3549         if (value != NAME_NOT_FOUND) {
3550             ALOGD("%s: Setting auto exposure %s", __func__, autoExp);
3551             updateParamEntry(KEY_QC_AUTO_EXPOSURE, autoExp);
3552             return AddSetParmEntryToBatch(m_pParamBuf,
3553                                           CAM_INTF_PARM_AEC_ALGO_TYPE,
3554                                           sizeof(value),
3555                                           &value);
3556         }
3557     }
3558     ALOGE("Invalid auto exposure value: %s", (autoExp == NULL) ? "NULL" : autoExp);
3559     return BAD_VALUE;
3560 }
3561 
3562 /*===========================================================================
3563  * FUNCTION   : setEffect
3564  *
3565  * DESCRIPTION: set effect
3566  *
3567  * PARAMETERS :
3568  *   @effect  : effect value string
3569  *
3570  * RETURN     : int32_t type of status
3571  *              NO_ERROR  -- success
3572  *              none-zero failure code
3573  *==========================================================================*/
setEffect(const char * effect)3574 int32_t QCameraParameters::setEffect(const char *effect)
3575 {
3576     if (effect != NULL) {
3577         int32_t value = lookupAttr(EFFECT_MODES_MAP,
3578                                    sizeof(EFFECT_MODES_MAP)/sizeof(QCameraMap),
3579                                    effect);
3580         if (value != NAME_NOT_FOUND) {
3581             ALOGD("%s: Setting effect %s", __func__, effect);
3582             updateParamEntry(KEY_EFFECT, effect);
3583             return AddSetParmEntryToBatch(m_pParamBuf,
3584                                           CAM_INTF_PARM_EFFECT,
3585                                           sizeof(value),
3586                                           &value);
3587         }
3588     }
3589     ALOGE("Invalid effect value: %s", (effect == NULL) ? "NULL" : effect);
3590     return BAD_VALUE;
3591 }
3592 
3593 /*===========================================================================
3594  * FUNCTION   : setBrightness
3595  *
3596  * DESCRIPTION: set brightness control value
3597  *
3598  * PARAMETERS :
3599  *   @brightness  : brightness control value
3600  *
3601  * RETURN     : int32_t type of status
3602  *              NO_ERROR  -- success
3603  *              none-zero failure code
3604  *==========================================================================*/
setBrightness(int brightness)3605 int32_t QCameraParameters::setBrightness(int brightness)
3606 {
3607     char val[16];
3608     sprintf(val, "%d", brightness);
3609     updateParamEntry(KEY_QC_BRIGHTNESS, val);
3610 
3611     int32_t value = brightness;
3612     ALOGD("%s: Setting brightness %s", __func__, val);
3613     return AddSetParmEntryToBatch(m_pParamBuf,
3614                                   CAM_INTF_PARM_BRIGHTNESS,
3615                                   sizeof(value),
3616                                   &value);
3617 }
3618 
3619 /*===========================================================================
3620  * FUNCTION   : setFocusMode
3621  *
3622  * DESCRIPTION: set focus mode
3623  *
3624  * PARAMETERS :
3625  *   @focusMode  : focus mode value string
3626  *
3627  * RETURN     : int32_t type of status
3628  *              NO_ERROR  -- success
3629  *              none-zero failure code
3630  *==========================================================================*/
setFocusMode(const char * focusMode)3631 int32_t QCameraParameters::setFocusMode(const char *focusMode)
3632 {
3633     if (focusMode != NULL) {
3634         int32_t value = lookupAttr(FOCUS_MODES_MAP,
3635                                    sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap),
3636                                    focusMode);
3637         if (value != NAME_NOT_FOUND) {
3638             ALOGD("%s: Setting focus mode %s", __func__, focusMode);
3639             mFocusMode = (cam_focus_mode_type)value;
3640 
3641             // reset need lock CAF flag
3642             m_bNeedLockCAF = false;
3643             m_bCAFLocked = false;
3644             m_bAFRunning = false;
3645 
3646             updateParamEntry(KEY_FOCUS_MODE, focusMode);
3647             return AddSetParmEntryToBatch(m_pParamBuf,
3648                                           CAM_INTF_PARM_FOCUS_MODE,
3649                                           sizeof(value),
3650                                           &value);
3651         }
3652     }
3653     ALOGE("Invalid focus mode value: %s", (focusMode == NULL) ? "NULL" : focusMode);
3654     return BAD_VALUE;
3655 }
3656 
3657 /*===========================================================================
3658  * FUNCTION   : setSharpness
3659  *
3660  * DESCRIPTION: set sharpness control value
3661  *
3662  * PARAMETERS :
3663  *   @sharpness  : sharpness control value
3664  *
3665  * RETURN     : int32_t type of status
3666  *              NO_ERROR  -- success
3667  *              none-zero failure code
3668  *==========================================================================*/
setSharpness(int sharpness)3669 int32_t QCameraParameters::setSharpness(int sharpness)
3670 {
3671     char val[16];
3672     sprintf(val, "%d", sharpness);
3673     updateParamEntry(KEY_QC_SHARPNESS, val);
3674     ALOGD("%s: Setting sharpness %s", __func__, val);
3675 
3676     int32_t value = sharpness;
3677     return AddSetParmEntryToBatch(m_pParamBuf,
3678                                   CAM_INTF_PARM_SHARPNESS,
3679                                   sizeof(value),
3680                                   &value);
3681 }
3682 
3683 /*===========================================================================
3684  * FUNCTION   : setSkinToneEnhancement
3685  *
3686  * DESCRIPTION: set skin tone enhancement value
3687  *
3688  * PARAMETERS :
3689  *   @sceFactore  : skin tone enhancement factor value
3690  *
3691  * RETURN     : int32_t type of status
3692  *              NO_ERROR  -- success
3693  *              none-zero failure code
3694  *==========================================================================*/
setSkinToneEnhancement(int sceFactor)3695 int32_t QCameraParameters::setSkinToneEnhancement(int sceFactor)
3696 {
3697     char val[16];
3698     sprintf(val, "%d", sceFactor);
3699     updateParamEntry(KEY_QC_SCE_FACTOR, val);
3700     ALOGD("%s: Setting skintone enhancement %s", __func__, val);
3701 
3702     int32_t value = sceFactor;
3703     return AddSetParmEntryToBatch(m_pParamBuf,
3704                                   CAM_INTF_PARM_SCE_FACTOR,
3705                                   sizeof(value),
3706                                   &value);
3707 }
3708 
3709 /*===========================================================================
3710  * FUNCTION   : setSaturation
3711  *
3712  * DESCRIPTION: set saturation control value
3713  *
3714  * PARAMETERS :
3715  *   @saturation : saturation control value
3716  *
3717  * RETURN     : int32_t type of status
3718  *              NO_ERROR  -- success
3719  *              none-zero failure code
3720  *==========================================================================*/
setSaturation(int saturation)3721 int32_t QCameraParameters::setSaturation(int saturation)
3722 {
3723     char val[16];
3724     sprintf(val, "%d", saturation);
3725     updateParamEntry(KEY_QC_SATURATION, val);
3726     ALOGD("%s: Setting saturation %s", __func__, val);
3727 
3728     int32_t value = saturation;
3729     return AddSetParmEntryToBatch(m_pParamBuf,
3730                                   CAM_INTF_PARM_SATURATION,
3731                                   sizeof(value),
3732                                   &value);
3733 }
3734 
3735 /*===========================================================================
3736  * FUNCTION   : setContrast
3737  *
3738  * DESCRIPTION: set contrast control value
3739  *
3740  * PARAMETERS :
3741  *   @contrast : contrast control value
3742  *
3743  * RETURN     : int32_t type of status
3744  *              NO_ERROR  -- success
3745  *              none-zero failure code
3746  *==========================================================================*/
setContrast(int contrast)3747 int32_t QCameraParameters::setContrast(int contrast)
3748 {
3749     char val[16];
3750     sprintf(val, "%d", contrast);
3751     updateParamEntry(KEY_QC_CONTRAST, val);
3752     ALOGD("%s: Setting contrast %s", __func__, val);
3753 
3754     int32_t value = contrast;
3755     return AddSetParmEntryToBatch(m_pParamBuf,
3756                                   CAM_INTF_PARM_CONTRAST,
3757                                   sizeof(value),
3758                                   &value);
3759 }
3760 
3761 /*===========================================================================
3762  * FUNCTION   : setSceneDetect
3763  *
3764  * DESCRIPTION: set scenen detect value
3765  *
3766  * PARAMETERS :
3767  *   @sceneDetect  : scene detect value string
3768  *
3769  * RETURN     : int32_t type of status
3770  *              NO_ERROR  -- success
3771  *              none-zero failure code
3772  *==========================================================================*/
setSceneDetect(const char * sceneDetect)3773 int32_t QCameraParameters::setSceneDetect(const char *sceneDetect)
3774 {
3775     if (sceneDetect != NULL) {
3776         int32_t value = lookupAttr(ON_OFF_MODES_MAP,
3777                                    sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap),
3778                                    sceneDetect);
3779         if (value != NAME_NOT_FOUND) {
3780             ALOGD("%s: Setting Scene Detect %s", __func__, sceneDetect);
3781             updateParamEntry(KEY_QC_SCENE_DETECT, sceneDetect);
3782             return AddSetParmEntryToBatch(m_pParamBuf,
3783                                           CAM_INTF_PARM_ASD_ENABLE,
3784                                           sizeof(value),
3785                                           &value);
3786         }
3787     }
3788     ALOGE("Invalid Scene Detect value: %s",
3789           (sceneDetect == NULL) ? "NULL" : sceneDetect);
3790     return BAD_VALUE;
3791 }
3792 
3793 /*===========================================================================
3794  * FUNCTION   : setVideoHDR
3795  *
3796  * DESCRIPTION: set video HDR value
3797  *
3798  * PARAMETERS :
3799  *   @videoHDR  : svideo HDR value string
3800  *
3801  * RETURN     : int32_t type of status
3802  *              NO_ERROR  -- success
3803  *              none-zero failure code
3804  *==========================================================================*/
setVideoHDR(const char * videoHDR)3805 int32_t QCameraParameters::setVideoHDR(const char *videoHDR)
3806 {
3807     if (videoHDR != NULL) {
3808         int32_t value = lookupAttr(ON_OFF_MODES_MAP,
3809                                    sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap),
3810                                    videoHDR);
3811         if (value != NAME_NOT_FOUND) {
3812             ALOGD("%s: Setting Video HDR %s", __func__, videoHDR);
3813             updateParamEntry(KEY_QC_VIDEO_HDR, videoHDR);
3814             return AddSetParmEntryToBatch(m_pParamBuf,
3815                                           CAM_INTF_PARM_VIDEO_HDR,
3816                                           sizeof(value),
3817                                           &value);
3818         }
3819     }
3820     ALOGE("Invalid Video HDR value: %s",
3821           (videoHDR == NULL) ? "NULL" : videoHDR);
3822     return BAD_VALUE;
3823 }
3824 
3825 /*===========================================================================
3826  * FUNCTION   : setFaceRecognition
3827  *
3828  * DESCRIPTION: set face recognition value
3829  *
3830  * PARAMETERS :
3831  *   @faceRecog  : face recognition value string
3832  *   @maxFaces   : number of max faces to be detected/recognized
3833  *
3834  * RETURN     : int32_t type of status
3835  *              NO_ERROR  -- success
3836  *              none-zero failure code
3837  *==========================================================================*/
setFaceRecognition(const char * faceRecog,int maxFaces)3838 int32_t QCameraParameters::setFaceRecognition(const char *faceRecog, int maxFaces)
3839 {
3840     if (faceRecog != NULL) {
3841         int32_t value = lookupAttr(ON_OFF_MODES_MAP,
3842                                    sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap),
3843                                    faceRecog);
3844         if (value != NAME_NOT_FOUND) {
3845             ALOGD("%s: Setting face recognition %s", __func__, faceRecog);
3846             updateParamEntry(KEY_QC_FACE_RECOGNITION, faceRecog);
3847 
3848             int faceProcMask = m_nFaceProcMask;
3849             if (value > 0) {
3850                 faceProcMask |= CAM_FACE_PROCESS_MASK_RECOGNITION;
3851             } else {
3852                 faceProcMask &= ~CAM_FACE_PROCESS_MASK_RECOGNITION;
3853             }
3854 
3855             if(m_nFaceProcMask == faceProcMask) {
3856                 ALOGD("%s: face process mask not changed, no ops here", __func__);
3857                 return NO_ERROR;
3858             }
3859             m_nFaceProcMask = faceProcMask;
3860             ALOGD("%s: FaceProcMask -> %d", __func__, m_nFaceProcMask);
3861 
3862             // set parm for face process
3863             cam_fd_set_parm_t fd_set_parm;
3864             memset(&fd_set_parm, 0, sizeof(cam_fd_set_parm_t));
3865             fd_set_parm.fd_mode = m_nFaceProcMask;
3866             fd_set_parm.num_fd = maxFaces;
3867 
3868             return AddSetParmEntryToBatch(m_pParamBuf,
3869                                         CAM_INTF_PARM_FD,
3870                                         sizeof(fd_set_parm),
3871                                         &fd_set_parm);
3872         }
3873     }
3874     ALOGE("Invalid face recognition value: %s", (faceRecog == NULL) ? "NULL" : faceRecog);
3875     return BAD_VALUE;
3876 }
3877 
3878 /*===========================================================================
3879  * FUNCTION   : setZoom
3880  *
3881  * DESCRIPTION: set zoom level
3882  *
3883  * PARAMETERS :
3884  *   @zoom_level : zoom level
3885  *
3886  * RETURN     : int32_t type of status
3887  *              NO_ERROR  -- success
3888  *              none-zero failure code
3889  *==========================================================================*/
setZoom(int zoom_level)3890 int32_t QCameraParameters::setZoom(int zoom_level)
3891 {
3892     char val[16];
3893     sprintf(val, "%d", zoom_level);
3894     updateParamEntry(KEY_ZOOM, val);
3895 
3896     return AddSetParmEntryToBatch(m_pParamBuf,
3897                                   CAM_INTF_PARM_ZOOM,
3898                                   sizeof(zoom_level),
3899                                   &zoom_level);
3900 }
3901 
3902 /*===========================================================================
3903  * FUNCTION   : setISOValue
3904  *
3905  * DESCRIPTION: set ISO value
3906  *
3907  * PARAMETERS :
3908  *   @isoValue : ISO value string
3909  *
3910  * RETURN     : int32_t type of status
3911  *              NO_ERROR  -- success
3912  *              none-zero failure code
3913  *==========================================================================*/
setISOValue(const char * isoValue)3914 int32_t  QCameraParameters::setISOValue(const char *isoValue)
3915 {
3916     if (isoValue != NULL) {
3917         int32_t value = lookupAttr(ISO_MODES_MAP,
3918                                    sizeof(ISO_MODES_MAP)/sizeof(QCameraMap),
3919                                    isoValue);
3920         if (value != NAME_NOT_FOUND) {
3921             ALOGD("%s: Setting ISO value %s", __func__, isoValue);
3922             updateParamEntry(KEY_QC_ISO_MODE, isoValue);
3923             return AddSetParmEntryToBatch(m_pParamBuf,
3924                                           CAM_INTF_PARM_ISO,
3925                                           sizeof(value),
3926                                           &value);
3927         }
3928     }
3929     ALOGE("Invalid ISO value: %s",
3930           (isoValue == NULL) ? "NULL" : isoValue);
3931     return BAD_VALUE;
3932 }
3933 
3934 /*===========================================================================
3935  * FUNCTION   : setFlash
3936  *
3937  * DESCRIPTION: set f;ash mode
3938  *
3939  * PARAMETERS :
3940  *   @flashStr : LED flash mode value string
3941  *
3942  * RETURN     : int32_t type of status
3943  *              NO_ERROR  -- success
3944  *              none-zero failure code
3945  *==========================================================================*/
setFlash(const char * flashStr)3946 int32_t QCameraParameters::setFlash(const char *flashStr)
3947 {
3948     if (flashStr != NULL) {
3949         int32_t value = lookupAttr(FLASH_MODES_MAP,
3950                                    sizeof(FLASH_MODES_MAP)/sizeof(QCameraMap),
3951                                    flashStr);
3952         if (value != NAME_NOT_FOUND) {
3953             ALOGD("%s: Setting Flash value %s", __func__, flashStr);
3954             updateParamEntry(KEY_FLASH_MODE, flashStr);
3955             return AddSetParmEntryToBatch(m_pParamBuf,
3956                                           CAM_INTF_PARM_LED_MODE,
3957                                           sizeof(value),
3958                                           &value);
3959         }
3960     }
3961     ALOGE("Invalid flash value: %s", (flashStr == NULL) ? "NULL" : flashStr);
3962     return BAD_VALUE;
3963 }
3964 
3965 /*===========================================================================
3966  * FUNCTION   : setAecLock
3967  *
3968  * DESCRIPTION: set AEC lock value
3969  *
3970  * PARAMETERS :
3971  *   @aecLockStr : AEC lock value string
3972  *
3973  * RETURN     : int32_t type of status
3974  *              NO_ERROR  -- success
3975  *              none-zero failure code
3976  *==========================================================================*/
setAecLock(const char * aecLockStr)3977 int32_t QCameraParameters::setAecLock(const char *aecLockStr)
3978 {
3979     if (aecLockStr != NULL) {
3980         int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP,
3981                                    sizeof(TRUE_FALSE_MODES_MAP)/sizeof(QCameraMap),
3982                                    aecLockStr);
3983         if (value != NAME_NOT_FOUND) {
3984             ALOGD("%s: Setting AECLock value %s", __func__, aecLockStr);
3985             updateParamEntry(KEY_AUTO_EXPOSURE_LOCK, aecLockStr);
3986             return AddSetParmEntryToBatch(m_pParamBuf,
3987                                           CAM_INTF_PARM_AEC_LOCK,
3988                                           sizeof(value),
3989                                           &value);
3990         }
3991     }
3992     ALOGE("Invalid AECLock value: %s", (aecLockStr == NULL) ? "NULL" : aecLockStr);
3993     return BAD_VALUE;
3994 }
3995 
3996 /*===========================================================================
3997  * FUNCTION   : setAwbLock
3998  *
3999  * DESCRIPTION: set AWB lock value
4000  *
4001  * PARAMETERS :
4002  *   @awbLockStr : AWB lock value string
4003  *
4004  * RETURN     : int32_t type of status
4005  *              NO_ERROR  -- success
4006  *              none-zero failure code
4007  *==========================================================================*/
setAwbLock(const char * awbLockStr)4008 int32_t QCameraParameters::setAwbLock(const char *awbLockStr)
4009 {
4010     if (awbLockStr != NULL) {
4011         int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP,
4012                                    sizeof(TRUE_FALSE_MODES_MAP)/sizeof(QCameraMap),
4013                                    awbLockStr);
4014         if (value != NAME_NOT_FOUND) {
4015             ALOGD("%s: Setting AWBLock value %s", __func__, awbLockStr);
4016             updateParamEntry(KEY_AUTO_WHITEBALANCE_LOCK, awbLockStr);
4017             return AddSetParmEntryToBatch(m_pParamBuf,
4018                                           CAM_INTF_PARM_AWB_LOCK,
4019                                           sizeof(value),
4020                                           &value);
4021         }
4022     }
4023     ALOGE("Invalid AWBLock value: %s", (awbLockStr == NULL) ? "NULL" : awbLockStr);
4024     return BAD_VALUE;
4025 }
4026 
4027 /*===========================================================================
4028  * FUNCTION   : setMCEValue
4029  *
4030  * DESCRIPTION: set memory color enhancement value
4031  *
4032  * PARAMETERS :
4033  *   @mceStr : MCE value string
4034  *
4035  * RETURN     : int32_t type of status
4036  *              NO_ERROR  -- success
4037  *              none-zero failure code
4038  *==========================================================================*/
setMCEValue(const char * mceStr)4039 int32_t QCameraParameters::setMCEValue(const char *mceStr)
4040 {
4041     if (mceStr != NULL) {
4042         int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
4043                                    sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap),
4044                                    mceStr);
4045         if (value != NAME_NOT_FOUND) {
4046             ALOGD("%s: Setting AWBLock value %s", __func__, mceStr);
4047             updateParamEntry(KEY_QC_MEMORY_COLOR_ENHANCEMENT, mceStr);
4048             return AddSetParmEntryToBatch(m_pParamBuf,
4049                                           CAM_INTF_PARM_MCE,
4050                                           sizeof(value),
4051                                           &value);
4052         }
4053     }
4054     ALOGE("Invalid MCE value: %s", (mceStr == NULL) ? "NULL" : mceStr);
4055     return BAD_VALUE;
4056 }
4057 
4058 /*===========================================================================
4059  * FUNCTION   : setDISValue
4060  *
4061  * DESCRIPTION: set DIS value
4062  *
4063  * PARAMETERS :
4064  *   @disStr : DIS value string
4065  *
4066  * RETURN     : int32_t type of status
4067  *              NO_ERROR  -- success
4068  *              none-zero failure code
4069  *==========================================================================*/
setDISValue(const char * disStr)4070 int32_t QCameraParameters::setDISValue(const char *disStr)
4071 {
4072     if (disStr != NULL) {
4073         int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
4074                                    sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap),
4075                                    disStr);
4076         if (value != NAME_NOT_FOUND) {
4077             ALOGD("%s: Setting DIS value %s", __func__, disStr);
4078             updateParamEntry(KEY_QC_DIS, disStr);
4079             return AddSetParmEntryToBatch(m_pParamBuf,
4080                                           CAM_INTF_PARM_DIS_ENABLE,
4081                                           sizeof(value),
4082                                           &value);
4083         }
4084     }
4085     ALOGE("Invalid DIS value: %s", (disStr == NULL) ? "NULL" : disStr);
4086     return BAD_VALUE;
4087 }
4088 
4089 /*===========================================================================
4090  * FUNCTION   : setHighFrameRate
4091  *
4092  * DESCRIPTION: set high frame rate
4093  *
4094  * PARAMETERS :
4095  *   @hfrStr : HFR value string
4096  *
4097  * RETURN     : int32_t type of status
4098  *              NO_ERROR  -- success
4099  *              none-zero failure code
4100  *==========================================================================*/
setHighFrameRate(const char * hfrStr)4101 int32_t QCameraParameters::setHighFrameRate(const char *hfrStr)
4102 {
4103     if (hfrStr != NULL) {
4104         int32_t value = lookupAttr(HFR_MODES_MAP,
4105                                    sizeof(HFR_MODES_MAP)/sizeof(QCameraMap),
4106                                    hfrStr);
4107         if (value != NAME_NOT_FOUND) {
4108             // HFR value changed, need to restart preview
4109             m_bNeedRestart = true;
4110             // Set HFR value
4111             ALOGD("%s: Setting HFR value %s", __func__, hfrStr);
4112             updateParamEntry(KEY_QC_VIDEO_HIGH_FRAME_RATE, hfrStr);
4113             return AddSetParmEntryToBatch(m_pParamBuf,
4114                                           CAM_INTF_PARM_HFR,
4115                                           sizeof(value),
4116                                           &value);
4117         }
4118     }
4119     ALOGE("Invalid HFR value: %s", (hfrStr == NULL) ? "NULL" : hfrStr);
4120     return BAD_VALUE;
4121 }
4122 
4123 /*===========================================================================
4124  * FUNCTION   : setLensShadeValue
4125  *
4126  * DESCRIPTION: set lens shade value
4127  *
4128  * PARAMETERS :
4129  *   @lensSahdeStr : lens shade value string
4130  *
4131  * RETURN     : int32_t type of status
4132  *              NO_ERROR  -- success
4133  *              none-zero failure code
4134  *==========================================================================*/
setLensShadeValue(const char * lensShadeStr)4135 int32_t QCameraParameters::setLensShadeValue(const char *lensShadeStr)
4136 {
4137     if (lensShadeStr != NULL) {
4138         int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
4139                                    sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap),
4140                                    lensShadeStr);
4141         if (value != NAME_NOT_FOUND) {
4142             ALOGD("%s: Setting LensShade value %s", __func__, lensShadeStr);
4143             updateParamEntry(KEY_QC_LENSSHADE, lensShadeStr);
4144             return AddSetParmEntryToBatch(m_pParamBuf,
4145                                           CAM_INTF_PARM_ROLLOFF,
4146                                           sizeof(value),
4147                                           &value);
4148         }
4149     }
4150     ALOGE("Invalid LensShade value: %s",
4151           (lensShadeStr == NULL) ? "NULL" : lensShadeStr);
4152     return BAD_VALUE;
4153 }
4154 
4155 /*===========================================================================
4156  * FUNCTION   : setExposureCompensation
4157  *
4158  * DESCRIPTION: set exposure compensation value
4159  *
4160  * PARAMETERS :
4161  *   @expComp : exposure compensation value
4162  *
4163  * RETURN     : int32_t type of status
4164  *              NO_ERROR  -- success
4165  *              none-zero failure code
4166  *==========================================================================*/
setExposureCompensation(int expComp)4167 int32_t QCameraParameters::setExposureCompensation(int expComp)
4168 {
4169     char val[16];
4170     sprintf(val, "%d", expComp);
4171     updateParamEntry(KEY_EXPOSURE_COMPENSATION, val);
4172 
4173     // Don't need to pass step as part of setParameter because
4174     // camera daemon is already aware of it.
4175     return AddSetParmEntryToBatch(m_pParamBuf,
4176                                   CAM_INTF_PARM_EXPOSURE_COMPENSATION,
4177                                   sizeof(expComp),
4178                                   &expComp);
4179 }
4180 
4181 /*===========================================================================
4182  * FUNCTION   : setWhiteBalance
4183  *
4184  * DESCRIPTION: set white balance mode
4185  *
4186  * PARAMETERS :
4187  *   @wbStr   : white balance mode value string
4188  *
4189  * RETURN     : int32_t type of status
4190  *              NO_ERROR  -- success
4191  *              none-zero failure code
4192  *==========================================================================*/
setWhiteBalance(const char * wbStr)4193 int32_t QCameraParameters::setWhiteBalance(const char *wbStr)
4194 {
4195     if (wbStr != NULL) {
4196         int32_t value = lookupAttr(WHITE_BALANCE_MODES_MAP,
4197                                    sizeof(WHITE_BALANCE_MODES_MAP)/sizeof(QCameraMap),
4198                                    wbStr);
4199         if (value != NAME_NOT_FOUND) {
4200             ALOGD("%s: Setting WhiteBalance value %s", __func__, wbStr);
4201             updateParamEntry(KEY_WHITE_BALANCE, wbStr);
4202             return AddSetParmEntryToBatch(m_pParamBuf,
4203                                           CAM_INTF_PARM_WHITE_BALANCE,
4204                                           sizeof(value),
4205                                           &value);
4206         }
4207     }
4208     ALOGE("Invalid WhiteBalance value: %s", (wbStr == NULL) ? "NULL" : wbStr);
4209     return BAD_VALUE;
4210 }
4211 
4212 /*===========================================================================
4213  * FUNCTION   : setAntibanding
4214  *
4215  * DESCRIPTION: set antibanding value
4216  *
4217  * PARAMETERS :
4218  *   @antiBandingStr : antibanding value string
4219  *
4220  * RETURN     : int32_t type of status
4221  *              NO_ERROR  -- success
4222  *              none-zero failure code
4223  *==========================================================================*/
setAntibanding(const char * antiBandingStr)4224 int32_t QCameraParameters::setAntibanding(const char *antiBandingStr)
4225 {
4226     if (antiBandingStr != NULL) {
4227         int32_t value = lookupAttr(ANTIBANDING_MODES_MAP,
4228                                    sizeof(ANTIBANDING_MODES_MAP)/sizeof(QCameraMap),
4229                                    antiBandingStr);
4230         if (value != NAME_NOT_FOUND) {
4231             ALOGD("%s: Setting AntiBanding value %s", __func__, antiBandingStr);
4232             updateParamEntry(KEY_ANTIBANDING, antiBandingStr);
4233             return AddSetParmEntryToBatch(m_pParamBuf,
4234                                           CAM_INTF_PARM_ANTIBANDING,
4235                                           sizeof(value),
4236                                           &value);
4237         }
4238     }
4239     ALOGE("Invalid AntiBanding value: %s",
4240           (antiBandingStr == NULL) ? "NULL" : antiBandingStr);
4241     return BAD_VALUE;
4242 }
4243 
4244 /*===========================================================================
4245  * FUNCTION   : setFocusAreas
4246  *
4247  * DESCRIPTION: set focus areas
4248  *
4249  * PARAMETERS :
4250  *   @focusAreasStr : focus areas value string
4251  *
4252  * RETURN     : int32_t type of status
4253  *              NO_ERROR  -- success
4254  *              none-zero failure code
4255  *==========================================================================*/
setFocusAreas(const char * focusAreasStr)4256 int32_t QCameraParameters::setFocusAreas(const char *focusAreasStr)
4257 {
4258     if (m_pCapability->max_num_focus_areas == 0 ||
4259         focusAreasStr == NULL) {
4260         ALOGI("%s: Parameter string is null", __func__);
4261         return NO_ERROR;
4262     }
4263 
4264     cam_area_t *areas = (cam_area_t *)malloc(sizeof(cam_area_t) * m_pCapability->max_num_focus_areas);
4265     if (NULL == areas) {
4266         ALOGE("%s: No memory for areas", __func__);
4267         return NO_MEMORY;
4268     }
4269     memset(areas, 0, sizeof(cam_area_t) * m_pCapability->max_num_focus_areas);
4270     int num_areas_found = 0;
4271     if (parseCameraAreaString(focusAreasStr,
4272                               m_pCapability->max_num_focus_areas,
4273                               areas,
4274                               num_areas_found) != NO_ERROR) {
4275         ALOGE("%s: Failed to parse the string: %s", __func__, focusAreasStr);
4276         free(areas);
4277         return BAD_VALUE;
4278     }
4279 
4280     if (validateCameraAreas(areas, num_areas_found) == false) {
4281         ALOGE("%s: invalid areas specified : %s", __func__, focusAreasStr);
4282         free(areas);
4283         return BAD_VALUE;
4284     }
4285 
4286     updateParamEntry(KEY_FOCUS_AREAS, focusAreasStr);
4287 
4288     //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0,
4289     //so no action is takenby the lower layer
4290     if (num_areas_found == 1 &&
4291         areas[0].rect.left == 0 &&
4292         areas[0].rect.top == 0 &&
4293         areas[0].rect.width == 0 &&
4294         areas[0].rect.height == 0 &&
4295         areas[0].weight == 0) {
4296         num_areas_found = 0;
4297     }
4298 
4299     int previewWidth, previewHeight;
4300     getPreviewSize(&previewWidth, &previewHeight);
4301     cam_roi_info_t af_roi_value;
4302     memset(&af_roi_value, 0, sizeof(cam_roi_info_t));
4303     af_roi_value.num_roi = num_areas_found;
4304     for (int i = 0; i < num_areas_found; i++) {
4305         ALOGD("%s: FocusArea[%d] = (%d, %d, %d, %d)",
4306               __func__, i, (areas[i].rect.top), (areas[i].rect.left),
4307               (areas[i].rect.width), (areas[i].rect.height));
4308 
4309         //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight)
4310         af_roi_value.roi[i].left = (int32_t)((areas[i].rect.left + 1000.0f) * (previewWidth / 2000.0f));
4311         af_roi_value.roi[i].top = (int32_t)((areas[i].rect.top + 1000.0f) * (previewHeight / 2000.0f));
4312         af_roi_value.roi[i].width = (int32_t)(areas[i].rect.width * previewWidth / 2000.0f);
4313         af_roi_value.roi[i].height = (int32_t)(areas[i].rect.height * previewHeight / 2000.0f);
4314         af_roi_value.weight[i] = areas[i].weight;
4315     }
4316     free(areas);
4317     return AddSetParmEntryToBatch(m_pParamBuf,
4318                                   CAM_INTF_PARM_AF_ROI,
4319                                   sizeof(af_roi_value),
4320                                   &af_roi_value);
4321 }
4322 
4323 /*===========================================================================
4324  * FUNCTION   : setMeteringAreas
4325  *
4326  * DESCRIPTION: set metering areas value
4327  *
4328  * PARAMETERS :
4329  *   @meteringAreasStr : metering areas value string
4330  *
4331  * RETURN     : int32_t type of status
4332  *              NO_ERROR  -- success
4333  *              none-zero failure code
4334  *==========================================================================*/
setMeteringAreas(const char * meteringAreasStr)4335 int32_t QCameraParameters::setMeteringAreas(const char *meteringAreasStr)
4336 {
4337     if (m_pCapability->max_num_metering_areas == 0 ||
4338         meteringAreasStr == NULL) {
4339         ALOGI("%s: Parameter string is null", __func__);
4340         return NO_ERROR;
4341     }
4342 
4343     cam_area_t *areas = (cam_area_t *)malloc(sizeof(cam_area_t) * m_pCapability->max_num_metering_areas);
4344     if (NULL == areas) {
4345         ALOGE("%s: No memory for areas", __func__);
4346         return NO_MEMORY;
4347     }
4348     memset(areas, 0, sizeof(cam_area_t) * m_pCapability->max_num_metering_areas);
4349     int num_areas_found = 0;
4350     if (parseCameraAreaString(meteringAreasStr,
4351                               m_pCapability->max_num_metering_areas,
4352                               areas,
4353                               num_areas_found) < 0) {
4354         ALOGE("%s: Failed to parse the string: %s", __func__, meteringAreasStr);
4355         free(areas);
4356         return BAD_VALUE;
4357     }
4358 
4359     if (validateCameraAreas(areas, num_areas_found) == false) {
4360         ALOGE("%s: invalid areas specified : %s", __func__, meteringAreasStr);
4361         free(areas);
4362         return BAD_VALUE;
4363     }
4364 
4365     updateParamEntry(KEY_METERING_AREAS, meteringAreasStr);
4366 
4367     //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0,
4368     //so no action is takenby the lower layer
4369     if (num_areas_found == 1 &&
4370         areas[0].rect.left == 0 &&
4371         areas[0].rect.top == 0 &&
4372         areas[0].rect.width == 0 &&
4373         areas[0].rect.height == 0 &&
4374         areas[0].weight == 0) {
4375         num_areas_found = 0;
4376     }
4377     cam_set_aec_roi_t aec_roi_value;
4378     int previewWidth, previewHeight;
4379     getPreviewSize(&previewWidth, &previewHeight);
4380 
4381     memset(&aec_roi_value, 0, sizeof(cam_set_aec_roi_t));
4382     if (num_areas_found > 0) {
4383         aec_roi_value.aec_roi_enable = CAM_AEC_ROI_ON;
4384         aec_roi_value.aec_roi_type = CAM_AEC_ROI_BY_COORDINATE;
4385 
4386         for (int i = 0; i < num_areas_found; i++) {
4387             ALOGD("%s: MeteringArea[%d] = (%d, %d, %d, %d)",
4388                   __func__, i, (areas[i].rect.top), (areas[i].rect.left),
4389                   (areas[i].rect.width), (areas[i].rect.height));
4390 
4391             //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight)
4392             aec_roi_value.cam_aec_roi_position.coordinate[i].x =
4393                 (uint32_t)(((areas[i].rect.left + areas[i].rect.width / 2) + 1000.0f) * previewWidth / 2000.0f) ;
4394             aec_roi_value.cam_aec_roi_position.coordinate[i].y =
4395                 (uint32_t)(((areas[i].rect.top + areas[i].rect.height / 2) + 1000.0f) * previewHeight / 2000.0f) ;
4396         }
4397     } else {
4398         aec_roi_value.aec_roi_enable = CAM_AEC_ROI_OFF;
4399     }
4400     free(areas);
4401     return AddSetParmEntryToBatch(m_pParamBuf,
4402                                   CAM_INTF_PARM_AEC_ROI,
4403                                   sizeof(aec_roi_value),
4404                                   &aec_roi_value);
4405 }
4406 
4407 /*===========================================================================
4408  * FUNCTION   : setSceneMode
4409  *
4410  * DESCRIPTION: set scene mode
4411  *
4412  * PARAMETERS :
4413  *   @sceneModeStr : scene mode value string
4414  *
4415  * RETURN     : int32_t type of status
4416  *              NO_ERROR  -- success
4417  *              none-zero failure code
4418  *==========================================================================*/
setSceneMode(const char * sceneModeStr)4419 int32_t QCameraParameters::setSceneMode(const char *sceneModeStr)
4420 {
4421     if (sceneModeStr != NULL) {
4422         int32_t value = lookupAttr(SCENE_MODES_MAP,
4423                                    sizeof(SCENE_MODES_MAP)/sizeof(QCameraMap),
4424                                    sceneModeStr);
4425         if (value != NAME_NOT_FOUND) {
4426             ALOGV("%s: Setting SceneMode %s", __func__, sceneModeStr);
4427             updateParamEntry(KEY_SCENE_MODE, sceneModeStr);
4428             int32_t rc = AddSetParmEntryToBatch(m_pParamBuf,
4429                                                 CAM_INTF_PARM_BESTSHOT_MODE,
4430                                                 sizeof(value),
4431                                                 &value);
4432             return rc;
4433         }
4434     }
4435     ALOGE("%s: Invalid Secene Mode: %s",
4436           __func__, (sceneModeStr == NULL) ? "NULL" : sceneModeStr);
4437     return BAD_VALUE;
4438 }
4439 
4440 /*===========================================================================
4441  * FUNCTION   : setSelectableZoneAf
4442  *
4443  * DESCRIPTION: set selectable zone AF algorithm
4444  *
4445  * PARAMETERS :
4446  *   @selZoneAFStr : selectable zone AF algorithm value string
4447  *
4448  * RETURN     : int32_t type of status
4449  *              NO_ERROR  -- success
4450  *              none-zero failure code
4451  *==========================================================================*/
setSelectableZoneAf(const char * selZoneAFStr)4452 int32_t QCameraParameters::setSelectableZoneAf(const char *selZoneAFStr)
4453 {
4454     if (selZoneAFStr != NULL) {
4455         int32_t value = lookupAttr(FOCUS_ALGO_MAP,
4456                                    sizeof(FOCUS_ALGO_MAP)/sizeof(QCameraMap),
4457                                    selZoneAFStr);
4458         if (value != NAME_NOT_FOUND) {
4459             ALOGV("%s: Setting Selectable Zone AF value %s", __func__, selZoneAFStr);
4460             updateParamEntry(KEY_QC_SELECTABLE_ZONE_AF, selZoneAFStr);
4461             return AddSetParmEntryToBatch(m_pParamBuf,
4462                                           CAM_INTF_PARM_FOCUS_ALGO_TYPE,
4463                                           sizeof(value),
4464                                           &value);
4465         }
4466     }
4467     ALOGE("%s: Invalid selectable zone af value: %s",
4468           __func__, (selZoneAFStr == NULL) ? "NULL" : selZoneAFStr);
4469     return BAD_VALUE;
4470 }
4471 
4472 /*===========================================================================
4473  * FUNCTION   : setAEBracket
4474  *
4475  * DESCRIPTION: set AE bracket value
4476  *
4477  * PARAMETERS :
4478  *   @aecBracketStr : AE bracket value string
4479  *
4480  * RETURN     : int32_t type of status
4481  *              NO_ERROR  -- success
4482  *              none-zero failure code
4483  *==========================================================================*/
setAEBracket(const char * aecBracketStr)4484 int32_t QCameraParameters::setAEBracket(const char *aecBracketStr)
4485 {
4486     if (aecBracketStr == NULL) {
4487         ALOGI("%s: setAEBracket with NULL value", __func__);
4488         return NO_ERROR;
4489     }
4490 
4491     cam_exp_bracketing_t expBracket;
4492     memset(&expBracket, 0, sizeof(expBracket));
4493 
4494     int value = lookupAttr(BRACKETING_MODES_MAP,
4495                            sizeof(BRACKETING_MODES_MAP)/sizeof(QCameraMap),
4496                            aecBracketStr);
4497     switch (value) {
4498     case CAM_EXP_BRACKETING_ON:
4499         {
4500             ALOGV("%s, EXP_BRACKETING_ON", __func__);
4501             const char *str_val = get(KEY_QC_CAPTURE_BURST_EXPOSURE);
4502             if ((str_val != NULL) && (strlen(str_val)>0)) {
4503                 expBracket.mode = CAM_EXP_BRACKETING_ON;
4504                 strlcpy(expBracket.values, str_val, MAX_EXP_BRACKETING_LENGTH);
4505                 ALOGI("%s: setting Exposure Bracketing value of %s",
4506                       __func__, expBracket.values);
4507             }
4508             else {
4509                 /* Apps not set capture-burst-exposures, error case fall into bracketing off mode */
4510                 ALOGI("%s: capture-burst-exposures not set, back to HDR OFF mode", __func__);
4511                 expBracket.mode = CAM_EXP_BRACKETING_OFF;
4512             }
4513         }
4514         break;
4515     default:
4516         {
4517             ALOGD("%s, EXP_BRACKETING_OFF", __func__);
4518             expBracket.mode = CAM_EXP_BRACKETING_OFF;
4519         }
4520         break;
4521     }
4522 
4523     /* save the value*/
4524     updateParamEntry(KEY_QC_AE_BRACKET_HDR, aecBracketStr);
4525     return AddSetParmEntryToBatch(m_pParamBuf,
4526                                   CAM_INTF_PARM_HDR,
4527                                   sizeof(expBracket),
4528                                   &expBracket);
4529 }
4530 
4531 /*===========================================================================
4532  * FUNCTION   : setRedeyeReduction
4533  *
4534  * DESCRIPTION: set red eye reduction value
4535  *
4536  * PARAMETERS :
4537  *   @redeyeStr : red eye reduction value string
4538  *
4539  * RETURN     : int32_t type of status
4540  *              NO_ERROR  -- success
4541  *              none-zero failure code
4542  *==========================================================================*/
setRedeyeReduction(const char * redeyeStr)4543 int32_t QCameraParameters::setRedeyeReduction(const char *redeyeStr)
4544 {
4545     if (redeyeStr != NULL) {
4546         int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
4547                                    sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap),
4548                                    redeyeStr);
4549         if (value != NAME_NOT_FOUND) {
4550             ALOGV("%s: Setting RedEye Reduce value %s", __func__, redeyeStr);
4551             updateParamEntry(KEY_QC_REDEYE_REDUCTION, redeyeStr);
4552             return AddSetParmEntryToBatch(m_pParamBuf,
4553                                           CAM_INTF_PARM_REDEYE_REDUCTION,
4554                                           sizeof(value),
4555                                           &value);
4556         }
4557     }
4558     ALOGE("%s: Invalid RedEye Reduce value: %s",
4559           __func__, (redeyeStr == NULL) ? "NULL" : redeyeStr);
4560     return BAD_VALUE;
4561 }
4562 
4563 /*===========================================================================
4564  * FUNCTION   : getWaveletDenoiseProcessPlate
4565  *
4566  * DESCRIPTION: query wavelet denoise process plate
4567  *
4568  * PARAMETERS : None
4569  *
4570  * RETURN     : WNR prcocess plate vlaue
4571  *==========================================================================*/
getWaveletDenoiseProcessPlate()4572 cam_denoise_process_type_t QCameraParameters::getWaveletDenoiseProcessPlate()
4573 {
4574     char prop[PROPERTY_VALUE_MAX];
4575     memset(prop, 0, sizeof(prop));
4576     property_get("persist.denoise.process.plates", prop, "0");
4577     int processPlate = atoi(prop);
4578     switch(processPlate) {
4579     case 0:
4580         return CAM_WAVELET_DENOISE_YCBCR_PLANE;
4581     case 1:
4582         return CAM_WAVELET_DENOISE_CBCR_ONLY;
4583     case 2:
4584         return CAM_WAVELET_DENOISE_STREAMLINE_YCBCR;
4585     case 3:
4586         return CAM_WAVELET_DENOISE_STREAMLINED_CBCR;
4587     default:
4588         return CAM_WAVELET_DENOISE_STREAMLINE_YCBCR;
4589     }
4590 }
4591 
4592 /*===========================================================================
4593  * FUNCTION   : setWaveletDenoise
4594  *
4595  * DESCRIPTION: set wavelet denoise value
4596  *
4597  * PARAMETERS :
4598  *   @wnrStr : wavelet denoise value string
4599  *
4600  * RETURN     : int32_t type of status
4601  *              NO_ERROR  -- success
4602  *              none-zero failure code
4603  *==========================================================================*/
setWaveletDenoise(const char * wnrStr)4604 int32_t QCameraParameters::setWaveletDenoise(const char *wnrStr)
4605 {
4606     if (wnrStr != NULL) {
4607         int value = lookupAttr(DENOISE_ON_OFF_MODES_MAP,
4608                                sizeof(DENOISE_ON_OFF_MODES_MAP)/sizeof(QCameraMap),
4609                                wnrStr);
4610         if (value != NAME_NOT_FOUND) {
4611             updateParamEntry(KEY_QC_DENOISE, wnrStr);
4612 
4613             cam_denoise_param_t temp;
4614             memset(&temp, 0, sizeof(temp));
4615             temp.denoise_enable = value;
4616             m_bWNROn = (value != 0);
4617             if (m_bWNROn) {
4618                 temp.process_plates = getWaveletDenoiseProcessPlate();
4619             }
4620             ALOGI("%s: Denoise enable=%d, plates=%d",
4621                   __func__, temp.denoise_enable, temp.process_plates);
4622             return AddSetParmEntryToBatch(m_pParamBuf,
4623                                           CAM_INTF_PARM_WAVELET_DENOISE,
4624                                           sizeof(temp),
4625                                           &temp);
4626         }
4627     }
4628     ALOGE("%s: Invalid Denoise value: %s", __func__, (wnrStr == NULL) ? "NULL" : wnrStr);
4629     return BAD_VALUE;
4630 }
4631 
4632 /*===========================================================================
4633  * FUNCTION   : setPreviewFrameRateMode
4634  *
4635  * DESCRIPTION: set preview frame rate mode
4636  *
4637  * PARAMETERS :
4638  *   @mode    : preview frame rate mode
4639  *
4640  * RETURN     : none
4641  *==========================================================================*/
setPreviewFrameRateMode(const char * mode)4642 void QCameraParameters::setPreviewFrameRateMode(const char *mode)
4643 {
4644     set(KEY_QC_PREVIEW_FRAME_RATE_MODE, mode);
4645 }
4646 
4647 /*===========================================================================
4648  * FUNCTION   : getPreviewFrameRateMode
4649  *
4650  * DESCRIPTION: get preview frame rate mode
4651  *
4652  * PARAMETERS : none
4653  *
4654  * RETURN     : preview frame rate mode string
4655  *==========================================================================*/
getPreviewFrameRateMode() const4656 const char *QCameraParameters::getPreviewFrameRateMode() const
4657 {
4658     return get(KEY_QC_PREVIEW_FRAME_RATE_MODE);
4659 }
4660 
4661 /*===========================================================================
4662  * FUNCTION   : setTouchIndexAec
4663  *
4664  * DESCRIPTION: set touch index AEC
4665  *
4666  * PARAMETERS :
4667  *   @x,y     :
4668  *
4669  * RETURN     : none
4670  *==========================================================================*/
setTouchIndexAec(int x,int y)4671 void QCameraParameters::setTouchIndexAec(int x, int y)
4672 {
4673     char str[32];
4674     snprintf(str, sizeof(str), "%dx%d", x, y);
4675     set(KEY_QC_TOUCH_INDEX_AEC, str);
4676 }
4677 
4678 /*===========================================================================
4679  * FUNCTION   : getTouchIndexAec
4680  *
4681  * DESCRIPTION: get touch index AEC
4682  *
4683  * PARAMETERS :
4684  *   @x,y     :
4685  *
4686  * RETURN     : none
4687  *==========================================================================*/
getTouchIndexAec(int * x,int * y)4688 void QCameraParameters::getTouchIndexAec(int *x, int *y)
4689 {
4690     *x = -1;
4691     *y = -1;
4692 
4693     // Get the current string, if it doesn't exist, leave the -1x-1
4694     const char *p = get(KEY_QC_TOUCH_INDEX_AEC);
4695     if (p == 0)
4696         return;
4697 
4698     int tempX, tempY;
4699     if (parse_pair(p, &tempX, &tempY, 'x') == 0) {
4700         *x = tempX;
4701         *y = tempY;
4702     }
4703 }
4704 
4705 /*===========================================================================
4706  * FUNCTION   : setTouchIndexAf
4707  *
4708  * DESCRIPTION: set touch index AF
4709  *
4710  * PARAMETERS :
4711  *   @x,y     :
4712  *
4713  * RETURN     : none
4714  *==========================================================================*/
setTouchIndexAf(int x,int y)4715 void QCameraParameters::setTouchIndexAf(int x, int y)
4716 {
4717     char str[32];
4718     snprintf(str, sizeof(str), "%dx%d", x, y);
4719     set(KEY_QC_TOUCH_INDEX_AF, str);
4720 }
4721 
4722 /*===========================================================================
4723  * FUNCTION   : getTouchIndexAf
4724  *
4725  * DESCRIPTION: get touch index AF
4726  *
4727  * PARAMETERS :
4728  *   @x,y     :
4729  *
4730  * RETURN     : none
4731  *==========================================================================*/
getTouchIndexAf(int * x,int * y)4732 void QCameraParameters::getTouchIndexAf(int *x, int *y)
4733 {
4734     *x = -1;
4735     *y = -1;
4736 
4737     // Get the current string, if it doesn't exist, leave the -1x-1
4738     const char *p = get(KEY_QC_TOUCH_INDEX_AF);
4739     if (p == 0)
4740         return;
4741 
4742     int tempX, tempY;
4743     if (parse_pair(p, &tempX, &tempY, 'x') == 0) {
4744         *x = tempX;
4745         *y = tempY;
4746 	}
4747 }
4748 
4749 /*===========================================================================
4750  * FUNCTION   : getStreamFormat
4751  *
4752  * DESCRIPTION: get stream format by its type
4753  *
4754  * PARAMETERS :
4755  *   @streamType : [input] stream type
4756  *   @format     : [output] stream format
4757  *
4758  * RETURN     : int32_t type of status
4759  *              NO_ERROR  -- success
4760  *              none-zero failure code
4761  *==========================================================================*/
getStreamFormat(cam_stream_type_t streamType,cam_format_t & format)4762 int32_t QCameraParameters::getStreamFormat(cam_stream_type_t streamType,
4763                                             cam_format_t &format)
4764 {
4765     int32_t ret = NO_ERROR;
4766 
4767     format = CAM_FORMAT_MAX;
4768     switch (streamType) {
4769     case CAM_STREAM_TYPE_PREVIEW:
4770     case CAM_STREAM_TYPE_POSTVIEW:
4771         format = mPreviewFormat;
4772         break;
4773     case CAM_STREAM_TYPE_SNAPSHOT:
4774     case CAM_STREAM_TYPE_NON_ZSL_SNAPSHOT:
4775         if ( mPictureFormat == CAM_FORMAT_YUV_422_NV16 ) {
4776             format = CAM_FORMAT_YUV_422_NV16;
4777         } else {
4778             char prop[PROPERTY_VALUE_MAX];
4779             int snapshotFormat;
4780             memset(prop, 0, sizeof(prop));
4781             property_get("persist.camera.snap.format", prop, "0");
4782             snapshotFormat = atoi(prop);
4783             if(snapshotFormat == 1) {
4784                 format = CAM_FORMAT_YUV_422_NV61;
4785             } else {
4786                 format = CAM_FORMAT_YUV_420_NV21;
4787             }
4788         }
4789         break;
4790     case CAM_STREAM_TYPE_VIDEO:
4791         format = CAM_FORMAT_YUV_420_NV12;
4792         break;
4793     case CAM_STREAM_TYPE_RAW:
4794         if (mPictureFormat >= CAM_FORMAT_YUV_RAW_8BIT_YUYV) {
4795             format = (cam_format_t)mPictureFormat;
4796         } else {
4797             ALOGE("%s: invalid raw picture format: %d", __func__, mPictureFormat);
4798             ret = BAD_VALUE;
4799         }
4800         break;
4801     case CAM_STREAM_TYPE_METADATA:
4802     case CAM_STREAM_TYPE_OFFLINE_PROC:
4803     case CAM_STREAM_TYPE_DEFAULT:
4804     default:
4805         break;
4806     }
4807 
4808     return ret;
4809 }
4810 
4811 /*===========================================================================
4812  * FUNCTION   : getFlipMode
4813  *
4814  * DESCRIPTION: get flip mode
4815  *
4816  * PARAMETERS :
4817  *   @cam_intf_parm_type_t : [input] stream type
4818  *
4819  * RETURN     : int type of flip mode
4820  *              0 - no filp
4821  *              1 - FLIP_H
4822  *              2 - FLIP_V
4823  *              3 - FLIP_H | FLIP_V
4824  *==========================================================================*/
getFlipMode(cam_stream_type_t type)4825 int QCameraParameters::getFlipMode(cam_stream_type_t type)
4826 {
4827     const char *str = NULL;
4828     int flipMode = 0; // no flip
4829 
4830     switch(type){
4831     case CAM_STREAM_TYPE_PREVIEW:
4832         str = get(KEY_QC_PREVIEW_FLIP);
4833         break;
4834     case CAM_STREAM_TYPE_VIDEO:
4835         str = get(KEY_QC_VIDEO_FLIP);
4836         break;
4837     case CAM_STREAM_TYPE_SNAPSHOT:
4838     case CAM_STREAM_TYPE_NON_ZSL_SNAPSHOT:
4839         str = get(KEY_QC_SNAPSHOT_PICTURE_FLIP);
4840         break;
4841     default:
4842         ALOGI("%s: No flip mode for stream type %d", __func__, type);
4843         break;
4844     }
4845 
4846     if(str != NULL){
4847         //Need give corresponding filp value based on flip mode strings
4848         int value = lookupAttr(FLIP_MODES_MAP,
4849                 sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap), str);
4850         if(value != NAME_NOT_FOUND)
4851             flipMode = value;
4852         }
4853 
4854     ALOGD("%s: the filp mode of stream type %d is %d .", __func__, type, flipMode);
4855     return flipMode;
4856 }
4857 
4858 /*===========================================================================
4859  * FUNCTION   : getStreamDimension
4860  *
4861  * DESCRIPTION: get stream dimension by its type
4862  *
4863  * PARAMETERS :
4864  *   @streamType : [input] stream type
4865  *   @dim        : [output] stream dimension
4866  *
4867  * RETURN     : int32_t type of status
4868  *              NO_ERROR  -- success
4869  *              none-zero failure code
4870  *==========================================================================*/
getStreamDimension(cam_stream_type_t streamType,cam_dimension_t & dim)4871 int32_t QCameraParameters::getStreamDimension(cam_stream_type_t streamType,
4872                                                cam_dimension_t &dim)
4873 {
4874     int32_t ret = NO_ERROR;
4875     memset(&dim, 0, sizeof(cam_dimension_t));
4876 
4877     switch (streamType) {
4878     case CAM_STREAM_TYPE_PREVIEW:
4879         getPreviewSize(&dim.width, &dim.height);
4880         break;
4881     case CAM_STREAM_TYPE_POSTVIEW:
4882         getPreviewSize(&dim.width, &dim.height);
4883         break;
4884     case CAM_STREAM_TYPE_SNAPSHOT:
4885     case CAM_STREAM_TYPE_NON_ZSL_SNAPSHOT:
4886         if (getRecordingHintValue() == true) {
4887             // live snapshot
4888             getLiveSnapshotSize(dim);
4889         } else {
4890             getPictureSize(&dim.width, &dim.height);
4891         }
4892         break;
4893     case CAM_STREAM_TYPE_VIDEO:
4894         getVideoSize(&dim.width, &dim.height);
4895         break;
4896     case CAM_STREAM_TYPE_RAW:
4897         dim = m_pCapability->raw_dim;
4898         break;
4899     case CAM_STREAM_TYPE_METADATA:
4900         dim.width = sizeof(cam_metadata_info_t);
4901         dim.height = 1;
4902         break;
4903     case CAM_STREAM_TYPE_OFFLINE_PROC:
4904         break;
4905     case CAM_STREAM_TYPE_DEFAULT:
4906     default:
4907         ALOGE("%s: no dimension for unsupported stream type %d",
4908               __func__, streamType);
4909         ret = BAD_VALUE;
4910         break;
4911     }
4912     return ret;
4913 }
4914 
4915 /*===========================================================================
4916  * FUNCTION   : getPreviewHalPixelFormat
4917  *
4918  * DESCRIPTION: get preview HAL pixel format
4919  *
4920  * PARAMETERS : none
4921  *
4922  * RETURN     : HAL pixel format
4923  *==========================================================================*/
getPreviewHalPixelFormat() const4924 int QCameraParameters::getPreviewHalPixelFormat() const
4925 {
4926     int32_t halPixelFormat;
4927 
4928     switch (mPreviewFormat) {
4929     case CAM_FORMAT_YUV_420_NV12:
4930         halPixelFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP;
4931         break;
4932     case CAM_FORMAT_YUV_420_NV21:
4933         halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
4934         break;
4935     case CAM_FORMAT_YUV_420_NV21_ADRENO:
4936         halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO;
4937         break;
4938     case CAM_FORMAT_YUV_420_YV12:
4939         halPixelFormat = HAL_PIXEL_FORMAT_YV12;
4940         break;
4941     case CAM_FORMAT_YUV_422_NV16:
4942     case CAM_FORMAT_YUV_422_NV61:
4943     default:
4944         halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
4945         break;
4946     }
4947     ALOGE("%s: format %d\n", __func__, halPixelFormat);
4948     return halPixelFormat;
4949 }
4950 
4951 /*===========================================================================
4952  * FUNCTION   : getthumbnailSize
4953  *
4954  * DESCRIPTION: get thumbnail size
4955  *
4956  * PARAMETERS :
4957  *   @width, height : [output] thumbnail width and height
4958  *
4959  * RETURN     : none
4960  *==========================================================================*/
getThumbnailSize(int * width,int * height) const4961 void QCameraParameters::getThumbnailSize(int *width, int *height) const
4962 {
4963     *width = getInt(KEY_JPEG_THUMBNAIL_WIDTH);
4964     *height = getInt(KEY_JPEG_THUMBNAIL_HEIGHT);
4965 }
4966 
4967 /*===========================================================================
4968  * FUNCTION   : getZSLBurstInterval
4969  *
4970  * DESCRIPTION: get ZSL burst interval setting
4971  *
4972  * PARAMETERS : none
4973  *
4974  * RETURN     : ZSL burst interval value
4975  *==========================================================================*/
getZSLBurstInterval()4976 int QCameraParameters::getZSLBurstInterval()
4977 {
4978     int interval = getInt(KEY_QC_ZSL_BURST_INTERVAL);
4979     if (interval < 0) {
4980         interval = 1;
4981     }
4982     return interval;
4983 }
4984 
4985 /*===========================================================================
4986  * FUNCTION   : getZSLQueueDepth
4987  *
4988  * DESCRIPTION: get ZSL queue depth
4989  *
4990  * PARAMETERS : none
4991  *
4992  * RETURN     : ZSL queue depth value
4993  *==========================================================================*/
getZSLQueueDepth()4994 int QCameraParameters::getZSLQueueDepth()
4995 {
4996     int qdepth = getInt(KEY_QC_ZSL_QUEUE_DEPTH);
4997     if (qdepth < 0) {
4998         qdepth = 2;
4999     }
5000     return qdepth;
5001 }
5002 
5003 /*===========================================================================
5004  * FUNCTION   : getZSLBackLookCount
5005  *
5006  * DESCRIPTION: get ZSL backlook count setting
5007  *
5008  * PARAMETERS : none
5009  *
5010  * RETURN     : ZSL backlook count value
5011  *==========================================================================*/
getZSLBackLookCount()5012 int QCameraParameters::getZSLBackLookCount()
5013 {
5014     int look_back = getInt(KEY_QC_ZSL_BURST_LOOKBACK);
5015     if (look_back < 0) {
5016         look_back = 2;
5017     }
5018     return look_back;
5019 }
5020 
5021 /*===========================================================================
5022  * FUNCTION   : getZSLMaxUnmatchedFrames
5023  *
5024  * DESCRIPTION: get allowed ZSL max unmatched frames number
5025  *
5026  * PARAMETERS : none
5027  *
5028  * RETURN     : ZSL backlook count value
5029  *==========================================================================*/
getMaxUnmatchedFramesInQueue()5030 int QCameraParameters::getMaxUnmatchedFramesInQueue()
5031 {
5032     return m_pCapability->min_num_pp_bufs;
5033 }
5034 
5035 /*===========================================================================
5036  * FUNCTION   : setRecordingHintValue
5037  *
5038  * DESCRIPTION: set recording hint
5039  *
5040  * PARAMETERS :
5041  *   @value   : video hint value
5042  *
5043  * RETURN     : int32_t type of status
5044  *              NO_ERROR  -- success
5045  *              none-zero failure code
5046  *==========================================================================*/
setRecordingHintValue(int32_t value)5047 int QCameraParameters::setRecordingHintValue(int32_t value)
5048 {
5049     ALOGD("%s: VideoHint = %d", __func__, value);
5050     bool newValue = (value > 0)? true : false;
5051 
5052     if ( m_bRecordingHint != newValue ) {
5053         m_bNeedRestart = true;
5054         m_bRecordingHint_new = newValue;
5055     } else {
5056         m_bRecordingHint_new = m_bRecordingHint;
5057     }
5058     return AddSetParmEntryToBatch(m_pParamBuf,
5059                                   CAM_INTF_PARM_RECORDING_HINT,
5060                                   sizeof(value),
5061                                   &value);
5062 }
5063 
5064 /*===========================================================================
5065  * FUNCTION   : getNumOfSnapshots
5066  *
5067  * DESCRIPTION: get number of snapshot per shutter
5068  *
5069  * PARAMETERS : none
5070  *
5071  * RETURN     : number of snapshot per shutter
5072  *==========================================================================*/
getNumOfSnapshots()5073 uint8_t QCameraParameters::getNumOfSnapshots()
5074 {
5075     int numOfSnapshot = getInt(KEY_QC_NUM_SNAPSHOT_PER_SHUTTER);
5076     if (numOfSnapshot <= 0) {
5077         numOfSnapshot = 1; // set to default value
5078     }
5079     return (uint8_t)numOfSnapshot;
5080 }
5081 
5082 /*===========================================================================
5083  * FUNCTION   : getNumOfExtraHDRBufsIfNeeded
5084  *
5085  * DESCRIPTION: get number of extra buffers needed by HDR if HDR is enabled
5086  *
5087  * PARAMETERS : none
5088  *
5089  * RETURN     : number of extra buffer needed by HDR; 0 if not HDR enabled
5090  *==========================================================================*/
getNumOfExtraHDRBufsIfNeeded()5091 uint8_t QCameraParameters::getNumOfExtraHDRBufsIfNeeded()
5092 {
5093     uint8_t numOfBufs = 0;
5094     const char *scene_mode = get(KEY_SCENE_MODE);
5095     if (scene_mode != NULL && strcmp(scene_mode, SCENE_MODE_HDR) == 0) {
5096         // HDR mode
5097         numOfBufs = getBurstNum() * m_pCapability->min_num_hdr_bufs;
5098     }
5099     return numOfBufs;
5100 }
5101 
5102 /*===========================================================================
5103  * FUNCTION   : getNumOfHDRBufsIfNeeded
5104  *
5105  * DESCRIPTION: get number of buffers needed by HDR if HDR is enabled
5106  *
5107  * PARAMETERS : none
5108  *
5109  * RETURN     : number of buffer needed by HDR; 0 if not HDR enabled
5110  *==========================================================================*/
getNumOfHDRBufsIfNeeded()5111 uint8_t QCameraParameters::getNumOfHDRBufsIfNeeded()
5112 {
5113     uint8_t numOfBufs = 0;
5114     const char *scene_mode = get(KEY_SCENE_MODE);
5115     if (scene_mode != NULL && strcmp(scene_mode, SCENE_MODE_HDR) == 0) {
5116         // HDR mode
5117         const char *need_hdr_1x = get(KEY_QC_HDR_NEED_1X);
5118         if (need_hdr_1x != NULL && strcmp(need_hdr_1x, VALUE_TRUE) == 0) {
5119             numOfBufs = 2; // HDR needs both 1X and processed img
5120         } else {
5121             numOfBufs = 1; // HDR only needs processed img
5122         }
5123 
5124         numOfBufs += m_pCapability->min_num_hdr_bufs;
5125     }
5126     return numOfBufs;
5127 }
5128 
5129 /*===========================================================================
5130  * FUNCTION   : getBurstNum
5131  *
5132  * DESCRIPTION: get burst number of snapshot
5133  *
5134  * PARAMETERS : none
5135  *
5136  * RETURN     : number of burst
5137  *==========================================================================*/
getBurstNum()5138 int QCameraParameters::getBurstNum()
5139 {
5140     char prop[PROPERTY_VALUE_MAX];
5141     memset(prop, 0, sizeof(prop));
5142     property_get("persist.camera.snapshot.number", prop, "0");
5143     int nBurstNum = atoi(prop);
5144     if (nBurstNum > 0) {
5145         ALOGD("%s: Reading burst number = %d from properties",
5146               __func__, nBurstNum);
5147     } else {
5148         nBurstNum = 1;
5149     }
5150     return nBurstNum;
5151 }
5152 
5153 /*===========================================================================
5154  * FUNCTION   : getJpegQuality
5155  *
5156  * DESCRIPTION: get jpeg encoding quality
5157  *
5158  * PARAMETERS : none
5159  *
5160  * RETURN     : jpeg encoding quality
5161  *==========================================================================*/
getJpegQuality()5162 int QCameraParameters::getJpegQuality()
5163 {
5164     int quality = getInt(KEY_JPEG_QUALITY);
5165     if (quality < 0) {
5166         quality = 85; // set to default quality value
5167     }
5168     return quality;
5169 }
5170 
5171 /*===========================================================================
5172  * FUNCTION   : getJpegRotation
5173  *
5174  * DESCRIPTION: get rotation value
5175  *
5176  * PARAMETERS : none
5177  *
5178  * RETURN     : rotation value
5179  *==========================================================================*/
getJpegRotation()5180 int QCameraParameters::getJpegRotation() {
5181     int rotation = getInt(KEY_ROTATION);
5182     if (rotation < 0) {
5183         rotation = 0;
5184     }
5185     return rotation;
5186 }
5187 
5188 /*===========================================================================
5189  * FUNCTION   : parseGPSCoordinate
5190  *
5191  * DESCRIPTION: parse GPS coordinate string
5192  *
5193  * PARAMETERS :
5194  *   @coord_str : [input] coordinate string
5195  *   @coord     : [output]  ptr to struct to store coordinate
5196  *
5197  * RETURN     : int32_t type of status
5198  *              NO_ERROR  -- success
5199  *              none-zero failure code
5200  *==========================================================================*/
parseGPSCoordinate(const char * coord_str,rat_t * coord)5201 int QCameraParameters::parseGPSCoordinate(const char *coord_str, rat_t* coord)
5202 {
5203     if(coord == NULL) {
5204         ALOGE("%s: error, invalid argument coord == NULL", __func__);
5205         return BAD_VALUE;
5206     }
5207     float degF = atof(coord_str);
5208     if (degF < 0) {
5209         degF = -degF;
5210     }
5211     float minF = (degF - (int) degF) * 60;
5212     float secF = (minF - (int) minF) * 60;
5213 
5214     getRational(&coord[0], (int)degF, 1);
5215     getRational(&coord[1], (int)minF, 1);
5216     getRational(&coord[2], (int)(secF * 10000), 10000);
5217     return NO_ERROR;
5218 }
5219 
5220 /*===========================================================================
5221  * FUNCTION   : getExifDateTime
5222  *
5223  * DESCRIPTION: query exif date time
5224  *
5225  * PARAMETERS :
5226  *   @dateTime : string to store exif date time
5227  *   @count    : lenght of the dateTime string
5228  *
5229  * RETURN     : int32_t type of status
5230  *              NO_ERROR  -- success
5231  *              none-zero failure code
5232  *==========================================================================*/
getExifDateTime(char * dateTime,uint32_t & count)5233 int32_t QCameraParameters::getExifDateTime(char *dateTime, uint32_t &count)
5234 {
5235     //get time and date from system
5236     time_t rawtime;
5237     struct tm * timeinfo = NULL;
5238     memset(&rawtime, 0, sizeof(rawtime));
5239     time(&rawtime);
5240     timeinfo = localtime (&rawtime);
5241     if (timeinfo != NULL && count >= 20) {
5242         //Write datetime according to EXIF Spec
5243         //"YYYY:MM:DD HH:MM:SS" (20 chars including \0)
5244         snprintf(dateTime, 20, "%04d:%02d:%02d %02d:%02d:%02d",
5245                  timeinfo->tm_year + 1900, timeinfo->tm_mon + 1,
5246                  timeinfo->tm_mday, timeinfo->tm_hour,
5247                  timeinfo->tm_min, timeinfo->tm_sec);
5248         count = 20;
5249         return NO_ERROR;
5250     }
5251     return UNKNOWN_ERROR;
5252 }
5253 
5254 /*===========================================================================
5255  * FUNCTION   : getRational
5256  *
5257  * DESCRIPTION: compose rational struct
5258  *
5259  * PARAMETERS :
5260  *   @rat     : ptr to struct to store rational info
5261  *   @num     :num of the rational
5262  *   @denom   : denom of the rational
5263  *
5264  * RETURN     : int32_t type of status
5265  *              NO_ERROR  -- success
5266  *              none-zero failure code
5267  *==========================================================================*/
getRational(rat_t * rat,int num,int denom)5268 int32_t QCameraParameters::getRational(rat_t *rat, int num, int denom)
5269 {
5270     if (NULL == rat) {
5271         ALOGE("%s: NULL rat input", __func__);
5272         return BAD_VALUE;
5273     }
5274     rat->num = num;
5275     rat->denom = denom;
5276     return NO_ERROR;
5277 }
5278 
5279 /*===========================================================================
5280  * FUNCTION   : getExifFocalLength
5281  *
5282  * DESCRIPTION: get exif focal lenght
5283  *
5284  * PARAMETERS :
5285  *   @focalLength : ptr to rational strcut to store focal lenght
5286  *
5287  * RETURN     : int32_t type of status
5288  *              NO_ERROR  -- success
5289  *              none-zero failure code
5290  *==========================================================================*/
getExifFocalLength(rat_t * focalLength)5291 int32_t QCameraParameters::getExifFocalLength(rat_t *focalLength)
5292 {
5293     int focalLengthValue =
5294         (int)(getFloat(QCameraParameters::KEY_FOCAL_LENGTH) * FOCAL_LENGTH_DECIMAL_PRECISION);
5295     return getRational(focalLength, focalLengthValue, FOCAL_LENGTH_DECIMAL_PRECISION);
5296 }
5297 
5298 /*===========================================================================
5299  * FUNCTION   : getExifIsoSpeed
5300  *
5301  * DESCRIPTION: get exif ISO speed
5302  *
5303  * PARAMETERS : none
5304  *
5305  * RETURN     : ISO speed value
5306  *==========================================================================*/
getExifIsoSpeed()5307 uint16_t QCameraParameters::getExifIsoSpeed()
5308 {
5309     uint16_t isoSpeed = 0;
5310     const char *iso_str = get(QCameraParameters::KEY_QC_ISO_MODE);
5311     int iso_index = lookupAttr(ISO_MODES_MAP,
5312         sizeof(ISO_MODES_MAP)/sizeof(ISO_MODES_MAP[0]), iso_str);
5313     switch (iso_index) {
5314     case CAM_ISO_MODE_AUTO:
5315         isoSpeed = 0;
5316         break;
5317     case CAM_ISO_MODE_DEBLUR:
5318         isoSpeed = 1;
5319         break;
5320     case CAM_ISO_MODE_100:
5321         isoSpeed = 100;
5322         break;
5323     case CAM_ISO_MODE_200:
5324         isoSpeed = 200;
5325         break;
5326     case CAM_ISO_MODE_400:
5327         isoSpeed = 400;
5328         break;
5329     case CAM_ISO_MODE_800:
5330         isoSpeed = 800;
5331         break;
5332     case CAM_ISO_MODE_1600:
5333         isoSpeed = 1600;
5334         break;
5335     }
5336     return isoSpeed;
5337 }
5338 
5339 /*===========================================================================
5340  * FUNCTION   : getExifGpsProcessingMethod
5341  *
5342  * DESCRIPTION: get GPS processing method
5343  *
5344  * PARAMETERS :
5345  *   @gpsProcessingMethod : string to store GPS process method
5346  *   @count               : lenght of the string
5347  *
5348  * RETURN     : int32_t type of status
5349  *              NO_ERROR  -- success
5350  *              none-zero failure code
5351  *==========================================================================*/
getExifGpsProcessingMethod(char * gpsProcessingMethod,uint32_t & count)5352 int32_t QCameraParameters::getExifGpsProcessingMethod(char *gpsProcessingMethod,
5353                                                       uint32_t &count)
5354 {
5355     const char *str = get(KEY_GPS_PROCESSING_METHOD);
5356     if(str != NULL) {
5357         memcpy(gpsProcessingMethod, ExifAsciiPrefix, EXIF_ASCII_PREFIX_SIZE);
5358         count = EXIF_ASCII_PREFIX_SIZE;
5359         strncpy(gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE, str, strlen(str));
5360         count += strlen(str);
5361         gpsProcessingMethod[count++] = '\0'; // increase 1 for the last NULL char
5362         return NO_ERROR;
5363     } else {
5364         return BAD_VALUE;
5365     }
5366 }
5367 
5368 /*===========================================================================
5369  * FUNCTION   : getExifLatitude
5370  *
5371  * DESCRIPTION: get exif latitude
5372  *
5373  * PARAMETERS :
5374  *   @latitude : ptr to rational struct to store latitude info
5375  *   @ladRef   : charater to indicate latitude reference
5376  *
5377  * RETURN     : int32_t type of status
5378  *              NO_ERROR  -- success
5379  *              none-zero failure code
5380  *==========================================================================*/
getExifLatitude(rat_t * latitude,char * latRef)5381 int32_t QCameraParameters::getExifLatitude(rat_t *latitude,
5382                                            char *latRef)
5383 {
5384     const char *str = get(KEY_GPS_LATITUDE);
5385     if(str != NULL) {
5386         parseGPSCoordinate(str, latitude);
5387 
5388         //set Latitude Ref
5389         float latitudeValue = getFloat(KEY_GPS_LATITUDE);
5390         if(latitudeValue < 0.0f) {
5391             latRef[0] = 'S';
5392         } else {
5393             latRef[0] = 'N';
5394         }
5395         latRef[1] = '\0';
5396         return NO_ERROR;
5397     }else{
5398         return BAD_VALUE;
5399     }
5400 }
5401 
5402 /*===========================================================================
5403  * FUNCTION   : getExifLongitude
5404  *
5405  * DESCRIPTION: get exif longitude
5406  *
5407  * PARAMETERS :
5408  *   @longitude : ptr to rational struct to store longitude info
5409  *   @lonRef    : charater to indicate longitude reference
5410  *
5411  * RETURN     : int32_t type of status
5412  *              NO_ERROR  -- success
5413  *              none-zero failure code
5414  *==========================================================================*/
getExifLongitude(rat_t * longitude,char * lonRef)5415 int32_t QCameraParameters::getExifLongitude(rat_t *longitude,
5416                                             char *lonRef)
5417 {
5418     const char *str = get(KEY_GPS_LONGITUDE);
5419     if(str != NULL) {
5420         parseGPSCoordinate(str, longitude);
5421 
5422         //set Longitude Ref
5423         float longitudeValue = getFloat(KEY_GPS_LONGITUDE);
5424         if(longitudeValue < 0.0f) {
5425             lonRef[0] = 'W';
5426         } else {
5427             lonRef[0] = 'E';
5428         }
5429         lonRef[1] = '\0';
5430         return NO_ERROR;
5431     }else{
5432         return BAD_VALUE;
5433     }
5434 }
5435 
5436 /*===========================================================================
5437  * FUNCTION   : getExifAltitude
5438  *
5439  * DESCRIPTION: get exif altitude
5440  *
5441  * PARAMETERS :
5442  *   @altitude : ptr to rational struct to store altitude info
5443  *   @altRef   : charater to indicate altitude reference
5444  *
5445  * RETURN     : int32_t type of status
5446  *              NO_ERROR  -- success
5447  *              none-zero failure code
5448  *==========================================================================*/
getExifAltitude(rat_t * altitude,char * altRef)5449 int32_t QCameraParameters::getExifAltitude(rat_t *altitude,
5450                                            char *altRef)
5451 {
5452     const char *str = get(KEY_GPS_ALTITUDE);
5453     if(str != NULL) {
5454         double value = atof(str);
5455         *altRef = 0;
5456         if(value < 0){
5457             *altRef = 1;
5458             value = -value;
5459         }
5460         return getRational(altitude, value*1000, 1000);
5461     }else{
5462         return BAD_VALUE;
5463     }
5464 }
5465 
5466 /*===========================================================================
5467  * FUNCTION   : getExifGpsDateTimeStamp
5468  *
5469  * DESCRIPTION: get exif GPS date time stamp
5470  *
5471  * PARAMETERS :
5472  *   @gpsDateStamp : GPS date time stamp string
5473  *   @bufLen       : length of the string
5474  *   @gpsTimeStamp : ptr to rational struct to store time stamp info
5475  *
5476  * RETURN     : int32_t type of status
5477  *              NO_ERROR  -- success
5478  *              none-zero failure code
5479  *==========================================================================*/
getExifGpsDateTimeStamp(char * gpsDateStamp,uint32_t bufLen,rat_t * gpsTimeStamp)5480 int32_t QCameraParameters::getExifGpsDateTimeStamp(char *gpsDateStamp,
5481                                                    uint32_t bufLen,
5482                                                    rat_t *gpsTimeStamp)
5483 {
5484     const char *str = get(KEY_GPS_TIMESTAMP);
5485     if(str != NULL) {
5486         time_t unixTime = (time_t)atol(str);
5487         struct tm *UTCTimestamp = gmtime(&unixTime);
5488 
5489         strftime(gpsDateStamp, bufLen, "%Y:%m:%d", UTCTimestamp);
5490 
5491         getRational(&gpsTimeStamp[0], UTCTimestamp->tm_hour, 1);
5492         getRational(&gpsTimeStamp[1], UTCTimestamp->tm_min, 1);
5493         getRational(&gpsTimeStamp[2], UTCTimestamp->tm_sec, 1);
5494 
5495         return NO_ERROR;
5496     } else {
5497         return BAD_VALUE;
5498     }
5499 }
5500 
5501 /*===========================================================================
5502  * FUNCTION   : updateFocusDistances
5503  *
5504  * DESCRIPTION: update focus distances
5505  *
5506  * PARAMETERS :
5507  *   @focusDistances : ptr to focus distance info
5508  *
5509  * RETURN     : int32_t type of status
5510  *              NO_ERROR  -- success
5511  *              none-zero failure code
5512  *==========================================================================*/
updateFocusDistances(cam_focus_distances_info_t * focusDistances)5513 int32_t QCameraParameters::updateFocusDistances(cam_focus_distances_info_t *focusDistances)
5514 {
5515     String8 str;
5516     char buffer[32] = {0};
5517     //set all distances to infinity if focus mode is infinity
5518     if(mFocusMode == CAM_FOCUS_MODE_INFINITY) {
5519         str.append("Infinity,Infinity,Infinity");
5520     } else {
5521         snprintf(buffer, sizeof(buffer), "%f", focusDistances->focus_distance[0]);
5522         str.append(buffer);
5523         snprintf(buffer, sizeof(buffer), ",%f", focusDistances->focus_distance[1]);
5524         str.append(buffer);
5525         snprintf(buffer, sizeof(buffer), ",%f", focusDistances->focus_distance[2]);
5526         str.append(buffer);
5527     }
5528     ALOGD("%s: setting KEY_FOCUS_DISTANCES as %s", __FUNCTION__, str.string());
5529     set(QCameraParameters::KEY_FOCUS_DISTANCES, str.string());
5530     return NO_ERROR;
5531 }
5532 
5533 /*===========================================================================
5534  * FUNCTION   : updateRecordingHintValue
5535  *
5536  * DESCRIPTION: update recording hint locally and to daemon
5537  *
5538  * PARAMETERS :
5539  *   @value   : video hint value
5540  *
5541  * RETURN     : int32_t type of status
5542  *              NO_ERROR  -- success
5543  *              none-zero failure code
5544  *==========================================================================*/
updateRecordingHintValue(int32_t value)5545 int32_t QCameraParameters::updateRecordingHintValue(int32_t value)
5546 {
5547     int32_t rc = NO_ERROR;
5548     if(initBatchUpdate(m_pParamBuf) < 0 ) {
5549         ALOGE("%s:Failed to initialize group update table", __func__);
5550         return BAD_TYPE;
5551     }
5552 
5553     rc = setRecordingHintValue(value);
5554     if (rc != NO_ERROR) {
5555         ALOGE("%s:Failed to update table", __func__);
5556         return rc;
5557     }
5558 
5559     rc = commitSetBatch();
5560     if (rc != NO_ERROR) {
5561         ALOGE("%s:Failed to update recording hint", __func__);
5562         return rc;
5563     }
5564 
5565     return rc;
5566 }
5567 
5568 /*===========================================================================
5569  * FUNCTION   : setHistogram
5570  *
5571  * DESCRIPTION: set histogram
5572  *
5573  * PARAMETERS :
5574  *   @enabled : if histogram is enabled
5575  *
5576  * RETURN     : int32_t type of status
5577  *              NO_ERROR  -- success
5578  *              none-zero failure code
5579  *==========================================================================*/
setHistogram(bool enabled)5580 int32_t QCameraParameters::setHistogram(bool enabled)
5581 {
5582     if(m_bHistogramEnabled == enabled) {
5583         ALOGD("%s: histogram flag not changed, no ops here", __func__);
5584         return NO_ERROR;
5585     }
5586 
5587     // set parm for histogram
5588     if(initBatchUpdate(m_pParamBuf) < 0 ) {
5589         ALOGE("%s:Failed to initialize group update table", __func__);
5590         return BAD_TYPE;
5591     }
5592 
5593     int32_t value = enabled;
5594     int32_t rc = NO_ERROR;
5595     rc = AddSetParmEntryToBatch(m_pParamBuf,
5596                                 CAM_INTF_PARM_HISTOGRAM,
5597                                 sizeof(value),
5598                                 &value);
5599     if (rc != NO_ERROR) {
5600         ALOGE("%s:Failed to update table", __func__);
5601         return rc;
5602     }
5603 
5604     rc = commitSetBatch();
5605     if (rc != NO_ERROR) {
5606         ALOGE("%s:Failed to set histogram", __func__);
5607         return rc;
5608     }
5609 
5610     m_bHistogramEnabled = enabled;
5611 
5612     ALOGD(" Histogram -> %s", m_bHistogramEnabled ? "Enabled" : "Disabled");
5613 
5614     return rc;
5615 }
5616 
5617 /*===========================================================================
5618  * FUNCTION   : setFaceDetection
5619  *
5620  * DESCRIPTION: set face detection
5621  *
5622  * PARAMETERS :
5623  *   @enabled : if face detection is enabled
5624  *
5625  * RETURN     : int32_t type of status
5626  *              NO_ERROR  -- success
5627  *              none-zero failure code
5628  *==========================================================================*/
setFaceDetection(bool enabled)5629 int32_t QCameraParameters::setFaceDetection(bool enabled)
5630 {
5631     int faceProcMask = m_nFaceProcMask;
5632     // set face detection mask
5633     if (enabled) {
5634         faceProcMask |= CAM_FACE_PROCESS_MASK_DETECTION;
5635     } else {
5636         faceProcMask &= ~CAM_FACE_PROCESS_MASK_DETECTION;
5637     }
5638 
5639     if(m_nFaceProcMask == faceProcMask) {
5640         ALOGD("%s: face process mask not changed, no ops here", __func__);
5641         return NO_ERROR;
5642     }
5643 
5644     // set parm for face detection
5645     int requested_faces = getInt(KEY_QC_MAX_NUM_REQUESTED_FACES);
5646     cam_fd_set_parm_t fd_set_parm;
5647     memset(&fd_set_parm, 0, sizeof(cam_fd_set_parm_t));
5648     fd_set_parm.fd_mode = faceProcMask;
5649     fd_set_parm.num_fd = requested_faces;
5650 
5651     ALOGD("[KPI Perf] %s: Face detection value = %d num_fd = %d",
5652           __func__, faceProcMask,requested_faces);
5653     if(initBatchUpdate(m_pParamBuf) < 0 ) {
5654         ALOGE("%s:Failed to initialize group update table", __func__);
5655         return BAD_TYPE;
5656     }
5657     int32_t rc = NO_ERROR;
5658 
5659     rc = AddSetParmEntryToBatch(m_pParamBuf,
5660                                 CAM_INTF_PARM_FD,
5661                                 sizeof(fd_set_parm),
5662                                 &fd_set_parm);
5663     if (rc != NO_ERROR) {
5664         ALOGE("%s:Failed to update table", __func__);
5665         return rc;
5666     }
5667 
5668     rc = commitSetBatch();
5669     if (rc != NO_ERROR) {
5670         ALOGE("%s:Failed to set face detection parm", __func__);
5671         return rc;
5672     }
5673 
5674     m_nFaceProcMask = faceProcMask;
5675     ALOGD("%s: FaceProcMask -> %d", __func__, m_nFaceProcMask);
5676 
5677     return rc;
5678 }
5679 
5680 /*===========================================================================
5681  * FUNCTION   : setLockCAF
5682  *
5683  * DESCRIPTION: Lock CAF
5684  *
5685  * PARAMETERS :
5686  *   @bLock : if CAF needs to be locked
5687  *
5688  * RETURN     : int32_t type of status
5689  *              NO_ERROR  -- success
5690  *              none-zero failure code
5691  *==========================================================================*/
setLockCAF(bool bLock)5692 int32_t QCameraParameters::setLockCAF(bool bLock)
5693 {
5694     if(initBatchUpdate(m_pParamBuf) < 0 ) {
5695         ALOGE("%s:Failed to initialize group update table", __func__);
5696         return BAD_TYPE;
5697     }
5698     int32_t rc = NO_ERROR;
5699     int32_t value = bLock;
5700 
5701     rc = AddSetParmEntryToBatch(m_pParamBuf,
5702                                 CAM_INTF_PARM_LOCK_CAF,
5703                                 sizeof(value),
5704                                 &value);
5705     if (rc != NO_ERROR) {
5706         ALOGE("%s:Failed to update table", __func__);
5707         return rc;
5708     }
5709 
5710     rc = commitSetBatch();
5711     if (rc != NO_ERROR) {
5712         ALOGE("%s:Failed to set lock CAF parm", __func__);
5713         return rc;
5714     } else {
5715         m_bCAFLocked = bLock;
5716         return NO_ERROR;
5717     }
5718 }
5719 
5720 /*===========================================================================
5721  * FUNCTION   : setFrameSkip
5722  *
5723  * DESCRIPTION: send ISP frame skip pattern to camera daemon
5724  *
5725  * PARAMETERS :
5726  *   @pattern : skip pattern for ISP
5727  *
5728  * RETURN     : int32_t type of status
5729  *              NO_ERROR  -- success
5730  *              none-zero failure code
5731  *==========================================================================*/
setFrameSkip(enum msm_vfe_frame_skip_pattern pattern)5732 int32_t QCameraParameters::setFrameSkip(enum msm_vfe_frame_skip_pattern pattern)
5733 {
5734     int32_t rc = NO_ERROR;
5735     int32_t value = (int32_t)pattern;
5736 
5737     if ( m_pParamBuf == NULL ) {
5738         return NO_INIT;
5739     }
5740 
5741     if(initBatchUpdate(m_pParamBuf) < 0 ) {
5742         ALOGE("%s:Failed to initialize group update table", __func__);
5743         return BAD_TYPE;
5744     }
5745 
5746     rc = AddSetParmEntryToBatch(m_pParamBuf,
5747                                 CAM_INTF_PARM_FRAMESKIP,
5748                                 sizeof(value),
5749                                 &value);
5750     if (rc != NO_ERROR) {
5751         ALOGE("%s:Failed to update table", __func__);
5752         return rc;
5753     }
5754 
5755     rc = commitSetBatch();
5756     if (rc != NO_ERROR) {
5757         ALOGE("%s:Failed to set frameskip info parm", __func__);
5758         return rc;
5759     }
5760 
5761     return rc;
5762 }
5763 
5764 /*===========================================================================
5765  * FUNCTION   : parseNDimVector
5766  *
5767  * DESCRIPTION: helper function to parse a string like "(1, 2, 3, 4, ..., N)"
5768  *              into N-dimension vector
5769  *
5770  * PARAMETERS :
5771  *   @str     : string to be parsed
5772  *   @num     : output array of size N to store vector element values
5773  *   @N       : number of dimension
5774  *   @delim   : delimeter to seperete string
5775  *
5776  * RETURN     : int32_t type of status
5777  *              NO_ERROR  -- success
5778  *              none-zero failure code
5779  *==========================================================================*/
parseNDimVector(const char * str,int * num,int N,char delim=',')5780 int32_t QCameraParameters::parseNDimVector(const char *str, int *num, int N, char delim = ',')
5781 {
5782     char *start, *end;
5783     if (num == NULL) {
5784         ALOGE("%s: Invalid output array (num == NULL)", __func__);
5785         return BAD_VALUE;
5786     }
5787 
5788     //check if string starts and ends with parantheses
5789     if(str[0] != '(' || str[strlen(str)-1] != ')') {
5790         ALOGE("%s: Invalid format of string %s, valid format is (n1, n2, n3, n4 ...)",
5791               __func__, str);
5792         return BAD_VALUE;
5793     }
5794     start = (char*) str;
5795     start++;
5796     for(int i=0; i<N; i++) {
5797         *(num+i) = (int) strtol(start, &end, 10);
5798         if(*end != delim && i < N-1) {
5799             ALOGE("%s: Cannot find delimeter '%c' in string \"%s\". end = %c",
5800                   __func__, delim, str, *end);
5801             return -1;
5802         }
5803         start = end+1;
5804     }
5805     return NO_ERROR;
5806 }
5807 
5808 /*===========================================================================
5809  * FUNCTION   : parseCameraAreaString
5810  *
5811  * DESCRIPTION: helper function to parse a string of camera areas like
5812  *              "(1, 2, 3, 4, 5),(1, 2, 3, 4, 5),..."
5813  *
5814  * PARAMETERS :
5815  *   @str             : string to be parsed
5816  *   @max_num_areas   : max number of areas
5817  *   @pAreas          : ptr to struct to store areas
5818  *   @num_areas_found : number of areas found
5819  *
5820  * RETURN     : int32_t type of status
5821  *              NO_ERROR  -- success
5822  *              none-zero failure code
5823  *==========================================================================*/
parseCameraAreaString(const char * str,int max_num_areas,cam_area_t * pAreas,int & num_areas_found)5824 int32_t QCameraParameters::parseCameraAreaString(const char *str,
5825                                                  int max_num_areas,
5826                                                  cam_area_t *pAreas,
5827                                                  int& num_areas_found)
5828 {
5829     char area_str[32];
5830     const char *start, *end, *p;
5831     start = str; end = NULL;
5832     int values[5], index=0;
5833     num_areas_found = 0;
5834 
5835     memset(values, 0, sizeof(values));
5836     while(start != NULL) {
5837        if(*start != '(') {
5838             ALOGE("%s: error: Ill formatted area string: %s", __func__, str);
5839             return BAD_VALUE;
5840        }
5841        end = strchr(start, ')');
5842        if(end == NULL) {
5843             ALOGE("%s: error: Ill formatted area string: %s", __func__, str);
5844             return BAD_VALUE;
5845        }
5846        int i;
5847        for (i=0,p=start; p<=end; p++, i++) {
5848            area_str[i] = *p;
5849        }
5850        area_str[i] = '\0';
5851        if(parseNDimVector(area_str, values, 5) < 0){
5852             ALOGE("%s: error: Failed to parse the area string: %s", __func__, area_str);
5853             return BAD_VALUE;
5854        }
5855        // no more areas than max_num_areas are accepted.
5856        if(index >= max_num_areas) {
5857             ALOGE("%s: error: too many areas specified %s", __func__, str);
5858             return BAD_VALUE;
5859        }
5860        pAreas[index].rect.left = values[0];
5861        pAreas[index].rect.top = values[1];
5862        pAreas[index].rect.width = values[2] - values[0];
5863        pAreas[index].rect.height = values[3] - values[1];
5864        pAreas[index].weight = values[4];
5865 
5866        index++;
5867        start = strchr(end, '('); // serach for next '('
5868     }
5869     num_areas_found = index;
5870     return 0;
5871 }
5872 
5873 /*===========================================================================
5874  * FUNCTION   : validateCameraAreas
5875  *
5876  * DESCRIPTION: helper function to validate camera areas within (-1000, 1000)
5877  *
5878  * PARAMETERS :
5879  *   @areas     : ptr to array of areas
5880  *   @num_areas : number of areas
5881  *
5882  * RETURN     : true --  area is in valid range
5883  *              false -- not valid
5884  *==========================================================================*/
validateCameraAreas(cam_area_t * areas,int num_areas)5885 bool QCameraParameters::validateCameraAreas(cam_area_t *areas, int num_areas)
5886 {
5887     // special case: default area
5888     if (num_areas == 1 &&
5889         areas[0].rect.left == 0 &&
5890         areas[0].rect.top == 0 &&
5891         areas[0].rect.width == 0 &&
5892         areas[0].rect.height == 0 &&
5893         areas[0].weight == 0) {
5894         return true;
5895     }
5896 
5897     for(int i = 0; i < num_areas; i++) {
5898         // left should be >= -1000
5899         if(areas[i].rect.left < -1000) {
5900             return false;
5901         }
5902 
5903         // top  should be >= -1000
5904         if(areas[i].rect.top < -1000) {
5905             return false;
5906         }
5907 
5908         // width or height should be > 0
5909         if (areas[i].rect.width <= 0 || areas[i].rect.height <= 0) {
5910             return false;
5911         }
5912 
5913         // right  should be <= 1000
5914         if(areas[i].rect.left + areas[i].rect.width > 1000) {
5915             return false;
5916         }
5917 
5918         // bottom should be <= 1000
5919         if(areas[i].rect.top + areas[i].rect.height > 1000) {
5920             return false;
5921         }
5922 
5923         // weight should be within (1, 1000)
5924         if (areas[i].weight < 1 || areas[i].weight > 1000) {
5925             return false;
5926         }
5927     }
5928     return true;
5929 }
5930 
5931 /*===========================================================================
5932  * FUNCTION   : initBatchUpdate
5933  *
5934  * DESCRIPTION: init camera parameters buf entries
5935  *
5936  * PARAMETERS :
5937  *   @p_table : ptr to parameter buffer
5938  *
5939  * RETURN     : int32_t type of status
5940  *              NO_ERROR  -- success
5941  *              none-zero failure code
5942  *==========================================================================*/
initBatchUpdate(parm_buffer_t * p_table)5943 int32_t QCameraParameters::initBatchUpdate(parm_buffer_t *p_table)
5944 {
5945     int32_t hal_version = CAM_HAL_V1;
5946     m_tempMap.clear();
5947 
5948     memset(p_table, 0, sizeof(parm_buffer_t));
5949     p_table->first_flagged_entry = CAM_INTF_PARM_MAX;
5950     AddSetParmEntryToBatch(p_table, CAM_INTF_PARM_HAL_VERSION,
5951                 sizeof(hal_version), &hal_version);
5952     return NO_ERROR;
5953 }
5954 
5955 /*===========================================================================
5956  * FUNCTION   : AddSetParmEntryToBatch
5957  *
5958  * DESCRIPTION: add set parameter entry into batch
5959  *
5960  * PARAMETERS :
5961  *   @p_table     : ptr to parameter buffer
5962  *   @paramType   : parameter type
5963  *   @paramLength : length of parameter value
5964  *   @paramValue  : ptr to parameter value
5965  *
5966  * RETURN     : int32_t type of status
5967  *              NO_ERROR  -- success
5968  *              none-zero failure code
5969  *==========================================================================*/
AddSetParmEntryToBatch(parm_buffer_t * p_table,cam_intf_parm_type_t paramType,uint32_t paramLength,void * paramValue)5970 int32_t QCameraParameters::AddSetParmEntryToBatch(parm_buffer_t *p_table,
5971                                                   cam_intf_parm_type_t paramType,
5972                                                   uint32_t paramLength,
5973                                                   void *paramValue)
5974 {
5975     int position = paramType;
5976     int current, next;
5977 
5978     /*************************************************************************
5979     *                 Code to take care of linking next flags                *
5980     *************************************************************************/
5981     current = GET_FIRST_PARAM_ID(p_table);
5982     if (position == current){
5983         //DO NOTHING
5984     } else if (position < current){
5985         SET_NEXT_PARAM_ID(position, p_table, current);
5986         SET_FIRST_PARAM_ID(p_table, position);
5987     } else {
5988         /* Search for the position in the linked list where we need to slot in*/
5989         while (position > GET_NEXT_PARAM_ID(current, p_table))
5990             current = GET_NEXT_PARAM_ID(current, p_table);
5991 
5992         /*If node already exists no need to alter linking*/
5993         if (position != GET_NEXT_PARAM_ID(current, p_table)) {
5994             next = GET_NEXT_PARAM_ID(current, p_table);
5995             SET_NEXT_PARAM_ID(current, p_table, position);
5996             SET_NEXT_PARAM_ID(position, p_table, next);
5997         }
5998     }
5999 
6000     /*************************************************************************
6001     *                   Copy contents into entry                             *
6002     *************************************************************************/
6003 
6004     if (paramLength > sizeof(parm_type_t)) {
6005         ALOGE("%s:Size of input larger than max entry size",__func__);
6006         return BAD_VALUE;
6007     }
6008     memcpy(POINTER_OF(paramType,p_table), paramValue, paramLength);
6009     return NO_ERROR;
6010 }
6011 
6012 /*===========================================================================
6013  * FUNCTION   : AddGetParmEntryToBatch
6014  *
6015  * DESCRIPTION: add get parameter entry into batch
6016  *
6017  * PARAMETERS :
6018  *   @p_table     : ptr to parameter buffer
6019  *   @paramType   : parameter type
6020  *
6021  * RETURN     : int32_t type of status
6022  *              NO_ERROR  -- success
6023  *              none-zero failure code
6024  *==========================================================================*/
AddGetParmEntryToBatch(parm_buffer_t * p_table,cam_intf_parm_type_t paramType)6025 int32_t QCameraParameters::AddGetParmEntryToBatch(parm_buffer_t *p_table,
6026                                                   cam_intf_parm_type_t paramType)
6027 {
6028     int position = paramType;
6029     int current, next;
6030 
6031     /*************************************************************************
6032     *                 Code to take care of linking next flags                *
6033     *************************************************************************/
6034     current = GET_FIRST_PARAM_ID(p_table);
6035     if (position == current){
6036         //DO NOTHING
6037     } else if (position < current){
6038         SET_NEXT_PARAM_ID(position, p_table, current);
6039         SET_FIRST_PARAM_ID(p_table, position);
6040     } else {
6041         /* Search for the position in the linked list where we need to slot in*/
6042         while (position > GET_NEXT_PARAM_ID(current, p_table))
6043             current = GET_NEXT_PARAM_ID(current, p_table);
6044 
6045         /*If node already exists no need to alter linking*/
6046         if (position != GET_NEXT_PARAM_ID(current, p_table)) {
6047             next=GET_NEXT_PARAM_ID(current, p_table);
6048             SET_NEXT_PARAM_ID(current, p_table, position);
6049             SET_NEXT_PARAM_ID(position, p_table, next);
6050         }
6051     }
6052 
6053     return NO_ERROR;
6054 }
6055 
6056 /*===========================================================================
6057  * FUNCTION   : commitSetBatch
6058  *
6059  * DESCRIPTION: commit all set parameters in the batch work to backend
6060  *
6061  * PARAMETERS : none
6062  *
6063  * RETURN     : int32_t type of status
6064  *              NO_ERROR  -- success
6065  *              none-zero failure code
6066  *==========================================================================*/
commitSetBatch()6067 int32_t QCameraParameters::commitSetBatch()
6068 {
6069     int32_t rc = NO_ERROR;
6070     if (m_pParamBuf->first_flagged_entry < CAM_INTF_PARM_MAX) {
6071         rc = m_pCamOpsTbl->ops->set_parms(m_pCamOpsTbl->camera_handle, m_pParamBuf);
6072     }
6073     if (rc == NO_ERROR) {
6074         // commit change from temp storage into param map
6075         rc = commitParamChanges();
6076     }
6077     return rc;
6078 }
6079 
6080 /*===========================================================================
6081  * FUNCTION   : commitGetBatch
6082  *
6083  * DESCRIPTION: commit all get parameters in the batch work to backend
6084  *
6085  * PARAMETERS : none
6086  *
6087  * RETURN     : int32_t type of status
6088  *              NO_ERROR  -- success
6089  *              none-zero failure code
6090  *==========================================================================*/
commitGetBatch()6091 int32_t QCameraParameters::commitGetBatch()
6092 {
6093     if (m_pParamBuf->first_flagged_entry < CAM_INTF_PARM_MAX) {
6094         return m_pCamOpsTbl->ops->get_parms(m_pCamOpsTbl->camera_handle, m_pParamBuf);
6095     } else {
6096         return NO_ERROR;
6097     }
6098 }
6099 
6100 /*===========================================================================
6101  * FUNCTION   : updateParamEntry
6102  *
6103  * DESCRIPTION: update a parameter entry in the local temp map obj
6104  *
6105  * PARAMETERS :
6106  *   @key     : key of the entry
6107  *   @value   : value of the entry
6108  *
6109  * RETURN     : int32_t type of status
6110  *              NO_ERROR  -- success
6111  *              none-zero failure code
6112  *==========================================================================*/
updateParamEntry(const char * key,const char * value)6113 int32_t QCameraParameters::updateParamEntry(const char *key, const char *value)
6114 {
6115     m_tempMap.replaceValueFor(String8(key), String8(value));
6116     return NO_ERROR;
6117 }
6118 
6119 /*===========================================================================
6120  * FUNCTION   : commitParamChanges
6121  *
6122  * DESCRIPTION: commit all changes in local temp map obj into parameter obj
6123  *
6124  * PARAMETERS : none
6125  *
6126  * RETURN     : int32_t type of status
6127  *              NO_ERROR  -- success
6128  *              none-zero failure code
6129  *==========================================================================*/
commitParamChanges()6130 int32_t QCameraParameters::commitParamChanges()
6131 {
6132     size_t size = m_tempMap.size();
6133     for (size_t i = 0; i < size; i++) {
6134         String8 k, v;
6135         k = m_tempMap.keyAt(i);
6136         v = m_tempMap.valueAt(i);
6137         set(k, v);
6138     }
6139     m_tempMap.clear();
6140 
6141     // update local changes
6142     m_bRecordingHint = m_bRecordingHint_new;
6143     m_bZslMode = m_bZslMode_new;
6144 
6145     return NO_ERROR;
6146 }
6147 
6148 }; // namespace qcamera
6149